类和对象

#include <iostream>
using namespace std;
 
class A
{
private:
    int a;
public:
    A(int i){a=i;}    //内联的构造函数
    A(A    &aa);
    int geta(){return a;}
};
 
A::A(A &aa)        //拷贝构造函数
{
    a=aa.a;
    cout<<"拷贝构造函数执行！"<<endl;
}
 
int get_a(A aa)        //③参数是对象，是值传递，会调用拷贝构造函数
{
    return aa.geta();
}
 
int get_a_1(A &aa)    //如果参数是引用类型，本身就是引用传递，所以不会调用拷贝构造函数
{
    return aa.geta();
}
 
A get_A()        //④返回值是对象类型，会调用拷贝构造函数。会调用拷贝构造函数，因为函数体内生成的对象aa是临时的，离开这个函数就消失了。所有会调用拷贝构造函数复制一份。
{
    A aa(1);
    return aa;
}
 
A& get_A_1()    //会调用拷贝构造函数，因为函数体内生成的对象aa是临时的，离开这个函数就消失了。所有会调用拷贝构造函数复制一份。
{
    A aa(1);
    return aa;
}
 
int _tmain(int argc, _TCHAR* argv[])
{
    A a1(1);
    A b1(a1);            //①用a1初始化b1，调用拷贝构造函数
    A c1=a1;            //②用a1初始化c1，调用拷贝构造函数
 
    int i=get_a(a1);        //③函数形参是类的对象，调用拷贝构造函数
    int j=get_a_1(a1);        //函数形参类型是引用，不调用拷贝构造函数
 
    A d1=get_A();        //调用拷贝构造函数
    A e1=get_A_1();        //调用拷贝构造函数
 
    return 0;
}

调用拷贝构造函数的四种时机：
1、A b1(a1); //①用a1初始化b1，调用拷贝构造函数 
2、A c1=a1; //②用a1初始化c1，调用拷贝构造函数
3、int i=get_a(a1);        //③函数形参是类的对象，调用拷贝构造函数　
4、A get_A()    //④函数的返回类型是对象
注意：

int get_a_1(A &aa)    //如果参数是引用类型，本身就是引用传递，所以不会调用拷贝构造函数

　　构造函数和析构函数的调用顺序：

　　　　1）当类中有成员变量是其它类的对象时，首先调用成员变量的构造函数，调用顺序与声明顺序相同；之后调用自身类的构造函数

　　　　2）析构函数的调用顺序与对应的构造函数调用顺序相反

#include <iostream>
using namespace std;

class A
{
    public:
        A(int &v) : i(v), p(v), j(v) {}
        void print_val() { cout << "hello:" << i << "  " << j << endl;}
    private:
        const int i;
        int p;
        int &j;
};

int main(int argc ,char **argv)
{
    int pp = 45;
    A b(pp);
    b.print_val();
}

#include <iostream>
using namespace std;

class Base
{
    public:
        Base(int a) : val(a) {}
    private:
        int val;
};

class A
{
    public:
        A(int v) : p(v), b(v) {}
        void print_val() { cout << "hello:" << p << endl;}
    private:
        int p;
        Base b;
};

int main(int argc ,char **argv)
{
    int pp = 45;
    A b(pp);
    b.print_val();
}

#include <iostream>
using namespace std;

class Base
{
    public:
        Base(int a) : val(a) {}
    private:
        int val;
};

class A : public Base
{
    public:
        A(int v) : p(v), Base(v) {}
        void print_val() { cout << "hello:" << p << endl;}
    private:
        int p;
};

int main(int argc ,char **argv)
{
    int pp = 45;
    A b(pp);
    b.print_val();
}

Constructor::Contructor() : m1(v1), m2(v1,v2), m3(v3)

{

    // some other assignment operation

}