【C++高阶（一）】继承

最新推荐文章于 2024-08-04 22:43:03 发布
最新推荐文章于 2024-08-04 22:43:03 发布
阅读量865 收藏 26
点赞数 25
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/G17861308017/article/details/139193568
版权

目录

一、继承的概念

1.继承的基本概念

2.继承的定义和语法

3.继承基类成员访问方式的变化

​编辑 4.总结

二、基类和派生类对象赋值转换

三、继承中的作用域

四、派生类的默认成员函数

1.派生类中的默认构造函数

2.派生类中的拷贝构造函数

3.派生类中的移动构造函数

4.派生类的拷贝赋值运算符

 5.派生类的移动赋值运算符

6.派生类的析构函数

为什么基类析构函数需要virtual关键字修饰？

理由：多态性和正确的析构顺序

问题：非虚析构函数导致的资源泄漏

总结

五、继承和友元

六、继承与静态成员

 七、复杂的菱形继承和菱形虚拟继承

1.单继承

2.多继承

3.菱形继承

 菱形继承的问题

4.菱形虚拟继承

5.虚拟继承解决数据冗余和二义性的原理

虚基表的工作机制

一、继承的概念

在C++中，继承是一种面向对象编程的重要特性，它允许一个类（称为派生类或子类）从另一个类（称为基类或父类）继承属性和行为（成员变量和成员函数）。通过继承，派生类不仅可以拥有基类的所有成员，还可以扩展或修改这些成员以提供更具体或特殊的功能。

1.继承的基本概念

  1. 基类（Base Class）：提供基础属性和行为的类。
  2. 派生类（Derived Class）：从基类继承并扩展或修改其功能的类。
  3. 访问控制（Access Control）：
    • Public 继承：基类的public和protected成员在派生类中保持其访问级别不变，public成员依然是public，protected成员依然是protected。
    • Protected 继承：基类的public和protected成员在派生类中都变为protected成员。
    • Private 继承：基类的public和protected成员在派生类中都变为private成员。
  4. 构造函数和析构函数：派生类的构造函数在执行前会先调用基类的构造函数，析构函数的调用顺序则相反，先调用派生类的析构函数，再调用基类的析构函数。
  5. 多重继承（Multiple Inheritance）：C++允许一个派生类从多个基类继承。

2.继承的定义和语法

class Base {
public:
    int baseValue;
    void baseFunction() {
        // 基类成员函数
    }
};

class Derived : public Base {
public:
    int derivedValue;
    void derivedFunction() {
        // 派生类成员函数
    }
};

3.继承基类成员访问方式的变化

 4.总结

  1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管是在类内还是在类外都不能去访问它。
  2. 基类private成员在派生类中是不能被访问的，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是继承才出现的。
  3. 实际上面的表格我们进行一下总结就能发现，基类的私有成员在子类中都是不可见的。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式),public > protected > private。
  4. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
  5. 在实际运用中一般都是使用public继承，几乎很少使用protected/private继承，也不提倡使用protected/private继承，因为 protected/private继承下来的成员都只能在派生类的类里使用，实际中扩展维护性不强。

二、基类和派生类对象赋值转换

  • 派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。
  • 基类对象不能赋值给派生类对象。
  • 基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。

class Base {
public:
    int baseValue;
    virtual void display() {
        std::cout << "Base class" << std::endl;
    }
};

class Derived : public Base {
public:
    int derivedValue;
    void display() override {
        std::cout << "Derived class" << std::endl;
    }
};

Base baseObj;
Derived derivedObj;

baseObj = derivedObj;  // 对象切割发生
baseObj.display();     // 输出 "Base class"

在上面的例子中，尽管derivedObj赋值给了baseObj，但baseObj只保留了Base类的部分，派生类的derivedValue被切割掉了，调用display函数时也只会调用基类的版本。

此外，C++允许使用基类的指针或引用来指向派生类对象，这可以实现多态性。多态性允许你通过基类接口调用派生类的重载函数。

Base* basePtr = &derivedObj;
basePtr->display();  // 输出 "Derived class"（多态性）

Base& baseRef = derivedObj;
baseRef.display();  // 输出 "Derived class"（多态性）

 在上面代码中，basePtr和baseRef都指向Derived对象，并且调用display方法时，会调用派生类Derived中的版本，这是因为display函数被声明为virtual。（virtual关键字我们下面会讲）

另外还有类型转换:static_cast和dynamic_cast，感兴趣的可以去了解下。

三、继承中的作用域

1. 在继承体系中 基类 和 派生类 都有 独立的作用域 。
2. 子类和父类中有同名成员， 子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，
也叫重定义。 （在子类成员函数中，可以 使用 基类 :: 基类成员 显示访问 ）
3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
4. 注意在实际中在 继承体系里 面最好 不要定义同名的成员 。 
// Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是非常容易混淆
class Person
{
protected :
 string _name = "小李子"; // 姓名
 int _num = 111;   // 身份证号
};
class Student : public Person
{
public:
 void Print()
 {
 cout<<" 姓名:"<<_name<< endl;
 cout<<" 身份证号:"<<Person::_num<< endl;
 cout<<" 学号:"<<_num<<endl;
 }
protected:
 int _num = 999; // 学号
};
void Test()
{
 Student s1;
 s1.Print();
};
// B中的fun和A中的fun不是构成重载，因为不是在同一作用域
// B中的fun和A中的fun构成隐藏，成员函数满足函数名相同就构成隐藏。
class A
{
public:
 void fun()
 {
 cout << "func()" << endl;
 }
};
class B : public A
{
public:
 void fun(int i)
 {
 A::fun();
 cout << "func(int i)->" <<i<<endl;
 }
};
void Test()
{
 B b;
 b.fun(10);
};

四、派生类的默认成员函数

在之前的学习中， 我们知道类可以自动生成一些默认的成员函数，这些成员函数包括默认构造函数、拷贝构造函数、移动构造函数、拷贝赋值运算符、移动赋值运算符和析构函数。而对于派生类，这些默认成员函数的生成和行为有一些特殊的规则和注意事项，下面我讲详细介绍。

1.派生类中的默认构造函数

默认构造函数在没有用户定义的构造函数时自动生成。对于派生类的默认构造函数，它会调用基类的默认构造函数（如果存在），然后初始化派生类的成员。而如果基类没有默认构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。

class Base {
public:
    Base() {
        std::cout << "Base default constructor" << std::endl;
    }
};

class Derived : public Base {
public:
    Derived() {
        std::cout << "Derived default constructor" << std::endl;
    }
};

int main() {
    Derived d;  // 输出：Base default constructor
                //      Derived default constructor
    return 0;
}

2.派生类中的拷贝构造函数

拷贝构造函数在没有用户定义的情况下自动生成，用于创建类的对象副本。派生类的拷贝构造函数会首先调用基类的拷贝构造函数，然后复制派生类的成员。

class Base {
public:
    Base(const Base&) {
        std::cout << "Base copy constructor" << std::endl;
    }
};

class Derived : public Base {
public:
    Derived(const Derived& other) : Base(other) {
        std::cout << "Derived copy constructor" << std::endl;
    }
};

int main() {
    Derived d1;
    Derived d2 = d1;  // 输出：Base copy constructor
                      //      Derived copy constructor
    return 0;
}

3.派生类中的移动构造函数

移动构造函数在没有用户定义的情况下自动生成，用于移动资源所有权。派生类的移动构造函数会首先调用基类的移动构造函数，然后移动派生类的成员。

class Base {
public:
    Base(Base&&) noexcept {
        std::cout << "Base move constructor" << std::endl;
    }
};

class Derived : public Base {
public:
    Derived(Derived&& other) noexcept : Base(std::move(other)) {
        std::cout << "Derived move constructor" << std::endl;
    }
};

int main() {
    Derived d1;
    Derived d2 = std::move(d1);  // 输出：Base move constructor
                                 //      Derived move constructor
    return 0;
}

4.派生类的拷贝赋值运算符

拷贝赋值运算符在没有用户定义的情况下自动生成，用于将一个对象的内容赋值给另一个对象。派生类的拷贝赋值运算符会首先调用基类的拷贝赋值运算符，然后赋值派生类的成员。

class Base {
public:
    Base& operator=(const Base&) {
        std::cout << "Base copy assignment operator" << std::endl;
        return *this;
    }
};

class Derived : public Base {
public:
    Derived& operator=(const Derived& other) {
        Base::operator=(other);
        std::cout << "Derived copy assignment operator" << std::endl;
        return *this;
    }
};

int main() {
    Derived d1, d2;
    d1 = d2;  // 输出：Base copy assignment operator
              //      Derived copy assignment operator
    return 0;
}

 5.派生类的移动赋值运算符

移动赋值运算符在没有用户定义的情况下自动生成，用于将一个对象的内容移动到另一个对象。派生类的移动赋值运算符会首先调用基类的移动赋值运算符，然后移动派生类的成员。

class Base {
public:
    Base& operator=(Base&&) noexcept {
        std::cout << "Base move assignment operator" << std::endl;
        return *this;
    }
};

class Derived : public Base {
public:
    Derived& operator=(Derived&& other) noexcept {
        Base::operator=(std::move(other));
        std::cout << "Derived move assignment operator" << std::endl;
        return *this;
    }
};

int main() {
    Derived d1, d2;
    d1 = std::move(d2);  // 输出：Base move assignment operator
                         //      Derived move assignment operator
    return 0;
}

6.派生类的析构函数

析构函数在没有用户定义的情况下自动生成，用于清理对象。派生类的析构函数会首先调用派生类的析构函数，然后调用基类的析构函数。

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

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

int main() {
    Base* b = new Derived();
    delete b;  // 输出：Derived destructor
               //      Base destructor
    return 0;
}

为什么基类析构函数需要virtual关键字修饰？

基类的析构函数需要加virtual关键字是为了确保在删除派生类对象时能够正确调用析构函数。这是一个非常重要的概念，尤其是在使用多态性和通过基类指针或引用操作派生类对象时。

理由：多态性和正确的析构顺序

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

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

当基类的析构函数是虚函数时，通过基类指针删除派生类对象时,C++会首先调用派生类的析构函数，然后再调用基类的析构函数。这确保了派生类中分配的资源可以先被正确释放，再释放基类中分配的资源。

int main() {
    Base* b = new Derived();
    delete b;  // 输出顺序：Derived destructor
               //           Base destructor
    return 0;
}

问题：非虚析构函数导致的资源泄漏

如果基类的析构函数不是虚函数，则通过基类指针删除派生类对象时，只会调用基类的析构函数，而不会调用派生类的析构函数。这会导致派生类中的资源没有被正确释放，造成资源泄漏。

class Base {
public:
    ~Base() {
        std::cout << "Base destructor" << std::endl;
    }
};

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

int main() {
    Base* b = new Derived();
    delete b;  // 只输出：Base destructor
    return 0;
}

在上述代码中，由于 Base 类的析构函数不是虚函数，删除 b 时只调用了 Base 的析构函数，Derived 类的析构函数没有被调用，这会导致 Derived 类中的资源没有被正确释放。

总结

为了确保在使用多态性时派生类对象可以被正确地销毁，避免资源泄漏，基类的析构函数应该声明为虚函数。这一做法可以保证删除派生类对象时，派生类和基类的析构函数都能被正确调用。以下是总结的要点：

  1. 多态性支持：使用基类指针或引用操作派生类对象时，确保正确调用派生类的析构函数。
  2. 正确的析构顺序：先调用派生类的析构函数，再调用基类的析构函数，确保资源正确释放。
  3. 避免资源泄漏：防止派生类中的资源没有被释放，导致内存泄漏或其他资源泄漏。

五、继承和友元

友元关系是单向的和局部的，友元关系不能继承！也就是说基类友元不能访问子类私有和保护成员。

#include <iostream>

// 基类
class Base {
private:
    int basePrivateVar;
protected:
    int baseProtectedVar;
public:
    int basePublicVar;

    Base() : basePrivateVar(1), baseProtectedVar(2), basePublicVar(3) {}

    friend void baseFriendFunction(Base &obj);
};

// 基类的友元函数
void baseFriendFunction(Base &obj) {
    std::cout << "Base Private Var: " << obj.basePrivateVar << std::endl;
    std::cout << "Base Protected Var: " << obj.baseProtectedVar << std::endl;
}

// 派生类
class Derived : public Base {
private:
    int derivedPrivateVar;
protected:
    int derivedProtectedVar;
public:
    int derivedPublicVar;

    Derived() : derivedPrivateVar(4), derivedProtectedVar(5), derivedPublicVar(6) {}

    friend void derivedFriendFunction(Derived &obj);
};

// 派生类的友元函数
void derivedFriendFunction(Derived &obj) {
    // 基类的友元不能访问派生类的私有或保护成员
    // std::cout << "Derived Private Var: " << obj.derivedPrivateVar << std::endl; // 错误
    // std::cout << "Derived Protected Var: " << obj.derivedProtectedVar << std::endl; // 错误

    std::cout << "Derived Public Var: " << obj.derivedPublicVar << std::endl;
}

int main() {
    Base baseObj;
    Derived derivedObj;

    baseFriendFunction(baseObj); // 可以访问Base类的私有和保护成员
    derivedFriendFunction(derivedObj); // 可以访问Derived类的公共成员

    // 基类的友元函数不能访问派生类的私有和保护成员
    // baseFriendFunction(derivedObj); // 错误

    return 0;
}

六、继承与静态成员

基类定义了static成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例。

静态成员变量需要在类外进行定义和初始化。静态成员函数则不需要在类外定义。

#include <iostream>

// 基类
class Base {
public:
    static int staticVar;  // 声明静态成员变量
    static void staticFunction() {  // 声明并定义静态成员函数
        std::cout << "Static Function in Base" << std::endl;
    }
};

// 定义静态成员变量
int Base::staticVar = 10;

// 派生类
class Derived : public Base {
public:
    void display() {
        std::cout << "Base staticVar: " << staticVar << std::endl;  // 访问基类的静态成员变量
        staticFunction();  // 调用基类的静态成员函数
    }
};

int main() {
    Derived obj;
    obj.display();

    // 静态成员可以通过类名直接访问
    Base::staticVar = 20;
    Derived::staticVar = 30;

    std::cout << "Base staticVar after modification: " << Base::staticVar << std::endl;
    std::cout << "Derived staticVar after modification: " << Derived::staticVar << std::endl;

    return 0;
}

静态成员的特点

  1. 类共享性：所有类的对象共享同一个静态成员变量。
  2. 类作用域：静态成员变量和静态成员函数在类作用域内，但可以通过类名直接访问。
  3. 内存管理：静态成员变量在程序启动时分配内存，程序结束时释放内存。

注意：

  • 静态成员函数：静态成员函数不能访问非静态成员变量和非静态成员函数，因为它们属于类本身，而不是类的某个对象。但是静态成员函数可以访问静态成员变量和其他静态成员函数。

 七、复杂的菱形继承和菱形虚拟继承

1.单继承

一个子类只有一个直接父类时称这个继承关系为单继承。

2.多继承

一个子类有两个或以上直接父类时称这个继承关系为多继承

3.菱形继承

菱形继承（也称钻石继承）是指一种特殊的多继承情况，其中一个类从两个基类继承，而这两个基类又继承自同一个祖先类。这种继承关系形成了一个菱形结构。

 菱形继承的问题

 从上面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。在Assistant的对象中Person成员会有两份。

#include <iostream>

// 祖先类
class A {
public:
    int value;
    A() : value(0) {}
};

// 两个派生类继承自 A
class B : public A {};
class C : public A {};

// 派生类 D 同时继承自 B 和 C
class D : public B, public C {};

int main() {
    D obj;
    // obj.value; // 错误：二义性问题，不知道是从 B 继承的 A 还是从 C 继承的 A

    // 解决方法之一是明确指定路径
    obj.B::value = 1;
    obj.C::value = 2;

    std::cout << "obj.B::value: " << obj.B::value << std::endl;
    std::cout << "obj.C::value: " << obj.C::value << std::endl;

    return 0;
}

4.菱形虚拟继承

为了解决上面菱形继承所带来的问题，我们可以使用虚拟继承。虚拟继承确保在菱形继承结构中只存在一个基类的实例。

如在上面的代码中，我们可以在B和C继承A的时候使用虚拟继承，即

class B : virtual public A {};
class C : virtual public A {};

需要注意的是，虚拟继承不要在其他地方去使用。

5.虚拟继承解决数据冗余和二义性的原理

class A
{
public:
 int _a;
};
// class B : public A
class B : virtual public A
{
public:
 int _b;
};
// class C : public A
class C : virtual public A
{
public:
 int _c;
};
class D : public B, public C
{
public:
 int _d;
};
int main()
{
 D d;
 d.B::_a = 1;
 d.C::_a = 2;
 d._b = 3;
 d._c = 4;
 d._d = 5;
 return 0;
}

下面是菱形继承的内存对象成员模型：这里可以看到数据冗余

下面是菱形虚拟继承的内存对象成员模型：

 

这里可以分析出D对象中将A放到了D对象组成的最下面，这个A同时属于B和C，那么B和C如何去找到公共的A呢？

这里是通过了B和C的两个指针，指向的一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存储的是偏移量，通过偏移量就能找到A 。

总结：

虚拟继承通过确保每个虚拟基类在派生类中只有一个共享实例，从而避免了重复实例化和二义性问题。为了实现这一点，编译器会使用虚基表来跟踪和管理虚拟基类的实例。

虚基表的工作机制

  1. 虚基表的引入： 每个使用虚拟继承的类会包含一个虚基表指针。这个指针指向一个虚基表，该表包含虚拟基类的指针。

  2. 共享基类实例： 在派生类（如 D）的对象中，虚基表指针确保所有虚拟基类实例都指向同一个实际基类实例。这意味着 D 中只有一个 A 类的实例。

  3. 成员访问的重定向： 在访问基类成员时，编译器使用虚基表来正确地定位基类成员，确保访问的是唯一的基类实例。

所以，当一个类虚拟继承另一个类时，编译器在对象布局中插入一个虚基表指针（vbptr）。这个指针指向一个虚基表（vbtbl），而虚基表中包含指向虚拟基类的偏移量或地址。通过这种方式，每个派生类能够正确地定位并访问唯一的虚拟基类实例。

上面就是我们对C++继承的全部理解了~

说记得我的好_
关注
  • 25
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 10
    评论
专栏目录
21天学通c++牛津高阶双解词典.zip
10-16
而《牛津高阶双解词典》则是一部权威的双语词典，对于学习C++这样的英文编程语言来说，尤其重要。它不仅提供了英汉词汇的精准翻译，还包含了丰富的例句和用法说明，帮助读者更好地理解和运用专业术语。这对于阅读...
深度探索C++对象模型
02-11
模板元编程是更高级的技术，它利用模板作为编译时计算的工具，实现了类似函数式编程中的高阶函数功能。 此外，C++的对象模型还包括异常处理和命名空间。异常处理为错误处理提供了一种结构化的方式，通过try-catch块...
＜C++中的继承＞——《C++高阶》
m0_57859086的博客
08-09 203
＜C++中的继承＞——《C++高阶》
【C++高阶】C++继承学习手册：全面解析继承的各个方面
EterNity_TiMe_的计算机学习之路
06-13 2108
当我们踏上C++编程的旅程时，继承无疑是一个无法回避且至关重要的概念。作为面向对象编程的三大特性之一，继承不仅让我们能够创建出层次清晰、结构合理的代码，还极大地提高了代码的可重用性和可维护性。在本文中，我们将一起深入探讨C++继承的奥秘，从基础概念到高级应用，逐步揭开它的神秘面纱
C++ 高阶操作：模板元编程
青春不老，奋斗不止！
11-01 1526
星标/置顶公众号????，硬核文章第一时间送达！链接 | https://www.cnblogs.com/xiangtingshen/p/11613183.html泛型编程大家应该都很熟悉了，...
【C++高阶】：异常详解
island1314的博客
08-04 1032
✨惊起归鸿不成字，辞柯落叶最知秋🌏📃。
c++高阶-1-模板
ccb1372098的博客
07-03 381
类模板中的成员函数在调用时才创建。使用这个模板，有2种调用方法。
c++高阶编程(2)
Bobowen的博客
11-03 205
继承： // Person.h #include <iostream> #include <string> using namespace std; class Person { public: // 公有属性成员函数 Person(); ~Person(); void setName(const string &name); string getName() const; void setAge(int age); in
C++菱形继承_多态
努力学习C/C++
03-01 844
继承还有菱形继承没有解决，会在这篇解决菱形继承。本篇重点多态，多态在面试和笔试经常考，重点中的重点。
高阶C++ 一些备忘
weixin_47387060的博客
09-23 147
OOP 面向对象:封装是基础,继承是手段,多态是目的 泛型编程:参数化类型是基础，模板是手段，通用是目的。 面向对象的编程依赖运行时多态，泛型编程是编译时多态。 1. 避免使用vector<bool> 使用deque与bitset来替换vector deque提供了几乎所有vector所提供的成员函数（缺是reserve和capacity）。并且，deque是一个STL容器，它保存真正的bool值。 bitset不是一个STL容器，但它是C++标准库的一部分 2. 调用empty而不是检查s
【C++高阶(七)】C++异常处理的方式
杭电码农-NEO的博客
12-18 3246
本篇文章着重讲解了C++的异常处理方式,包括try,catch,throw三个关键字的用法以及RAII思想在异常体系中的使用.还讲解了自定义异常体系的设计和C++库中的异常体系.内附代码和图文讲解,看完就能学会
C++ 编程艺术 中文
11-28
1. **面向对象编程**：C++是面向对象的，它支持类、对象、封装、继承和多态等概念。书中会详细介绍如何设计和实现面向对象的系统，包括抽象类、接口、模板类以及智能指针等高级特性。 2. **STL（标准模板库）**：...
C++学习资料.rar
09-07
函数式编程的组合性、无副作用和高阶函数等概念，能帮助我们写出简洁、可测试的代码。 "加餐 再八卦几门语言！.pdf"可能涉及跨语言比较，这有助于拓宽我们的编程视野，理解不同语言的优缺点，从而更好地应用C++。 ...
C++核心编程讲义和相关代码
02-15
- **函数指针**：理解函数指针的用途和操作方式，以及它们在回调函数和高阶函数中的应用。 3. **类与对象**（面向对象编程） - **类的定义**：学习如何定义类，包括成员变量和成员函数，以及访问修饰符（public、...
【C语言】Top K问题【建小堆】
2301_80840905的博客
08-04 477
在我们生活中，经常会遇到TopK问题。建小堆解决
C++ STL copy, move 用法
08-04 227
前向（从前向后的顺序）拷贝/移动操作，将一个容器元素拷贝/移动到另一容器中。
【C++】输入输出
2401_83948390的博客
08-02 532
在C++中，输入输出操作主要通过标准库中的iostream头文件提供的一系列对象和函数来完成。
OD C卷 - 中庸行者
最新发布
weixin_45228198的博客
08-04 187
DFS
C++高阶编程：从对象到数据抽象与隐藏实现
"C++高阶编程教程深入讲解了面向对象（Object-Oriented Programming, OOP）在C++中的应用。该教程首先从基本概念入手，如对象的定义（特性与行为的结合）、继承（类型之间的层次关系）、多态性（允许不同类型的对象...
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值