【C++】类和对象

文章介绍：

类和对象是C++面向对象语言最重要的部分。
对于C语言，在考虑解决一个问题时，其思考过程是按照流程式地将步骤一一列出，在通过编写函数通过一个个阶段来解决问题。而C++不同，它解决问题是考虑的主体，也就是所谓的对象。
例如考虑司机将顾客载到目的地：
司机和乘客都做好出发准备 ——> XX地图做好导航 ——> 司机开车 ——> 到达目的地
C语言：会根据每一个阶段都编写相应的函数来解决问题。
C++ ： 司机 和 乘客 都分别作为一个对象，在各自的对象中，司机和乘客的各自特殊属性和行动都封装其中，等到遇上实际问题时，会分别实体化成一个具体的“人”，通过已经封装好的属性和行动控制这些“人”来解决。
从以上描述应该可以看出C语言和C++的解决思路的不同了吧。
而接下来的文章主要介绍相关知识。
请注意：这篇文章只是大致介绍类与对象中比较重要的入门知识，很多知识还需要补充，应该以后还会出相关文章以不断完善对这方面的了解。

类的定义：

在文章介绍中我说明了每一种对象中都有专门属性和行为，这种对象是由类给封装起来的。
说白了，是由类搭建好一种对象所需要的属性，再通过类进行实例化成每一个具体的对象。
比如司机是一个类，而其中的一个司机小明则是通过类的实例化所具体"创建"出来的一个人，小明是一个对象。

//大致模板：
class classname
{
	//成员变量和成员函数
	
};//这里要写分号，想一下，这里和C语言中的什么很像？

类的定义有两种方式：
主要是成员函数的定义在类内还是类外。
1、成员函数定义在类内：

class classname
{
	void fun(int x)
	{
		cout << x + 10 << endl;
	}

	int a;
	double b;
};

这种方式定义，编译器可能会将其当作内联函数使用。

2、成员函数定义在类外：
上面的定义方式不推荐，一般将类声明在类的头文件中，而成员函数实现在cpp文件中。

//classname.h
class classname
{
	void fun(int x);

	int a;
	double b;
};

//classname.cpp
void classname::fun(int x)
{
	cout << x + 10 << endl:
}

命名规则：

类名根据实际需求命名即可。
需要注意的是函数的形参和成员变量，它们可能出现命名冲突。

class Date
{

 void Init(int year)
 {
 	// 这里的year到底是成员变量，还是函数形参？
	year = year;
 }

 int year;
};

因此为了区分，在成员变量会进行修改，一般在变量名加上_来表明身份。

class Date
{

 void Init(int year)
 {
	_year = year;
 }

 int _year;
 //year_ 也可以
};

访问限定符：

C++有一个非常重要的特性，那就是封装。
在类中是这样体现的：**用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。**而这其中，类的访问限定符起了很大作用。

类的访问限定符有三个：

public //公有
protected //保护
private //私有

权限范围大小：public ——> protected ——> private

需要知道的特性：
1、public 所修饰的成员可以在类外被访问，而其它两种则需要通过类内的函数间接访问。
2、访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止如果后面没有访问限定符，作用域就到 } 即类结束。
3、 class的默认访问权限为private。

一种特殊的类：结构体

在C语言中，结构体中只允许写成员变量，不能写成员函数，但是在C++中却可以写。
这是因为在C++中将结构体当成了类来实现。

struct classname
{
 private:
	void init()
	{
		age = 10;
	]

	int age;
};

//在具体化时也不需要写struct
classname A;

但是，需要注意的一点的是：结构体的默认访问权限是public。

类的大小：

介绍完类的定义，访问权限以及特别的类——结构体后，让人不禁疑惑的是：类的大小究竟为多大？

有好几个疑惑点：
1、类中含有成员变量和成员函数，它们的大小是如何定义的？
2、程序是如何调用它们的？它们是否都是存放在内存中的同一块地方？

要想回答这个问题，首先是要知道C++把数据类型分为内置类型和自定义类型。

内置类型和自定义类型：

内置类型包含char/int/float/double以及指针类等数据类型，这些数据类型一般都已经知道所占的内存大小。
自定义类型一般是使用class/struct/union等我们自主定义的数据类型。

因此，结合C语言的基础可以知道内置类型以及只含有内置类型的类的大小，其中，只含有内置类型的类的大小可以由结构体内存对齐规则得出。

类的成员分布：

知道了内置类型以及只含有内置类型的类的大小，那如果是成员函数怎么办？它的大小是如何计算呢？
答案是，类的大小不包含成员函数。

类的存储也是分为成员变量和成员函数，其中，成员变量是保存在类当中，而成员函数是保存在一个公共的代码区。
需要注意的是，自定义变量若是一个类，那它的大小也是不包含成员函数。

每一个类对象都有其专属的成员变量。但对于成员函数而言，其就像工具一样，被放在公共的代码区中，这个工具可以被这个类的对象共同使用，不属于任何一个对象。

this指针：

成员函数，作为一个公共的工具被放在公共的代码区，那如果一个类对象想要调用这个函数，并且这个函数内部所使用的参数除了从外来传来的形参还有这个类对象内部的实参，那C++是怎么实现的呢？

class A
{
private:
	int a_ = 1;

public:
	int fun(int a)
	{
		return a + a_;
	}
};

int main()
{
	A a;
	int b = a.fun(5);//这个怎么实现？编译器怎么知道里面的a_是a中的成员变量？
}

事实上，这里面是含有一个内置隐式指针this.

//作为编译器，实际上会这么处理
	int fun(int a)
	{
		return a + a_;
	}

	int fun(A* this, int a)
	{
		return a + this->a_;
	}
	

this指针一般不允许显式实现，其本质是函数形参，是跟普通参数一样存在于函数栈帧中。也就是说，我们编写程序时不需要也不能为其添加this指针。

this指针作为空指针的情况：
通过这个例子应该可以更好地明白成员函数和成员变量的区别。

class B
{
public:
	void fun1(int a)
	{
		printf("%d", a);
	}
	void fun2(int a)
	{
		printf("%d", a + a_);
	}

private:
	int a_ = 1;
};

int main()
{
	B* p = nullptr;
	p.fun1(5);//正常运行
	p.fun2(5);//运行报错
}

为什么会出现这样的差异呢？
实际上，作为成员函数，都将this指针传入到函数里，只不过，这里的this指针是一个空指针。
p即使是一个空指针，但它仍然表示类B，因为成员函数的代码并不是放在具体的类对象中，而是放在一个公共的类代码区，于是可以正常调用成员函数。

//对于fun1，在调用函数后，函数内部不对this指针进行解引用，因此不报错。
//对于fun2，在调用函数后对this指针进行解引用，而this指针是空指针
printf("%d", a + this->a_);

类的功能：

类相比较于结构体，多了成员函数、this指针，还有6个默认成员函数，这些组成让类的使用更加便捷和广泛。

什么是默认成员函数？
默认成员函数就是用户在没有显式定义相应函数时，编译器就会默认生成的成员函数。
就是说，哪怕是一个空类，类中一定会有6个默认成员函数，以完成类对象从创建到销毁的全过程。

构造函数：

一个类对象需要构造函数来对一个类对象进行初始化，而不是创建一个类对象。

需要注意：

1、构造函数的函数名与类名相同。
2、没有返回值。
3、构造函数允许重构。
4、默认构造函数包括无参数和全缺省参数，且只能一个是默认构造函数。
5、如果是编译器自己写的默认构造函数，一般来说，对于内置类型不做处理（有个别编译器会将其初始化），对于自定义类型会调用其构造函数。

什么时候需要写构造函数？

一般情况下，最好都要写上构造函数，防止某些成员变量因为未初始化而发生意外错误。
那需要在什么情况下才不需要写构造函数？
1、内置类型已经有了符合实际需要的缺省值。
2、自定义类型都已经定义了符合实际需要的构造函数。

析构函数：

与构造函数相反，析构函数是用来在类对象进行销毁时，对类对象的资源进行清除，并不是对类对象本身的销毁。

需要注意：

1、析构函数与构造函数类似，不需要返回值，函数名是在类名前加上 ~。
2、析构函数不允许重载，不允许有参数。
3、在类对象的生命周期结束时，编译器会自动调用析构函数。

什么时候需要写析构函数？

在类中需要申请动态资源的情况下都要写析构函数来自主释放资源，否则发生内存泄漏。

class test
{
public:
	test()
	{
		_a = (int* )malloc(sizeof(int) * 10);
	}

	~test()
	{
		free(_a);
		_a = nullptr;//将_a动态申请到的空间返回给系统
	}

private:
	int* _a = nullptr;
};

那什么时候不需要写析构函数？
1、没有动态申请资源的类。
2、类中的自定义类型都已经定义好了析构函数。

拷贝构造函数：

能不能将一个对象拷贝复制到另一个对象中？
那就是拷贝构造函数需要实现的内容了。

需要注意：

1、拷贝构造函数是特别的构造函数，准确地说，拷贝构造函数是构造函数的重载形式之一。
2、函数名与类名一致，但参数是也只能是该类对象的引用，一般还要使用const修饰。否则会发生无穷递归调用。

3、如果没有显式定义拷贝构造函数，那编译器就会生成默认拷贝构造函数，是按照内存存储字节序来进行拷贝，也称为值拷贝或浅拷贝。

什么时候需要拷贝构造函数？

首先要清楚的是，对于大部分内置类型而言，可以实现值传递，而自定义类型就必须使用拷贝构造函数。
对于指针类的数据类型，我们需要的类对象应该是两个构造一样但在内存存储不同位置的两个对象，如果只是使用值传递，那么两个对象的指针指向同一个地方，无法做到独立运行。
而且，更危险的是，一旦对象的生命周期结束，调用析构函数会将同一个地方连续释放两次空间，这会引起程序崩溃。

因此，在使用拷贝构造函数对需要开辟动态内存空间的行为需要额外关注。

class Data 
{
public:
	//构造函数
	Data(int year, int mouth, int day)
	{
		_year = year;
		_mouth = mouth;
		_day = day;
	}

	//构造函数的重载
	Data(int year, int mouth, int day = 10)
	{
		_year = year;
		_mouth = mouth;
		_day = day;
	}

	//析构函数
	~Data()
	{
		_year = 0;
		_mouth = 0;
		_day = 0;
	}

//拷贝构造函数
	Data(const Data& data)
	{
		_year = data._year;
		_mouth = data,_mouth;
		_day = data._day;
	}

private:
	int _year;
	int _mouth;
	int _day;
};

赋值重载函数：

复制重载函数主要用于将一个对象赋给另一个对象，其与拷贝构造函数不同在于：复制重载函数是两个已经初始化的对象之间的行为，拷贝构造函数是将一个已经初始化的对象赋给即将初始化的对象。

另外还有区别：
拷贝构造函数的本质是构造函数，而复制重载函数的本质是运算符重载。

运算符重载：

C++的一个重要变化是引入了运算符重载，运算符重载是具有特殊函数名的函数，它可以令已存在的运算符可以实现不同数据类型的操作数，而不只是受限于C语言中的内置类型。可以通过运算符重载大大提高代码的可读性。

需要注意的点：

1、函数原型：返回值类型 operator操作符(参数列表)。

Data operator+(int day);//定义在Data类中

2、operator连接的操作符一定是已经存在的操作符，而不是随便一个符号从而组成的一个新操作符。
3、运算符重载的参数其中有一个参数必须是类类型参数。
4、运算符重载的参数个数和运算符原本的操作数的个数相等，如果运算符重载被定义在类中，则编译器会自动在第一个参数位置加上this指针充当类类型参数，于是看上去就少一个参数。
5、对于已经实现的内置类型的运算符，不可以进行运算符重载以改变其原本含义。
6、有以下操作符不能进行运算符重载：

.       .*    ?:     ::   sizeof

赋值运算符重载：

格式：
1、类型引用 operator=(const 类型引用)。
2、如果要想实现连续赋值，返回类型要写成类型引用，以提高传参效率。
3、与拷贝构造函数一样的情况，在参数上使用const 类型引用，这样才能避免函数的无限递归调用。
4、在具体实现上，还要考虑能不能自我赋值。

关于赋值运算符需要特别注意的事情：

1、赋值运算符的重载只能在类的范围里进行，不能当成全局函数。
2、与拷贝构造函数类似，在没有显式定义的情况下，编译器会生成默认的赋值重载函数。
3、在默认重载函数中，是按照值方式逐字节拷贝，也就是值拷贝。而内置类型通过值传递赋值，自定义类型需要调用内部的赋值重载函数进行赋值。

取地址重载：

主要是普通对象和const对象取地址，这两个很少需要自己实现。

//对普通对象取地址
Date* operator&()
{
	return this;
}

//对const对象取地址
const Date* operator&()const
{
	return this;
}

需要注意的是，由于取地址符&的操作数只有一个，因此在函数列表上只能写上一个形参，但在类中重载的函数默认有一个类对象形参，因此在对const对象进行重载时，不仅考虑上述事项，还需要标识要引入的类对象是const对象，因此在（）的后面补上const来表明引入的是const对象。

初始化列表：

对于类而言，由于构造函数的存在，在创建类的时候，会自动调用构造函数来对成员变量进行赋值，但那个并不是初始化，因为在构造函数中，可以对同一个成员变量进行多次赋值，因此这被称为赋值而不是初始化。
我们想真正做到初始化，并且对于某些特殊成员而言，只能在初始化中才能完成。

语法：

以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个“成员变量”后面跟一个放在括号中的初始值或表达式。

Data(int year, int mouth, int day)
	: _year(year)
	, _mouth(mouth)
	, _day(day)
{
	
}

需要注意：

1、每个成员变量在初始化列表中只能出现一次。
2、当类中包含：引用成员变量，const成员变量、自定义类型成员（该类没有默认构造函数时），必须使用初始化列表。
3、最好一直使用初始化列表，对于自定义类型成员。一定会使用初始化列表。
4、初始化列表的顺序最好是和成员变量的声明顺序一致，因为声明顺序就是其在初始化列表中的初始化顺序，与在初始化列表中的顺序无关。反而，如果前后的变量有联系的话，会将未初始化的变量值赋给另一个变量，造成不必要的错误。

explicit关键字：

构造函数不仅可以构造与初始化对象，针对单个参数或者是除第一个参数无默认值其余均有默认值的构造函数，还具有阻止类型转换的作用。

1、
Data(int year)
	: _year(year)
{

}

2、
explicit Data(int year)
	: _year(year)
{

}

int main()
{
	Data d1(1999);
}

对于1而言，在调用构造函数时，其实是编译器先创建一个临时类对象，再将这个对象赋给d1。

但是如果是2，由于有explict的限制，会报编译错误。

友元：

在一些情况下，需要在类外定义函数，但又需要访问类中变量，此时需要友元来解决。比如输出流符<<的重载，cout的输出流对象和隐含的this指针在抢占第一个参数的位置，因此需要将重载函数定义在类外。

分类：

友元分为两种，一种是友元函数，另一种是友元类。
从上述中可以知道，友元事实上破坏了类的封闭性，增加了程序的耦合度，友元是不应该多用的。

友元函数：

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类中的内部声明，声明需要加friend关键字。

class Data 
{
	//友元函数声明
	friend ostream& operator<<(ostream& _cout, const Data& d);
public:
	//构造函数
	Data(int year, int mouth, int day)
	{
		_year = year;
		_mouth = mouth;
		_day = day;
	}


private:
	int _year;
	int _mouth;
	int _day;
};

//在类外定义，因为进行了友元函数声明，因此对于该函数而言可以直接以成员函数的写法来访问成员变量
ostream& operator<<(ostream& _cout, const Data& d)
{
	cout << d._year << "-" << d._mouth << "-" << d._day;
	return _cout; 
}

说明：

1、友元函数的声明可以在类内部任意一处进行，而且可以在多个类中可以进行声明，也就是说，一个函数可以是多个类的友元函数，但又不是类的成员函数。
2、友元函数不能用const修饰。
3、在实际调用时，友元函数和普通函数的调用原理相同。

友元类：

class Data 
{
	//友元类声明
	friend class Person;
public:
	//构造函数
	Data(int year, int mouth, int day)
	{
		_year = year;
		_mouth = mouth;
		_day = day;
	}


private:
	int _year;
	int _mouth;
	int _day;
};

class Person
{
public:
	Person(int year)
		: _year(year)
	{
	}

	setDataYear()
	{
		A._year = _year;
	}
private:
	int _year;
	Data A;
}

说明：

1、友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
2、友元关系不能传递。
3、友元关系不能继承。

内部类：

类A定义在另一个类B的内部，类A称为类B的内部类。

class Data 
{
public:
	//构造函数
	Data(int year, int mouth, int day)
	{
		_year = year;
		_mouth = mouth;
		_day = day;
	}

	class Person
	{
	public:
		Person(int weight)
			: _weight(weight)
		{
		}

		getInf(const Data& a)
		{
			_year = a._year;
			_weight = weight;
		}
		
	private:
		double _weight;
		int _year;
	};

private:
	int _year;
	int _mouth;
	int _day;
	static double weight = 1;
};

说明：

1、内部类就是外部类的友元类，但是一个独立的类，外部类对内部类没有访问特权。
2、内部类可以定义在外部类的public、protected、private都是可以的。
3、内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
4、内部类的大小不算入外部类中。

匿名对象：

匿名对象就是构建一个不带名字的对象，其生命周期就一行，读完语句后就会启动析构函数进行销毁。

Data();

有时候使用匿名对象是为了使用类中成员函数。

编译器优化：

纵观类的多个默认成员函数，大部分情况下都要返回值和传参，除非使用引用，否则在传递过程中需要先创建临时对象再进行传递，这样十分耗费时间。因此，一些编译器会做出相应的优化。

class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		
	}

	A(const A& aa)//这里要使用const，因为临时变量具有常性
		: _a(aa._a)
	{
		
	}

private:
	int _a;
};

void f1(A aa)
{
	
}

A f2()
{
	A aa;
	return aa;
}

int main(）
{
	//隐式类型，连续构造+拷贝构造->优化为直接构造
	f1(1);

	//一个表达式中，连续构造+拷贝构造->优化为一个构造
	f1(A(2));

	//一个表达式中，连续拷贝构造+拷贝构造->优化为一个拷贝函数
	A aa2 = f2();

	//一个表达式，连续拷贝构造+赋值重载->无法优化
	aa1 = f1();
}