【C++从青铜到王者】第二篇:C++类和对象(上篇)

傷城~ 2022-10-16 06:17 137阅读 0赞

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

# 系列文章目录 #

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

### 文章目录 ###

*  系列文章目录
 *  前言
 *  一、面向过程和面向对象初步认识
 *  二、类的引入
 *  三、类的定义
 *  四、类的访问限定符及封装
 *   *   *  1.类的访问限定符
         *  2.类的封装
 *  五、类的作用域
 *  六、类的实例化
 *  七、类对象模型
 *   *   *  1.如何计算类对象的大小
         *  2 类对象的存储方式猜测
         *   *   *  1.对象中包含类的各个成员
                 *  2.只保存成员变量，成员函数存放在公共的代码段
         *  3.结构体内存对齐规则
 *  八、this指针
 *   *   *  1.this指针的引出
         *  2.this指针的特性
 *  总结

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

# 前言 #

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

![在这里插入图片描述][20210527142839271.png_pic_left]

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70]  
编程思想不同：  
**面向过程**：是一种以过程为中心的编程思想。都是以什么正在发生为主要目标进行编程。**C语言**是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。  
**面向对象**：是一类以对象作为基本程序结构单位的程序设计语言，指用于描述的设计是以对象为核心，而对象是程序运行时刻的基本成分。**C++语言**是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 1]

# 二、类的引入 #

C语言中，结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数  
代码如下：

typedef int STDateType;
    struct Stack
    { 
    	void StackInit(int initSize = 4)
    	{ 
    		a = (STDateType*)malloc(sizeof(STDateType)*initSize);
    		size = 0;
    		capacity = initSize;
    	}
    	void StackPush(STDateType x)
    	{ 
    		a[size] = x;
    		size++;
    	}
    	STDateType* a;
    	int size;
    	int capacity;
    };

上面结构体栈的定义，在C++中更喜欢用class来代替

# 三、类的定义 #

1.  class为定义类的关键字，ClassName为类的名字，\{\}中为类的主体，注意类定义结束时后面分号。
2.  类中的元素称为类的成员：类中的数据称为类的属性或者成员变量; 类中的函数称为类的方法或者成员函数。  
    ![在这里插入图片描述][20210527145141985.png]

类的两种定义方式：  
**第一种声明和定义都放在类体中:**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 2]  
代码如下：

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    typedef int STDateType;
    class Stack
    { 
    public:
    	void StackInit(int initSize = 4)
    	{ 
    	  a = (STDateType*)malloc(sizeof(STDateType)*initSize);
    	  size = 0;
    	  capacity = initSize;
        }
    	void StackPush(STDateType x)
    	{ 
    	  a[size] = x;
    	  size++;
        } 
    public:
    	STDateType* a;
    	int size;
    	int capacity;
    };

**第二种声明和定义分开放:**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 3]  
代码如下：

typedef int STDateType;
    class Stack
    { 
    public:
    	//成员函数的声明
    	void StackInit(int initSize = 4);
    	void StackPush(STDateType x);
    
    	//成员变量的声明
    	STDateType* a;
    	int size;
    	int capacity;
    };
    
    //成员函数的定义
    void Stack::StackInit(int initSize)
    { 
    	a = (STDateType*)malloc(sizeof(STDateType)*initSize);
    	size = 0;
    	capacity = initSize;
    }
    void Stack::StackPush(STDateType x)	
    { 
    	a[size] = x;
    	size++;
    }

# 四、类的访问限定符及封装 #

### 1.类的访问限定符 ###

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

1.  public修饰的成员在类外可以直接被访问
2.  protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的)
3.  访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
4.  class的默认访问权限为private，struct为public(因为struct要兼容C)  
    **注意：访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别**  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 4]  
    **问题：C++中struct和class的区别是什么？**  
    解答：C++需要兼容C语言，所以C++中struct可以当成结构体去使用。另外C++中struct还可以用来定义类。和class是定义类是一样的，区别是struct的成员默认访问方式是public，class是的成员默认访问方式是private

### 2.类的封装 ###

**【面试题】 面向对象的三大特性：封装、继承、多态**。

在类和对象阶段，我们只研究类的封装特性，那什么是封装呢？

**封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。**

**封装本质上是一种管理**：我们如何管理兵马俑呢？比如如果什么都不管，兵马俑就被随意破坏了。那么我们首先建了一座房子把兵马俑给封装起来。但是我们目的全封装起来，不让别人看。所以我们开放了售票通道，可以买票突破封装在合理的监管机制下进去参观。类也是一样，我们使用类数据和方法都封装到一下。不想给别人看到的，我们使用protected/private把成员封装起来。开放一些共有的成员函数对成员合理的访问。所以封装本质是一种管理。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 5]

# 五、类的作用域 #

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

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    typedef int STDateType;
    class Stack
    { 
    public:
    	void StackInit(int initSize = 4);
    	void StackPush(STDateType x);
    private:
    	STDateType* a;
    	int size;
    	int capacity;
    };
    void Stack::StackInit(int initSize) //作用域符号::表示StackInit成员函数属于Stack域
    { 
    	a = (STDateType*)malloc(sizeof(STDateType)*initSize);
    	size = 0;
    	capacity = initSize;
    }
    void Stack::StackPush(STDateType x)//作用域符号::表示StackPush成员函数属于Stack域
    { 
    	a[size] = x;
    	size++;
    }

# 六、类的实例化 #

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

1.  类只是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它。
2.  一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量。
3.  做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 6]

代码如下：

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    typedef int STDateType;
    class Stack
    { 
    public:
    	void StackInit(int initSize = 4);
    	void StackPush(STDateType x);
    private:
    	STDateType* a;
    	int size;
    	int capacity;
    };
    class  A1
    { 
    
    };
    class A2
    { 
    	void fun()
    	{ 
    
    	}
    };
    
    int main()
    { 
    	Stack st; //类的实例化，创建一个对象st
    	std::cout << sizeof(st) << std::endl;
    	std::cout << sizeof(A1) << std::endl;
    	std::cout << sizeof(A2) << std::endl;
    	return 0;
    }

# 七、类对象模型 #

### 1.如何计算类对象的大小 ###

代码如下：

class Stack
    { 
    public:
    	void StackInit(int initSize = 4);
    	void StackPush(STDateType x);
    private:
    	STDateType* a;
    	int size;
    	int capacity;
    };
    class  A1
    { 
    
    };
    class A2
    { 
    	void fun()
    	{ 
    
    	}
    };

问题：类中既可以有成员变量，又可以有成员函数，那么一个类的对象中包含了什么？如何计算一个类的大小？

### 2 类对象的存储方式猜测 ###

##### 1.对象中包含类的各个成员 #####

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

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 8]  
问题：对于上述两种存储方式，那计算机到底是按照那种方式来存储的？  
我们再通过对下面的不同对象分别获取大小来分析看下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 9]  
**结论**：一个类的大小，实际就是该类中”成员变量”之和，当然也要进行内存对齐，注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类。

### 3.结构体内存对齐规则 ###

1.  第一个成员在与结构体偏移量为0的地址处。
2.  其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。  
    **注意**：对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。VS中默认的对齐数为8
3.  结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。
4.  如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

**面试题**

1.  结构体怎么对齐？ 为什么要进行内存对齐？  
    **平台原因（移植原因）**：不是所有的硬件平台都能访问任意地址上的任意数据，某些硬 件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常  
    **硬件原因**：经过内存对齐之后，CPU的内存访问速度大大提升。
2.  如何让结构体按照指定的对齐参数进行对齐？  
    **\#pragma pack(n)**//强制使对齐模数为n(不管VS和Linux)
3.  什么是大小端？如何测试某台机器是大端还是小端，有没有遇到过要考虑大小端的场景？  
    大端存储模式：就是内存的低地址上存着数据的高位，高地址上存着数据的低位。  
    小端存储模式：就是内存的低地址上存数据的低位，而高地址上存数据的高位。  
    **大小端场景**:代码移植和网络通信。

# 八、this指针 #

### 1.this指针的引出 ###

我们先来定义一个日期类Date：  
代码如下：

class Date
    { 
    public:
    	void InitDate(int year, int month, int day)
    	{ 
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    	void Print()
    	{ 
    		std::cout << _year << ":" << _month << ":" << _day << std::endl;
    	}
    private:
    	int _year;   //年
    	int _month;  //月
    	int _day;    //天
    };
    int main()
    { 
    	Date d1;
    	Date d2;
    	d1._year = 2021;
    	//d1._month = 5;
    	//d1._day = 27;
    	d1.InitDate(2021, 5, 27);
    	d2.InitDate(2021, 5, 28);
    	d1.Print();
    	d2.Print();
    	return 0;
    }

我们不能通过实例化出来的对象d1或者d2直接去访问私有成员变量，而是通过公有成员函数取访问。  
![在这里插入图片描述][20210529172523111.png]  
**对于上述类，还有这样的一个问题：**  
Date类中有SetDate与Display两个成员函数，函数体中没有关于不同对象的区分，那当s1调用SetDate函数时，该函数是如何知道应该设置s1对象，而不是设置s2对象呢？  
C++中通过引入this指针解决该问题，即：C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有成员变量的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

### 2.this指针的特性 ###

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

【面试题】

1.  this指针存在哪里？  
    **其实编译器在生成程序时加入了获取对象首地址的相关代码。并把获取的首地址存放在了寄存器ECX中(VC++编译器是放在ECX中，其它编译器有可能不同)。也就是成员函数的其它参数正常都是存放在栈中。而this指针参数则是存放在寄存器中。类的静态成员函数因为没有this指针这个参数，所以类的静态成员函数也就无法调用类的非静态成员变量。**
2.  this指针可以为空吗？  
    **可以为空，当我们调用函数时，如果函数内部不需要使用到this,也就是不需要通过this指向当前对象并对其进行操作时才可以为空(当我们在其中什么都不放或者在里面随便打印一个字符串)，如果调用的函数需要指向当前对象，并进行操作，则会发生错误（空指针引用）就跟C中一样不能进行空指针的引用。**

下面程序编译能通过吗？  
代码如下：

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    // 1.下面程序能编译通过吗？
    // 2.下面程序会崩溃吗？在哪里崩溃
    class A
    { 
    public:
    	void PrintA()
    	{ 
    		std::cout << _a << std::endl;
    	}
    	void Show()
    	{ 
    		std::cout << "Show()" << std::endl;
    	}
    private:
    	int _a;
    };
    int main()
    { 
    	A* p = nullptr;
    	p->PrintA();
    	p->Show();
    }

1.  PrintA函数运行时会崩溃，因为要访问类A里面的成员变量要通过this指针去访问，但是指针P是一个空指针，所以解引用去访问成员变量\_a会发生崩溃。
2.  能输出Show(),因为Show成员函数虽然有this指针，但是并没有用this指针去访问类A里面的成员变量，所以能正常打印Show()。

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

# 总结 #

以上就是今天要讲的内容，本文仅仅简单介绍了类和对象(上)的使用，而类提供了大量能使我们快速便捷地处理数据的成员函数和成员变量，我们务必掌握。另外如果上述有任何问题，请懂哥指教，不过没关系，主要是自己能坚持，更希望有一起学习的同学可以帮我指正，但是如果可以请温柔一点跟我讲，爱与和平是永远的主题，爱各位了。

![在这里插入图片描述][20210529192332906.png_pic_center]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221014/adebf7382aca4223b9a30a86d0a13ce0.png
[20210527142839271.png_pic_left]: /images/20221014/026e49077c614d6eaee7da4336e6d032.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70]: /images/20221014/e78c2279510345fe904646b446acaa62.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 1]: /images/20221014/5741968e775e4378b60bc959c8163b0e.png
[20210527145141985.png]: /images/20221014/8b029545d9d64b2f8b2399f6f143b5eb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 2]: /images/20221014/c2f0c4401ccc47a0831da1bebd019ad6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 3]: /images/20221014/4fa5764fa72f4ef0b2c2c98764f89560.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 4]: /images/20221014/0b7a05c93a9b4c8c9018904b12e52d70.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 5]: /images/20221014/34c5b52cdc8244c0a85f33f2b75c42e2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 6]: /images/20221014/9e4f40884c2a4b2f8e9c9d2cc0823dc1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 7]: /images/20221014/9ede95b4846d4383903d3d37e13241b6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 8]: /images/20221014/217ccf78e2594c799474373c5ff2a1e0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 9]: /images/20221014/d43f6bdc73344093bf0db1007bb92a76.png
[20210529172523111.png]: /images/20221014/0d99ad0b09bb415081d852d64d7062fd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 10]: /images/20221014/55caad56e4a94a528574fca25ff475da.png
[20210529192332906.png_pic_center]: /images/20221014/0a7efa03e5664b45bfab68730b5d03f7.png