再论C++构造函数分类和调用时机以及匿名对象

原创请注明出处：

我们这里主要讨论构造函数的构造函数的分类和其调用时机
测试类如下：
namespace test_n
{
        int A_G=0;
        class test
        {
                public:
                        test() //无参数构造函数,如果没有调用默认构造函数
                        {
                                cout<<"无参构造函数调用"<<" adress: "<<&a<<endl;
                        }
                        test(int c_a,int c_b)//有参构造函数
                        {
                                cout<<"有参构造函数调用"<<" adress: "<<&a<<endl;
                                a=c_a;
                                b=c_b;


                        }
                        test(int c_a)
                        {
                                cout<<"有参构造函数调用"<<" adress: "<<&a<<endl;
                                a=c_a;
                        }


                        test(const test &m) //copy 构造函数
                        {
                                cout<<"copy构造函数调用"<<" adress: "<<&a<<endl;
                                a = m.a;
                                b = m.b;
                        }


                        void print()
                        {
                                cout<<a<<" "<<b<<endl;=""  ="" }=""
                        ~test()
                        {
                                cout<<"析构函数调用"<<" adress: "<<&a<<endl;
                                A_G++;
                                cout<<a_g<<endl;
                        }
                        void plus20()
                        {
                                a = a+20;
                                b = b+20;
                        }
//3-3
                        void printany(test p)
                        {
                                cout<<"匿名对象生成"<<endl;
                                p.print();
                        }
                        void printany(test* p)
                        {
                                cout<<"无名对象生成"<<endl;
                                p->print();
                        }
                        void printanys(test& p)
                        {
                                cout<<"无名对象生成"<<endl;
                                p.print();
                        }


//3-4
                   test test34(test p)
                   {
                           p.plus20();
                           return p;
                   }
                private:
                        int a;
                        int b;


        };
}




1、默认构造函数和无参构造函数
实际上默认构造函数就是什么都不做的无参构造函数，这个时候如果不初始化会私有变量的值会出现一些垃圾值
如：
test() //无参数构造函数
{
     cout<<"无参构造函数调用"<<" adress: "<<&a<<endl;
}
这样成员变量a和b就会出现垃圾值


调用时机：
test a; //1-1无参数构造函数调用test(),如果没有调用默认构造函数 


2、有参构造函数
如下都是有参构造函数：
test(int c_a,int c_b)//有参构造函数
{
        cout<<"有参构造函数调用"<<" adress: "<<&a<<endl;
        a=c_a;
        b=c_b;


}
test(int c_a)//有参构造函数
{      
        cout<<"有参构造函数调用"<<" adress: "<<&a<<endl;
        a=c_a;
}


调用时机：
test b(1,2);//2-1有参构造函数调用test(int c_a,int c_b)
b.print();
test c = (100,100);//2-2有参构造函数调用100，100后面的这一个100忽略，逗号表达式，调用test(int c_a)
c.print();
test d = test(100,100);//2-3有参构造函数调用test(int c_a,int c_b),先生成一个匿名对象 然后被赋予给d，只调用一次构造和析构函数
d.print();


3、COPY构造函数(也叫赋值构造函数)
如下：
test(const test &m) //copy 构造函数
{
        cout<<"copy构造函数调用"<<" adress: "<<&a<<endl;
        a = m.a;
        b = m.b;
}
copy构造函数调用时机有4种其中有2个难点就是，将对象作为实参和对象作为返回值的时候
调用时机：
3-1：用其他对象初始化赋值操作
        test e = b;//3-1copy构造函数调用test(const test &m)，用b对象来初始化e 注意是初始化而不是等号操作
        e.print();
3-2：使用COPY构造函数原型，实参为其他对象
        test f(d);
        f.print();//3-2copy构造函数调用test(const test &m)，用d对象来初始化f
3-3：难点作为函数实参，会生成匿名对象
        f.printany(d);//3-3copy构造函数调用test(const test &m)，用d对象来初始化一个匿名对象，这个匿名对象在printany函数生命周期中使用，然后析构掉
3-4：难点作为函数返回值，会生成匿名对象，当作为返回值的时候匿名对象又要考虑到如何去接这个返回值分3种如下
        d.test34(d);//3-4 调用了2次copy构造函数，第一个匿名对象是传值对象d和上面一样肯定生命周期完成要析构掉，第二次是return p返回一个匿名对象，最后调用函数无接就析构掉
。
        test m = d.test34(d);//3-5 调用了2次copy构造函数，第一个匿名对象是传值对象d和上面一样肯定生命周期完成要析构掉，第二次是return p返回一个匿名对象，最后用于初始化
，因为匿名对象内存已经分配，就直接用匿名对象的内存给对象m即可，它的析构随m的使用完成而析构，避免不必要的内存分配和析构提高性能
        m.print();
        c = d.test34(d); //3-6 调用了2次copy构造函数，第一个匿名对象是传值对象d和上面一样肯定生命周期完成要析构掉，第二次是return p返回一个匿名对象，虽然有接，但是这个
使用等于符号重载操作，因为c已经有了内存空间，那么也会及时析构掉
        c.print();


总结：实际上构造函数调用一定要分清是否是初始化和等号操作，等号操作调用的是操作符重载，而初始化是要考虑到内存空间的分配的，我们的构造行数都是在初始化的时候调用的。
     关于匿名对象需要考虑到内存分配，比如作为实参C++编译器自然要生成一个匿名对象在函数生命周期中使用，完成后自然要析构掉，如果作为一个返回值，自然也要生成一个匿名
     对象，关键是看你如何去接，如果初始化方法去接这个匿名对象的内存将会被"转正"，如果不接受或者不是初始化则析构掉，因为没有用了。
     
下面是全部的测试代码以及注释
</endl;
</endl;
</endl;
</endl;
</endl;
</endl;
</endl;
</a_g<<endl;
</endl;
</a<</endl;
</endl;
</endl;
</endl;