对象

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

[b] 同理delete[/b]

[b] new T; delete T;[/b]

[b] new T[]; delete[] T;[/b]

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

[b] static函数只能访问static成员[/b]

#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;
}

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

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;
}

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

[b]五.成员对象和封闭类[/b]

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

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

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

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

}

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

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

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

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

[b]六.对象的内存分配[/b]

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

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

#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;
}

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

[b]七.对象大小[/b]

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

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)