C++面向对象三大特性

最新推荐文章于 2024-07-24 08:30:00 发布
最新推荐文章于 2024-07-24 08:30:00 发布
阅读量973 收藏 15
点赞数 25
分类专栏： C++ 文章标签： c++ 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wy2458984254/article/details/140610308
版权

1 基本概念

面向对象语言有以下三个特性：封装，继承，多态。本文将从这三个方面展开讲解，首先介绍一些基本的概念，然后分别介绍着三个特性。

1.1 虚函数

1.1.1 概念

虚函数允许在子类中重新定义基类中定义的函数，使得通过基类指针或引用调用的函数在运行时根据实际对象类型来确定。这种机制称为动态绑定或者运行时多态。在基类中通过在函数声明前增加virtual 关键字，将函数声明为虚函数。

1.1.2 实现原理

虚函数的实现原理涉及虚函数表（Virtual Table，简称vtable）和虚函数指针（Virtual Pointer，简称vptr）。

  • 虚函数表是一个函数指针数组，每个包含虚函数的类都有一个虚函数表。虚函数表中存储了该类的虚函数的地址。在派生类中，虚函数表会重载基类的虚函数地址，以指向派生类的对应实现。
  • 虚函数指针是一个指向虚函数表的指针。每个包含虚函数的类对象都有一个隐藏的虚函数指针，通常称为vptr。当一个对象被创建时，vptr被初始化为指向该对象所属类的虚函数表。
    当通过基类指针或引用调用虚函数时，程序会通过对象的vptr查找虚函数表，并根据表中存储的函数指针调用正确的函数实现。这样实现了在运行时根据对象的实际类型调用对应的函数。
示例代码
#include <iostream>

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

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

int main() {
    Base* b = new Derived();
    b->show(); // 动态绑定，调用 Derived::show
    delete b;
    return 0;
}

在上述示例代码中，

  1. 类定义和对象创建：
    • 当定义Base类时，编译器会创建一个虚函数表Base_vtable，其中包含指向Base::show的指针。
    • 当定义Derived类时，编译器会创建一个虚函数表Derived_vtable，其中包含指向Derived::show的指针。
  2. 对象初始化：
    • 当创建Derived对象时，编译器会在对象中添加一个隐藏的vptr，并将其初始化为指向Derived_vtable。
  3. 函数调用：
    • 当调用b->show()时，编译器生成代码，通过b对象的vptr访问虚函数表，并调用表中对应的函数指针。由于b指向一个Derived对象，其vptr指向Derived_vtable，因此调用的是Derived::show。

1.1.3 总结

虚函数的实现主要依赖于虚函数表（vtable）和虚函数指针（vptr）。虚函数表存储了类的虚函数地址，而虚函数指针则指向对象所属类的虚函数表。在运行时，通过虚函数指针查找并调用虚函数表中的函数地址，实现了动态绑定和多态性。这种机制使得在面向对象编程中可以灵活地实现接口重载和运行时行为的改变。

1.2 纯虚函数

纯虚函数是一个在基类中声明但不在该基类中实现的虚函数。它的声明方式是在函数声明的末尾添加 = 0。纯虚函数使得基类变成抽象类，无法实例化，需要在派生类中实现这些函数才能创建对象。纯虚函数的主要目的是强制派生类提供自己的实现，以便实现多态性。

以下是一个示例代码展示纯虚函数的定义和使用：

#include <iostream>

// 定义一个抽象基类 Shape
class Shape {
public:
    // 纯虚函数
    virtual void draw() = 0;
};

// 定义一个派生类 Circle 继承自 Shape
class Circle : public Shape {
public:
    // 实现纯虚函数 draw
    void draw() override {
        std::cout << "Drawing a Circle" << std::endl;
    }
};

int main() {
    // Shape shape; // 错误：无法实例化抽象类
    Circle circle;
    circle.draw(); // 输出：Drawing a Circle

    return 0;
}

在这个示例中：

  1. Shape 类是一个抽象基类，包含一个纯虚函数 draw。
  2. Circle 类继承自 Shape，并实现了纯虚函数 draw。
  3. 尝试实例化 Shape 类会导致编译错误，因为它是抽象类。
  4. 实例化 Circle 类并调用其 draw 方法将会输出 Drawing a Circle。

通过这种方式，纯虚函数确保了所有派生类都必须提供具体的实现，从而实现了多态性的要求。

1.3 抽象类

抽象类是不能直接实例化的类，通常用于作为其他类的基类。抽象类至少包含一个纯虚函数，它定义了一种接口要求，强制所有派生类实现这些函数。抽象类本身提供了一些公共功能和接口定义，但无法创建其对象。

抽象类的主要作用包括：

  1. 定义接口：通过纯虚函数，抽象类可以定义派生类必须实现的接口。
  2. 提供部分实现：抽象类可以提供一些默认实现，这些实现可以在派生类中继承和使用。
  3. 实现多态性：通过基类指针或引用调用派生类的实现，实现多态性。

以下是一个抽象类的示例代码：

#include <iostream>

// 定义一个抽象基类 Animal
class Animal {
public:
    // 纯虚函数
    virtual void makeSound() = 0;

    // 普通成员函数
    void sleep() {
        std::cout << "Sleeping" << std::endl;
    }
};

// 定义一个派生类 Dog 继承自 Animal
class Dog : public Animal {
public:
    // 实现纯虚函数 makeSound
    void makeSound() override {
        std::cout << "Woof" << std::endl;
    }
};

int main() {
    // Animal animal; // 错误：无法实例化抽象类
    Dog dog;
    dog.makeSound(); // 输出：Woof
    dog.sleep();     // 输出：Sleeping

    return 0;
}

在这个示例中：

  1. Animal 类是一个抽象基类，因为它包含一个纯虚函数 makeSound。
  2. Dog 类继承自 Animal，并实现了纯虚函数 makeSound。
  3. 尝试实例化 Animal 类会导致编译错误，因为它是抽象类。
  4. 实例化 Dog 类并调用其 makeSound 方法将会输出 Woof，调用 sleep 方法将会输出 Sleeping。

通过这种方式，抽象类为派生类提供了一个统一的接口，同时也可以提供一些公共功能的实现。

1.4 虚析构函数

虚析构函数是一种特殊的析构函数，用于在基类中声明为虚函数。它的主要目的是确保当通过基类指针删除一个派生类对象时，能够正确调用派生类的析构函数，从而防止资源泄漏。
当我们使用基类指针删除一个派生类对象时，如果基类的析构函数不是虚函数，则只会调用基类的析构函数，而不会调用派生类的析构函数。这可能导致派生类中分配的资源没有被正确释放。因此，为了确保析构函数的正确调用，我们需要将基类的析构函数声明为虚函数。

以下是一个示例代码展示虚析构函数的使用：

#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() override {
        std::cout << "Derived destructor" << std::endl;
    }
};

int main() {
    Base* obj = new Derived();
    delete obj; // 通过基类指针删除派生类对象

    return 0;
}

在这个示例中：

  1. Base 类有一个虚析构函数 ~Base()。
  2. Derived 类继承自 Base，并实现了自己的析构函数 ~Derived()。
  3. 在 main 函数中，我们通过基类指针 obj 指向一个派生类对象 Derived。
  4. 当我们通过基类指针删除这个对象时，会正确调用派生类的析构函数 ~Derived()，然后调用基类的析构函数 ~Base()。

输出结果将会是：

Base constructor
Derived constructor
Derived destructor
Base destructor

这表明当 delete obj 时，首先调用派生类的析构函数，然后调用基类的析构函数，从而确保资源正确释放。这就是虚析构函数的作用和重要性。

2 封装

把客观事务抽象成类，并且类可以把自己的数据和方法只让可信的类或者对象进行操作，对不可信的对象进行信息隐藏。

3 继承

3.1 基本概念

继承指的是某种类型对象获得另一种类型对象属性或者方法。
示例代码：

class Base {
public:
    int value;
    void foo() {
        std::cout << "Base::foo" << std::endl;
    }
};

class Derived : public Base {
    // 其他成员
};
  • Derived类继承了Base类的value属性和foo方法；
  • Derived类内部也可以定义自己的属性和方法。

3.2 继承的访问控制权限

上述示例代码中，Base类的属性和方法都被声明为public，即公有访问。关于访问控制的权限，下面将详细介绍。
C++提供了三个访问修饰符： public 、 private 和 protected 。这些修饰符决定了类中的成员对外部代码的可⻅性和访问权限。

  • public 修饰符⽤于指定类中的成员可以被类的外部代码访问。公有成员可以被类外部的任何代码（包括类的实例）访问。
  • private 修饰符⽤于指定类中的成员只能被类的内部代码访问。私有成员对外部代码是不可⻅的，只有类内部的成员函数可以访问私有成员。
  • protected 修饰符⽤于指定类中的成员可以被类的派⽣类访问。受保护成员对外部代码是不可⻅的，但可以在派⽣类中被访问。

3.3 多重继承

一个类可以从多个基类继承属性和行为。多重继承可能会导致菱形继承问题。

3.3.1 菱形继承

在C++中，菱形继承问题是指当一个类继承了两个直接基类，而这两个基类又继承自同一个基类时，会导致二义性和冗余问题。
考虑以下继承关系：

class Base {
public:
    int value;
    void foo() {
        std::cout << "Base::foo" << std::endl;
    }
};

class Derived1 : public Base {
    // 其他成员
};

class Derived2 : public Base {
    // 其他成员
};

class Derived3 : public Derived1, public Derived2 {
    // 其他成员
};

在这个例子中，Derived3通过Derived1和Derived2继承了Base。这就引发了两个主要问题：

  1. 数据成员的二义性：
    Base类中的value成员在Derived3中会有两份拷贝：一份来自Derived1，一份来自Derived2。这样，当我们试图访问value时，就会产生二义性。
  2. 方法的二义性：
    同样，Base类中的foo方法在Derived3中会有两份拷贝，这也会导致二义性。
解决方案：虚继承

C++ 提供了虚继承（virtual inheritance）来解决这些问题。通过虚继承，基类的数据成员和方法在派生类中只会保留一份实例。以下是如何使用虚继承来解决上述问题的示例：

class Base {
public:
    int value;
    void foo() {
        std::cout << "Base::foo" << std::endl;
    }
};

class Derived1 : virtual public Base {
    // 其他成员
};

class Derived2 : virtual public Base {
    // 其他成员
};

class Derived3 : public Derived1, public Derived2 {
    // 其他成员
};

在这个例子中，Derived1和Derived2都虚继承了Base。这意味着Base的成员（包括数据成员和方法）在Derived3中只有一份实例。下面是一个示例代码：

#include <iostream>

class Base {
public:
    int value;
    void foo() {
        std::cout << "Base::foo" << std::endl;
    }
};

class Derived1 : virtual public Base {
    // 其他成员
};

class Derived2 : virtual public Base {
    // 其他成员
};

class Derived3 : public Derived1, public Derived2 {
public:
    void bar() {
        value = 10;  // 无二义性
        foo();       // 无二义性
    }
};

int main() {
    Derived3 d3;
    d3.bar();  // 输出: Base::foo
    std::cout << d3.value << std::endl;  // 输出: 10
    return 0;
}
总结

通过虚继承，C++可以有效地解决菱形继承带来的二义性问题。使用虚继承时，基类的数据成员和方法在派生类中只会保留一份实例，从而避免了冗余和二义性。

4 多态

多态指的是相同的操作作用于不同的对象时，会产生不同的效果。
实现多态有两种常见的方式：

  1. 函数重写（override）
  2. 函数重载（overload）

4.1 函数重写（Override）

函数重写是指在派生类中重新定义基类中的虚函数。重写的函数必须具有与基类中虚函数相同的名称、返回类型和参数列表。使用关键字override可以显式指示函数是重写基类中的虚函数，从而提高代码的可读性和安全性。如果基类中的函数发生变化（例如参数列表改变），编译器会提示错误，从而避免潜在的错误。
示例代码

#include <iostream>

class Base {
public:
    virtual void display() const {
        std::cout << "Base display" << std::endl;
    }
    virtual ~Base() = default;  // 虚析构函数
};

class Derived : public Base {
public:
    void display() const override {  // 使用 override 关键字
        std::cout << "Derived display" << std::endl;
    }
};

int main() {
    Base* b = new Derived();
    b->display();  // 输出: Derived display
    delete b;
    return 0;
}

在这个例子中，Derived类重写了Base类的display函数，并使用override关键字来显式表明这是一个重写操作。

4.2 函数重载（Overload）

函数重载是指在同一个作用域中定义多个同名但参数列表不同的函数。重载的函数可以有不同的参数类型、参数数量或参数顺序。编译器通过函数调用时传递的参数来确定调用哪个重载函数。函数重载不涉及继承关系，只在同一个类中或者同一个作用域内进行。
示例代码

#include <iostream>

class Printer {
public:
    void print(int i) {
        std::cout << "Printing int: " << i << std::endl;
    }

    void print(double f) {
        std::cout << "Printing double: " << f << std::endl;
    }

    void print(const std::string& s) {
        std::cout << "Printing string: " << s << std::endl;
    }
};

int main() {
    Printer p;
    p.print(10);              // 输出: Printing int: 10
    p.print(3.14);            // 输出: Printing double: 3.14
    p.print("Hello World");   // 输出: Printing string: Hello World
    return 0;
}

在这个例子中，Printer类中定义了三个同名的print函数，但它们的参数列表不同，因此它们是函数重载。

4.3 总结

  1. 函数重写（Override）：
    • 发生在继承关系中。
    • 派生类重新定义基类中的虚函数。
    • 使用override关键字显式表明重写操作。
    • 函数签名必须与基类中的虚函数一致。
  2. 函数重载（Overload）：
    • 发生在同一个作用域中（同一个类或同一个函数内）。
    • 定义多个同名但参数列表不同的函数。
    • 不涉及继承关系。
    • 函数签名（参数类型、数量或顺序）必须不同。
wy2458984254
关注
  • 25
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 面向对象三大特征总结(详解)
qq_52575999的博客
09-20 1405
1.面向对象的三大特征 1).封装 封装:将一个对象的全部的属性变量和行为方法进行包装(集中到一个类中,), 并用权限对其成员属性和成员方法加以限制,使得外部对其访问时,不能随意改变该包装. #include <iostream> using namespace std; class Shape{ private: int x;//重心的横坐标 int y;//重心的纵坐标 public : Shape(int x = 0,int y =0):x(x),y(
C++面向对象的三大特性
weixin_44728238的博客
04-27 5114
C++ 三大特性是：封装，继承，多态 一、概念和优点 封装(encapsulation)：封装就是将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。封装的目的是增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过 外部接口，一特定的访问权限来使用类的成员。通过封装使一部分成员充当类与外部的接口，而将其他的成员隐蔽起来，这样就达到了对成员访问权限的合理控制，使不同类之间的相互影响减少到最低限度，进而增强
C++ 面向对象的三大特征 - 详解
weixin_60733596的博客
10-27 904
C++面向对象的三大特征是：封装、继承、多态。
C++—面向对象三大特性以及多态重点详解
拥抱技术
06-30 1160
面向对象三大特性、C++多态详解
【C++笔记】第十三篇 面向对象及三大特性
青鸠的博客
10-31 921
面向对象及三大特性
C++面向对象的三个基本特征
程序员小明
09-19 4426
一、三大特征 封装,继承,多态。 二、封装 所谓封装就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏.封装是面向对象的特征之一，是对象和类概念的主要特性. 简单的说，一个类就是一个封装了数据以及操作这些数据的代码的逻辑实体。在一个对象内部，某些代码或某些数据可以是私有的，不能被外界访问。通过这种方式，对象对内部数据提供了不同级别的保护，以防...
C++面向对象程序设计课程大作业-通讯录管理系统
05-21
本项目是学习C++面向对象编程的实战案例，通过设计和实现通讯录管理系统，学生可以深入理解面向对象编程的概念和技巧，并提升解决问题的能力。同时，项目的完整流程，包括需求分析、设计、编码、测试，也能帮助学生...
CPP.zip_C++面向对象
09-24
**C++面向对象编程概述** C++是一种强大的、通用的编程语言，以其高效性、灵活性和丰富的特性而闻名。尤其在面向对象编程（Object-Oriented Programming, OOP）方面，C++展现了其独特的优势。面向对象编程是C++的...
c++面向对象程序设计语言重点难点复习题及答案.doc
06-27
首先，我们来看看一些关于C++面向对象的重点和难点： 1. 数据共享与保护： - **静态成员**：类的静态数据成员属于类本身，而不是类的实例。这意味着所有类对象共享同一份静态数据成员的拷贝，它们是类的属性，而...
剖析C++的面向对象编程思想
09-03
总之，C++的面向对象特性使其成为编写大型、复杂系统的一种强大工具。理解并熟练掌握面向对象编程，不仅能够提升代码质量，还能提高开发效率，使软件的维护和扩展变得更加容易。在实践中，我们需要不断地探索和实践...
CPP.rar_C++面向对象
09-21
在这个“一个月挑战C++”的学习过程中，我们将深入探讨C++中的面向对象特性，特别是构造函数和析构函数。 首先，让我们了解构造函数。在C++中，构造函数是类的一个特殊成员函数，它的主要任务是在创建新对象时自动...
【刷题汇总 -- 爱丽丝的人偶、集合、最长回文子序列】
m0_69455439的博客
07-23 683
今日刷题汇总day021 -- 爱丽丝的人偶、集合、最长回文子序列
C++笔试强训7
m0_74189279的博客
07-21 968
这意味着编译器会尝试将函数的代码直接插入到每个调用该函数的地方，而不是像通常那样进行函数调用（即，生成调用指令，跳转到函数代码，执行函数体，然后返回）。友元函数是在类外部定义的普通函数，它只能通过传入的参数（如果有的话）来访问类的成员，或者通过类的对象显式地访问（如果该函数设计为接受类的对象作为参数）。函数参数默认值又叫缺省参数，缺省参数必须从右向左开始缺省，必须连续给定缺省值，也就是说，从左到右，一旦遇到一个参数是缺省的，那么之后的参数也必须都是缺省的。指针是类成员函数特有的，用于指向调用该函数的对象。
商品信息管理系统(C语言)
zeyeqianli的博客
07-22 319
该案例使用了C语言中最具特色的结构体，将每个商品的所有信息存在结构体中，并且定义一个结构体类型的数组保存所有商品的信息，并且按照模块化的编程思想，将要实现的每个功能编写成独立的函数，这样即方便阅读同时也方便差错修改。该系统的主要功能如下：(1) 登录系统。(2) 创建商品信息。(3) 打印商品信息。(4) 查询商品信息。(5) 修改商品信息。(6) 删除商品信息。(7) 商品价格排名显示。(8) 退出系统。
C++笔记3：基类指针delete子类对象的内存泄漏问题
subtitle_的博客
07-21 253
C++笔记3：基类指针delete子类对象的内存泄漏问题
C语言动态内存管理
m0_62183318的博客
07-22 1015
⚽️动态内存管理是一种内存管理方法。它允许程序在运行时根据需要🍤动态地申请和回收内存空间🍤。与静态内存管理（如变量和数组的预先分配）不同，动态内存管理根据程序的需求即时分配内存，并且分配的内存大小就是程序要求的大小。🥪能更好地适应系统的动态需求，提高内存的利用率🥪可以根据程序的实际需要分配内存，而不是预先分配固定大小的内存🥪允许程序在不需要时释放内存空间，供其他应用程序使用总结来说，🍔动态内存管理。
2024年华为OD机试真题-虚拟游戏理财-C++-OD统一考试（C卷D卷）
热门推荐
面试高手的博客
07-21 4万+
现有一家Bank，它提供有若干理财产品m，风险及投资回报不同，你有N（元）进行投资，能接受的总风险值为X。第一行：产品数(取值范围[1, 20])，总投资额(整数，取值范围[1, 10000])，可接受的总风险(整数，取值范围[1, 200])投资第二项30个单位，第四项40个单位，总的投资风险为两项相加为4+6=10。第四行：最大投资额度序列，输入为整数，取值范围[1,10000]第二行：产品投资回报率序列，输入为整数，取值范围[1,60]第三行：产品风险值序列，输入为整数，取值范围[1,100]
内网对抗-隧道技术篇&防火墙组策略&HTTP反向&SSH转发&出网穿透&CrossC2&解决方案
最新发布
siu~
07-24 613
1、C2/C2上线-CrossC2插件-多系统平台支持 2、隧道技术篇-应用层-SSH协议-判断&封装&建立&穿透 3、隧道技术篇-应用层-HTTP协议-判断&封装&建立&穿透
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值