C++_Note

类与对象

构造函数与析构函数

编译器提供的构造函数与析构函数都是空实现

构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用

析构函数：主要作用在与对象销毁前系统自动调用，执行一些清理工作

构造函数的语法：类名(){}

1.无返回值也不写void

2.函数名与类名相同

3.可以有参数，可以发生重载

4.程序在调用对象时会自动调用构造函数，无须手动调用，且只会调用一次

析构函数的语法：~类名(){}

1.无返回值也不写void

2.函数名与类名相同，在前 + ~

3.不可以有参数，不可以发生重载

4.程序在销毁对象时会自动调用析构函数，无须手动调用，且只会调用一次

构造函数的分类和调用

分类：

按参数分类：无参构造（默认构造）

​ 有参构造

按类型分类：普通构造

​ 拷贝构造

调用：

括号法

显示法

隐式转换法

note：

1.调用默认构造函数时，不要加() 会被编译器会认为是一个函数的声明，不会在认为是在创建对象

2.匿名对象，特点：当前行执行结束时， 系统会立即回收掉匿名对象

3.不要利用拷贝构造函数来初始化匿名对象

// 假设有个 Person 的一个类
// 编译器会认为 Person(p3) 等价于 Person p3(认为是一个对象的声明)

拷贝构造函数的调用时机

使用一个已经创建完毕的对象来初始化一个新对象

值传递的方式给函数传值

值方式返回局部对象

构造函数的调用规则

默认情况下，C++编译器会至少给一个类添加三个函数：

1.默认构造函数(无参，函数体为空)

2.默认析构函数(无参，函数体为空)

3.默认拷贝构造函数，对属性进行值拷贝

如果写了有参构造函数，编译器就不再提供默认构造，依然提供拷贝构造

如果写了拷贝构造函数，编译器就不再其他构造函数

深拷贝与浅拷贝

浅拷贝：简单的赋值拷贝

深拷贝：在堆区重新申请空间，进行拷贝操作

浅拷贝所带来的问题就是堆区的内存重复释放

自己实现拷贝构造函数解决浅拷贝，即称深拷贝，在堆区重新申请一个堆区的内存

note：

析构代码，把手动在堆区开辟的空间释放

如果属性在堆区有开辟内存，务必使用自己的拷贝构造函数，避免浅拷贝

初始化列表

作用：C++提供了初始化列表语法，来初始化属性

语法：构造函数():属性一(值1)，属性二(值2)……{函数体}

类对象作为类成员

类似结构体的一个成员是结构体

当其他类对象作为本类成员，构造时候先构造类对象，再构造自身

析构顺序与构造顺序相反

静态成员

静态成员是指在成员变量和成员函数前加上static关键字

class Person
{
    public:
    static int m_A;
    static void func()
    {
        ;
    }
}

分类：

静态成员变量：所有对象共享一份数据

​ 在编译阶段分配内存

​ 类内声明，类外初始化

静态成员函数：所有对象共享一个函数

​ 静态成员函数只能访问静态成员变量

note：静态成员变量（函数）不属于某一个对象，所有对象都共享同一份数据（函数）

因此静态成员变量（函数）有俩种访问方式：

1.通过对象进行访问

Person P1;
P1.m_A;
P1.func();

2.通过类名进行访问

Person::m_A;
Person::func();

静态成员变量（函数）也是有访问权限的

C++对象模型和this指针

成员变量和成员函数分来存储

空对象占用内存空间为：1

C++编译器会给每个空对象也分配一个字节的空间，是为了区分空对象占内存的位置

每个空对象也应该有一个独一无二的地址空间

成员	类别	是否属于类的对象上
int m_A	非静态成员变量	是
static int m_B	静态成员变量	否
void func(){}	非静态成员函数	否
static void func2(){}	静态成员函数	否

this指针概念

this指针指向被调用的成员函数所属的对象

this指针是隐含在每一个非静态函数内的一种指针

this指针不需要定义，直接使用即可

用途：

当形参与成员变量同名时，可以使用this指针来区分

在类的非静态成员函数中返回对象本身，可使用return *this，返回类的引用

note：

this的本质：指针常量，指针的指向是不可以修改的，this指针不可以修改指针的指向，this指针指向的值是可以修改的

空指针访问成员函数

const修饰成员函数 —限制只读

常函数：

成员函数加const后我们称这个函数为常函数
常函数不可修改成员属性

成员属性声明是加关键字mutable后，在常函数中依然可以修改

常对象：

声明对象前加const称该对象为常对象

常对象只能调用常函数

成员属性声明是加关键字mutable后，在常对象依然可以修改

常对象不可以调用普通成员函数，因为普通成员函数可以修改属性

note：

在类中成员函数后加const，修饰的是this指针，让指针指向的值也不可以修改

class Person
{
	public:
	void showperson() const{} // 常函数
    mutable int m_A;
}
// 不在成员函数加const this指针相当于Person * const
// 加const后，this指针相当于const Person * const
// 若成员类型前有mutable修饰，则该成员可以在常函数中修改

友元(friend)

友元的目的就是一个函数或者类访问另外一个类中的私有成员

friend关键字，对类内作用域权限无需求

实现方式：全局函数做友元

​ 类做友元

​ 成员函数做友元

#include <iostream>
#include <string>

using namespace std;

class Building;

void test01(Building *building);

class Friend
{
public:
    Friend();
    void othervisit();
private:
    Building * building;
};

class Goodgay
{
public:
    Goodgay();
    void visit();
private:
    Building *building;
};

class Building
{

    friend void test01(Building *building); // 全局函数做友元
    friend class Goodgay; // 类做友元
    friend void Friend::othervisit(); // 成员函数做友元

public:
    Building();
    string settingroom;

private:
    string badroom;
};


Friend::Friend()
{
    building = new Building;
}

void Friend::othervisit()
{
    cout << "好基友成员函数可以访问：" << building->settingroom << endl;
    cout << "好基友成员函数可以访问：" << building->badroom << endl;
}

Goodgay::Goodgay()
{
    building = new Building;
}

void Goodgay::visit()
{
    cout << "好基友类可以访问：" << building->settingroom << endl;
    cout << "好基友类可以访问：" << building->badroom << endl;
}

Building::Building()
{
    settingroom = "客厅";
    badroom = "卧室";
}

void test01(Building *building)
{
    cout << "好基友正在访问：" << building->settingroom << endl;
    cout << "好基友正在访问：" << building->badroom << endl;
}

void test02()
{
    Goodgay gg;
    gg.visit();
}

void test03()
{
    Friend ff;
    ff.othervisit();
}

int main()
{
    Building building;
    test01(&building);
    test02();
    test03();
    return 0;
}

运算符重载

对已有的运算符号重新定义，赋予其另外一种功能，以适应不同的数据类型

返回值类型 operator 运算符 (参数列表) 
{
    // 实现运算符功能的代码
}

实现方式：成员函数重载，全局函数重载

// 以重载加号运算符为例
// 成员函数重载的本质：
// Person p3 = p1.operator+(p2);
// 全局函数重载的本质：
// Person p3 = operator+(p1,p2);
// 都可以简化为：Person p3 = p1 + p2;

运算符重载也可以发生函数重载

继承：减少重复代码

基本语法：class 子类 : 继承方式 父类

子类 又称 派生类

父类 又称 基类

派生类的成员中包含：继承基类的成员(共性)，新增的成员(个性)

继承方式：公共 保护 私有

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qZlnHyoK-1684414372620)(/home/zhj/图片/2023-05-05_20-49.png)]

继承中的对象模型

父类中所有非静态成员属性都会被子类继承下去

父类的私有成员是被编译器隐藏了，因此是访问不到的，但的确是被继承下去了

继承中的构造和析构顺序

在C++中，当一个派生类继承了基类，其构造函数会首先调用基类的构造函数，然后才执行自己的构造函数。而析构函数的调用顺序则相反，先执行派生类的析构函数，再调用基类的析构函数。

继承中的同名成员处理

1.访问子类同名函数，直接访问

2.访问父类同名函数，需要加作用域

继承中的同名静态成员处理

在C++中，同名静态成员是可以被继承的。子类会继承父类中所有的静态成员，包括同名的静态成员。当子类和父类有同名的静态成员时，它们并不会冲突，而是各自独立存在于自己的作用域内。

多继承语法

C++允许一个类继承多个类

语法：class 子类 : 继承方式 父类1 , 继承方式 父类2 , …

当父类中出现同名成员，需要加作用域区分

多继承中的菱形继承问题以及解决方法

菱形继承是 C++ 中多重继承可能会引发的一个问题，它发生在当一个派生类同时继承自两个不同的基类，并且这两个基类又都继承自同一个基类时。这样就会导致在派生类中出现两份相同的间接基类子对象，其中一份或者两份都是多余的，从而浪费了内存和资源。

例如：

class A {
public:
  int a;
};

class B : public A {};

class C : public A {};

class D : public B, public C {};

上述代码中，D 类通过多重继承同时继承自 B 和 C 类，而 B 和 C 类又都直接继承自 A 类，这就形成了菱形继承结构。

为了解决菱形继承问题，C++ 引入了**虚继承（virtual inheritance）**的概念。使用虚继承可以让派生类只包含一个共享的间接基类子对象，这样就避免了浪费内存和资源的问题。

虚继承的语法是，在基类名前加上 virtual 关键字，例如：

class A {
public:
  int a;
};

class B : virtual public A {};

class C : virtual public A {};

class D : public B, public C {};

上述代码中，B 和 C 类在继承 A 类时使用了虚继承，这样在 D 类中就只会包含一个共享的间接基类子对象， 从而避免了菱形继承问题。

需要注意的是，使用虚继承可能会影响代码的性能和复杂度，因此需要根据实际情况进行权衡取舍。

多态

分类：静态多态，动态多态

静态多态：函数地址早绑定，编译阶段绑定

静态多态性（也称为编译时多态性）是通过函数重载和运算符重载实现的，它在编译时就确定了函数或运算符的行为。例如，当你在 C++ 中使用重载函数时，编译器会根据参数的数量和类型选择正确的函数。

动态多态：函数地址晚绑定，运行阶段绑定

动态多态性（也称为运行时多态性）则是通过虚函数实现的。在 C++ 中，如果一个成员函数被声明为虚函数，它就可以在派生类中被重写并覆盖基类中的实现。当你使用基类指针或引用调用虚函数时，实际上会调用派生类中的实现，这就是动态多态性的体现。

动态多态的满足条件：

• 有继承关系
• 子类重写父类的虚函数

动态多态的使用：父类的指针或者引用执行子类的的对象

动态多态的原理：

// 测试代码
#include <iostream>
using namespace ::std;

class Animal
{
public:
  virtual void speek()
  {
    cout << "动物在说话!" << endl;
  }
};

class Cat : public Animal
{
public:
  void speek()
  {
    cout << "小猫在说话!" << endl;
  }
};

void dospeek(Animal &animal)
{
  animal.speek();
}

void test()
{
  Cat cat;
  dospeek(cat);
}

int main()
{
  test();
  exit(0);
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-i8a4IZhe-1684414372620)(/home/zhj/.config/Typora/typora-user-images/image-20230508215321779.png)]

纯虚函数和抽象类

纯虚函数语法：virtual 返回值类型 函数名 (参数列表) = 0

抽象类：包含至少一个纯虚函数的类

• 无法实例化对象

• 子类必须重写抽象类中的纯虚函数，否则也属于抽象类

#include <iostream>
using namespace ::std;

class Shape
{
public:
  virtual double area() = 0; // 纯虚函数
};
// 这里定义了一个名为 Shape 的抽象类，并声明了一个纯虚函数 area()。由于这个函数没有定义实现，所以 Shape 类无法直接实例化。派生类必须实现 area() 函数才能创建实例

class Rectangle : public Shape
{
public:
  Rectangle(double w, double h) : width(w), height(h) {}
  double area() { return width * height; }

private:
  double width, height;
};
// 这里定义了一个名为 Rectangle 的派生类，它继承自 Shape 类，并实现了 area() 函数以计算矩形的面积。由于 Rectangle 类实现了 area() 函数，因此可以创建 Rectangle 类的实例。

int main()
{
  Rectangle rect(5.0, 4.0);
  double area = rect.area();
  cout << "Area of rectangle: " << area << endl;
  return 0;
}

虚析构和纯虚析构

多态使用时，若子类中有属性开辟在堆区，那么父类指针在释放时无法调用子类的析构代码，若子类中无属性开辟在堆区，可以不写为虚析构和纯虚析构

解决方式：将父类的析构代码改为虚析构和纯虚析构

虚析构和纯虚析构共性：

• 可以解决父类指针释放子类对象
• 都需要有具体的函数实现

虚析构和纯虚析构的区别：

• 如果是纯虚析构，该类属于抽象类，无法实例化对象
• 纯虚析构：需要声明也需要实现

文件操作

通过文件可以将数据持久化

文本文件：ASCII码形式存储

二进制文件：二进制形式存储

操作文件的三大类：

• ofstream：写操作
• ifstream：读操作
• fstream：读写操作

文本文件：

文件打开方式：

打开方式	解释
ios::in	为读文件而打开
ios::out	为写文件而打开
ios::ate	初始位置：文件尾
ios::app	追加方式写
ios::trunc	文件存在先删除，在创建
ios::binary	二进制文件

二进制文件：指定打开方式：ios::binary

写文件：write()

函数原型：ostream & writer(const char *buffer,int len);

读文件：read()

函数原型：istream & read(char *buffer,int len);

模板

函数模板：

函数语法：template <typename T> 函数声明或定义

利用函数模板的使用方法：

1.自动类型推导：函数名(参数...);

2.显示指定类型：函数名<参数类型>(参数...);

注意事项：

• 自动类型推导，必须推导出相同类型T,才可以使用
• 模板必须要确定出T的数据类型，才可以使用

普通函数与函数模板的区别：隐式类型转换是否发生

普通函数与函数模板的调用规则：

1.优先使用普通函数

2.可以通过空模板参数列表来强制调用函数模板

3.函数模板也可以发生重载

4.若函数模板可以产生更好的匹配，优先使用函数模板

类模板：

基本语法类：template <typename T> 类

与函数模板的区别：

1.类模板没有自动类型推导的使用方式

2.类模板在模板参数列表中可以有默认参数

类模板中的成员函数和普通类中的成员函数创建时机是有区别的：

1.普通类的成员函数一开始就可以创建

2.类模板中的成员函数在调用时才创建

类模板实例化出的对象，向函数传参的方式

实现方式有三种：

1.指定传入的类型 --直接显示对象的数据类型

2.参数模板化 --将对象中的参数变为模板进行传递

3.整类模板化 --将这个对象类型 模板化进行传递

类模板与继承：

当类模板碰到继承时，需要注意以下几点：

1.当子类继承的父类是一个类模板时，子类在声明的时候，要指出父类中T的类型

2.如果不指定，编译器无法给子类分配内存

3.如果灵活指定出父类中T的类型，子类也需要变为类模板

类模板成员函数类外实现：

template<class T1,class T2>
class Person
{
    public:
    Person(T1 name,T2 age);
    T1 name;
    T2 age;
    void ShowPerson();
}// 一个类模板
// 在类外实现Person的构造函数Person();
template<class T1,class T2>
void Person<T1,T2>::Person(T1 name,T2 age)
{
    this->name = namme;
    this->age = age;
}
// 类外实现Person的成员函数ShowPerson()
template(class T1,class T2)
void Person<T1,T2>::ShowPerson()
{
    cout << "Sucess" << endl;
}

类模板分文件编写 ：

1.直接包含源文件

2.将声明和实现写一起.hpp

类模板与友元：

全局函数类内实现，直接在类内声明友元即可

全局函数类外实现，需要提前让编译器知道全局函数的存在

test 实现一个自定义数组MyArray

这是一个实现动态数组（Dynamic Array）的模板类 MyArray，支持模板参数 T，即可以定义不同类型的数组。下面是代码的详细注释：

```c++
#include <iostream>
#include <string>

using namespace std;

template <class T>
class MyArray
{
public:
    MyArray(int capacity)
    {
        this->m_Capacity = capacity;
        this->m_Size = 0;
        this->Address = new T[this->m_Capacity];
    }

    ~MyArray()
    {
        if (this->Address != NULL)
        {
            delete[] this->Address;
            this->Address = NULL;
        }
    }

    MyArray(const MyArray &arr)
    {
        this->m_Capacity = arr.m_Capacity;
        this->m_Size = arr.m_Size;
        this->Address = new T[arr.m_Capacity];

        for (int i = 0; i < this->m_Size; i++)
        {
            this->Address[i] = arr.Address[i];
        }
    }

    MyArray &operator=(const MyArray &arr)
    {
        if (this->Address != NULL)
        {
            delete[] this->Address;
            this->Address = NULL;
            this->m_Capacity = 0;
            this->m_Size = 0;
        }

        this->m_Capacity = arr.m_Capacity;
        this->m_Size = arr.m_Size;
        this->Address = new T[arr.m_Capacity];
        for (int i = 0; i < this->m_Size; i++)
        {
            this->Address[i] = arr.Address[i];
        }
        return *this;
    }

    void Push_Back(const T &val)
    {
        if (this->m_Capacity == this->m_Size)
        {
            return;
        }
        this->Address[this->m_Size] = val;
        this->m_Size++;
    }

    void Pop_Back()
    {
        if (this->m_Size == 0)
        {
            return;
        }
        this->m_Size--;
    }

    T &operator[](int index)
    {
        return this->Address[index];
    }

    int GetCapacity()
    {
        return this->m_Capacity;
    }

    int GetSize()
    {
        return this->m_Size;
    }

private:
    T *Address;     // 指针指向堆区地址
    int m_Capacity; // 数组容量
    int m_Size;     // 数组大小
};

void PrintfIntArray(MyArray<int> &arr)
{
    for (int i = 0; i < arr.GetSize(); i++)
    {
        cout << arr[i] << " ";
    }
}

int main()
{
    // 创建一个容量为 5 的 MyArray<int> 对象
    MyArray<int> arr(5);

    // 向数组中插入元素
    arr.Push_Back(1);
    arr.Push_Back(2);
    arr.Push_Back(3);
    arr.Push_Back(4);
    arr.Push_Back(5);

    // 打印数组大小和容量
    cout << "Array size: " << arr.GetSize() << endl;
    cout << "Array capacity: " << arr.GetCapacity() << endl;

    // 打印数组元素
    PrintfIntArray(arr);
    cout << endl;

    // 删除数组尾部元素
    arr.Pop_Back();

    // 打印数组大小和容量
    cout << "Array size: " << arr.GetSize() << endl;
    cout << "Array capacity: " << arr.GetCapacity() << endl;

    // 打印数组元素
    PrintfIntArray(arr);
    cout << endl;

    // 创建另一个 MyArray<int> 对象并赋值给原对象
    MyArray<int> arr2(10);
    arr2.Push_Back(6);
    arr2.Push_Back(7);
    arr2.Push_Back(8);

    arr = arr2;

    // 打印数组大小和容量
    cout << "Array size: " << arr.GetSize() << endl;
    cout << "Array capacity: " << arr.GetCapacity() << endl;

    // 打印数组元素
    PrintfIntArray(arr);
    cout << endl;

    return 0;
}