对象

一.new 分配时会调用相应构造函数，malloc不会

    同理delete

    new T;  delete T;

    new T[]; delete[] T;

二.static变量属于类本身，不属于任何对象

    static函数只能访问static成员

#include<iostream>
using namespace std;

class A
{
public:
    static int s;
    static void ABC(){cout << 2 << endl;};
};
int A::s = 1;

int main()
{
    A a, *p = new A();
    cout << a.s << endl;//1
    cout << A::s << endl;//1
    cout << p->s << endl;//1
    cout << sizeof(A) << endl;//1

    a.ABC();//2
    A::ABC();//2
    p->ABC();//2

    return 0;
}

三.this（指向成员函数作用的对象）

this不能作为赋值，递增，递减只有在非static成员函数才有效

static成员函数不具体作用于某个对象，真实的参数个数就是程序中写出的参数个数

#include<iostream>
using namespace std;

class C
{
public:
    int a;
    void set(int p);
};
void C::set(int p)
{
    a = p;
}

int main()
{
    C c;
    c.set(200);
    return 0;
}

等价于
struct C
{
    int p;
};

void set(struct C *this, int p)
{
    this->p = p;
}

int main()
{
    struct C c;
    set(&c, 200);
    return 0;
}

#include<iostream>
using namespace std;

class A
{
    int i;
public:
    void h()
    {
        cout << "1";
    }
    /*
    void h(A *this)
    {
        cout << "1";
    }
    */
    void g()
    {
        cout << i << "hello";
    }
    /*
    void g(A *this)
    {
        cout << this->i << "hello";
    }
    */
};

int main()
{
    A *p = NULL;
    p->h();//ok, 1
    //p->g();error，空指针

    return 0;
}

四.若函数f中有一个对象参数obj标记为const，则在f中调用obj的任何非const成员都是错误的。

五.成员对象和封闭类

成员对象：一个类的成员变量是另一个类的对象

包含成员对象的类，叫封闭类

定义封闭类的构造函数时，添加初始化列表

类名::构造函数(参数表) :成员变量1(参数表), 成员变量2(参数表)
{

}

成员对象初始化列表中的参数：任意复杂的表达式，函数/变量/表达式中的函数，变量有定义

当封闭类对象生成时：执行所有成员对象的构造函数，再执行封闭类的构造函数

成员对象构造函数的调用顺序和成员对现在类中的说明顺序一致，与在初始化列表中出现顺序无关

封闭类对象消亡时，先执行封闭类的析构函数，再执行成员对象的析构函数

六.对象的内存分配

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

一个对象的某个成员变量被改变，不会影响其他对象

#include<iostream>
using namespace std;

class CSample
{
public:
    CSample()
    {
        cout << "1" << endl;
    }
    CSample(int n)
    {
        cout << "2" << endl;
    }
};

int main()
{
    CSample c1[2];//1 1
    CSample c2[2] = {4, 5};//2 2
    CSample c3[2] = {3};//2 1
    CSample *c4 = new CSample[2];//1 1
    return 0;
}

#include<iostream>
using namespace std;

class CSample
{
public:
    CSample()
    {
        cout << "1" << endl;
    }
    CSample(int n)
    {
        cout << "2" << endl;
    }
    CSample(int n, int m)
    {
        cout << "3" << endl;
    }
};

int main()
{
    CSample c1[3] = {1, CSample(1, 2)};//2 3 1
    CSample c2[3] = {CSample(1, 2), CSample(3, 4), 1};//3 3 2
    CSample *c4[3] = {new CSample(4), new CSample(1, 2)};//2 3
    return 0;
}

类中不能定义自身对象，可定义指针对象和引用对象

七.对象大小

空类同样被实例化，每个实例在内存中都有一个独一无二的地址，为达到这个目的

class A{};
sizeof(A);//1

class A{int a;};
sizeof(A);//4

class A
{
    A(int a)
    {
        this->a = a;
    }
    int a;
};
sizeof(A);//4

class A
{
    A(int a)
    {
        this->a = a;
    }
    virtual void x(){};
    virtual void y(){};
    int a;
};
sizeof(A);//8

虚函数表4个字节

sizeof(类)=sizeof(非static成员变量)+4*(有无虚函数?1:0)

class A
{
    virtual void x(){};
    int a;
};

class B: public A
{
    int a;
};

class C: public A, public B
{
    int a;
};

sizeof(B);//12
sizeof(C);//24 sizeof(C) = sizeof(A) + sizeof(B) + sizeof(C)