C++ 引用与拷贝构造函数

今天重新看了c++的引用，和python的引用一起思考

首先，对一个整数的引用思路还是比较清晰的

int n=10;
int & r = n;
r = 10;
n = 20;

我做了MOOC的题目，看到的一个题目是 对指针进行引用，相当于加了一层抽象，但还是可以理解的

int a=10;
int b=20;
int* pa = &a;   //0x10000
int* pb = &b;   //0x20000
int* & r_pa = pa;
int* & r_pb = pb;
int* temp = r_pa; //0x10000 (temp）
r_pa = r_pb;      //0x20000 (r_pa, pa)
r_pb = temp;      //0x10000 (r_pb, pb)
cout<< *pa <<","<<*pb;

然后我看了复制构造函数。思考我很可能用一个现有的对象去初始化另一个对象，在操作系统中的子线程都是复制父线程，思路也是类似的。那么，我就需要用复制构造函数。实际使用的形式可以是：

Complex c2(c1)

Complex c2 = c1;

我查看了python的对象拷贝

a=[1,2,3]

b = a 两者的id是一样的，实际是一个东西，改其中一个，另一个也变

如果要不那么一样，可以用浅拷贝，使得b和a是两个内存地址，但这里浅拷贝就是说，只是外壳不一样，实际list元素的内容还是用的引用。b = copy.copy(a)

只有copy.deepcopy(a)才是从外壳到元素完完全全不一样的

那么对象可以定义 __copy__来定义复制构造函数的实现

今天还自己写了个小程序，一个class的constructor, deconstuct.

• 首先看有没有全局变量，全局变量在main之前就形成了，所以全局变量是最先进行初始化的 demo1
• 局部变量demo 4
• d4=6; 这个语句会构造6这个类型转换构造函数，同时这个语句执行完后，也就析构了
• 函数里面构建2，3
• 退出函数的是时候，3也析构了，但是2是static的，所以退出函数还不析构
• 析构main里面的局部变量
• 析构static变量
• 析构全局变量

#include 
using namespace std;
class Demo
{
  public:
    int id;
    Demo( int i )
    {
        id = i;
        cout << "construct " << i << "\n";
    }
    ~Demo() { cout << "deconstructed " << id << "\n"; }
};
Demo d( 1 );
void func()
{
    static Demo d( 2 );
    Demo        d3( 3 );
    cout << "func\n";
}
int main()
{
    cout << "main\n";
    Demo d4( 4 );
    d4 = 6;
    func();
    return 0;
}

然后这道题也挺有意思的

#include 
using namespace std;
class Demo
{
  public:
    int id;

    Demo( int i = 0 ) { id = i; }
    Demo( const Demo& b ) { id = b.id + 2; }
};
void func( Demo a ) { cout << a.id << "\n"; }

int main()
{
    Demo a( 5 );  // int 构造函数
    Demo b = a;   // 这个语句是创建对象的，所以是复制构造函数
    // cout << b.id << "\n";
    func( b );    //传参，这里是复制了一遍形参，所以是调用了复制构造函数，
    Demo c = 20;  // int 构造函数
    func( c );    // 传参，这里是复制了一遍形参，所以是调用了复制构造函数
    Demo d;        //int 构造函数，默认参数为0
    d = a;         //赋值语句
    cout << d.id << "\n";
    return 0;
}

另外一个收获就是C++编译器如何翻译class，本质是翻译成C程序的struct，成员函数翻译成全局函数，第一个参数就是对象，就是this

然后我又写了一个函数 Demo* p = NULL; p->hello(); 发现可以跑。因为本质p->hello()就是 hello(p), 这个p就是this，就是指向对象的指针，虽然这里的对象没有初始化，但确实又一个指针，因此是可以的。

说一下我是如何理解友元函数的

首先由一个类，这个类是一家岩馆，这个家岩馆由自己的私有变量（柜子），然后这个类会声明一些友元函数（就是会员），然后这些会员就可以访问这家岩馆的柜子。

class Upper:
   private:
       int guizi;
   friend void chuny(){
       guizi+1;
   }
   friend void xiaofang(){
       guizi+1;
   }