【Cpp筑基】五、类的继承、虚函数、抽象基类

已于 2024-08-10 17:54:24 修改
阅读量1k 收藏 10
点赞数 16
分类专栏： # C\Cpp 文章标签： 开发语言 cpp c++
于 2024-08-10 16:33:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44940689/article/details/141067994
版权

【Cpp筑基】五、类的继承、虚函数、抽象基类

Cpp系列笔记目录

【Cpp筑基】一、内联函数、引用变量、函数重载、函数模板
【Cpp筑基】二、声明 vs 定义、头文件、存储持续性作用域和链接性、名称空间
【Cpp筑基】三、对象和类
【Cpp筑基】四、重载运算符、友元、类的转换函数
【Cpp筑基】五、类的继承、虚函数、抽象基类

文章目录

1. 类的继承

在C++中，类的继承（inheritance）是一种创建新类（派生类）的方式，该新类可以从现有的类（基类）中继承属性和方法。继承是面向对象编程的一个核心特性，允许代码复用并提供了实现多态性的基础。从一个类派生出另一个类时，原始类被称为基类，继承类被称为派生类。

1.1 基本语法

C++中，继承使用的是冒号:来指明基类。派生类从基类继承成员（成员变量和成员函数）。语法如下：

class BaseClass {
    // 基类成员
};

class DerivedClass : access-specifier BaseClass {
    // 派生类成员
};

其中access-specifier用于指定访问控制权限，可以指定三种访问控制权限：

  • public继承：基类的public成员在派生类中保持为public，protected成员保持为protected，private成员不可访问。
  • protected继承：基类的public成员和protected成员在派生类中都变为protected，private成员不可访问。
  • private继承：基类的public成员和protected成员在派生类中都变为private，private成员不可访问。

举个例子：

class Base {
public:
    int publicVar;
protected:
    int protectedVar;
private:
    int privateVar;
};

class BasePlus : public Base {
    // publicVar -> public
    // protectedVar -> protected
    // privateVar -> 不可访问
};

在完成继承之后，派生类储存了基类的数据成员（派生类继承了基类的实现）；派生类对象可以使用基类的方法（派生类继承了基类的接口）。

1.2 派生类的构造和析构函数

在C++中的继承关系中，构造函数和析构函数的调用顺序和方式有其特定的规则。这些规则确保了基类和派生类的对象在构造和销毁时都能正确初始化和清理。下面将详细介绍这些规则以及构造和析构函数在继承中的使用方式

  • 构造函数：派生类的构造函数调用时，会首先调用基类的构造函数。基类构造函数可以在初始化列表中显式调用。
  • 析构函数：析构函数的调用顺序与构造函数相反，首先调用派生类的析构函数，然后自动调用基类的析构函数。

派生类不能直接访问基类中的私有private成员，而必须通过基类方法进行访问（即必须使用基类的方法来访问私有的基类成员变量），这就意味着派生类的构造函数必须使用基类的构造函数。当你创建派生类的对象时，基类的构造函数总是会被调用。这是因为派生类继承了基类的成员，基类部分需要在派生类的构造函数执行之前被初始化。

显式调用：在派生类的构造函数中，你可以通过初始化列表显式调用基类的某个构造函数。这在你需要传递参数给基类的构造函数时是必要的。举个例子：

class Base {
public:
    Base(int x) {
        // 基类构造函数
    }
};

class Derived : public Base {
public:
    Derived(int x, int y) : Base(x) {  // 显式调用基类构造函数
        // 派生类构造函数
    }
};

隐式调用：如果你在派生类的构造函数中没有显式调用基类的构造函数，编译器会自动调用基类的默认构造函数（如果存在）。但如果基类没有默认构造函数，而你又没有在派生类中显式调用基类的其他构造函数，那么代码将无法编译。

class Base {
public:
    Base() {
        // 基类默认构造函数
    }
};

class Derived : public Base {
public:
    Derived() {
        // 派生类构造函数，隐式调用Base()
    }
};

派生类构造函数的要点如下：

  • 首先创建基类对象；
  • 派生类构造函数应通过成员初始化列表将基类信息传递给基类构造函数；
  • 派生类构造函数应初始化派生类新增的数据成员。

举个例子：

#include <iostream>
#include <string>

// 基类：Animal
class Animal {
protected:
    std::string name;
    int age;

public:
    Animal(const std::string& name, int age) : name(name), age(age) {
        std::cout << "Animal Constructor: " << name << std::endl;
    }
};

class Mammal : public Animal {
protected:
    std::string furColor;

public:
	// 使用基类的构造函数来初始化基类的成员，然后初始化派生类的成员
    Mammal(const std::string& name, int age, const std::string& furColor)
        : Animal(name, age), furColor(furColor) {			
        std::cout << "Mammal Constructor: " << name << std::endl;
    }
};

1.3 基类和派生类的关系

派生类和基类之间存在一些关系：

  • 派生类可以使用基类的非私有private方法；
  • 基类指针可以在不进行显示类型转换的情况下指向派生类；
  • 基类引用可以在不进行显示类型转换的情况下引用派生类；
  • 基类指针或引用只能调用基类的方法，而不能调用派生类的方法。（这一点非常好理解，因为派生类会存在一些基类没有的成员变量，当派生类方法可能会操作这些变量，所以基类方法不能调用派生类的方法）

举个例子：

// Animal是基类, Dog是派生类
#include <iostream>
#include <string>
// 基类：Animal
class Animal {
protected:
    std::string name;
public:
    Animal(const std::string& name) : name(name) {}
    void makeSound() const {
        std::cout << name << " makes a sound!" << std::endl;
    }
    void displayInfo() const {
        std::cout << "Animal Name: " << name << std::endl;
    }
};
// 派生类：Dog
class Dog : public Animal {
public:
    Dog(const std::string& name) : Animal(name) {}
    // 重写基类方法
    void makeSound() const {
        std::cout << name << " barks!" << std::endl;
    }
    void wagTail() const {
        std::cout << name << " is wagging its tail!" << std::endl;
    }
};
int main() {
    Dog myDog("Buddy");
    // 1. 基类指针可以指向派生类对象
    Animal* animalPtr = &myDog;
    // 2. 基类引用可以引用派生类对象
    Animal& animalRef = myDog;
    // 调用基类方法
    animalPtr->makeSound();  // 输出: Buddy makes a sound!
    animalRef.displayInfo(); // 输出: Animal Name: Buddy
    // 注意：通过基类指针或引用，不能直接调用派生类的方法
    // animalPtr->wagTail(); // 错误：Animal类没有wagTail方法
    return 0;
}

1.4 多态公有继承

派生类可能会遇到这样的情况，希望同一个方法在派生类和基类中的行为是不同的，换句话来说，方法的行为应该取决于调用该方法的对象，这种较为复杂的行为称为多态——具有多种形态，即同一个方法随上下文而异。有两种方式可以实现多态公有继承：

  • 在派生类中重写override，也称为覆盖基类方法
  • 使用虚函数（在下一节中介绍）

在派生类中重写基类方法，如上面的例子中，我们在派生来Dog中覆盖了基类Animal中的makeSound()方法。

class Animal {
public:
	...
    void makeSound() const {
        std::cout << name << " makes a sound!" << std::endl;
    }
};
// 派生类：Dog
class Dog : public Animal {
public:
	...
	// 覆盖基类方法
    void makeSound() const {
        std::cout << name << " barks!" << std::endl;
    }
};

int main(){
	Dog myDog("Buddy");
	Animal* animalPtr = &myDog;
	Dog* dogPtr = &myDog;
	// 基类指针调用基类方法，不能调用派生类方法
    animalPtr->makeSound();  // 输出: Buddy makes a sound!
    // 派生类指针调用派生类方法
    dogPtr->makeSound();		// 输出: Buddy barks
}

这里简单区别一下重载与覆盖

  • 重载（Overloading）：在同一个类中，具有相同名称但参数列表不同的方法被称为重载。
  • 覆盖（Overriding）：派生类中的方法与基类的方法具有相同的名称和参数列表，但派生类的方法会“覆盖”基类的方法。这种覆盖通常通过virtual关键字来实现动态多态性。
    如果你不使用virtual，那么派生类的方法虽然可以覆盖基类的方法，但当你通过基类指针或引用调用这个方法时，不会调用派生类的方法，而是调用基类的方法。这是因为在没有virtual的情况下，方法调用是静态绑定的。

2. 虚函数

虚函数（Virtual Function）是一个在基类中使用 virtual 关键字声明的成员函数，它允许派生类重写这个函数。虚函数的主要目的是支持运行时多态性，使得通过基类指针或引用可以调用派生类的重写版本，而不是基类的版本。

在上面的例子中，我们希望当我们使用基类指针指向派生类对象的时候，能够调用派生类的方法，这样我们就可以使用基类指针来管理派生类的对象了。这就需要用到virtual关键字所代表的虚函数，我们将上述例子中的makeSound()函数改写成虚函数的形式，如下：

// Animal是基类, Dog,Cat是派生类
#include <iostream>
#include <string>
// 基类：Animal
class Animal {
protected:
    std::string name;
public:
    Animal(const std::string& name) : name(name) {}
    virtual void makeSound() const {
        std::cout << name << " makes a sound!" << std::endl;
    }
    void displayInfo() const {
        std::cout << "Animal Name: " << name << std::endl;
    }
};
// 派生类：Dog
class Dog : public Animal {
public:
    Dog(const std::string& name) : Animal(name) {}
    // 重写基类方法
    void makeSound() const override {
        std::cout << name << " barks!" << std::endl;
    }
    void wagTail() const {
        std::cout << name << " is wagging its tail!" << std::endl;
    }
};
// 派生类：Cat
class Cat : public Animal {
public:
    Cat(const std::string& name) : Animal(name) {}
    // 重写基类方法
    void makeSound() const override {
        std::cout << name << " miao!" << std::endl;
    }
};
int main() {
    Dog myDog("Buddy");
    Cat myCat("Kitty");
    // 1. 基类指针可以指向派生类对象
    Animal* animalPtr = &myDog;
    // 2. 基类引用可以引用派生类对象
    Animal& animalRef = myCat;
    // 调用基类方法
    animalPtr->makeSound();  // 输出: Buddy barks!
    animalRef.makeSound(); // 输出: Kitty miao!
    return 0;
}

需要注意上面例子中virtual与override关键字的用法，virtual关键字用于指定函数在运行时支持动态绑定，这意味着通过基类指针或引用调用该函数时，会调用派生类中对应的重写函数，而不是基类版本。override关键字用于派生类的成员函数定义中，指示该函数是对基类中虚函数的重写，但注意在某些Cpp标准中，override不是必须的，但是尽量需要加上override用于指定该成员函数是重写基类的虚函数。

2.1 静态联编与动态联编

程序调用函数时，将使用哪个可执行代码呢？编译器负责回答这个问题，将源代码中的函数调用解释为执行特定的函数代码块被称为函数名联编（binding），在C语言中，这非常简单，因为每个函数名都对应一个不同的函数，在Cpp中，由于函数重载的缘故，这项任务更复杂，编译器必须查看函数参数以及函数名才能确定使用哪个函数，然而，C/C++编译器可以在编译过程中完成这种联编，在编译过程中进行联编被称为静态联编（static binding）。然而虚函数的出现让这项工作变得困难，所以编译器必须能够在程序运行时选择正确的虚函数方法的代码，这被称为动态联编（dynamic binding）。

这里存在一个类型提升的问题，将派生类引用或指针转为基类引用或指针被称为向上强制转换（upcasting），这是因为派生类是继承自基类，拥有基类对象的所有数据成员和成员函数，这种转换是可以允许的，举个例子，现在有基类Animal和派生类Cat，我们可以这样做

void useBasePtr(Animal an);
Cat mycat;
useBasePtr(mycat);			//相当于，(Animal)mycat，将mycat对象从Cat类型转化为Animal类型了

相反的过程——将基类指针或引用转换为派生类指针或引用被称为向下强制转换（downcasting），如果不使用显示类型转换，则向下类型转换是不被允许的。举一个完整的例子：

// Animal是基类, Dog是派生类
#include <iostream>
#include <string>
// 基类：Animal
class Animal {
protected:
    std::string name;
public:
    Animal(const std::string& name) : name(name) {}
    virtual void makeSound() const {
        std::cout << name << " makes a sound!" << std::endl;
    }
};
// 派生类：Cat
class Cat : public Animal {
public:
    Cat(const std::string& name) : Animal(name) {}
    // 重写基类方法
    void makeSound() const override {
        std::cout << name << " miao!" << std::endl;
    }
};
void fr(Animal* an) {
    an->makeSound();
};
void fp(Animal& an) {
    an.makeSound();
}
void fv(Animal an) {
    an.makeSound();
}
int main() {
    Cat myCat("Kitty");
    fr(&myCat);         // use Cat::makeSound()
    fp(myCat);          // use Cat::makeSound()
    fv(myCat);          // use Animal::makeSound(),向上强制转换
    return 0;
}

2.2 虚函数表与虚函数指针

在C++中，虚函数的实现依赖于两个重要的概念：虚函数表（Virtual Table，vtable）和虚函数指针（Virtual Table Pointer，vptr）。它们是实现动态联编和多态性的核心机制。

虚函数表是编译器为每一个包含虚函数的类生成的一个隐式结构。这个结构包含了指向该类的虚函数实现的指针列表。每个包含虚函数的类（或派生类）都会有一个虚函数表。

特点：

  • 虚函数表是一个表格，包含了该类中所有虚函数的地址。
  • 如果一个类没有虚函数，那么它不会有虚函数表。
  • 派生类继承了基类的虚函数表，并且可以覆盖或扩展虚函数表。

工作方式：

  • 当程序运行时，如果通过基类指针或引用调用虚函数，编译器会查找对象的虚函数表，并使用其中的函数指针调用实际的函数实现。

虚函数指针是每个对象中隐含的指针，指向该对象所属类的虚函数表。每个包含虚函数的对象都有一个虚函数指针（vptr），这个指针在对象的构造函数中被自动初始化，指向正确的虚函数表。

特点：

  • vptr是对象的一部分，通常由编译器隐式管理。
  • 当对象创建时，构造函数会设置vptr指向正确的虚函数表。
  • 在派生类对象中，vptr指向派生类的虚函数表。

工作方式：

  • 当对象调用虚函数时，编译器通过vptr查找到对应的虚函数表，并根据表中的指针调用适当的函数实现。
  • 如果派生类重写了基类的虚函数，派生类的虚函数表会指向新的函数实现，而不是基类的实现。

2.2 构造函数与析构函数，谁应该是虚函数？

构造函数不能是虚函数，创建派生类对象时，将调用派生类的构造函数，而不是基类的构造函数，然后，派生类的构造函数将使用基类的构造函数，这种顺序不同于继承机制。因此，派生类不继承基类的构造函数，所以将构造函数声明为虚virtual的没有意义。

举个例子：

class Base {
public:
    Base() {
        std::cout << "Base Constructor" << std::endl;
    }
    virtual void show() {
        std::cout << "Base show()" << std::endl;
    }
};

class Derived : public Base {
public:
    Derived() {
        std::cout << "Derived Constructor" << std::endl;
    }
    void show() override {
        std::cout << "Derived show()" << std::endl;
    }
};

int main() {
    Derived obj;  // 构造顺序：Base Constructor -> Derived Constructor
    return 0;
}

析构函数应该是虚函数，原因是在面向对象编程中，如果通过基类指针删除一个派生类对象，而基类的析构函数不是虚函数，程序将只调用基类的析构函数，派生类的析构函数不会被调用。这会导致派生类中动态分配的资源没有被正确释放，造成内存泄漏等问题。

举个例子：

#include <iostream>

class Base {
public:
    Base() {
        std::cout << "Base Constructor" << std::endl;
    }
    virtual ~Base() {
        std::cout << "Base Destructor" << std::endl;
    }
};

class Derived : public Base {
public:
    Derived() {
        std::cout << "Derived Constructor" << std::endl;
    }
    ~Derived() {
        std::cout << "Derived Destructor" << std::endl;
    }
};

int main() {
    Base* basePtr = new Derived();
    delete basePtr;  // 正确调用Base和Derived的析构函数
    return 0;
}

3. 抽象基类

在C++中，纯虚函数和抽象基类是实现抽象和接口的一种机制，用于创建不能直接实例化的类，并强制派生类提供具体的实现。这是面向对象编程中的关键概念，尤其在设计框架、库和接口时非常有用。

3.1 纯虚函数

纯虚函数是一种没有实现的虚函数。它只在基类中声明，必须在派生类中被重写。纯虚函数的存在使得一个类成为抽象类，不能被直接实例化。

特点：

  • 纯虚函数在声明时没有函数体（即可以不提供抽象基类的函数体），用=0来表示。
  • 任何包含一个或多个纯虚函数的类都是抽象类，不能直接创建该类的对象。

举个例子：

// 拥有纯虚函数就称为了抽象基类
class Base {
public:
    virtual void display() = 0;  // 纯虚函数，没有实现
};

3.2 抽象基类

抽象基类是指包含至少一个纯虚函数的类。抽象基类不能直接实例化，它的目的是为派生类提供接口或基本行为。派生类必须实现抽象基类中的所有纯虚函数，才能实例化派生类对象。

特点：

  • 抽象基类通常用作接口定义，强制派生类实现特定的功能。
  • 抽象基类可以包含普通的成员函数和数据成员，这些成员可以在派生类中继承。
  • 抽象基类无法实例化，但可以用于定义指向派生类对象的指针或引用，从而实现多态性。

举个例子：

#include <iostream>
// 抽象基类
class Shape {
public:
    virtual void draw() = 0;  // 纯虚函数，派生类必须实现
    virtual ~Shape() = default;  // 虚析构函数
};
// 派生类，实现了抽象基类中的纯虚函数
class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a circle" << std::endl;
    }
};
// 派生类，实现了抽象基类中的纯虚函数
class Square : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a square" << std::endl;
    }
};

int main() {
    Shape* shape1 = new Circle();
    Shape* shape2 = new Square();
    shape1->draw();  // 输出：Drawing a circle
    shape2->draw();  // 输出：Drawing a square
    delete shape1;
    delete shape2;
    return 0;
}

其中= default是 C++11 引入的一种语法，用于指示编译器生成默认的构造函数、析构函数或拷贝/移动操作符。这是一种显式要求编译器为我们生成函数体的方式。

Reference

《C++ Primier Plus》

木心
关注
专栏目录
C++学习篇?纯虚函数和抽象类
12-22
虚函数允许我们进行多态调用，即在基类指针或引用上调用派生类中的重写函数。纯虚函数的声明形式是在函数声明后面加上`=0`，表示这个函数没有实际的实现，而是作为接口供派生类实现。例如： ```cpp class Base { ...
C++ 虚函数和抽象类的简单应用(cpp&h文件)
07-08
在C++编程语言中，虚函数和抽象类是面向对象设计的重要组成部分，它们为多态性提供了基础。本文将深入探讨这两个概念，并结合VS2010开发环境下的实际应用进行讲解。 首先，我们来理解“虚函数”。虚函数是C++中实现...
CPP.rar_C++虚函数
09-24
至于“有关虚函数.txt”，则可能深入讨论虚函数的工作原理、纯虚函数（用于声明抽象类）、虚析构函数的重要性（确保基类的析构函数在派生类析构时也能被调用），以及C++11引入的`final`关键字（防止函数被进一步覆盖...
表面积和体积_抽象类Shape_shape类继承_
10-02
在C++中，我们通过包含至少一个纯虚函数（即只有声明没有实现的虚函数）来定义抽象类。这里的`Shape`类就是这样一个抽象类，它定义了计算表面积和体积的通用接口，但不具体实现这些功能，因为不同形状的对象（如...
详解C++纯虚函数与抽象类
08-18
详解C++纯虚函数与抽象类 C++中的虚函数和抽象类是两个非常重要的概念，它们在...虚函数可以让程序在运行时选择合适的成员函数，而抽象类可以定义派生类继承的接口。理解虚函数和抽象类的概念是学习C++的重要一步。
嵌入式鸿蒙系统开发语言与开发方法分析
嵌入式技术开发
09-10 1108
可复用的UI单元，可组合其它组件，如上述被@Component装饰的struct Hello。UI描述:声明式的方法来描述UI的结构，例如build()方法中的代码块。
【c++23种设计模式概述】
m0_45463480的博客
09-09 834
c++23种设计模式概述。
C语言作用域
天道酬勤
09-07 1040
作用域 (scope) 是描述程序可以访问标识符的区域。块是一对花括号 {} 括起来的区域 或 函数体内任意复合语句定义范围内的区域。定义在块中的变量具有块作用域。块作用域的变量的可见范围从定义处开始到该块定义范围的末尾为止。函数作用域是在整个函数体内可见的意思，在 C 程序中，函数形参和 goto 语句的标签具有函数作用域，在整个函数体内可见。在所有函数外定义的变量具有全局作用域，在整个程序都可见。在数据类型前加 static 关键字定义的全局变量具有文件作用域。
Linux和C语言（Day10）
weixin_65095004的博客
09-10 1134
实现特定功能的代码块定义函数： 存储类型 数据类型 函数名(参数列表){ 实现特定功能的代码块 }
＜C++＞ set、map模拟实现
prodigy623的博客
09-10 856
set、map仿STL模拟实现
C和指针：预处理(#include/define/if...)
暮色年华的博客
09-10 721
预处理器把所有name替换成 stuff。在程序中扩展#define定义符号和宏时，需要涉及几个步骤：1.在调用宏时，首先对参数进行检查，看看是否包含了任何由#define 定义的符号。如果是，它们首先被替换。2.替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被它们的值所替代。3.最后，再次对结果文本进行扫描，看看它是否包含了任何由#define 定义的符号。如果是，就重复上述处理过程。这样，宏参数和#define 定义可以包含其他#define定义的符号。但是，宏不可以出现递归。
C++ #include ＜cstring＞（详解）
qq_51753728的博客
09-08 1041
是在 C++ 程序中引入头文件<cstring>的语句。这个头文件提供了用于处理 C 风格字符串（即以空字符'\0'结尾的字符数组）的函数。具体来说，<cstring>（1）strcpystrcpy是cstring中用于复制 C 风格字符串的函数，它将源字符串的内容复制到目标字符串中，包括末尾的空字符 ('\0'使用strcpy时需要确保目标数组有足够的空间来存放源字符串。source。
C 标准库 - `＜float.h＞`
wjs2024的博客
09-08 312
float.h>是 C 标准库中的一个头文件，它定义了与浮点数类型相关的宏。这些宏提供了关于浮点数的属性信息，如精度、最小和最大值、以及舍入误差等。这个头文件对于需要精确控制浮点数行为的程序非常有用，尤其是在数值计算和科学计算领域。<float.h>是 C 标准库中一个重要的头文件，它提供了关于浮点数的属性信息，对于需要精确控制浮点数行为的程序非常有用。掌握<float.h>中的宏，可以帮助开发者更好地理解和处理浮点数。
C++ Qt开发：运用QJSON模块解析数据
最新发布
qq_35662333的博客
09-11 1003
转载Qt 是一个跨平台C++图形界面开发库，利用Qt可以快速开发跨平台窗体应用程序，在Qt中我们可以通过拖拽的方式将不同组件放到指定的位置，实现图形化开发极大的方便了开发效率，本章将重点介绍如何运用QJson组件的实现对JSON文本的灵活解析功能。JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，它易于人阅读和编写，也易于机器解析和生成。该格式是基于JavaScript语言的一个子集，但它是一种独立于语言的数据格式，因此可以在许多不同的编程语言中使用。
STL经典案例（四）——实验室预约综合管理系统（项目涉及知识点很全面，内容有点多，耐心看完会有收获的！）
beyond谚语的博客
09-08 442
高校实验室预约管理系统 管理员：创建实验室教师账号、学生账号、实验室；查看实验室教师、学校、实验室信息；清空所有学生的预约记录 学生：申请实验室预约、查看所有实验室预约 实验室教师：审核学生的申请、查看所有学生的实验室申请预约
C++（二）----类和对象
weixin_73579966的博客
09-11 763
众所周知，C++与C语言不同的地方就是，C++引入了类和对象，可以在兼容C语言的同时面向对象编程，同时具备了封装、继承、多态三种特点（划重点）。面向对象可以说是C++最重要的部分了，而类和对象就是面向对象的基础，所以这一节我们学习类和对象。
C 语言实例：掌握基础与进阶技巧
wjs2024的博客
09-10 332
C 语言作为一门古老而强大的编程语言，自诞生以来就广受欢迎。它以其高效率、灵活性和功能强大著称，是许多现代编程语言的基础。本文旨在通过一系列实例，帮助读者深入理解 C 语言的基础知识和进阶技巧。
设计一个支持多线程写入的并发日志记录系统：C++实战指南
windowshht的博客
09-11 543
并发日志记录系统是一种能够在多线程环境中安全、高效地记录日志的系统。它需要解决多个线程同时写入日志时的数据竞争问题，确保日志的顺序和完整性。并发日志记录系统是多线程编程中的重要组成部分，通过合理使用互斥锁，可以有效地解决多线程写入日志时的数据竞争问题。本文详细介绍了如何在C++中设计一个支持多线程写入的并发日志记录系统，并提供了完整的代码示例和详细的解释。希望这篇文章能帮助你更好地理解和掌握并发日志记录技术。如果你有任何问题或需要进一步的解释，欢迎在评论区留言。祝你在多线程编程的学习和实践中取得好成绩！
C++ linux下的cmake
JackerCSDN的博客
09-08 488
cmake简单使用
C++编程：深度解析虚函数与虚基类应用
在实际编程中，虚函数和虚基类常用于设计模式如工厂模式、策略模式等，以及创建面向对象的接口和抽象基类，提高代码的可扩展性和复用性。理解并正确使用这些概念对于编写高质量的C++代码至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

木心

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值