C++ 函数语义学——静动态类型、绑定、坑点与多态体现深谈

于 2024-08-10 14:00:06 发布
阅读量469 收藏 2
点赞数 16
分类专栏： C++ 新经典：对象模型 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_68194402/article/details/141090017
版权

静动态类型、绑定、坑点与多态体现深谈

静动态类型、绑定、坑点与多态体现深谈

1. 静态类型和动态类型

静态类型在编译期间确定，而动态类型在运行时确定。静态类型决定了编译器如何解析代码，而动态类型决定了在运行时实际调用的函数。

静态类型

静态类型是对象定义时的类型，在编译期间就确定好的。

Base base;       // 静态类型是 Base
Derived derived; // 静态类型是 Derived
Base* pbase;     // 静态类型是 Base*，无论指向什么
Base* pbase2 = new Derived();  // 静态类型是 Base*
Base* pbase3 = new Derived2(); // 静态类型是 Base*
动态类型

动态类型是对象在运行时所指向的实际类型。一般来说，只有指针或引用才有动态类型的说法，通常指向父类的指针或引用。

根据上面的代码行，动态类型如下：

  • Base 和 Derived 没有动态类型，因为它们既不是指针也不是引用。
  • pbase2 的动态类型是 Derived。
  • pbase3 的动态类型是 Derived2。

动态类型在执行过程中可以改变。例如：

pbase = pbase2;  // pbase 的动态类型是 Derived
pbase = pbase3;  // pbase 的动态类型是 Derived2
示例代码

以下是一个示例，展示了静态类型和动态类型的工作原理：

#include <iostream>

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

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

class Derived2 : public Base {
public:
    void myFunction() override {
        std::cout << "Derived2::myFunction" << std::endl;
    }
};

int main() {
    Base base;       // 静态类型是 Base
    Derived derived; // 静态类型是 Derived
    Base* pbase;     // 静态类型是 Base*
    Base* pbase2 = new Derived();  // 静态类型是 Base*
    Base* pbase3 = new Derived2(); // 静态类型是 Base*

    // 动态类型示例
    pbase = pbase2;      // pbase 的动态类型是 Derived
    pbase->myFunction(); // 调用 Derived::myFunction

    pbase = pbase3;      // pbase 的动态类型是 Derived2
    pbase->myFunction(); // 调用 Derived2::myFunction

    return 0;
}
解释
  • 静态类型：在编译期间确定的类型。例如，Base* pbase2 的静态类型是 Base*。
  • 动态类型：在运行时确定的实际类型。例如，pbase2 的动态类型是 Derived。

2. 静态绑定和动态绑定

静态绑定

静态绑定是指绑定的是静态类型，所对应的函数或属性依赖于对象的静态类型，发生在编译期。

动态绑定

动态绑定是指绑定的是动态类型，所对应的函数或属性依赖于对象的动态类型，发生在运行期。

示例代码

以下是一个示例，展示了静态绑定和动态绑定的工作原理：

#include <iostream>

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

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

int main() {
    Base base;
    Derived derived;#include <iostream>

class Base {
public:
    void staticFunction(int x = 10) {
        std::cout << "Base::staticFunction, x = " << x << std::endl;
    }
    virtual void dynamicFunction(int x = 20) {
        std::cout << "Base::dynamicFunction, x = " << x << std::endl;
    }
};

class Derived : public Base {
public:
    void staticFunction(int x = 30) {
        std::cout << "Derived::staticFunction, x = " << x << std::endl;
    }
    void dynamicFunction(int x = 40) override {
        std::cout << "Derived::dynamicFunction, x = " << x << std::endl;
    }
};

int main() {
    Base base;
    Derived derived;
    Base* pbase = &derived;

    base.staticFunction();       // 静态绑定，调用 Base::staticFunction，输出 x = 10
    derived.staticFunction();    // 静态绑定，调用 Derived::staticFunction，输出 x = 30
    pbase->staticFunction();     // 静态绑定，调用 Base::staticFunction，输出 x = 10

    base.dynamicFunction();      // 动态绑定，调用 Base::dynamicFunction，输出 x = 20
    derived.dynamicFunction();   // 动态绑定，调用 Derived::dynamicFunction，输出 x = 40
    pbase->dynamicFunction();    // 动态绑定，调用 Derived::dynamicFunction，但输出 x = 20

    return 0;
}
    Base* pbase = &derived;

    base.staticFunction();       // 静态绑定，调用 Base::staticFunction
    derived.staticFunction();    // 静态绑定，调用 Derived::staticFunction
    pbase->staticFunction();     // 静态绑定，调用 Base::staticFunction

    base.dynamicFunction();      // 动态绑定，调用 Base::dynamicFunction
    derived.dynamicFunction();   // 动态绑定，调用 Derived::dynamicFunction
    pbase->dynamicFunction();    // 动态绑定，调用 Derived::dynamicFunction

    return 0;
}
解释
  • 静态绑定：staticFunction 是普通成员函数，绑定的是静态类型，发生在编译期。例如，pbase->staticFunction() 调用的是 Base::staticFunction，因为 pbase 的静态类型是 Base*。
  • 动态绑定：dynamicFunction 是虚函数，绑定的是动态类型，发生在运行期。例如，pbase->dynamicFunction() 调用的是 Derived::dynamicFunction，因为 pbase 的动态类型是 Derived。
  • 缺省参数（也称为默认参数）：缺省参数一般是静态绑定。例如，pbase->dynamicFunction() 调用 Derived::dynamicFunction 时，缺省参数 x 的值是 20，因为 pbase 的静态类型是 Base*，而 Base::dynamicFunction 的缺省参数是 20。
结论
  • 普通成员函数是静态绑定，而虚函数是动态绑定。
  • 缺省参数（也称为默认参数）一般是静态绑定。

3. 继承的非虚函数坑

在继承关系中，不应该在子类中重新定义一个继承来的非虚成员函数。这是因为这样做会导致函数的隐藏和意外的行为，破坏代码的可维护性和可读性。

示例代码

以下是一个示例，展示了在子类中重新定义继承来的非虚成员函数所带来的问题：

#include <iostream>

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

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

int main() {
    Base base;
    Derived derived;
    Base* pbase = &derived;

    base.nonVirtualFunction();       // 调用 Base::nonVirtualFunction
    derived.nonVirtualFunction();    // 调用 Derived::nonVirtualFunction
    pbase->nonVirtualFunction();     // 调用 Base::nonVirtualFunction

    return 0;
}
解释
  • 隐藏问题：在 Derived 类中重新定义 nonVirtualFunction 会隐藏 Base 类中的同名函数。这意味着通过基类指针或引用调用该函数时，仍然会调用基类的实现，而不是子类的实现。
  • 意外行为：在上面的示例中，pbase->nonVirtualFunction() 调用的是 Base::nonVirtualFunction，而不是 Derived::nonVirtualFunction，因为 nonVirtualFunction 不是虚函数，绑定的是静态类型。
结论
  1. 函数隐藏：在子类中重新定义继承来的非虚成员函数会导致基类中的同名函数被隐藏，破坏代码的可维护性和可读性。
  2. 意外行为：通过基类指针或引用调用该函数时，仍然会调用基类的实现，而不是子类的实现，可能导致意外行为。

为了避免这些问题，建议遵循以下原则：

  • 如果需要在子类中重写基类的函数，应该将该函数声明为虚函数。
  • 如果不希望子类重写某个函数，可以将该函数声明为 final（C++11 及以上版本支持）。

4. 虚函数的动态绑定

虚函数的动态绑定是指在运行时根据对象的动态类型来决定调用哪个函数实现。这种机制允许通过基类指针或引用调用派生类的函数，实现多态性。

示例代码

以下是一个示例，展示了虚函数的动态绑定：

#include <iostream>

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

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

int main() {
    Base base;
    Derived derived;
    Base* pbase;

    pbase = &base;
    pbase->dynamicFunction();  // 调用 Base::dynamicFunction

    pbase = &derived;
    pbase->dynamicFunction();  // 调用 Derived::dynamicFunction

    return 0;
}
解释
  • 虚函数：在基类中使用 virtual 关键字声明的函数。派生类可以重写该函数。
  • 动态绑定：在运行时，根据对象的动态类型来决定调用哪个函数实现。例如，pbase->dynamicFunction() 会根据 pbase 指向的对象类型来调用相应的函数实现。
结论
  • 多态性：虚函数的动态绑定实现了多态性，使得通过基类指针或引用可以调用派生类的函数。
  • 运行时决策：动态绑定在运行时根据对象的动态类型来决定调用哪个函数实现，而不是在编译期决定。

5. 重新定义虚函数的缺省参数坑

在继承关系中，重新定义虚函数的缺省参数可能会导致意外的行为。这是因为缺省参数是静态绑定的，即在编译期就确定了，而虚函数是动态绑定的，即在运行时根据对象的动态类型来决定调用哪个函数实现。

示例代码

以下是一个示例，展示了重新定义虚函数的缺省参数所带来的问题：

#include <iostream>

class Base {
public:
    virtual void dynamicFunction(int x = 20) {
        std::cout << "Base::dynamicFunction, x = " << x << std::endl;
    }
};

class Derived : public Base {
public:
    void dynamicFunction(int x = 40) override {
        std::cout << "Derived::dynamicFunction, x = " << x << std::endl;
    }
};

int main() {
    Base base;
    Derived derived;
    Base* pbase = &derived;

    base.dynamicFunction();      // 调用 Base::dynamicFunction，输出 x = 20
    derived.dynamicFunction();   // 调用 Derived::dynamicFunction，输出 x = 40
    pbase->dynamicFunction();    // 调用 Derived::dynamicFunction，但输出 x = 20

    return 0;
}
解释
  • 虚函数：dynamicFunction 是虚函数，通过基类指针或引用调用时，会根据对象的动态类型来决定调用哪个函数实现。
  • 缺省参数：缺省参数是静态绑定的，即在编译期就确定了。例如，pbase->dynamicFunction() 调用 Derived::dynamicFunction 时，缺省参数 x 的值是 20，因为 pbase 的静态类型是 Base*，而 Base::dynamicFunction 的缺省参数是 20。
结论
  • 缺省参数的静态绑定：缺省参数在编译期就确定了，即使虚函数在运行时进行动态绑定，缺省参数的值仍然取决于静态类型。
  • 意外行为：重新定义虚函数的缺省参数可能会导致意外的行为，因为通过基类指针或引用调用时，缺省参数的值不会根据动态类型来决定。
  • 不要在子类中重新定义虚函数缺省参数的值：为了避免意外行为和代码的可维护性问题，不要在子类中重新定义继承来的虚函数的缺省参数。

6. C++ 中的多态性

多态性是面向对象编程的一个重要特性，它允许同一个接口调用不同的实现。在 C++ 中，多态性必须通过虚函数来实现，没有虚函数，就不可能存在多态性。

多态的概念

多态性可以从两个方面来讨论：

  1. 从代码实现上：

    • 多态性通过虚函数和继承来实现。基类中声明虚函数，派生类中重写这些虚函数。
    • 在运行时，通过基类指针或引用调用虚函数，根据对象的动态类型来决定调用哪个函数实现。

  2. 从表现形式上：

    • 多态性允许通过同一个接口调用不同的实现。具体表现为，通过基类指针或引用调用派生类的函数，实现了动态绑定。
    • 这种机制提高了代码的灵活性和可扩展性，使得代码可以处理不同类型的对象，而无需修改调用代码。
示例代码

以下是一个示例，展示了 C++ 中的多态性：

#include <iostream>

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

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

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

void display(Base* base) {
    base->show();
}

int main() {
    Base base;
    Derived1 derived1;
    Derived2 derived2;

    display(&base);      // 调用 Base::show
    display(&derived1);  // 调用 Derived1::show
    display(&derived2);  // 调用 Derived2::show

    return 0;
}
解释

  • 从代码实现上：

    • Base 类中声明了虚函数 show。
    • Derived1 和 Derived2 类中重写了 show 函数。
    • 在 display 函数中，通过基类指针 base 调用虚函数 show，在运行时根据对象的动态类型来决定调用哪个函数实现。

  • 从表现形式上：

    • 有父类有子类（有继承关系）：Base 是父类，Derived1 和 Derived2 是子类，且 Base 类中含有虚函数 show，子类重写了该虚函数。
    • 父类指针指向子类对象：在 main 函数中，Base* pbase 可以指向 Derived1 或 Derived2 对象。
    • 调用子类中重写的虚函数：通过 display 函数，基类指针 base 调用虚函数 show，实际调用的是子类的实现。例如，display(&derived1) 调用 Derived1::show，display(&derived2) 调用 Derived2::show。
    • 通过同一个接口 display，调用了不同的实现，实现了多态性。
结论
  • 多态必须存在虚函数并且调用虚函数：没有虚函数，就不可能存在多态性。
  • 从代码实现上：多态性通过虚函数和继承来实现，基类中声明虚函数，派生类中重写这些虚函数。
  • 从表现形式上：多态性允许通过同一个接口调用不同的实现，提高了代码的灵活性和可扩展性。
不是仙人的闲人
关注
  • 16
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Cplusplus基础与提高.zip_C++ 基础与提高_c++入门和提高
09-15
1. **基本语法**：C++的基础语法与C语言相似，包括变量定义、数据类型（如int、float、char等）、运算符、控制结构（如if-else、for、while循环）以及函数的使用。 2. **类与对象**：C++的基石是面向对象编程，你...
VC程序设计核心——类与对象学习教案.pptx
09-30
面向对象程序设计是现代软件开发中的重要概念，尤其在Visual C++（VC）环境中，它提供了强大的工具来实现这一设计理念。本教程的核心是理解和运用类与对象，这是面向对象编程的基础。 面向对象程序设计（Object-...
c++各种库函数接口，内核函数的API解释入口帮助文档
03-02
从C++11开始，C++引入了许多新特性，如lambda表达式、右值引用、自动类型推断（auto）、移动语义等。这些新特性提高了代码的简洁性和效率。 七、内存管理 C++提供了动态内存分配和释放的接口，如`new`和`delete`。...
C++编程惯用法——高级程序员常用方法和技巧
01-21
- **多态**：利用虚函数和抽象基类实现动态绑定，提高程序的灵活性。 2. **模板与泛型编程**： - **函数模板**：实现函数的通用性，允许使用不同类型的数据作为参数。 - **类模板**：用于创建具有通用特性的类，...
c++学习心得2.zip
10-12
函数模板可以让我们编写出能够处理不同类型数据的通用函数，而泛型编程则是这种思想在C++中的体现，如STL（Standard Template Library）就大量使用了泛型编程。 C++的内存管理也是一大重点，包括栈、堆、静态存储区...
STL中的迭代器失效（vector为例）
2302_80190394的博客
08-08 261
STL中的迭代器失效（vector为例）
c++ error: ‘*’ does not name a type； did you mean ‘**’?
xiaozhi
08-08 184
c++ error: ‘*’ does not name a type； did you mean ‘**’?
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
qq_19319481的博客
08-09 177
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
C++ - 函数重载
jiaowenjie的专栏
08-06 297
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
c++——map、set底层之AVL树（动图演示旋转）
2301_80687320的博客
08-05 1082
我们之前学了过二叉搜索树，二这里的AVL也是一种搜索树，当我们二叉搜索树发生偏移时，搜索时间就会边长，就不树logN了，变成N；而AVL就修复了这一点。一、{}// 该节点的左孩子// 该节点的右孩子// 该节点的双亲T _data;int _bf;// 该节点的平衡因子。
C语言：复读机2种写法（输入什么就输出什么）
weixin_55021541的博客
08-08 260
（1）题目：输入什么内容，输出就是什么内容，遇到"#"为止。【2】不用getchar()和putchar()【1】getchar()和putchar()
CSAPP B站陪跑视频学习笔记
Eeeeye_的博客
08-08 526
视频地址栈的作用：局部变量和参数：当函数被调用时，函数的局部变量和参数会被分配到栈上。这是因为这些变量的生命周期通常只限于函数执行期间。 函数调用链：栈用于管理函数调用链，包括保存函数调用的返回地址、当前函数的状态和局部变量等。 自动内存管理：栈是一种LIFO（后进先出）的数据结构，函数调用结束后，栈上的内存会自动释放，无需显式管理。运行时内存分配：动态变化的内存需求：在程序运行时，某些数据的大小和数量可能无法提前确定。栈允许在函数调用时动态分配这些数据的内存。栈帧（Stack Frame）：每次函数调用都
C++ primer plus 第17 章 输入、输出和文件：使用 cin 进行输入
zhyjhacker的博客
08-05 1161
C++ primer plus 第17 章 输入、输出和文件：使用 cin 进行输入。
Qt/C++最新地图组件发布/历时半年重构/同时支持各种地图内核/包括百度高德腾讯天地图
Qt/C++视频监控/推流/物联网/大屏系统/自定义控件/UI定制/输入法
08-06 1480
最近花了半年时间，专门重构了整个地图组件，之前写的比较粗糙，有点为了完成功能而做的，没有考虑太多拓展性和易用性。这套地图自检这几年大量的实际项目和用户使用下来，反馈了不少很好的建议和意见，经过这几年的整理，刚好趁着近期经济下行严重，抽出时间把整个地图组件重构一下，首要的任务就是搞个地图基类，然后子类分别实现不同地图的具体功能。
C入门基础题：最长上升子序列（C语言版）
我就知道你会来，我们一起进步吧！
08-06 297
给出一个由 n(n < 5000)个不超过 10“的正整数组成的序列。请输出这个序列的最长上升子序列的长度。最长上升子序列是指，从原序列中按顺序取出一些数字排在一起，这些数字是逐渐增大的。第一行，一个整数 n，表示序列长度。第二行有 n 个整数，表示这个序列。分别取出 1、2、3、4 即可。这是一个简单的动规板子题。
C++ 知识点（长期更新）
weixin_51332735的博客
08-09 886
必知必会
矩阵转置（c语言）
scy2429828663的博客
08-09 408
int m = 0;int a = 0;//输入 n m//将数据存储在arr上//输入 aj < n;j++)i < m;i++)//转置i < m;i++)j < n;
智能驾驶（95%用例）C卷(Java&&Python&&C++&&Node.js&&C语言)
荆赫同艺的博客
08-06 61
有一辆汽车需要从m*n的地图的左上角(起点)开往地图的右下角(终点)，去往每一个地区都需要消耗一定的油量，加油站可进行加油,请你计算汽车确保从起点到达终点时所需的最少初始油量说明:(1)智能汽车可以上、下、左、右四个方向移动(2)地图中的数字取值是0或-1或正整数:-1:表示加油站，可以加满油，汽车的油箱容量最大为1000:表示这个地区是障碍物，汽车不能通过;正整数:表示汽车走过这个地区的耗油量(3)如果汽车无论如何都无法到达终点，则返回-1。
C++ Poco框架判断请求方式是GET还是POST
最新发布
jiexijihe945的博客
08-09 181
作为服务器开发者GET和POST等Method还是要区分的，不同的请求方法要走不同的逻辑。这篇文章很简短但是基于另一篇文章，如果你已经了解Poco了就不用看了。手把手教你使用Poco框架开发服务器应用1、看似简单的一个小函数却是决定成败的关键。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值