【C++从0到1】新手都能看懂的C++入门（中篇）类入门，建议收藏！！！

朱雀 2022-09-15 06:05 59阅读 0赞

### 类 ###

*  前言
 *  1.类的声明和定义
 *  2.this指针
 *   *   *  2.1 vs和gcc下的this指针
 *  3.类的大小
 *   *  内存对齐
 *  4.C和C++在命名对象调用函数的区别
 *  5.构造函数
 *  6.运算符重载
 *   *  6.1运算符重载入门
     *  6.2赋值重载和拷贝构造的小比较
 *  7.构造函数，析构函数，赋值重载比较
 *  总结

--------------------

# 前言 #

类犹如一张图纸一样，类实例化出对象就是拿这张图纸建房子。  
C++中struct，class都是类的关键字，他们的区别就是struct的默认访问限定符不同，struct是public（公有），class是private（私有）。

如果一个类中在没有写任何东西时都会自动生成下面6个默认成员函数  
**1.构造函数（初始化）  
2.析构函数（清理）  
3.拷贝构造（拷贝赋值）  
4.赋值重载（拷贝赋值）  
5.普通对象取地址重载（取地址重载）  
6.const对象取地址重载（取地址重载）**

--------------------

# 1.类的声明和定义 #

对于函数而言：函数的实现就是定义；  
对于成员变量：声明就是告诉变量的类型,名称,但是没有分配空间。真正分配到空间的时候才是成员变量的定义。即类的实例化

//这里是Stack.h
    #include<iostream>
    #include<assert.h>
    //hpp表示类的声明和实现写在一起
    class Stack
    { 
    public:
    	//不能写到private
    	Stack(int cap = 5)
    		:_size(0)
    		,_cap(cap)
    	{ 
    		_a = (int*)malloc(sizeof(int) * cap);
    	}
    	void push(int val);
    	void pop();
    	int top();
    	bool empty();
    	//声明和定义一起写编译器默认会认为是内联函数
    	~Stack()
    	{ 
    		free(_a);
    		_a = nullptr;
    		_size = _cap = 0;
    	}
    private:
    	void CheckCacity();
    
    private:
    	int* _a;
    	int _cap;
    	int _size;
    };

//这里是Stack.c
    #include"Stack.h"
    void Stack::push(int val)
    { 
    	CheckCacity();
    	_a[_size++] = val;
    }
    void Stack::pop()
    { 
    	assert(_size != 0);
    	_size--;
    }
    int Stack::top()
    { 
    	assert(_size != 0);
    	return _a[_size-1];
    }
    bool Stack::empty()
    { 
    	return _size == 0;
    }
    //私有函数的实现和声明也能分离
    void Stack::CheckCacity()
    { 
    	if (_size == _cap)
    	{ 
    		int newcap = _cap == 0 ? 2 : _cap * 2;
    		_cap = newcap;
    		//这里不做判断了
    		int* tmp = (int*)realloc(_a, _cap * sizeof(int));
    		if (tmp == nullptr)
    		{ 
    			std::cout << "扩容失败，程序退出\n";
    			exit(1);
    		}
    		_a = tmp;
    	}
    }

> 这是一个类的基本实现，以下几点需要注意。  
> **1**.私有函数的**实现和声明也能分离**！  
> **2**.hpp通常是**实现和声明在一起的**。  
> **3**.在类内部定义的函数默认是内联函数，所以我们通常会把一些使用频率高，代码简洁的函数放到类内部实现，其余的在.cpp当中实现。  
> **4**.Stack::push，表示push这个函数是在Stack这个域当中，往后push内部访问成员变量会默认带上this指针。  
> **5**.构造函数和析构函数都需要在public，我们的成员变量不希望外部直接修改，所以放在private当中，我们提供public的接口给外部使用。

--------------------

# 2.this指针 #

class Date
    { 
    	int _year;
    	int _month;
    	int _day;
    public:
    	Date(int year = 0, int month = 1, int day = 1)
    		:_year(year)
    		, _month(month)
    		, _day(day)
    	{ }
    	void Print()
    	{ 
    		std::cout << _year << "/" << _month << "/" << _day << std::endl;
    	}
    };
    int main()
    { 
    	Date d1(2021,10,10);
    	Date d2(2222,2,2);
    	d1.Print();
    	return 0;
    }

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAXmpoYW9e_size_20_color_FFFFFF_t_70_g_se_x_16]

观察上面日期类Date，在没有编译前Date是文件，编译后他是指令放到**代码段当中**，那么我们的Print怎么知道我们是这里的d1还是d2调用的呢？

> 非静态函数调用的时候，会默认给我们加上一个this指针，实际上调用的时候是这样的  
> ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAXmpoYW9e_size_20_color_FFFFFF_t_70_g_se_x_16 1]

--------------------

### 2.1 vs和gcc下的this指针 ###

> vs下是将this指针放入ecx寄存器当中，通常也可以放入栈中，由于需要大量使用，所以放入寄存器也是很好的选择。![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAXmpoYW9e_size_20_color_FFFFFF_t_70_g_se_x_16 2]

> linux下是由寄存器rdi存储this指针![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAXmpoYW9e_size_20_color_FFFFFF_t_70_g_se_x_16 3][]

--------------------

# 3.类的大小 #

计算类的大小和计算类实例化的对象的大小是一样的。  
如：int a; sizeof(int) == sizeof(a);  
类实例化出来的对象的大小只包括成员变量，因为每个对象的成员变量可能都是不一样的，但是每个对象调用的成员函数可以是同一份，如果每个对象都存储一份就会比较臃肿，所以编译时他就会变成指令存到代码段当中。  
![在这里插入图片描述][a83637d596e24fbfa85bf9d8ba9f366a.png]  
上述的结果是：12，这里跟计算结构体的大小一样，需要进行内存对齐。

## 内存对齐 ##

> 这里我们来复习以下内存对齐 内存对齐规则：首先得掌握结构体的对齐规则：
> 
> 1.  第一个成员在与结构体变量偏移量为0的地址处。
> 2.  其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。 对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。 VS中默认的值为8
> 3.  结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
> 4.  如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

试试计算下题的结构体大小吧：

struct A
    { 
    	char c;
    	int a;
    	int e;
    };
    struct B
    { 
    	char i;
    	struct A a;//A当中的最大对齐数是4
    	double q;
    };
    int main()
    { 
    	/*std::cout << sizeof(A)<<std::endl; std::cout << sizeof(B);*/
    	printf("%d", sizeof(struct B));
    	return 0;
    }

result：24 **如下图**  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAXmpoYW9e_size_20_color_FFFFFF_t_70_g_se_x_16 4]

--------------------

# 4.C和C++在命名对象调用函数的区别 #

c写的在命名空间中就还要通过域名才能调用函数，但是如果是cpp的话，就可以直接通过对象直接调用，因为对象就是在那个域当中的！

namespace ljhC
    { 
    	struct Date
    	{ 
    		int _year;
    		int _month;
    		int _day;
    		Date(int year = 0, int month = 1, int day = 1)
    			:_year(year)
    			, _month(month)
    			, _day(day)
    		{ }	
    	};
    	void Print(Date* _this)
    	{ 
    		std::cout << _this->_year << "/" << _this->_month << "/" << _this->_day << std::endl;
    	}
    }
    namespace ljhCPP
    { 
    	struct Date
    	{ 
    		int _year;
    		int _month;
    		int _day;
    		Date(int year = 0, int month = 1, int day = 1)
    			:_year(year)
    			, _month(month)
    			, _day(day)
    		{ }
    		void Print()
    		{ 
    			std::cout << _year << "/" << _month << "/" << _day << std::endl;
    		}
    	};
    }
    int main()
    { 	//C实现，调用函数需要加上域名
    	ljhC::Date d1;
    	ljhC::Print(&d1);
    	//C++实现，d2这个对象已经在ljhCPP这个域中，可以直接调用内部公有函数
    	ljhCPP::Date d2;
    	d2.Print();
    	return 0;
    }

--------------------

# 5.构造函数 #

构造函数不是构造对象，是初始化对象。  
注意构造函数会自己生成，如果写了一个就不会再生成默认的  
空类常用于标志  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAXmpoYW9e_size_20_color_FFFFFF_t_70_g_se_x_16 5]  
只有成员变量的类通常用来重载operator()  
![在这里插入图片描述][f471cad793b64a38b26ba2b97a6ca88c.png]

--------------------

# 6.运算符重载 #

## 6.1运算符重载入门 ##

> **1.** 作为类成员的重载函数时，其形参看起来比操作数数目少1成员函数的,操作符有一个默认的形参this，限定为第一个形参。  
> **2.** **.**\* 、:: 、sizeof 、?: 、. 注意以上5个运算符不能重载。这个经常在笔试选择题中出现。  
> **3.** 不能通过连接其他符号来创建新的操作符：比如operator@

这里我们演示全局的用法，operator==来举例，说明**并非所有的运算符重载都可以用于全局**，有写就不行，如operator=。![在这里插入图片描述][389de50ab1b046e89ea0358e729ef305.png]  
全局的用法有很多限制，在类外面为了访问成员变量我们不得不设置成公有的，但是实际上这样子是不好的！！！

#include<iostream>
    using namespace std;
    class Date
    { 
    public:
    	int _year;
    	int _month;
    	int _day;
    
    	Date()
    	{ }
    	Date(const Date& d)
    	{ 
    		cout << "Date(const Date& d)"<<endl;
    	}
    };
    //全局operator=
    bool operator==(const Date& d1, const Date& d2) { 
    	return d1._day == d2._day
    	&& d1._month == d2._month
    	&& d1._year == d2._year;
    }
    int main()
    { 
    	Date d1;
    	Date d2;
    	//全局的用法！
    	cout<<operator==(d1,d2);
    	return 0;
    }

由于上述原因，所以我们通常将运算符重载放入类内部实现，类内部就可以访问私有成员变量。

这个时候调用函数也不能用operator==(d1,d2);我们就要用**d1.operator==(d2)** 或者 **d1 == d2**，后面这种可读性强，我们推荐这种。

#include<iostream>
    using namespace std;
    class Date
    { 
    
    	int _year;
    	int _month;
    	int _day;
    public:
    	Date()
    	{ }
    	Date(const Date& d)
    	{ 
    		cout << "Date(const Date& d)"<<endl;
    	}
    	bool operator==(const Date& d2) { 
    		return _day == d2._day
    			&& _month == d2._month
    			&& _year == d2._year;
    	}
    };
    //全局operator=
    
    int main()
    { 
    	Date d1;
    	Date d2;
    	//可读性差
    	cout<<d1. operator==(d2)<<endl;
    	//可读性强
    	cout << (d1 == d2);
    	return 0;
    }

--------------------

## 6.2赋值重载和拷贝构造的小比较 ##

**拷贝构造传参时需要注意传引用，避免无穷递归调用：在传参若不加引用则又是一次拷贝构造**

赋值重载注意一下几点：

1.  参数类型
2.  返回值
3.  **检测是否自己给自己赋值**（无意义）
4.  返回\*this
5.  **一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝。**

赋值重载就是在用一个对象去对另外一个对象进行赋值，对于内置类型，下面用int举例。

int a =0;
    int b =0;
    a=b;//这个就是一个赋值

对于一个自定义类型，我们需要重载operator=,用日期类举个例子

#include<iostream>
    using namespace std;
    class Date
    { 
    	int _year;
    	int _month;
    	int _day;
    public:
    	Date()
    	{ }
    
    	Date& operator=(const Date& d)
    	{ 
    	//这里没有实现，只是证明调用该函数
    		cout << "Date& operator=(const Date& d)"<<endl;
    		return *this;
    	}
    	Date(const Date& d)
    	{ 
    	//这里没有实现，只是证明调用该函数
    		cout << "Date(const Date& d)"<<endl;
    	}
    };
    int main()
    { 
    	Date d1;
    	Date d2;
    	d1 = d2;//这个就是赋值构造，两个对象都已经存在 d1.operator=(d2);
    	Date d3 = d1;//这个就是拷贝构造，Date d3(d1);
    	
    
    	return 0;
    }

结果：我们可以看到赋值对象是需要两个对象存在才可以赋值的。![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAXmpoYW9e_size_20_color_FFFFFF_t_70_g_se_x_16 6]

--------------------

# 7.构造函数，析构函数，赋值重载比较 #

由于过于相似，就不一一说了。  
**构造函数**：编译器默认对于内置类型（基础类型）是不做处理的，对于自定义类型（class ，struct，union）就会进行调用他们的构造函数，如果他们的构造函数没有对基础类型有初始化，那么也都是随机值！

**析构函数**：析构函数**对于日期类**的，一般没有堆上面开辟的不需要写析构函数，但对于常见的数据结构，如栈（数组动态开辟），队列（链表动态开辟），我们就需要对于堆上的空间做处理。  
编译器生成的析构函数：**调用自定义类型的析构函数，内置类型不做处理**。所以对于栈想要对int\*进行free的时候我们也要手动操作。

**赋值重载**：跟**拷贝构造**的行为类似，**内置类型成员会完成值拷贝**，自定义类型成员换会调用他的赋值重载。注意：赋值重载是在两个已经定义出来的对象间的拷贝复制。

Date d2;  
Date d1 =d2;**//这个就是拷贝构造**

--------------------

# 总结 #

本章节对几个默认的成员函数进行了解释，下一期会详细讲讲一些类的细节，易错点。  
**看到这里不妨一键三连哟！**

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAXmpoYW9e_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/e2a445c1b2eb4630991ba8854c768448.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAXmpoYW9e_size_20_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220828/45803862dbc8474b9166d1d8a5d1163f.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAXmpoYW9e_size_20_color_FFFFFF_t_70_g_se_x_16 2]: /images/20220828/6a8f2b5b1694405f9570f08bbc436935.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAXmpoYW9e_size_20_color_FFFFFF_t_70_g_se_x_16 3]: /images/20220828/45adaa1355c34ed08ad210c20c95bbcb.png
[a83637d596e24fbfa85bf9d8ba9f366a.png]: /images/20220828/ccdeb5ad8bb74f208c29dda8cbb49790.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAXmpoYW9e_size_20_color_FFFFFF_t_70_g_se_x_16 4]: /images/20220828/d8143b6a379243c09d4bc6b2483974d3.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAXmpoYW9e_size_20_color_FFFFFF_t_70_g_se_x_16 5]: /images/20220828/0bddd39ea4e34829b9037ece785acf1d.png
[f471cad793b64a38b26ba2b97a6ca88c.png]: /images/20220828/bcd5c30a53b142808c63538ebea57606.png
[389de50ab1b046e89ea0358e729ef305.png]: /images/20220828/4e93efc0fca344b28c134fc6e7983767.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAXmpoYW9e_size_20_color_FFFFFF_t_70_g_se_x_16 6]: /images/20220828/70352d7b98504b80adc374ddc3092553.png