【C++ Primer】第十五章：面向对象程序设计

最新推荐文章于 2026-01-09 20:10:30 发布
原创 最新推荐文章于 2026-01-09 20:10:30 发布 · 210 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #开发语言

面向对象程序设计是 C++ 的核心章节，涵盖了继承、多态、动态绑定等关键概念。这是理解 C++ 面向对象编程精髓的关键。

1. 继承基础

基本继承语法

// 基类
class Quote {
private:
    std::string bookNo;  // 私有成员，派生类不能访问
protected:
    double price;        // 受保护成员，派生类可以访问
public:
    Quote() = default;
    Quote(const std::string& book, double sales_price)
        : bookNo(book), price(sales_price) {}
    
    std::string isbn() const { return bookNo; }
    
    // 虚函数：派生类可以覆盖
    virtual double net_price(std::size_t n) const {
        return n * price;
    }
    
    // 虚析构函数：确保正确释放派生类对象
    virtual ~Quote() = default;
};

// 派生类
class Bulk_quote : public Quote {  // public 继承
private:
    std::size_t min_qty = 0;      // 享受折扣的最低购买量
    double discount = 0.0;        // 折扣额
public:
    Bulk_quote() = default;
    Bulk_quote(const std::string& book, double p, 
               std::size_t qty, double disc)
        : Quote(book, p), min_qty(qty), discount(disc) {}
    
    // 覆盖基类的虚函数
    double net_price(std::size_t n) const override {
        if (n >= min_qty) {
            return n * (1 - discount) * price;
        } else {
            return n * price;  // 没有折扣
        }
    }
};

继承中的访问控制

class Base {
public:
    int public_member;
protected:
    int protected_member;
private:
    int private_member;  // 派生类不能访问
};

class Public_Derived : public Base {
    // public_member 仍然是 public
    // protected_member 仍然是 protected
    // private_member 不可访问
};

class Protected_Derived : protected Base {
    // public_member 变为 protected
    // protected_member 仍然是 protected
    // private_member 不可访问
};

class Private_Derived : private Base {
    // public_member 变为 private
    // protected_member 变为 private
    // private_member 不可访问
};

2. 虚函数和多态

动态绑定机制

void print_total(std::ostream& os, const Quote& item, std::size_t n) {
    // 动态绑定：在运行时根据 item 的实际类型调用正确的 net_price
    os << "ISBN: " << item.isbn() 
       << " # sold: " << n 
       << " total due: " << item.net_price(n) << std::endl;
}

void polymorphism_demo() {
    Quote basic("123-456-789", 20.0);
    Bulk_quote bulk("123-456-789", 20.0, 10, 0.1);  // 10本以上打9折
    
    print_total(std::cout, basic, 15);  // 调用 Quote::net_price
    print_total(std::cout, bulk, 15);   // 调用 Bulk_quote::net_price
    // 输出：
    // ISBN: 123-456-789 # sold: 15 total due: 300
    // ISBN: 123-456-789 # sold: 15 total due: 270
}

虚函数表（vtable）概念

class Base {
public:
    virtual void func1() { std::cout << "Base::func1" << std::endl; }
    virtual void func2() { std::cout << "Base::func2" << std::endl; }
    void func3() { std::cout << "Base::func3" << std::endl; }  // 非虚函数
};

class Derived : public Base {
public:
    void func1() override { std::cout << "Derived::func1" << std::endl; }
    void func3() { std::cout << "Derived::func3" << std::endl; }  // 隐藏基类版本
};

void vtable_concept() {
    Base* bp = new Derived();
    bp->func1();  // 动态绑定：调用 Derived::func1（通过 vtable）
    bp->func2();  // 动态绑定：调用 Base::func2（通过 vtable）
    bp->func3();  // 静态绑定：调用 Base::func3（编译时确定）
    
    delete bp;
}

3. 抽象基类

纯虚函数和抽象基类

// 抽象基类：包含纯虚函数
class Shape {
protected:
    std::string name;
public:
    Shape(const std::string& n) : name(n) {}
    virtual ~Shape() = default;
    
    // 纯虚函数：派生类必须实现
    virtual double area() const = 0;
    virtual double perimeter() const = 0;
    
    // 普通虚函数：派生类可以选择性覆盖
    virtual void print() const {
        std::cout << "Shape: " << name << std::endl;
    }
    
    // 非虚函数：派生类继承
    const std::string& get_name() const { return name; }
};

// 具体派生类
class Circle : public Shape {
private:
    double radius;
public:
    Circle(double r, const std::string& n = "Circle") 
        : Shape(n), radius(r) {}
    
    // 必须实现纯虚函数
    double area() const override {
        return 3.14159 * radius * radius;
    }
    
    double perimeter() const override {
        return 2 * 3.14159 * radius;
    }
    
    // 可以选择性覆盖普通虚函数
    void print() const override {
        std::cout << "Circle: " << name << ", radius: " << radius << std::endl;
    }
};

class Rectangle : public Shape {
private:
    double width, height;
public:
    Rectangle(double w, double h, const std::string& n = "Rectangle")
        : Shape(n), width(w), height(h) {}
    
    double area() const override {
        return width * height;
    }
    
    double perimeter() const override {
        return 2 * (width + height);
    }
};

4. 访问控制和继承

公有、保护、私有继承

class Base {
public:
    void pub_func() {}
protected:
    void prot_func() {}
private:
    void priv_func() {}
};

// 公有继承：接口继承
class PublicDerived : public Base {
public:
    void test() {
        pub_func();     // OK：公有继承，保持 public
        prot_func();    // OK：派生类可以访问 protected
        // priv_func(); // 错误：不能访问 private
    }
};

// 保护继承：实现继承
class ProtectedDerived : protected Base {
public:
    void test() {
        pub_func();     // OK：但变为 protected
        prot_func();    // OK：仍然是 protected
    }
};

// 私有继承：实现继承，不暴露接口
class PrivateDerived : private Base {
public:
    void test() {
        pub_func();     // OK：但变为 private
        prot_func();    // OK：但变为 private
    }
};

void access_control_demo() {
    PublicDerived d1;
    d1.pub_func();      // OK
    
    ProtectedDerived d2;
    // d2.pub_func();   // 错误：在派生类中变为 protected
    
    PrivateDerived d3;
    // d3.pub_func();   // 错误：在派生类中变为 private
}

5. 构造函数和析构函数在继承中的行为

构造函数调用顺序

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

class Derived : public Base {
public:
    // 默认调用 Base()，然后执行 Derived 构造函数体
    Derived() { std::cout << "Derived constructor" << std::endl; }
    
    // 显式调用基类构造函数
    Derived(int x, int y) : Base(x) {
        std::cout << "Derived(" << y << ") constructor" << std::endl;
    }
    
    ~Derived() { 
        std::cout << "Derived destructor" << std::endl;
        // 自动调用 ~Base()
    }
};

void constructor_demo() {
    std::cout << "Creating d1:" << std::endl;
    Derived d1;
    std::cout << "\nCreating d2:" << std::endl;
    Derived d2(10, 20);
    std::cout << "\nDestroying objects:" << std::endl;
}
// 输出：
// Creating d1:
// Base constructor
// Derived constructor
//
// Creating d2:
// Base(10) constructor
// Derived(20) constructor
//
// Destroying objects:
// Derived destructor
// Base destructor
// Derived destructor
// Base destructor

6. 纯虚函数和抽象基类实践

#include <vector>
#include <memory>

class Shape {
public:
    virtual ~Shape() = default;
    virtual double area() const = 0;
    virtual double perimeter() const = 0;
    virtual void draw() const = 0;
    virtual std::unique_ptr<Shape> clone() const = 0;  // 原型模式
};

class Circle : public Shape {
private:
    double radius;
public:
    Circle(double r) : radius(r) {}
    
    double area() const override {
        return 3.14159 * radius * radius;
    }
    
    double perimeter() const override {
        return 2 * 3.14159 * radius;
    }
    
    void draw() const override {
        std::cout << "Drawing Circle with radius " << radius << std::endl;
    }
    
    std::unique_ptr<Shape> clone() const override {
        return std::make_unique<Circle>(*this);
    }
};

class Rectangle : public Shape {
private:
    double width, height;
public:
    Rectangle(double w, double h) : width(w), height(h) {}
    
    double area() const override {
        return width * height;
    }
    
    double perimeter() const override {
        return 2 * (width + height);
    }
    
    void draw() const override {
        std::cout << "Drawing Rectangle " << width << "x" << height << std::endl;
    }
    
    std::unique_ptr<Shape> clone() const override {
        return std::make_unique<Rectangle>(*this);
    }
};

// 使用多态容器
void shape_system_demo() {
    std::vector<std::unique_ptr<Shape>> shapes;
    shapes.push_back(std::make_unique<Circle>(5.0));
    shapes.push_back(std::make_unique<Rectangle>(4.0, 6.0));
    
    // 多态行为
    for (const auto& shape : shapes) {
        shape->draw();
        std::cout << "Area: " << shape->area() 
                  << ", Perimeter: " << shape->perimeter() << std::endl;
    }
    
    // 克隆演示
    auto original = std::make_unique<Circle>(10.0);
    auto cloned = original->clone();
    std::cout << "Original area: " << original->area() << std::endl;
    std::cout << "Cloned area: " << cloned->area() << std::endl;
}

7. 类型转换和继承

动态类型转换

class Base {
public:
    virtual ~Base() = default;
};

class Derived : public Base {
public:
    void derived_method() {
        std::cout << "Derived specific method" << std::endl;
    }
};

void type_conversion_demo() {
    Base* bp = new Derived();
    
    // 向下转换：Base* -> Derived*
    Derived* dp = dynamic_cast<Derived*>(bp);
    if (dp) {  // 转换成功
        dp->derived_method();
    } else {
        std::cout << "Dynamic cast failed" << std::endl;
    }
    
    // 引用转换
    try {
        Derived& dr = dynamic_cast<Derived&>(*bp);
        dr.derived_method();
    } catch (const std::bad_cast& e) {
        std::cout << "Bad cast: " << e.what() << std::endl;
    }
    
    delete bp;
}

8. 面向对象设计原则

Liskov 替换原则

// 好的设计：正方形是矩形的特例，但要注意行为一致性
class Rectangle {
protected:
    double width, height;
public:
    Rectangle(double w, double h) : width(w), height(h) {}
    
    virtual void set_width(double w) { width = w; }
    virtual void set_height(double h) { height = h; }
    
    double area() const { return width * height; }
};

class Square : public Rectangle {
public:
    Square(double side) : Rectangle(side, side) {}
    
    void set_width(double w) override {
        width = height = w;  // 保持正方形特性
    }
    
    void set_height(double h) override {
        width = height = h;  // 保持正方形特性
    }
};

void lsp_demo() {
    Rectangle* rect = new Square(5);
    rect->set_width(10);     // 正确设置正方形的边长
    std::cout << "Area: " << rect->area() << std::endl;  // 100
    
    delete rect;
}

最佳实践总结

  1. 对多态基类声明虚析构函数
  2. 使用 public 继承表示 “is-a” 关系
  3. 通过引用或指针传递多态类型
  4. 抽象基类定义接口，具体类实现行为
  5. 谨慎使用多重继承
  6. 使用 override 关键字明确表示覆盖虚函数

常见陷阱

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

class Derived : public Base {
public:
    // 错误：拼写错误，创建了新函数而不是覆盖
    void func(int x) { std::cout << "Derived" << std::endl; }
    
    // 正确：使用 override 编译器会检查
    void func() override { std::cout << "Derived" << std::endl; }
};
《c++primer》 第15章：面向对象程序设计
qq_40844444的博客
02-05 323
基类是派生类的父类，派生类继承基类的成员。class Base { // 基类public:void print() const { // 打印函数// 输出基类信息class Derived : public Base { // 派生类，公有继承基类public:void print() const { // 重写基类的 print 函数// 输出派生类信息。
c++Primer——第十五章：面向对象程序设计
judith的博客
08-11 391
1、动态绑定 c++中当使用基类的引用或指针调用一个虚函数时将发生动态绑定。 2、虚函数继承 如果基类吧一个函数声明成虚函数，则该函数再派生类中隐式地也是虚函数。 3、派生类构造函数 尽管再派生类对象中含有从基类 继承而来的成员，但是派生类并不能直接初始化这些成员。和其他创建了基类对象的代码一样，派生类也必须使用基类的构造函数来初始化它的基类部分。每个类控制它自己的额成员初始化过程。 class A { public: A() :a(0) { cout << "A cons"
C++Primer第15章：面向对象程序设计(习题解答）
qq_50271250的博客
12-25 1060
15.2.1节练习 15.1 在类中被声明为virtual的成员，基类希望这种成员在派生类中重定义，除了构造函数外，任意非 static成员都可以为虚成员 15.2 protected可以被该类的成员，友元和派生类成员访问，而不可以被该类型的普通成员访问，而private 成员只能被基类和友元访问，派生类不可访问 15.3 ...
C++ primer第15章：面向对象程序设计
weixin_44623330的博客
07-27 532
面向对象程序设计的核心思想是数据抽象、继承和动态绑定。通过数据抽象，可以将类的接口与实现分离；通过继承，可以定义相似的类型并对其相似关系建模；使用动态绑定，可以在一定程度上忽略相似类型的区别，而以统一的方式使用它们的对象。公有继承：public继承，继承类的可见性与基类相同私有继承：private继承，保护继承：protected继承，除了公有继承，其他的很少用，不用过多细究。公有继承 public protected 不可见私有继承 private private 不可见。
c++primer第十五章：面向对象程序设计（更新中）
qq_45572149的博客
03-19 716
某个类的友元 可以访问该类的所有成员 可以通过该类的对象访问该类基类的protected成员 不可以直接访问该类的基类的成员（包括基类的protected成员） 不可以访问该类的派生类的成员 某个类的private成员 只能被该类的成员或该类的友元访问 某个类的protected成员 可以被其派生类的成员函数通过该派生类的对象访问 可以被其派生类的友元通过该派生类的对象访问 可以被该类的成员或友元访问 某个类的public成员 可以被类的所有用户访问 派生访问说明符（public priva
C++Primer 第十五章 面向对象程序设计 习题答案
BadWomannnn的博客
03-10 358
如果D继承B的方式时公有的或保护的，则D的派生类的成员和友元可以使用D向B的转换,所以drived_from_public合法，drived_from_private非法。新对象的shared_ptr的引用计数加1，原对象的shared_ptr的引用计数减1。拷贝：会调用合成的拷贝构造函数，拷贝Query的数据成员，成员q由于是shared_ptr，其引用计数会加1.销毁：调用合成的析构函数，shared_ptr的引用计数减1，如果其引用计数减至0，则会释放它指向的内存。©错误，声明不用写出它的派生列表。
C++Primer第五版 习题答案 第十五章 面向对象程序设计（Object-Oriented Programming）
shamozhizhoutx的博客
05-25 4117
练习15.1 什么是虚成员？ 虚函数是基类希望其派生类进行覆盖的函数。 练习15.2 protected 访问说明符与 private 有何区别？ 派生类的成员函数可以访问protected访问运算符的成员，而不能访问private的。 练习15.3 定义你自己的 Quote 类和 print_total 函数。 Quote_ex03.h #ifndef QUOTE_H_ #defin...
C++ Primer学习笔记-----第十五章：面向对象程序设计
weixin_41155760的博客
08-02 313
面向对象这章不说太多，简单说下语法即可，因为程序设计是一个比较大的命题，更多的问题是怎么设计，而不是语法。派生类的拷贝控制成员。
C++ Primer 总结索引 | 第十五章：面向对象程序设计
AsherGu的博客
06-05 788
OOP：继承，动态绑定；定义基类和派生类：定义基类，定义派生类，类型转换与继承；虚函数；抽象基类；访问控制与继承；继承中的类作用域；构造函数与拷贝控制：虚析构函数，合成拷贝与控制，派生类的拷贝控制成员，继承的构造函数；容器与继承；文本查询程序
C++ Primer(第五版)|练习题答案与解析(第十五章:面向对象程序设计)
qq_24739717的博客
02-28 853
C++ Primer(第五版)|练习题答案与解析(第十五章:面向对象程序设计) 本博客主要记录C++ Primer(第五版)中的练习题答案与解析。 参考:C++ Primer C++ Primer 练习题15.1 什么是虚成员？ P526-52。.虚成员是基类希望派生类进行覆盖的函数，在其成员前加关键字virtual，使得该成员可以实现动态绑定。 练习题15.2 protected访问说明符...
C++ Primer 第十五章 面向对象程序设计 15.9
大琪子的博客
03-03 403
15.31 位取反，位与，位或的优先级分别时 ~ > & > | 所以a，最终创建一个OrQuery b，最终创建一个OrQuery c,最终创建一个OrQuey 15.32 Query对象被拷贝q的引用计数+1 被赋值，原来指向的对象引用计数-1，赋值语句左边的对象引用计数+1，如果左侧对象引用计数为0则调用析构销毁对象回收的内存。 被移动，q引用计数变为传入左值的引用计...
C++读取exe程序标准输出
duke0226的专栏
01-07 222
Test.exe代码如下：逐行打印输入参数。
如何解决 PyCharm 控制台 pip install 报错 OSError: [Errno 18] Cross-device link 问题
全栈小辉
01-09 449
本文分析了PyCharm控制台执行pip install时出现OSError: [Errno 18] Cross-device link报错的根源及解决方案。该错误是由于操作系统限制跨存储设备移动文件所致，当pip缓存路径与虚拟环境路径位于不同设备时（如C盘缓存D盘安装），就会触发此错误。文章从底层系统调用机制出发，指出三种典型诱因：pip缓存路径与虚拟环境路径跨设备、虚拟环境部署在外接设备、Linux下tmpfs缓存冲突。提供了四种解决方案：临时禁用缓存安装、修改pip缓存路径到同一设备、迁移虚拟环境位置
C++ 入门完全指南（四）--函数与模块化编程
whc的博客
01-06 424
本章介绍了C++函数的基础知识，包括函数的作用、基本语法和参数传递方式。函数通过代码复用、模块化提高程序的可维护性和可读性。基本语法涵盖函数定义、声明与调用，演示了有返回值和无返回值函数的实现。参数传递部分详细对比了值传递（创建参数副本，不影响原始变量）和引用传递（直接操作原始变量）的区别，并通过交换变量等实例展示其应用场景。本章内容为后续函数高级特性学习奠定了基础，帮助读者掌握模块化编程的基本方法。
【GESP】C++五级练习（贪心思想考点） luogu-P9532 [YsOI2023] 前缀和
CoderCoding的博客
01-06 227
GESP C++ 五级练习题，虽然题目名称叫前缀和，但却是贪心考点，确实有点奇怪的误导。题目难度⭐⭐★☆☆，五级来说难度适中。洛谷难度等级普及−。
信奥赛C++提高组csp-s之强连通分量详解
王老师青少年编程
01-09 718
信奥赛C++提高组csp-s之强连通分量详解
C++ STL | 容器适配器
weixin_65043441的博客
01-07 1111
摘要：适配器模式将类接口转换为客户期望的接口。STL中stack和queue是容器适配器，默认使用deque作为底层结构。deque是双端队列，由分段连续空间组成，通过中控数组管理，支持O(1)时间复杂度的头尾操作。相比vector和list，deque在头尾插入删除效率高且空间利用率好，但不适合遍历和中部操作。STL选择deque作为stack和queue的底层容器，因其完美适配这两种数据结构只需固定端操作的需求，避开了deque遍历效率低的缺陷，同时发挥其高效扩容和内存利用率高的优势。
C++交叉编译过程中的踩坑与收获
威桑的博客
01-08 348
交叉编译踩坑与收获
详细介绍 C 语言中的 #define 宏定义
最新发布
2301_80136889的博客
01-09 272
C语言中的#define预处理指令用于文本替换，分为无参宏和带参宏两种形式。无参宏主要用于常量定义和简单文本替换，需要注意避免分号陷阱和类型检查缺失问题。带参宏类似函数但本质是文本替换，使用时必须加括号防止运算优先级错误。宏支持#参数字符串化和##标识符拼接等特殊操作，还可配合条件编译指令实现跨平台和调试功能。相比函数，宏没有运行时开销但缺乏类型检查，适合简单运算场景。合理使用宏能提高代码复用性，但复杂逻辑建议使用函数实现。
C++ Primer 第15章：深入Query_base类及其继承体系
在C++ Primer一书中，第15章详细讲解了如何构建一个文本查询程序，这个程序能够让用户输入一个单词，然后程序会展示包含该单词的所有文本行。在这个过程中，涉及到的核心类是`Query_base`以及其派生类体系。这个体系...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值