C++类相关知识

鸽了好久，回来更新下吧

C++类

类用于指定对象的形式，是一种用户自定义的数据类型，它是一种封装了数据和函数的组合。类中的数据称为成员变量，函数称为成员函数。类可以被看作是一种模板，可以用来创建具有相同属性和行为的多个对象。

C++类的定义

定义一个类需要使用关键字 class，然后指定类的名称，并类的主体是包含在一对花括号中，主体包含类的成员变量和成员函数。

定义一个类，本质上是定义一个数据类型的蓝图，它定义了类的对象包括了什么，以及可以在这个对象上执行哪些操作。

C++访问限定符

访问限定符:public(共有)、private(私有)、protected(保护)

访问限定符说明

1.public修饰的成员在类外可以直接被访问

2.protected和private修饰的成员在类不能直接被访问

3.访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止

4.如果后面没用访问限定符作用域到}类结束

5.访问限定符只在编译时有用，当数据映射到内存时，没用任何访问限定符上的区别

 面向对象的三大特性

封装、继承、多态

封装更加严格管理设计

在类里面定义的函数默认是inline

短小函数可以直接在类内定义，长一点的函数声明和定义分离

用类类型创建对象的过程，称为类的实例化

类的大小计算的是变量类型的内存对齐大小

类内的变量存在类中，类内的函数存在公共代码段中

当类中仅有函数或者空类，那么大小是1，给他们分配1byte的空间表示他们存在过。

不同对象调用同一函数为什么会出现不同的结果？

因为编译器会做处理，把对象的地址传给函数，函数就能执行不同对象的内容

结构体怎么对齐？

第一成员在与结构体偏移量为0处的地址处，其他成员变量要与自身类型的整数信地址对齐，结构体大小与最大类型的整数信对齐，嵌套的结构体对齐到自己最大对齐数的整数信，结构体大小时所有对齐数的整数信。

为什么要进行内存对齐？

1.平台原因（移植原因）不是所有硬件平台都能访问任意地址上的任意数据、

2.性能原因：对于访问未对齐的内存，处理器需要再次访问（需要访问两次）而对齐的内存处理器只需要访问一次

如果指定结构体的对齐参数

pragram pack（指定对齐参数）

什么是大小端？

在内存中存储字节的两种方式

将低序字节存储在起始地址称为小端

将高序列字节存储在起始地称为大端

this指针存在哪里？

this指针参数存在寄存器或栈中

this指针可以为空吗？

可以为空，当我们调用函数，函数内部不需要this，不用通过this指向当前对象，并且对其操作时，才可为空。

类的6个默认成员函数

如果一个类中什么成员都没有，简称空类，任何一个类在什么都不写的情况下，会自动生成六个默认成员函数

1.构造函数 完成初始化工作

2.析构函数 完成清理工作

3.拷贝构造 使用同类对象初始化创建对象

4.赋值重载 主要把一个对象赋值给另一个对象

取地址重载

5普通对象

6const对象取地址

1.构造函数

构造函数时特殊的成员函数，需要注意的是，构造函数虽然名叫构造，但是构造函数主要任务并不是开空间创建对象，而是初始化对象，不传参就可以调用，都叫默认构造函数

1.函数名与类名相同

2.无返回值

3.对象实例化时编译器自动调用对应的构造函数

4.构造函数可以重载

无参构造 例如 Date d1;

有参构造 例如 Date d1(2023，8.27)

 当我们不写构造函数，编译器会默认生成一个构造函数

内置类型/基本类型 int/char/double/指针

自定义类型 class/struct/定于类型对象

默认生成的函数构造对内置类型/基本类型不做处理，对自定义类型成员变量才会处理

总结：如果一个类的成员全是自定义类型，用默认构造，如果有内置类型成员，或者要传参初始化，就用自己实现的构造函数（大多数都是自己实现）

析构函数

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

1.析构函数名实在类名前加上~

2.无参数无返回值

3.一个类有且只有一个析构函数，若未显示，系统会自动生成默认的析构函数，（与构造函数相同，1.内置类型不做处理，自定义类型会去调用自定义类型的析构函数）

4.对象声明周期结束时，c++编译器系统自动调用析构函数，一般用来内存释放，指针置空

s1先构造，s2后构造

那么析构时为s2先析构，s1后析构

构造与析构相反

拷贝构造

只有单个形参，该形参是对类型对象的引用，一般用const修饰在用已之存在的类类型对象创建新对象时由编译器自动调用

1.拷贝构造函数是构造函数的一个重载方式

2.拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用，因为传值，传的是对象，传值是需要拷贝一份再传给函数，这时传对象，拷贝对象，又间接调用了拷贝函数，再传对象，再拷贝，无限循环 Date（const Date& a) 加const更加安全

3.内置类型的成员会完成值拷贝，浅拷贝，自定义类型，去调用自定义类型成员的拷贝构造

一个类对象传值给另一个类对象，必须使用拷贝构造函数，用拷贝构造函数时，会有些特殊场景，出现深浅拷贝问题（析构函数，重复释放同一块内存，导致越界，出现崩溃现象）

（这边再详细讲下细节，实际深浅拷贝问题，拷贝构造是浅拷贝，而当一个对象中有程序员new的空间时，再使用默认拷贝构造，就造成了两个对象公用了同一块空间，而当析构时，要析构，两个对象都要调用，就造成了两次析构空间，造成了越界问题，就造成了运行崩溃，解决方法很简单，只需要让两个对象的空间拥有自己的空间，而不是公用问题，即可解决）

结论：一般的类自己生成的拷贝构造就够用了，只有需要自己管理的资源，需要自己实现深拷贝。

赋值运算符重载

运算符重载一函数

函数名operator 运算符

返回值：运算符运算后结果

.*、::、sizeof、？:、.、五个符号不支持重载

建议成员函数中不修改成员变量的成员函数都加上const

普通对象与const对象都可以调用

const对象可以调用非const成员函数吗？

不可以，权限放大

const成员函数内可以调用其他的非const成员函数吗？

不可以，权限放大‘

非const成员函数内可以将调用其他的const成员函数吗？

可以，权限缩小

总结：const不可以调用非const，非const可以调用const

初始化列表

初始化列表可以认为就是对象的成员变量定义的地方，初始化列表只能初始化一次，而构造函数体内可以多次赋值

有些变量只能在定义时初始化

格式 已:冒号开始，逗号分隔，每个成员变量后面跟着一个放在括号中的初始值或表达式

1.每个成员变量在初始化列表只能出现一次（初始化只能初始化一次）

2.类中包括以下成员，必须在初始化列表位置进行初始化

1.引用成员变量

2.const成员变量

3.自定义类型成员（该类没用默认构造函数）

其他的变量既可以在初始化列表初始化，也可以在函数体内初始化

总结：建议尽量在初始化列表初始化

全局函数不具有this，static函数不具有this，友元函数不具有this

成员变量在类中声明次序就是其在初始化中的初始化顺序，与其在初始化列表中的先后次序无关

Date d1=2020 这个过程为隐式类型转换

构造函数对于单个参数的构造函数，还具有类型转换的作用。

用2020构造一个无名的Date对象，最后用无名对象给d1赋值

Date& d2=2020 X

2020转换成无名Date类型，生成临时变量，被d2引用，而调用时变量具有常性，所以要加const

const Date& d2=2020

用explicit修饰构造函数，就会禁止单构造函数的隐式转换

静态成员变量 static

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

静态成员在类内声明，在类外定义

所有对象都可以访问静态成员（这里的静态成员要开放公有，否则无法直接访问）

静态成员变量时存储在静态区的，不属于某个对象某个类

特性

静态成员为所有类对象所共享，，不属于某个具体的实例

静态成员变量必须在类外定义，定义时不添加static关键字

类静态成员即可用类名::静态成员或者对象，静态成员来访问

静态成员函数没用隐藏的this指针，不能访问任何的非静态成员

静态成员和普通成员一样，也有public，protected,private3种访问级别，也具有返回值

sum[a]数组 数组种n个数，那么构造函数就要构造n次

内部类

#include
using namespace std;

class Date
{
	friend  ostream& operator<<(ostream& out, const Date& d);
	friend istream& operator>>(istream& out, const Date& d);
public:
	Date(int _year, int _month, int _day)
	{
		year = _year;
		month = _month;
		day = _day;
	}

	void print();//打印

	bool operator<(Date& d)const ;
	bool operator<=(Date& d)const;
	bool operator>(Date& d)const;
	bool operator>=(Date& d)const;
	bool operator==(Date& d)const;
	bool operator!=(Date& d)const;

	int isyearday(int year, int month)const;//返回每个月的天数

	
	Date& operator+=(int _day);
	Date operator+(int _day);
    Date operator-(int _day);
	Date& operator-=(int _day);

	Date operator + (Date& d)const;
	Date operator - (Date& d)const;

	Date operator++(int);
	Date operator++();

	Date operator--(int);
	Date operator--();

	


	int year;
	int month;
	int day;
};

ostream& operator<<(ostream& out, const Date& d);
istream& operator>>(istream& out, const Date& d);

#include"Date.h"


void Date::print()
{
	cout << year << "年" << month << "月" << day << "日" << endl;
}

bool Date::operator<(Date& d)const
{
	if (year(Date& d)const
{
	if (!(*this < d))
	{
		return true;
	}
	else
	{
		return false;
	}
}

bool Date::operator>=(Date& d)const
{
	if (!(*this <= d))
	{
		return true;
	}
	else
	{
		false;
	}
}

bool Date::operator==(Date& d)const
{
	if (year == d.year && month == d.month && day == d.day)
	{
		return true;
	}
	else
	{
		return false;
	}
}

bool Date::operator!=(Date& d)const
{
	if (!(*this == d))
	{
		return true;
	}
	else
	{
		return false;
	}
}

int Date::isyearday(int year, int month)const
{
	static int day[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };//加static是因为反复创建函数时也要创建数组，会增加开销，改成静态即可不用创建，减少开销
	if (((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) && month == 2)
	{
		return 29;
	}
	else
	{
		return day[month];
	}

}

Date& Date::operator+=(int _day)
{
	day += _day;
		while (day > isyearday(year,month))
		{
			day -= isyearday(year, month);

			month++;
			if (month > 12)
			{
				month = 1;
				year++;
			}
	     }
	return *this;
}

Date Date::operator+(int _day)
{
	Date d(*this);
	d += _day;
	return d;
}

Date& Date::operator-=(int _day)
{
	if (day > _day)
	{
		day -= _day;
		return *this;
	}
	else
	{
		while (_day > isyearday(year, month))
		{
			_day -= day;
			month--;
			if (month == 0)
			{
				month = 12;
				year--;
			}
			day = isyearday(year, month);
		}
		day -= _day;
		return *this;
	}
}

Date Date::operator-(int _day)
{
	Date d(*this);
	d -= _day;
	return d;
}

ostream& operator<<(ostream& out, const Date& d)
{
	out << d.year << "-" << d.month <<"-" << d.day << endl;
	return out;
}

istream& operator>>(istream& cin, Date& d)
{
	cin >> d.year >> d.month >> d.day;
	return cin;
}

int main()
{
	Date d1(2023,8,27);
	d1.print();
	Date d2(d1);
	Date d3(2020, 8,27);
	/*cout << (d1 < d3) << endl;
	cout << (d1 <= d2) << endl;
	cout << (d1 <= d3) << endl;
	cout << (d1 > d3) << endl;
	cout << (d1 >= d2) << endl;
	cout << (d1 == d3) << endl;
	cout << (d1 != d3) << endl;*/
	//d1 += 10000;
	//d1.print();
	//Date d4 = d2 + 10000;
	//d4.print();
	//d2.print();
	//d1 -= 10000;
	//d1.print();
	//Date d4 = d1 - 10000;
	//d4.print();
	//d1.print();

	//cin >> d3;
	//cout << d2 << d3 << endl;

	return 0;
}

友元

友元分为:友元函数和友元类

友元提供了一种突破封装的方式，有时提供了便利，但是友元会增加耦合性，破坏了封装，所以友元不宜多用

友元函数

友元函数可访问类的私有和保护成员，但不是类的成员函数

友元函数不能用const修饰

友元函数可以在类定义的任何地方声明，不受类访问限定符限制

友元函数可以在类定义的任何地方声明，不受类访问限定符限制

一个函数可以是多个类的友元函数

友元函数的调用与普通函数的调用和原理相同

假设A要访问B的私有，在B种让A成为B的友元

友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问非公用成员

友元关系是单向的，不具有交换性

总结：友元更方便，但会破坏封装，不建议多用

内部类

一个类再定义一个类，这个类就叫内部类

注意:内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去调用内部类，但内部类可以通过外部类的对象参数访问外部类中的所有成员，但外部类不是内部类的友元

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

内部类可以直接访问外部类的static成员，不需要外部类的对象\类民

sizeof(外部类)=外部类，和内部类没有关系