类和对象总结

1.面向对象和面向过程的区别

面向过程：代表性语言：C语言
面向对象：代表性语言：C++、java

面向过程可以理解为用函数将解决问题的一个个步骤都实现，在解决问题时一个个调用即可，这一个个步骤就组合起来就是解决整个问题的过程。
面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。

面向对象与面向过程的本质区别

2.类的定义方式

类内声明类内定义：

class test1
{
	int getNum()
	{
		return a;
	}

	int a = 0;
};

类内声明类外定义：

class test1
{
	int getNum();

	int a = 0;
};
int test1::getNum()
{
	return a;
}

带模板的类内声明类外定义：

template<typename T>
class test1
{
	void show();

	T a = 0;
};
template<typename T>
void test1<T>::show(T data)
{
	cout << data;
}

3.封装

封装：隐藏对象的属性和实现细节，仅对外公开接口和对象进行交互，将数据和操作数据的方法进行有机结合。

函数就是一种封装，将函数体的实现细节封装在函数中，可以调用函数，但是无法访问函数的实现细节。
就像电脑，电脑封装了各种电子元件、电线等，但我们对电脑开关机是不知道这些线路、电子元件怎么跑的，除非拆开研究。

C++的封装是由类加作用域限定符来完成，类的作用域限定符有：
public：公有
private：私有
protected：保护

1、public成员可以在类外直接访问。
2、protected和private成员在类外不能够访问，但是可以通过类内成员函数来访问类中的保护、私有成员。
3、class的成员默认权限是private，而struct的成员默认权限是public
4、定义一个类相当于定义了一个新的作用域。

4.类的实例化

类相当于是一张图纸，而对象则是由这张图纸构造出来的房子或者说产品，这就是类和对象的关系。

类是抽象的，只是限定了类中有哪些成员，定义了类并没有分配实际的内存来存储它。

可以对类使用sizeof()来求类所需空间的大小，对空类进行sizeof()会得到1，这是因为为了让类的实例之间是独一无二的，因此编译器会给空类插进一个char来获得不同的内存地址，以此标识类的不同对象。

class test1
{

};
int main()
{
	cout << sizeof(test1);//1
	return 0;
}

5.this指针

在类中的成员函数是可以访问类中的任何成员的，但是需要有一个this指针来标识自己要访问的是哪个对象的成员，在 C++ 中，每一个对象都能通过 this 指针来访问自己的地址。this 指针是所有成员函数的隐含参数。因此，在成员函数内部，它可以用来指向调用对象。

例如：

class test1
{
public:
	int sum(int a)
	{
		return this->a + a;
	}
	int a = 10;
};
int main()
{
	test1 test;
	cout << test.sum(5);//15
	return 0;
}

this指针的创建：
this指针在成员函数的开始执行前构造的，在成员的执行结束后清除。

this指针

this指针存在哪里：一般在ecx寄存器中，由编译器添加
this指针可以为空吗：可以（成员函数不需要this指针功能的时候）

this指针问题

6.类中八个默认成员函数

6.1 构造函数

6.2 析构函数

6.3 拷贝构造函数

6.4 赋值运算符重载函数

6.5 取地址运算符重载函数

6.6 const取地址运算符重载函数

6.7 移动构造函数

6.8 移动赋值运算符重载函数

7.const类型成员

8.static类型成员

9.友元

友元提供了一种突破封装的方式，一般用friend +函数声明/类声明来实现友元。

9.1 友元函数

友元函数就像类的朋友一样，可以直接访问类的私有成员，但友元函数不属于类，需要在类内声明，类外定义。

class test1
{
public:
	friend void show(test1 * p);
private:
	int a = 10;
};

void show(test1 * p)
{
	cout << p->a;
}
int main()
{
	test1 test;
	show(&test);//10
	return 0;
}

友元函数特性：

1、友元函数可访问类的私有和保护成员，但不是类的成员函数
2、友元函数不能用const修饰
3、友元函数可以在类定义的任何地方声明，不受类访问限定符限定
4、一个函数可以是多个类的友元函数
5、友元函数的调用与普通函数调用原理相同

9.2 友元类

友元类也和友元函数相类似，友元类中的所有成员函数都是另一个类的友元函数，都可以访问其私有成员

友元关系是单向的，不具有交换性(我把你当朋友，你不把我当朋友）

友元关系不能传递（我朋友的朋友不是我的朋友）

class A
{
	friend class test1;
private:
	int a = 5;
};
class test1
{
public:
	void show(A * p)
	{
		cout << p->a;
	}
private:
	int b = 10;
};

int main()
{
	test1 test;
	A a;
	test.show(&a);//5
	return 0;
}

9.3 内部类

如果一个类定义在另一个类的内部，就称之为内部类

class test1
{
public:
	static int b ;
	class B
	{
		void show()
		{
			cout << b;//10
		}
	};
private:
	int a = 0;
};
int test1::b = 10;

1、内部类就是外部类的友元类。

2、内部类可以直接访问类中的static，枚举成员，不需要外部类的对象/类名

3、sizeof（外部类） == 外部类的大小，和内部类没有任何关系

4、内部类可以定义在外部类的public、protected、private都是可以的。

如果内部类定义在public，则可通过 外部类名::内部类名 来定义内部类的对象。
如果定义在private，则外部不可定义内部类的对象，这可实现“实现一个不能被继承的类”问题。