c++程序设计笔记（2）

对象的内存空间：

     对象的大小=所有成员变量的大小之和

     例如，一个对象中有两个int类型的变量，那么该对象的大小sizeof(thisobject)=8两个int的大小（8字节）

访问类的成员变量和成员函数：

     1、对象.成员变量/成员函数

     2、指针->成员名

          CRectangle r1,r2;

          CRectangle *p1 = &r1;

          p1->w;（注意：没有*号了）

      3、引用.成员名（等价于对象.成员名）

重载：

     相同的函数名，不同的参数列表（参数的个数，参数的类型），只有返回类型不同的不能算重载。

     在对使用了缺省参数的函数进行重载的时候要避免重载时的二义性void value(int v = 0){x=v;}和int value(){return x;}调用的时候不能确定是哪个函数

构造函数：

     1、名字与类名相同，可以有参数，但不能有返回值（void也不行）

     2、作用是对对象进行初始化

     3、定义类时没有写构造函数，会调用默认的构造函数，但默认的构造函数不做任何操作。

     4、对象生成时构造函数被自动调用，一旦对象生成完毕就再也不能在其上执行构造函数。

     构造函数在数组中的使用：

          CSample array2[2]={4,5}调用带参数的构造函数，且第一个构造函数的参数为4，第二个构造函数的参数为5

class A{

    int n;

    int m;

public:

    A(){}

    A(int a){

        n = a;

        cout<<"func 1"<<endl;

    }

    A(int a,int b){

        n = a;

        m = b;

        cout<<"func 2"<<endl;

    }

};

A a[ 2]={ 1,A( 1, 2)};

A * p[ 2] = { new A( 1), new A( 1, 2)};

          A * p[2]是一个指针数组，不是一个对象数组，在没有new之前是不会调用构造函数的

初始化列表：

     初始化的一种方式，不用=赋值，而是A(int a,int b):n(a),m(b){}，用括号中的值为变量进行初始化

复制构造函数：

     1、只有一个参数，即同类对象的引用

     2、X::X(X&) 或 X::X(const X &)，后者只能以常量对象作为参数

     复制构造函数起作用的三种情况：

     1、当用一个对象去初始化同类的另一个对象时

A b(1,2);

A c = b;此处是初始化(调用的是复制构造函数)

          

A b(1,2);

A c ;

c = b;此处是赋值（调用的是操作符的重载）

       2、如果某函数有一个参数是类A的对象，那么该函数被调用时，类A的复制构造函数将被调用。

class  A{
public:
    A(){}
    A( A & a){
        cout << "copy constructor" <<endl;
    }

};

void func( A a1){}

int main() {

    A a2;
    func(a2);
    return  0;

}

          由于复制构造函数是自己指定的，因此形参a1的值不一定等于实参a2的值，默认的复制构造函数是会执行复制的工作的。

        3、如果函数的返回值是类A的对象时，则函数返回时，A的复制构造函数被调用。

class A{

public:

    A(){}

    A(A & a){

        cout<<"copy constructor"<<endl;

    }

};

A func(){

    A b;

    return b;

}

int main() {

    func();

    return 0;

}

          不同的编译器会有优化措施，导致没有输出结果，visual stdio可以

类型转换构造函数：

     目的：实现类型的自动转换

     形式：

          1、只有一个参数

          2、不是复制构造函数

class A{

public:

    double real,image;

    A(){}

    A(int i){

        cout<<"int constructor"<<endl;

        real = i;

        image = 0;

    }

};

int main() {

    A a1;

    A a2 = 12;//调用类型转换构造函数但没有临时对象生成

    a1 = 9;//调用类型转化构造函数，9被自动转换成临时A对象

    return 0;

}

          不同的编译器对类型转换构造函数会有优化措施，g++下初始化处编译不通过，赋值可以正常输出，visual stdio都正常输出

析构函数：

     作用：对象消亡前的善后工作（释放分配空间），自动被调用。定义类时没写析构函数编译器生成缺省析构函数，但缺省的析构函数不做任何事情。

     1、成员函数的一种

     2、名字与类名相同

     3、名字前有’~’

     4、没有参数和返回值（构造函数有参数但没有返回值）

     5、一个类最多只有一个析构函数

class A{

public:

    double real,image;

    A(){}

    A(A & a){

        cout<<"copy constructor"<<endl;

    }

    A(int i){

        cout<<"int constructor"<<endl;

        real = i;

        image = 0;

    }

    ~A(){

        cout<<"destructor"<<endl;

    }

};

int main() {

    A a1;

    a1 = 9;

    return 0;

}

          输出结果：int constructor

destructor

destructor

          a1 = 9时会生成一个临时的对象，该对象赋值完后消亡。第二次消亡发生在return时