C++ 类与对象

一.类与对象

1. 简介

c语言是面向过程的编程语言，先分析出求解问题的步骤，然后通过函数调用逐步解决问题

c++是基于面向对象的编程语言，先将事件划分为不同的对象，依靠对象间的交互来解决问题

2. 类

a. 语法

   c++兼容了c语言中struct的语法，并且将struct定义的结构体升级为类。因此在c++中可以使用struct或class来定义类，但更多使用class关键字来定义类。

class className
{
    //类体：由成员变量和成员函数组成
};

b. 访问限定符

通过访问限定符的修饰，选择性的将类成员提供给外界使用。

1. public(公有)：其修饰的成员可以被类外直接访问
2. protected(保护)与private(私有)：其修饰的成员不能被类外直接访问

class中默认的访问权限为private，struct为public（因为需要兼容c语言）

一个访问权限的作用域：从该访问限定符出现位置开始到下一个访问限定符或到}(类结束)为止

c. 定义类

1. 声明与定义都在类体中

class Dog
{
public://如果不加public则默认为private
	void speak()
	{
		cout << "汪汪汪~" << endl;
	}
private:
	int age;
	char* name;
};

成员函数如果在类中定义，编译器可能将其当做内联(inline)函数处理

2. 声明在.h文件，成员函数定义在.cpp文件

//test.h//
#include <iostream>

using namespace std;

class Dog
{
public:
	void speak();
private:
	int age;
	char* name;
};

//test.cpp//
#include "test.h"

void Dog::speak()
{
	cout << "汪汪汪~" << endl;
}

类定义了一个新的作用域，其所有成员都在该作用域中，{}内。在类体外定义成员时，需要使用::作用域操作符指明成员属于哪个类域。如上例中：成员函数名前需要加 类名+::

建议：

使用频繁且代码少的成员函数，想成为内联函数，应该直接在类中定义

代码较多的成员函数，应该声明和定义分离

d. 封装

   隐藏对象的属性和实现细节(private: 成员变量与某些成员函数)，仅对外公开接口(public:成员函数)来和其他对象进行交互。

c语言中没法封装，直接访问数据的方法不规范

c++中使用封装后，则必须规范使用函数来访问数据

3. 对象

a. 简介

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

比如说：类只是图纸，对象是将类实例化建造出的楼房。实例化出的对象，才占用实际物理空间，来存储类成员变量

class Dog
{
public:
	void speak();//函数声明
private:
	int age;//声明（没开空间存储）
	char* name;//声明
};

Dog d1;	//类的实例化

b. 对象的存储

int main()
{
    Dog d1;
    Dog d2;  
    d1.speak();
    d2.speak();
    
    return 0;
}

对于成员函数的调用，编译链接时，会根据函数名去公共代码区找到函数的地址。

call + 函数地址来调用

示例：

对于Dog对象中speak()的调用，不会（解引用空指针）根据对象去找，而是编译链接时，直接去公共代码区找，因此上图程序可以正常运行。

c. 对象的大小

成员函数公共代码区中，因此不占对象空间的大小，成员变量遵循内存对齐的规则。

链接：计算结构体大小

没有成员变量的对象，给1byte空间，不存储数据用于占位，来标识对象的存在

4. this指针

a. 命名规范

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

对成员变量赋值时，为了避免和局部变量冲突，通常会对成员变量采用某种命名规范来区别

驼峰法： 单词和单词间通过首字母大写间隔

1.函数名、类名所有单词首字母大写 ：DogBaby

2.变量首字母小写 ：dogBaby

3.成员变量首字母前加"_" ： _dogBaby

b. 简介

Date d1, d2;
d1.Init(2022, 9, 2);
d2.Init(2016, 6, 6);

对于日期对象d1、d2，都调用了Init()函数，给自己的成员变量赋值。

成员函数存放在公共代码区，不同对象调用共同的函数。那么Init()函数体中的 _year，_month，_day是怎样区分属于不同的对象空间呢？

c++通过引入this指针来解决该问题。c++编译器给每一个非静态成员函数增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有对成员变量的操作，都是通过该指针去访问。

c. this指针特性

1. this指针的类型：类类型* const ，不能修改this
2. 可以在成员函数内部使用this指针
3. this指针本质是成员函数的隐含的形参，属于局部变量，存储于栈中。
4. vs编译器进行了优化，传递的this指针，存放于寄存器ecx中，来提高访问效率
   

二.类的6个默认成员函数

1. 简介

任何类在什么都没写时，编译器会自动生成6个默认成员函数

2. 构造函数

a. 简介

  构造函数是一个特殊的成员函数，创建类类型对象时由编译器自动调用，用于初始化对象。并且在对象整个生命周期内只调用一次

b. 特性

1. 函数名和类名相同

2. 无返回值

3. 可以重载

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

5. 如果类中没有显式定义构造函数，则编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成

6. 编译器默认生成的构造函数：内置(基本数据)类型的成员变量不做处理

---

C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在类中声明时可以给缺省值

---

7. 默认构造函数：a.无参的构造函数 b.全缺省的构造函数 c.编译器自动生成的 特点->只能有一个，不传参就可以调用，使用时可省略()

3. 析构函数

a. 简介

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

b. 特性

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

5. 析构函数：内置类型不处理
   

4. 拷贝构造函数

a. 简介

  拷贝构造函数：只有单个形参，且该形参是本类的引用类型(一般用const修饰)。当使用对象来创建同类的新对象时编译器会自动调用

增加const ，为确保不改变d1的值。

b. 特性

1. 拷贝构造函数是构造函数的一个重载形式
2. 其参数只有一个且必须是类类型对象的引用。使用传值方式编译器直接报错，因为会引发无穷递归调用

3. 若未显式定义，编译器会生成默认的拷贝构造函数。 在编译器生成的默认拷贝构造函数：a.内置类型是按照字节方式直接拷贝的（浅拷贝） b.自定义类型是调用其拷贝构造函数完成拷贝的

类中如果没有涉及资源申请时，拷贝构造函数是否写都可以。

一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝，拷贝的指针，因此会指向同一空间。

4. 自动调用拷贝构造函数的场景：

使用对象创建新对象

函数参数为类类型对象传参（为提高效率，一般对象传参时，尽量使用引用类型）

函数返回值类型为类类型对象

5. 赋值运算符重载

a. 运算符重载

运算符重载是具有特殊函数名的函数 ，有返回类型、及参数列表。

函数原型：返回类型 关键字operator+需要重载的符号 (参数列表)

1.不能通过连接其他符号来创建新的操作符：比如operator@

2.内置类型可以直接使用运算符运算，其不能改变

3.重载操作符必须有一个类类型参数

4.作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this

5..* :: sizeof ?: . 注意以上5个运算符不能重载。

操作符.*详情

b. =重载

赋值运算符：“=”

参数类型：const Date&，引用传参可以提高效率
返回值类型：Date&，返回引用提高返回的效率返回值目的是为了支持连续赋值
检测是否自己给自己赋值

c. 特性

1. 用户没有显式实现时，编译器会生成一个默认赋值运算符重载：a.内置类型成员变量是以值的方式逐字节拷贝赋值 b.自定义类型成员变量自动调用其赋值运算符重载完成赋值

类中如果没有涉及资源申请时，赋值运算符重载写不写都可以。

一旦涉及到资源申请时，则赋值运算符重载一定要写，否则就是浅拷贝，拷贝的指针，因此会指向同一空间。

2. 赋值运算符只能重载成为类的成员函数，不能重载成全局函数
   

赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现一个全局的赋值运算符重载，就会和编译器在类中生成的默认赋值运算符重载冲突，故赋值运算符重载只能是类的成员函数

d. 前置++与后置++重载

class Date
{
public:
	// 前置++：
	Date& operator++()
	{
		_day += 1;
		return *this;
	}
    
	// 后置++：
	Date operator++(int)
	{
		Date temp(*this);//拷贝构造
		_day += 1;
		return temp;
	}
private:
	int _year;	
	int _month;		
	int _day; 
};

前置++：

返回+1之后的结果

后置++：

为让前置++与后置++能正确重载，C++规定后置++重载时多增加一个int类型的参数，但调用时该参数不用传递，编译器自动传递

返回+1之前的结果

因此在实现时需要先将this保存一份，然后给this + 1。又因为temp是临时对象，因此只能以值的方式返回，不能返回引用

6. 取地址运算符重载

class Date
{
public:
    //取地址运算符重载:
	Date* operator&()
	{
		return this;
	}
    //const对象的取地址运算符重载:
	const Date* operator&()const
	{
		return this;
	}
private:
	int _year = 2022;
	int _month = 9;
	int _day = 3;
};
int main()
{
    Date d1;
    const Date d2;
    &d1;
    &d2;
    
    return 0;
}

编译器默认情况会自动生成这两个取地址运算符重载。

一般不需要显示定义，除非你不希望该类型对象能够进行取地址操作

三.其他

1. const成员函数

a. 简介

将const放在成员函数()后的位置，来修饰该函数，称为const成员函数

实际上const修饰的是该成员函数参数列表中隐含的this指针

如果将const放在成员函数开始，表明返回类型为const的

b. 使用

---

2. 初始化

a. 再谈构造函数

在创建对象时，编译器会自动调用构造函数，完成对象成员变量的初始化 。

但是实际上构造函数完成的不是对对象成员变量的初始化，而是赋值工作。

在构造函数体内可以进行多次赋值。而初始化这是在开辟空间时就给变量初始值

对于上述问题的解决，可以在B类中，增加默认构造函数。但是A()函数体创建对象temp来对B _b赋值的方式效率低，因此c++引入初始列表来解决该问题

b. 初始化列表

初始化列表：

以冒号:开始，以逗号,分隔成员变量，每个成员变量后是一个放在括号中的初始值(可以是表达式)

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. 成员变量在类中声明次序就是其在初始化列表里进行初始化的顺序，与其在初始化列表中的先后次序无关 。
   

c. explicit

  构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数，还具有类型转换的作用

上例中，代码的可读性不是很好，用explicit修饰构造函数，将禁止构造函数的隐式转换。

3. static成员

a. 简介

  用static修饰的类成员，称之为类的静态成员。

class A
{
public:
	A()
	{
		_count++;
	}
	static int GetCount()//静态成员函数
	{
		return _count;
	}
private:
	static int _count;//静态成员变量
};
//初始化
int A::_count = 0;

b. 特性

1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区

2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明

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

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

5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制

4. 友元

a. 简介

由于类通常采用封装，来限制外界的访问。但如果遇到特殊情况，需要访问privated /pretected修饰的成员。友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

格式：在类中 friend + 声明

b. 友元函数

在Date类中，使用关键字friend+该类友元函数的声明，则在该函数中，可以访问私有成员

1. 友元函数可访问类的私有和保护成员，但不是类的成员函数
2. 友元函数不能用const修饰
3. 友元函数可以在类定义的任何地方声明，不受类访问限定符限制
4. 一个函数可以是多个类的友元函数
5. 友元函数的调用与普通函数的调用原理相同

c. 友元类

一个类的友元类与友元函数类似，都是可以访问该类的非公有成员

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

   如上例中，Date是Time的友元类，Date中可以访问Time中的成员变量。反之不行

2. 友元关系不能传递

   如果B是A的友元类，C是B的友元类，不能传递所以C不是A的友元类。

3. 友元关系不能继承。

5. 内部类

概念：如果一个类定义在另一个类的内部，该类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。

内部类就是外部类的友元类，可以访问外部类中的所有成员。外部类不是内部类的友元。

特性：

1. 内部类可以定义在外部类的public、protected、private访问限定符下且被其修饰，默认为private。
2. 内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
3. 外部类的大小(sizeof(外部类))和内部类无关 。内部类是一个独立的类，它不属于外部类。

🦀🦀观看~