变量的引用

• 在C++中，变量的引用就是变量的别名alias
• 对一个变量的引用的所有操作，实际上都是对其所代表的原来的变量的操作
  变量a，别名为b
  int a;
  int &b=a;
  声明b是一个引用变量，初始化为a
  经过这样的声明之后，使用a或b的作用相同
  type * var 声明了一个指针变量
  type & 声明了一个引用变量
• 声明一个变量的引用后，在本函数执行期间，该引用不可以变更为其他变量的引用
• &何时为引用，何时为取地址
  &前面有type时为引用，elsewise为取地址
• 将引用作为函数参数

void swap(int&a, int&b)
{
  int temp=a;
  a=b;
  b=temp;
}

• 形参不是另外一个变量，而是实参的引用，与实参同占一个存储单元，也就是说改形参就可以改实参

inline function：compile时，将内联函数嵌入到main里，以空间换时间，适用于规模小且频繁调用的函数

作用域运算符：有个全局变量a，有个局部变量a，在局部，用a会屏蔽全局a，如果真想用a，通过::a

动态分配/回收内存的运算符new和delete
new int //allocate a space, return a ptr
new int(100) //eval the initial val
new int[10] //allocate a space to store array, in this case, you cannot specify initial val

float* p=new float(3.14);
float* parr=new float[10];
delete p;
delete[] ptr;

无参数的构造函数
Box b 而不是b()

类对象数组 Box b[3]={Box(参数), Box(参数), Box(参数)}

指向普通函数的指针：
void (p)( )
可以使它指向一个函数
p=&fun
可以通过该指针变量，调用该函数
(p)( )

指向成员函数的指针
void (Time::*p)()

普通函数： 类型名 （指针变量名）（参数列表）
成员函数： 类型名 （类名::指针变量名）（参数列表）

数据既能共享，又不会被修改，使用const
如果一个对象为const，那么它不可以call非const的成员

类名 *const 指针变量名 = 对象地址
这是个常指针，只能指向一开始确定的那个对象

const 类名*指针变量名
这个是指向常变量的指针，可以换别的常对象

静态定义对象，在runtime，对象所占的空间是不能随时释放的
想要提高内存的利用率，可以动态建立和释放对象
用new运算符动态地分配内存后，将返回一个指向新对象的指针
Box* p=new Box(12,13,14);
程序可以通过这个p访问对象
在执行new运算时，如果内存量不足，返回一个0
delete p；
memberwise copy

静态数据成员，为所有类对象所共享，只能在类外面进行初始化
类名::静态变量

友元函数：可以是普通函数，也可以是其他类的成员函数
友元函数可以访问私有变成员
用关键字friend声明友元函数
如果是其他类的成员函数作为友元函数，要提前声明其他类

运算符重载：
格式——类型 operator 运算符名（参数表）
{重新定义运算规则}
注意 operator 运算符名 就是函数名，其他的和普通函数没什么区别

对>>和<<进行重载，只能作为普通函数不可以作为成员函数
istream & operator >>(istream &, 自定义类 &)
ostream & operator >>(ostream &, 自定义类 &)

#include <iostream>
using namespace std;

class Complex{
private:
    float re;
    float im;
public:
    Complex():re(0),im(0){};
    Complex(float r,float i):re(r),im(i){};
    //Complex operator +(Complex& a);
    //void show();
    friend ostream & operator<<(ostream & nout,Complex &c);
    friend Complex operator + (Complex &a,Complex &b);
    friend istream & operator>>(istream & nin,Complex &c);
};

/*Complex Complex::operator +(Complex& a){
    float real,imag;
    real=a.re+re;
    imag=a.im+im;
    return Complex(real,imag);
}*/
istream & operator>>(istream & nin,Complex &c){
    cout<<"Enter real and imaginary part:"<<endl;
    nin>>c.re>>c.im;
    return nin;
}
ostream & operator<<(ostream & nout,Complex &c){
        if(c.im==0){
        nout<<c.re<<endl;
    }else if(c.im<0){
        nout<<c.re<<c.im<<"i"<<endl;
    }else{
        nout<<c.re<<"+"<<c.im<<"i"<<endl;
    }
    return nout;
}


Complex operator+(Complex &c1,Complex &c2){
    return Complex(c1.re+c2.re,c1.im+c2.im);
}
int main(){
    Complex u;
    Complex v;
    cin>>u>>v;
    Complex w;
    w=u+v;
    cout<<w;
    return 0;
}