c++的类和对象详解

一、面向过程和面向对象的初步认识

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。
C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。

二、类的引入

类：是定义出一个新的类型。
类由两部分构成：1.成员变量（属性）2.成员函数（做的行为）
C语言中，结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。

typedef int STDataType;
struct Stack
{
	void Init(int initSize = 4)
	{
		a = (STDataType*)malloc(sizeof(STDataType)*initSize);
		size = 0;
		capacity = initSize;
	}
	void Push(STDataType x)
	{
		a[size] = x;
		size++;
	}
	STDataType* a;
	int size;
	int capacity;
};
int main()
{
	Stack st;
	st.Init();
	st.Push(1);
	st.Push(2);
	st.Push(3);
	return 0;
}

访问限定符
C++实现封装的方式：用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。
【访问限定符说明】

1. public修饰的成员在类外可以直接被访问
2. protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的)
3. 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
4. class的默认访问权限为private，struct为public(因为struct要兼容C)
   【面试题】
   问题：C++中struct和class的区别是什么？
   解答：C++需要兼容C语言，所以C++中struct可以当成结构体去使用。另外C++中struct还可以用来定义类。
   和class是定义类是一样的，区别是struct的成员默认访问方式是public，class是的成员默认访问方式是private。
   c++的封装是一种管理，数据和方法是在一个类中，管理起来，想给你访问的定义成公有，不想给你访问的定义成私有和保护而c语言是方法和数据分开的。

三、类的存储方式

只保存成员变量，成员函数存放在公共的代码段。

一般情况下，成员变量都是私有的，成员函数可以是公有的。

四、类的作用域

类定义了一个新的作用域，类的所有成员都在类的作用域中。在类体外定义成员，需要使用 :: 作用域解析符指明成员属于哪个类域。

class Person
{
public:
 void PrintPersonInfo();
private:
 char _name[20];
 char _gender[3];
 int _age;
};
// 这里需要指定PrintPersonInfo是属于Person这个类域
void Person::PrintPersonInfo()
{
 cout<<_name<<" "_gender<<" "<<_age<<endl;
}

五、this指针

class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	d1.Init(2021, 5, 25);
	Date d2;
	d2.Init(2021, 5, 21);
	return 0;
}

Date类中有SetDate与Display两个成员函数，函数体中没有关于不同对象的区分，那当s1调用SetDate函数时，该函数是如何知道应该设置s1对象，而不是设置s2对象呢？
为了解决这个问题，编译器会在函数变量中增加一个隐含的参数this指针。
哪个对象去调用成员函数，成员函数中访问的就是哪个对象中的成员变量，是通过this指针来完成的。
注意：

1. this指针的类型：类类型* const。
2. 只能在“成员函数”的内部使用。
3. this指针本质上其实是一个成员函数的形参，是对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
4. this指针是成员函数第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递。

六、构造函数

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

1. 函数名与类名相同。
2. 无返回值。
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。
   一般情况下，对象初始化都分两种，默认值初始化，给定值初始化。
   给全缺省的，这样定义的构造函数写一个就行。

class Date
{ 
public :
 // 1.无参构造函数
 Date ()
 {}
 
 // 2.带参构造函数
 Date (int year, int month , int day )
 {
 _year = year ;
 _month = month ;
 _day = day ;
 }
private :
 int _year ;
 int _month ;
 int _day ;
};
void TestDate()
{
 Date d1; // 调用无参构造函数
 Date d2 (2015, 1, 1); // 调用带参的构造函数
 
 // 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
 // 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
 Date d3(); 
}

七、析构函数

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

1. 析构函数名是在类名前加上字符 ~。
2. 无参数无返回值。
3. 一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。

class Stack
{
	Stack(int capacity=4)
	{
		_a = (int *)malloc(sizeof(int)*capacity);
		_size = 0;
		_capacity = capacity;
	}
	~Stack()
	{
		free(_a);
		_a = nullptr;
		_size = _capacity = 0;
	}
private:
	int *_a;
	int _size;
	int _capacity;
};

因为对象是定义在函数中，函数调用会建立栈帧，栈帧中的对象构造和析构也要符合后进先出。

八、拷贝构造函数

1. 拷贝构造函数是构造函数的一个重载形式。
2. 拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用。

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	Date d2(d1);
	return 0;
}

3. 若未显示定义，系统生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝我们叫做浅拷贝，或者值拷贝。

九、赋值运算符重载

运算符重载
C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
当运算符是两个操作数时，第一个参数是左操作数，第二个参数是右操作数。
函数名字为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)

class Date
{ 
public :
 Date(int year = 1900, int month = 1, int day = 1)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 
 Date (const Date& d)
 {
 _year = d._year;
 _month = d._month;
 _day = d._day;
 }
 
 Date& operator=(const Date& d)
 {
 if(this != &d)
 {
 _year = d._year;
 _month = d._month;
 _day = d._day;
 }
 }
private:
 int _year ;
 int _month ;
 int _day ;
};

运算符重载和函数重载的区别：
1.函数重载是支持定义同名函数
2.运算符重载是为了让自定义类型可以像内置类型一样去使用运算符。
拷贝构造函数和赋值运算符重载的区别：
1.拷贝构造函数：拷贝初始化，特殊构造函数。
2.赋值运算符重载：也是拷贝行为，但不一样的是，拷贝构造是创建一个对象时，拿同类对象初始化的拷贝。
总结：
1.构造函数–初始化，大部分情况下，都需要我们自己写构造函数。
2.析构函数–清理内对象中资源
3.拷贝构造函数–拷贝初始化，特殊构造函数
4.赋值运算符重载–也是拷贝行为，但是不一样的是，拷贝构造是创建一个对象时，拿同类对象初始化的拷贝。
针对不写，编译默认生成
构造和析构的特性是类似，我们不写编译器内置类型不处理，自定义类型调用它的构造和析构处理。
拷贝构造和赋值重载特性是类似的，内置类型会完成浅拷贝，自定义类型会调用他们的拷贝构造和赋值重载。

十、Const修饰的成员函数

将const修饰的类成员函数称为const成员函数，加const的好处是，修饰的是*this，函数中不小心改变的成员变量，编译时就会被检查出来 。

class Date
{
public:
	bool operator==(const Date&d)const
	{
		return (_year == d._year)
			&& (_month == d._month)
			&& (_day == d._day);
	}
private:
	int _year;
	int _month;
	int _day;
};

十一、再谈构造函数

构造函数体赋值

class Date
{
public:
 Date(int year, int month, int day)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 
private:
 int _year;
 int _month;
 int _day;
};

虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称作为类对象成员的初始化，构造函数体中的语句只能将其称作为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。
初始化列表
初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。

{   
class Date:
public:
 Date(int year, int month, int day)
 : _year(year)
 , _month(month)
 , _day(day)
 {}
 
private:
 int _year;
 int _month;
 int _day;
};

注意：

1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
2. 类中包含以下成员，必须放在初始化列表位置进行初始化：
   引用成员变量，const成员变量，自定义类型成员
3. 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。
4. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关。

class A
{
public:
 A(int a)
 :_a1(a)
 ,_a2(_a1)
 {}
 
 void Print() {
 cout<<_a1<<" "<<_a2<<endl;
 }
private:
 int _a2;
 int _a1;
}
int main() {
 A aa(1);
 aa.Print();
}

因为先声明_a2所以初始化时传递的是_a1,所以输出的是1和随机值。
不用传参数就可以调用的构造函数：
1、全缺省的构造函数
2、无参的构造函数
3、我们不写编译器默认生成