类

类的基本介绍

class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略。类体中内容称为类的成员：类中的变量称为类的属性或成员变量;类中的函数称为类的方法或者成员函数。

class className
{
// 类体：由成员函数和成员变量组成
};  // 一定要注意后面的分号

对于类成员定义可以直接在类内部直接定义（声明与定义都放在类中），还可以使用类中进行声明，在类外部直接定义。但是在声明与定义分离时需要考虑定义时进行类名的限定。指定类名就是指定作用域。

class MyClass
{
	//直接定义
	int add(int a, int b)
	{
		return a + b;
	}
};
//
class MyClass
{
	//声明
	int add(int a, int b);
	
};
//定义
 int MyClass:: add(int a, int b)
{
	return a + b;
}

因为c++本身就兼容C语言，所以对于类可以看成是一个比较大的结构体，既然结构体中不能定义函数，类中可以定义函数。结构体定义后，对于使用结构体内部成员，可以直接进行访问。然而当我们定义一个类时，对于它类部函数或则成员直接访问时，会报错
在这里插入图片描述
这就涉及权限问题，c++为了更好保护使用结构体本身定义成员，所以对于默认类内部成员是私有权限，不能被外部所使用。所以使用类进行定义时，就需要自己进行权限设置，常见权限就是private（私有），protect（保护），public（公有）。需要进行关键字的限定成员的使用才会安全，一般比较常见就是private，还有public搭配使用。结构体struct内成员就是公有的。对于保护权限考虑一般在继承时会考虑基类和派生类继承后权限的问题。平时使用一般不会考虑。

类的实例化

类是一类对象的抽象，概括是比较宽泛。常见类有日期类，日期类对象就会实现日期的基本计算。实例化是就是由一个类实例化为一个具体的对象。类可以说就像是一张设计图，对象就好像是一个根据类设计出了一个实物。实例化出的对象占用实际的物理空间，存储类成员变量。需要计算类大小。

class memery
{
public:
int add(int a, int b)
	{
		return a + b;
	}
private:
	int* _a;
	int _b;
};

int main()
{


	memery M;
	cout << sizeof(memery) << endl;
	return 0;
}

在x86环境下，运行结果可就是8。可以看见类成员，有一个指针和一个int类型，还要一个函数体。可以猜测计算大小时并没有考虑类的成员函数。然后删除成员函数后，依旧是8。不会影响类的大小。所以可以说明成员函数实际是不在类中的。它存储在代码段。空类大小是1。这个1是为了来标记它出现过，用来占址。
在这里插入图片描述

对于不同对象访问同一个代码时时编译器为了区别对象，就给每一个对象一个this指针。但是在我们使用时不会用到，因为编译器会自己调用。C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量”的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

类的6个默认成员函数

如果一个类中什么成员都没有，简称为空类。
空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。

默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

在这里插入图片描述

构造函数

构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证每个数据成员都有一个合适的初始值，并且在对象整个生命周期内只调用一次。

简单说就是对于类成员初始化，建造一个初始化列表用来初始化数据。比如说数据结构常用的栈，在我们使用时一不小心就会忘记初始化。就会在后面使用栈时出现异常报错。所以构造函数就会直接被编译器直接使用，

 class Date
 {
  public:
 /*
 // 如果用户显式定义了构造函数，编译器将不再生成
 Date(int year, int month, int day)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 */
 
 void Print()
 {
 cout << _year << "-" << _month << "-" << _day << endl;
 }
  
  private:
 int _year;
 int _month;
 int _day;
 };

但是上面代码运行后会出现随机值。就是说内置类型不会处理，对于自定义类型就会调用无参的构造函数。所以内置类型定义时可以给缺省值。缺省值不是初始化。就像是去吃饭，自己已经准备好吃蛋炒饭，但是别人请你去吃了一份山珍海味。

总结：
1. 函数名与类名相同。
2. 无返回值。
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。

析构函数

析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

析构函数是特殊的成员函数，其特征如下：
1. 析构函数名是在类名前加上字符 ~。
2. 无参数无返回值类型。
3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构
函数不能重载
4. 对象生命周期结束时，C++编译系统系统自动调用析构函数

拷贝构造函数

拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。

拷贝构造函数实际是构造函数的重载，只有一个参数。

 Date(const Date& d)  //日期类

这里就会出现误区，比如

 Date(const Date d)

在传址传参，传址传参一直纠结，其实如果使用传值传参会出现一个无限递归出现，如果要进行传值传参就需要有参数，参数中又是一个需要进行参数来传递。就是套娃一直循环。当然在编译器中会直接报错。
在这里插入图片描述
使用场景

1、使用已存在对象创建新对象
2、函数参数类型为类类型对象
3、函数返回值类型为类类型对象

赋值重载

函数名字为：关键字operator后面接需要重载的运算符符号

//日期类
 Date& operator=(const Date& d)
 {
 if(this != &d)
       {
            _year = d._year;
            _month = d._month;
            _day = d._day;
       }
        
        return *this;
 }

参数类型：const T&，传递引用可以提高传参效率
返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
检测是否自己给自己赋值
返回*this ：要复合连续赋值的含义

在类中运算符重载需要直接进行参数-1。因为类中非静态成员函数都会有this指针。

静态成员

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化

class memery
{
public:
	memery()
	{
		_a = new int[12];
		cout << "this memey" << endl;
		_c++;
	}
	int
	~memery()
	{
		delete[] _a;
		cout << "~memery()" << endl;
	}
private:
	int* _a ;
	static int _c;
	const static int  _b = 0;
};
int memery::_c = 2;

静态成员不属于某个具体对象。属于整个类，属于全部对象。且受类权限限制。在使用时用过类名：：或者对象名.直接访问。静态成员函数可以说就是为了静态成员而定制的。

//计数创建了多少类
class memery
{
public:
	memery()
	{
		++_c;
		cout << "this memey" << endl;
		
	}
	~memery(const memery& d)
	{
	      _c++;
	}
	 static int get_static()
	{
		 return _c;
	}
	~memery()
	{
			_c--;
		cout << "~memery()" << endl;
	}
private:
	static int _c;
};
int memery::_c = 0;

友元

友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装。
在使用时通常讲究高内聚低耦合，所以会减少使用。

友元关键字friend 在类中声明函数是友元时，类中成员就可以使用类中成员。

内部类：概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。
内部类可以说是外部类的天生友元

注意：内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。
特性：
1. 内部类可以定义在外部类的public、protected、private都是可以的。
2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
3. sizeof(外部类)=外部类，和内部类没有任何关系。