c++04

this指针

#include
using namespace std;

//空类的对象占1个字节
//类中的成员变量 创建对象时才存在 每个对象都有自己独立的一份
//类中的成员函数 编译期存在 只有一份 每个对象都可以使用
//this 指针 关键字 指向当前调用本成员函数的对象
//this指针只能在成员函数（非静态）中使用

class AA
{
public:
	int a;
	char b;
	//有对齐
public:
	void Show(/*  AA* const this  *//*int a*/)
	{
		cout << this->a<<"  "<b << endl;
		/*this->a = a;*/
		//在函数里可以将成员变量看成全局变量 参数看成局部变量 当同名时 优先识别局部变量 所以给成员函数赋值用到this指针
		/*this++;*/
		//this 不可以改
	}
	//不占用对象的空间
};
class BB
{
public:
	void Show()
	{
		cout << "BB" << endl;
	}
};


int main()
{
	AA a;
	a.a = 100;
	a.b = 'a';
	a.Show();
	AA b;
	b.a = 200;
	b.b = 'b';
	b.Show();
	cout << sizeof(a) << endl;
	

	/*BB b;
	cout << sizeof(BB) << endl;*/

	system("pause");
	return 0;
}

拷贝构造

#include
using namespace std;
//不能在类中定义本类的对象
//类中含有一个默认的拷贝构造函数  只有一个参数 本类类型的引用的构造函数
//什么情况下会调用拷贝构造
//1.用一个对象初始化另一个对象时
//2.类对象作为函数参数时
//3.函数返回值为类对象时 用局部对象初始化临时对象
class AA
{
public:
	int a;
public:
	AA() {};
	AA(const AA &a)  //本类的引用
	{
		this->a = a.a;
		cout << "AA COPY" << endl;
	}
};
void Show(AA a)//->形参
{
	cout << a.a << endl;
}
AA func()
{
	AA a;
	a.a = 200;
	return a;
}

int main()
{
	/*AA a;
	a.a = 100;
	
	Show(a);*///实参  函数调用 实参向形参赋值 实参初始化了形参 所以执行了拷贝构造
	
	
	
	对象的初始化
	//AA b = a;
	//AA c(a);
	//
	赋值
	//AA d;
	//d = a;

	/*cout << func().a << endl;*/
	//当返回值为类对象时 会先生成一个临时对象 并用局部对象初始化临时对象 所以执行了拷贝构造

	AA a = func();
	cout << a.a << endl;
	//执行了一次拷贝构造 只执行了局部初始化临时  没执行临时初始化main中对象
	system("pause");
	return 0;
}

浅拷贝深拷贝

#include
using namespace std;
//浅拷贝 将源对象的值拷贝到目标对象
//深拷贝 拷贝的时候先开辟一个与源对象成员空间大小一样的空间 然后再将空间中的内容赋值过来
class AA
{
public:
	int* p;
public:
	AA()
	{
		p = new int;
		*p = 100;
	}
	AA(AA &a)
	{
		p = new int;
		*p = *a.p;

	}
	~AA()
	{
		if (p != NULL)
		{
			delete p;
		}
	}
};

void Show(AA &a)   //用类的引用作为函数参数 避免浅拷贝问题 没执行拷贝构造
{
	cout << *a.p << endl;
}
int main()
{
	AA a;
	cout << *a.p << endl;
	/*AA b = a;
	cout << *b.p << endl;*/

	Show(a);



	system("pause");
	return 0;
}

静态成员

#include
using namespace std;

int a = 100;//全局变量 在别的文件中需要外部引用 extern
//static int a;   静态全局变量 在声明它的整个文件都是可见的，而在文件之外是不可见的
void Show();//只需声明一下就可以 在其他文件中实现

//全局变量 使用范围整个程序 在其他文件中使用要外部引用 extern
//静态变量 使用范围 在作用域内定义 本作用域内 在作用域外定义 当前文件可以使用

//静态成员变量 只有一份 所有对象共享
//静态成员要在类外初始化
//初始化的格式  类型 + 类名 + :: + 变量名
//静态成员变量必须要在类外初始化如果不赋值 默认初始化为0
//可以不用对象直接访问   类名:: + 变量名
//依旧遵循访问修饰符的约束
class AA
{
public:
	static int a;//在类中定义静态变量 需要在类外进行初始化
	int b;
public:
	void Show()
	{
		cout << a << "  " << b << endl;
	}
	static void Showshow();
};
int AA::a = 100;//类外进行初始化
void AA::Showshow()//静态成员函数类外实现
{
	cout << a /*<< " " << b */<< endl;//不能使用普通变量 
}
//普通成员函数可以使用静态成员变量
//静态成员函数只能使用静态成员变量 不能使用普通成员变量
//静态成员函数没有this指针  所以找不到普通变量
int main()
{
	/*cout << ::a << endl;
	Show();*/

	AA a;
	/*a.a = 100;*/
	a.b = 200;
	a.Show();
	cout << sizeof(AA) << endl; //大小为4  存的是 int b
	AA b;
	b.b = 20;
	b.Show();

	system("pause");
	return 0;
}