一、类

1、类就是C语言里面的结构体

2、函数放在结构体里面和外面，区别是需要用结构体变量(变量就是c++中的对象)调用，结构体大小没有发生改变

3、调用结构体函数时，就算一一个参数都不传递，汇编层面会传递一个结构体首地址的参数

4、封装就是将函数放在结构体里面

5、this指针是为了区分成员与参数同名，或者是获取结构体首地址

二、构造函数

1、函数(方法)不能写返回值

2、函数(方法)要与结构(类)名一样

3、初始化对象用的(创建一个变量(对象)就调用了)

4、构造函数可以有多个

5、重载函数判断依据是参数的个数和类型不一样就可以

#include "stdafx.h"

struct Test
{
	int age;
	int level;
        //构造函数
	Test(int age, int level)
	{
		this->age = age;
		this->level = level;

	}
        //重载构造函数
	Test()
	{
	}
        //成员函数
	void Print()
	{
		printf("%d %d",this->age,this->level);
	}
};

int main(int argc, char* argv[])
{
	
	Test p(1,2);
	p.Print();
	getchar();
	return 0;
}

三、析构函数

1、只能有一个析构函数，不能重载

2、不能带任何参数

3、不能带返回值

4、主要用于清理工作

5、编译器不要求必须提供

#include "stdafx.h"
#include "malloc.h"

struct Person			
{			
	int age;		
	int level;		
	char* arr;		
		
	Person(int age,int level)		
	{		
		printf("有参构造函数执行了...\n");	
		this->age = age;	
		this->level = level;	
		arr = (char*)malloc(1024);	
	}
	
	~Person()		
	{		
		printf("析构函数执行了...");	
		free(arr);	
		arr = NULL;	
	}
	
	void Print()		
	{		
		printf("%d-%d\n",age,level);	
	}		
};			

void Test()
{
	Person p(1,2);
	p.Print();
}

int main(int argc, char* argv[])
{
	Test();
	getchar();
	return 0;
}

四、继承

1、继承就是数据的复制

2、减少重复代码的编写

3、Person 称为父类或者基类

4、Teacher、Student称为子类或者派生类

5、t和s可以称为对象或者实例

6、可以用父类指针指向子类的对象(但是不能访问子类成员)

#include "stdafx.h"

struct Person			
{			
	int age;		
	int sex;		
};			
struct Teacher:Person			
{			
	int level;		
	int classId;		
};			
struct Student:Person			
{			
	int code;		
	int score;		
};			

void Test()
{
	Student t;			
				
	t.age = 1;			
	t.sex = 2;			
	t.code = 3;			
	t.score = 4;			
			
	Person* pt = &t;
	printf("%d\n",pt->age);						
}

int main(int argc, char* argv[])
{
	Test();
	getchar();
	return 0;
}

五、多层继承

不推荐写法

#include "stdafx.h"
			
struct X			
{			
	int a;		
	int b;		
};			
struct Y:X			
{			
	int a;		
	int d;		
};			
struct Z:Y			
{			
	int e;		
	int f;		
};			
			
void Test()
{
	Z z;		
			
	z.X::a = 1;		
	z.b = 2;		
	z.Y::a = 3;		
	z.d = 4;		
	z.e = 5;		
	z.f = 6;		
			
	printf("%d\n",sizeof(z));		
					
}

int main(int argc, char* argv[])
{
	Test();
	getchar();
	return 0;
}

六、多重继承

不推荐写法

#include "stdafx.h"
					
struct X		
{		
	int a;	
	int b;	
};		
struct Y		
{		
	int a;	
	int d;	
};		
struct Z:X,Y		
{		
	int e;	
	int f;	
};		
		
void Test()
{
	Z z;	
		
	z.X::a = 1;	
	z.b = 2;	
	z.Y::a = 3;	
	z.d = 4;	
	z.e = 5;	
	z.f = 6;	
		
	printf("%d\n",sizeof(z));		
					
}

int main(int argc, char* argv[])
{
	Test();
	getchar();
	return 0;
}

七、public和private

不能编译，因为私有属性不能直接调用，需要在结构体内调用

#include "stdafx.h"					
		
struct Test		
{		
private:		
	int x;	
public:		
	int y;	
};		
		
int main(int argc, char* argv[])
{
	Test p;
	p.x = 10;
	return 0;
}

八、使用指针调用私有属性

• private修饰的成员与普通的成员没有区别 只是编译器会检测.

• private修饰的成员只要自己的其他成员才能访问

#include "stdafx.h"
										
struct Test				
{				
private:				
	int x;			
public:				
	int y;			
	void Init(int x,int y)			
	{			
		this->x = x;		
		this->y = y;		
	}			
};				
				
int main(int argc, char* argv[])
{
					
	Test t;			
	t.Init(1,2);			
				
				
	int* p = (int*)&t;			
				
	int n = *p;			
				
	int m = *(p+1);			
				
	printf("%d %d\n",n,m);			
	getchar();
	return 0;
}

九、class与struct的区别

1、class 默认是private，必须手动添加public才能访问

2、struct默认是public，直接就可以访问

3、class 继承需要手动添加如何继承，不添加默认是private继承，手动添加public，原来是public继承就是public，原来继承private，继承就是private

4、struct继承直接可以访问

十、私有属性继承

继承，相当于将父类的属性复制一份，但是编译器不允许我们使用私有的，但我们可以通过指针来调用

#include "stdafx.h"
			
class Base			
{			
public:			
	Base()		
	{		
		x = 11;	
		y = 12;	
	}		
private:			
	int x;		
	int y;		
};			
class Sub:Base			
{			
public:			
	int a;		
	int b;		
};			
			
int main(int argc, char* argv[])			
{			
	Sub sub;		
	sub.a = 1;		
	sub.b = 2;		
			
	int* p = (int*)⊂		
			
			
	printf("%d\n",sizeof(sub));		
	printf("%d\n",*(p+0));		
	printf("%d\n",*(p+1));		
	printf("%d\n",*(p+2));		
	printf("%d\n",*(p+3));		
	getchar();
	return 0;		
}