一文带你了解C++三大特性，封装、继承、多态

最新推荐文章于 2024-05-30 16:22:47 发布
最新推荐文章于 2024-05-30 16:22:47 发布
阅读量1.1k 收藏 9
点赞数 4
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z_991129/article/details/128822152
版权

目录

简介

封装

继承

1.1概念与基础使用

1.2构造函数

1.2.1透传构造

 1.2.2委托构造

1.2.3继承构造 

1.3 对象的创建与销毁

1.4 多重继承

1.4.1 基础使用

1.4.2 二义性问题

多态

1.1 概念

1.2函数覆盖

 1.3使用方式

 1.4应用

 1.5原理

 1.6缺陷 

简介

C++ 是一种高级语言，它是由 Bjarne Stroustrup 于 1979 年在贝尔实验室开始设计开发的。C++ 进一步扩充和完善了 C 语言，是一种面向对象的程序设计语言。C++ 可运行于多种平台上，如 Windows、MAC 操作系统以及 UNIX 的各种版本。

本教程是专门为初学者打造的，帮助他们理解与 C++ 编程语言相关的基础到高级的概念。

封装

所有的 C++ 程序都有以下两个基本要素：

  • 行为：这是程序中执行动作的部分，它们被称为函数。
  • 属性：属性是程序的信息，会受到程序函数的影响。

封装是面向对象编程中的把数据和操作数据的函数绑定在一起的一个概念，这样能避免受到外界的干扰和误用，从而确保了安全。数据封装引申出了另一个重要的 OOP 概念，即数据隐藏。

数据封装是一种把数据和操作数据的函数捆绑在一起的机制，数据抽象是一种仅向用户暴露接口而把具体的实现细节隐藏起来的机制。

C++ 通过创建类来支持封装和数据隐藏（public、protected、private）。我们已经知道，类包含私有成员（private）、保护成员（protected）和公有成员（public）成员。默认情况下，在类中定义的所有项目都是私有的。

封装的写法并不唯一，在实际的过程中会结合业务需求而定，下面的以一个最基础的案例进行编写。通常先对属性私有化，使属性隐藏，然后根据当前属性的需求，通过getter函数和setter函数对类外分别公开读和写的功能。

#include <iostream>

using namespace std;

class MobilePhone
{
private: // 私有权限：只有类内部可访问
    string brand; // 可读可写
    string model; // 只写
    int weight = 188; // 初始值

public: // 公开接口
    string get_brand() // getter：读属性
    {
        return brand;
    }

    void set_brand(string b) // setter：写属性
    {
        brand = b;
    }

    void set_model(string m) // setter
    {
        model = m;
    }

    int get_weight() // getter
    {
        return weight;
    }

};


int main()
{
    MobilePhone mp1;
    mp1.set_brand("小米");
    mp1.set_model("13 Pro");
    cout << mp1.get_brand() << " " << mp1.get_weight() << endl;

    MobilePhone* mp2 = new MobilePhone;
    mp2->set_brand("红米");
    mp2->set_model("K60 Pro");
    cout << mp2->get_brand() << " " << mp2->get_weight() << endl;

    delete mp2;

    return 0;
}

封装最主要的作用是提升程序安全性。

继承

1.1概念与基础使用

继承就是在一个已经存在的类的基础上建立一个新的类，并拥有其特性，体现了代码复用的思想。

已经存在类被称为“基类”或“父类”；

新建立的类被称为“派生类”或“子类”。

例如：

#include <iostream>

using namespace std;

/**
 * @brief The Father class 基类
 */
class Father
{
public:
    string first_name = "王";

    void work()
    {
        cout << "我是个厨师" << endl;
    }
};

/**
 * @brief The Son class 派生类
 */
class Son:public Father
{

};

int main()
{
    Son s;
    cout << s.first_name << endl; // 王
    s.work(); // 我是个厨师

    return 0;
}

上面的代码中Son类与Father基本一致，在实际开发中，无需保持一致，通常派生类会在继承的基础上增加或修改一些基类的内容。

#include <iostream>

using namespace std;

/**
 * @brief The Father class 基类
 */
class Father
{
public:
    string first_name = "王";

    void work()
    {
        cout << "我是个厨师" << endl;
    }
};

/**
 * @brief The Son class 派生类
 */
class Son:public Father
{
public:
    Son()
    {
        // 如果派生类对基类的属性值不满意
        // 可以修改，前提是能修改
        first_name = "刘";
    }

    // 函数隐藏：对基类的函数不满意
    void work()
    {
        cout << "我是个律师" << endl;
    }

    // 增加内容
    void play()
    {
        cout << "我喜欢打游戏" << endl;
    }
};

int main()
{
    Son s;
    cout << s.first_name << endl; // 刘
    s.work(); // 我是个律师
    s.play(); // 我喜欢打游戏
    // 调用被隐藏的基类函数
    s.Father::work(); // 我是个厨师

    return 0;
}

需要注意的是，基类和派生类是相对的，某个类可能既是类A的基类，又是类B的派生类；派生类往往比基类更具体，基类往往比派生类更抽象。

1.2构造函数

类的构造函数和析构函数不能被继承。

#include <iostream>

using namespace std;


class Father
{
private:
    string name;
public:
    Father(string name):name(name){}

    string get_name() const
    {
        return name;
    }

    void set_name(string name)
    {
        this->name = name;
    }
};


class Son:public Father
{
public:

};

int main()
{
//    Son s("张三"); 错误

    return 0;
}

上面的例子可以看出，派生类并没有继承基类的带参数的构造函数。实际上1.1节中的派生类Son也没有继承Father的构造函数，这是因为当程序员不手写构造函数时，编译器会增加以下代码：

  • 给基类Father增加一个无参构造函数
  • 给派生类Son增加一个无参构造函数
  • 在派生类Son的无参构造函数中，调用基类的无参构造函数

因为派生类中省略了基类的代码，因此在创建派生类对象时，需要调用基类的代码完成派生类中基类代码部分内存的开辟，即派生类的任意一个构造函数都必须直接或间接调用基类的任意一个的构造函数。

派生类调用基类构造函数的写法：

  • 透传构造
  • 委托构造
  • 继承构造（只是叫这个名字，并没有继承构造函数）

1.2.1透传构造

透传构造指的是在派生类的构造函数中直接调用基类的构造函数。

#include <iostream>

using namespace std;


class Father
{
private:
    string name = "无名氏";
    int age = 1;

public:
    Father(string name)
        :name(name)
    {
        cout << "Father的一参构造函数" << endl;
    }

    Father(string name,int age)
        :name(name),age(age)
    {
        cout << "Father的二参构造函数" << endl;
    }

    void show()
    {
        cout << name << " " << age << endl;
    }
};


class Son:public Father
{
public:
    Son(string name)
        :Father(name)
    {

    }

    Son(string name,int age)
        :Father(name,age)
    {

    }
};

int main()
{
    Son s("张三",12);
    s.show();

    Son s2("李四");
    s2.show();

    return 0;
}

 1.2.2委托构造

委托构造指的是，某个类的构造函数可以调用这个类的另一个重载的构造函数。

 

#include <iostream>

using namespace std;


class Father
{
private:
    string name = "无名氏";
    int age = 1;

public:
    Father(string name)
        :name(name)
    {
        cout << "Father的一参构造函数" << endl;
    }

    Father(string name,int age)
        :name(name),age(age)
    {
        cout << "Father的二参构造函数" << endl;
    }

    void show()
    {
        cout << name << " " << age << endl;
    }
};


class Son:public Father
{
public:
    Son(string name)
        :Son(name,10)
    {

    }

    Son(string name,int age)
        :Father(name,age)
    {

    }
};

int main()
{
    Son s("张三",12);
    s.show();

    Son s2("李四");
    s2.show();

    return 0;
}

委托构造需要注意以下几点：

  • 如果是派生类，最终委托的构造函数要透传调用基类的构造函数。
  • 不要形成委托闭环。

1.2.3继承构造 

是C++11的新写法，在派生类中使用继承构造后，编译器会按照基类的构造函数格式，创建出派生类的构造函数，并且分别使用透传构造调用基类的同参数构造函数。

#include <iostream>

using namespace std;


class Father
{
private:
    string name = "无名氏";
    int age = 1;

public:
    Father(string name)
        :name(name)
    {
        cout << "Father的一参构造函数" << endl;
    }

    Father(string name,int age)
        :name(name),age(age)
    {
        cout << "Father的二参构造函数" << endl;
    }

    void show()
    {
        cout << name << " " << age << endl;
    }
};


class Son:public Father
{
public:
    using Father::Father; // 继承构造
};

int main()
{
    Son s("张三",12);
    s.show();

    Son s2("李四");
    s2.show();

    return 0;
}

实际开发不建议使用继承构造。

1.3 对象的创建与销毁

#include <iostream>

using namespace std;

/**
 * @brief The Value class
 * 作为其它类的变量
 */
class Value
{
private:
    string name;

public:
    Value(string name):name(name)
    {
        cout << name << "创建了" << endl;
    }

    ~Value()
    {
        cout << name << "销毁了" << endl;
    }
};

class Father
{
public:
    static Value s_value;
    Value value = Value("Father类的成员变量");

    Father()
    {
        cout << "Father的构造函数" << endl;
    }

    ~Father()
    {
        cout << "Father的析构函数" << endl;
    }
};

Value Father::s_value = Value("Father类的静态成员变量");

class Son:public Father
{
public:
    static Value s_value;
    Value value = Value("Son类的成员变量");

    Son()
    {
        cout << "Son的构造函数" << endl;
    }

    ~Son()
    {
        cout << "Son的析构函数" << endl;
    }
};

Value Son::s_value = Value("Son类的静态成员变量");


int main()
{
    cout << "主函数开始执行" << endl;

    { // 局部代码块
        Son s;
        cout << "Son类对象使用中......" << endl;
    }

    cout << "主函数结束执行" << endl;
    return 0;
}

 

上述运行结果可以发现遵循如下规律：

  • 创建流程与销毁流程对称。
  • 相同部分的创建，基类先派生类后；相同部分的销毁，派生类先基类后。
  • 静态成员先创建，后销毁。

一个派生类对象的创建与销毁需要逐层调用到最上层的基类，因此体现了面向对象编程的特点：编写效率高，运行效率低。

可以使用继承，但是不要滥用继承。

1.4 多重继承

1.4.1 基础使用

之前的代码都是单继承，即一个派生类只有一个基类，实际上C++是支持多继承的，即一个派生类可以有多个基类，派生类在多重继承中与每一个基类的关系，仍然可以看做是一个单继承。

#include <iostream>

using namespace std;

class Sofa
{
public:
    void sit()
    {
        cout << "能坐着" << endl;
    }
};

class Bed
{
public:
    void lay()
    {
        cout << "能躺着" << endl;
    }
};

class SofaBed:public Sofa,public Bed
{

};

int main()
{
    SofaBed sb;
    sb.lay();
    sb.sit();

    return 0;
}

1.4.2 二义性问题

多重继承容易出现二义性问题，主要有两种情况：

  • 在多继承中，不同的基类拥有同名成员，此时派生类的调用会出现二义性问题。

解决方法：可以通过类名::的方式区分重名成员

#include <iostream>

using namespace std;

class Sofa
{
public:
    void sit()
    {
        cout << "能坐着" << endl;
    }

    void position()
    {
        cout << "放在客厅" << endl;
    }
};

class Bed
{
public:
    void lay()
    {
        cout << "能躺着" << endl;
    }

    void position()
    {
        cout << "放在卧室" << endl;
    }
};

class SofaBed:public Sofa,public Bed
{

};

int main()
{
    SofaBed sb;
    sb.lay();
    sb.sit();
//    sb.position(); 错误
    sb.Bed::position();
    sb.Sofa::position();

    return 0;
}
  • 菱形（钻石）继承：如果一个基类有两个派生类，这两个派生类又作为基类拥有一个派生类，此时在最终的派生类中访问间接基类的成员会出现二义性。

解决方法1：可以通过类名::的方式区分重名成员

#include <iostream>

using namespace std;

class Furniture // 家具
{
public:
    void func()
    {
        cout << "家里要有家具" << endl;
    }
};

class Sofa:public Furniture
{
};

class Bed:public Furniture
{
};

class SofaBed:public Sofa,public Bed
{
};

int main()
{
    SofaBed sb;
//    sb.func(); 错误
//    sb.Furniture::func(); 错误
    sb.Bed::func();
    sb.Sofa::func();

    return 0;
}

解决方法2：使用虚继承。

 

虚继承的实现通过虚基类指针与虚基类表完成，当Sofa和Bed使用虚继承继承Furniture类时，会在Sofa和Bed类中增加一个虚基类表，虚基类表中记录的是Furniture的成员，Sofa类（Bed类）的所有对象共用这一张虚基类表，通过每个对象创建时新增一个隐藏成员虚基类表指针调用虚基类表。SofaBed继承了Sofa和Bed类，SofaBed对象也会有继承来的虚基类指针，虚基类指针可以查询Sofa和Bed的虚基类表，在调用时通过查表来区分二义性问题。

#include <iostream>

using namespace std;

class Furniture // 家具
{
public:
    void func()
    {
        cout << "家里要有家具" << endl;
    }
};

class Sofa:virtual public Furniture
{
};

class Bed:virtual public Furniture
{
};

class SofaBed:public Sofa,public Bed
{
};

int main()
{
    SofaBed sb;
    sb.func();

    return 0;
}

虚继承在代码形式上完美解决了菱形继承的二义性问题，但是在调用这些原本二义性的代码时，增加了一些开销（虚基类表与虚基类指针内存占用和查询等），因此虚继承代码执行效率比普通继承要低。

多态

1.1 概念

多态按照字面的意思可以认为是“多种状态”，可以简单概括为“一个接口，多种状态”，即程序在运行时动态决定调用的代码。

多态与模板的区别在于，模板针对不同的数据类型采用同样的策略，而多态针对不同的数据类型采用不同的策略。

多态的实现需要以下3个条件：

1. 要有公有继承

2. 要有函数覆盖：派生类中覆盖基类的成员函数

3. 基类引用/指针指向派生类对象

1.2函数覆盖

函数覆盖与函数隐藏类似，但是函数覆盖可以通过虚函数来支持多态，一个成员函数使用virtual关键字修饰，这个函数就是虚函数。

在派生类中，使用之前函数隐藏的方式重新实现一个基类中的虚函数，此时就是函数覆盖，函数覆盖与虚函数具有以下特点：

  • 当函数覆盖成功时，虚函数具有传递性
  • C++11中可以在派生类的新覆盖的函数后增加override关键字进行覆盖是否成功的验证
  • 成员函数与析构函数可以定义为虚函数，静态成员函数与构造函数不可以定义为虚函数。
  • 如果成员函数的声明与定义分离，virtual关键字只需要在声明时使用
#include <iostream>

using namespace std;

class Animal
{
public:
    virtual void eat()
    {
        cout << "吃东西" << endl;
    }
};

class Dog:public Animal
{
public:
    void eat() override
    {
        cout << "吃骨头" << endl;
    }
};


int main()
{
    Animal a;
    a.eat(); // 吃东西

    Dog d;
    d.eat(); // 吃骨头

    return 0;
}

 1.3使用方式

多态既可以引用的方式，也可以使用指针的方式实现。

#include <iostream>

using namespace std;

class Animal
{
public:
    virtual void eat()
    {
        cout << "吃东西" << endl;
    }
};

class Dog:public Animal
{
public:
    void eat() override
    {
        cout << "吃骨头" << endl;
    }
};

class Cat:public Animal
{
public:
    void eat()
    {
        cout << "吃鱼" << endl;
    }
};

int main()
{
    Dog d;
    Cat c;

    // 基类引用派生类对象
    Animal& a1 = d;
    Animal& a2 = c;
    // 多态
    a1.eat(); // 吃骨头
    a2.eat(); // 吃鱼

    Dog* d2 = new Dog;
    Cat* c2 = new Cat;
    //  基类指针指向派生类对象
    Animal* a3 = d2;
    Animal* a4 = c2;
    // 多条
    a3->eat(); // 吃骨头
    a4->eat(); // 吃鱼

    // 先别管delete问题

    return 0;
}

 1.4应用

多态的主要应用是函数的参数传递，从而实现“一个接口，多种状态”的效果。

#include <iostream>

using namespace std;

class Animal
{
public:
    virtual void eat()
    {
        cout << "吃东西" << endl;
    }
};

class Dog:public Animal
{
public:
    void eat() override
    {
        cout << "吃骨头" << endl;
    }
};

class Cat:public Animal
{
public:
    void eat()
    {
        cout << "吃鱼" << endl;
    }
};

// 基于引用的多态参数传递
void test_eat1(Animal& a)
{
    a.eat();
}

// 基于指针的多态参数传递
void test_eat2(Animal* a)
{
    a->eat();
}

int main()
{
    Dog d1;
    Cat c1;
    Animal a1;
    // 测试基于引用的多态参数传递
    test_eat1(d1); // 吃骨头
    test_eat1(c1); // 吃鱼
    test_eat1(a1); // 吃东西

    Dog* d2 = new Dog;
    Cat* c2 = new Cat;
    Animal* a2 = new Animal;
    // 测试基于指针的多态参数传递
    test_eat2(d2); // 吃骨头
    test_eat2(c2); // 吃鱼
    test_eat2(a2); // 吃东西

    // 先别管delete问题

    return 0;
}

 1.5原理

当一个类中有虚函数时，编译器会为这个类创建一个虚函数表，这个类的对象拥有隐藏的成员变量虚函数表指针指向虚函数表。此类被继承时，虚函数表也会被继承，但是如果当前继承的派生类中出现函数覆盖，则会在派生类中更新这张表。

 

 注：重写=覆盖

在实际多态的运行中是一个动态类型绑定的过程，当使用基类引用或指针指向派生类对象时，编译器会产生一段代码，用来检查当前内存中的对象的真正类型，在运行时通过对象的虚函数表指针找到真正的调用函数，因此多态也是一个查表的过程。

使用多态会产生一些额外的代码调用开销，不要滥用多态。

 1.6缺陷 

当形成多态时，有可能会出现内存泄露的问题。

#include <iostream>

using namespace std;

class Animal
{
public:
    virtual void eat()
    {
        cout << "吃东西" << endl;
    }

    ~Animal()
    {
        cout << "Animal析构函数" << endl;
    }
};

class Dog:public Animal
{
public:
    void eat() override
    {
        cout << "吃骨头" << endl;
    }

    ~Dog()
    {
        cout << "Dog析构函数" << endl;
    }
};


int main()
{
    Dog* d = new Dog;
    delete d; // 先调用Dog的析构，再调用Animal的析构

    Animal* a = new Dog;
    delete a; // 只调用Animal的析构函数

    return 0;
}

上面问题的出现是由于析构函数没有函数覆盖，实际上析构函数也无法覆盖，但是析构可以设置为虚函数，且无需覆盖就能解决上述问题。

#include <iostream>

using namespace std;

class Animal
{
public:
    virtual void eat()
    {
        cout << "吃东西" << endl;
    }

    virtual ~Animal()
    {
        cout << "Animal析构函数" << endl;
    }
};

class Dog:public Animal
{
public:
    void eat() override
    {
        cout << "吃骨头" << endl;
    }

    ~Dog() // 仍然具有虚函数的传递性
    {
        cout << "Dog析构函数" << endl;
    }
};


int main()
{
    Dog* d = new Dog;
    delete d; // 先调用Dog的析构，再调用Animal的析构

    Animal* a = new Dog;
    delete a; // 先调用Dog的析构，再调用Animal的析构

    return 0;
}

如果一个类可能作为基类，建议都手写为虚析构函数，以防未来可能出现的内存泄露问题。

我宣布个事!
关注
  • 4
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【C++】三大特性之---封装、继承、多态
weixin_44768184的博客
08-24 153
你要的所有答案， 都在你为之努力的当下！ 目录： 每日总结 封装 继承 1.继承中的作用域 2.六个默认成员函数 3.继承体系下派生类的对象模型 多态 >>每日总结 在关系表中，属性值必须是另一个表主键的有效值或空值，这样的属性是“外键”； 数据库的特点：数据结构化-->数据冗余度小(冗余低且以扩充)-->数据独立性高-->数据共享性好-->...
【C++】三大特性：封装、继承、多态
weixin_42761454的博客
01-24 671
访问权限 C++通过public、protected、private三个关键字来控制成员变量和成员函数的访问权限，他们分别表示公有的、受保护的、私有的，被称为成员访问限定符。 在类的内部（定义类的代码内部），无论成员被声明为public、protected还是private，都是可以互相访问的，没有访问权限的限制。 在类的外部（定义类的代码之外），只能通过对象访问成员，并且通过对象只能访问public属性的成员，不能访问private、private属性的成员。 ？？ 无论公有继承、私有继承还是保护继承，私
【c++ 封装、继承、多态】
小呆鸟blog
09-10 5957
函数运行的版本不是一开始就确定好了的而是在程序运行的时候才选择函数运行的版本，至于到底选择哪个函数版本取决于调用该函数的指针或者引用实际绑定的数据对象。
c++面向对象之封装、继承、和多态
qaaaaaaz的博客
05-05 1626
派生类中会包含并且使用从基类继承而来的成员，为了使用这些成员，派生类必须知道他们是什么。代码来源阿秀的学习笔记class A {// 1，空对象，只有一个占位 cout
【C++ | 面向对象思想】 C++ 的面向对象(OOP)思想详解：抽象、封装、继承、多态
最新发布
wkd_007的博客
05-30 1138
👉本文介绍了面向过程和面向对象的区别，然后介绍了几个面向对象的特性：抽象、封装、继承、多态。
c++：封装、继承、多态
嵌入式小企鹅的博客
11-04 1734
封装是面向对象编程中的一种重要概念，它将数据和操作封装在一起，形成一个“黑盒子”，对外部只暴露必要的接口，隐藏内部实现细节。C++通过类（Class）来实现封装，其中包括私有成员（Private）、保护成员（Protected）和公有成员（Public）等访问控制修饰符。私有成员只能在类内部访问，保护成员可以在类及其子类中访问，公有成员可以在任何地方访问。首先，在介绍封装前，应该要知道类和对象这么一个事，什么是类和对象？
C++之对封装、继承、多态的理解
爱喝橙汁儿的博客
05-20 2812
对封装、继承、多态的简单认识和理解。
C++基础知识（封装继承多态）
壹的博客
03-26 1163
面试要点：C++的封装继承多态
Java面向对象三大特性，即封装、继承、多态
12-23
面向对象三大特性知识模板 大家好，我是Ziph！ 今天分享下面向对象三大特性的知识内容。 结合思维导图学习效果更佳！点击下方链接进入 Java面向对象三大特性思维导图 一、封装 封装的必要性：在对象的外部为对象的...
C# 面向对象三大特性：封装、继承、多态
09-02
在C#中，面向对象的三大特性——封装、继承和多态，是实现这一目标的关键工具。 1. 封装 封装是面向对象编程的基础，它意味着将数据和操作这些数据的方法捆绑在一起，形成一个独立的单元，即类。在C#中，我们可以...
C# 一个完整的类 面向对象三大特性 封装 继承 多态 的示例
10-25
C# 一个完整的类 面向对象三大特性 封装 继承 多态 的示例 封装通过私有字段和公共方法来实现对数据的访问控制。 继承通过派生类Student继承自Person类，获得了Person类的所有属性和方法，并在此基础上扩展了自己的...
C++中的封装、继承、多态理解
12-20
封装(encapsulation)：就是将抽象得到的数据和行为(或功能)相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成”类”，其中数据和函数都是类的成员。封装的目的是增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，特定的访问权限来使用类的成员。封装可以隐藏实现细节，使得代码模块化。 继承(inheritance)：C++通过类派生机制来支持继承。被继承的类型称为基类或超类，新产生的类为派生类或子类。保持已有类的特性而构造新类的过程称为继承。在已有类的基础上新增自己的特性而产生新类的过程称为派生。继承和派生的目的是保持已有类的特性并构造新
C++程序设计-封装、继承多态应用示例
05-09
在C++编程语言中，封装、继承和多态是面向对象编程（OOP）的三大核心概念。这些特性使得C++能够构建出高效、模块化的软件系统。下面将详细解释这三个概念及其在“C++程序设计-封装、继承多态应用示例”中的体现。 1...
C++ 封装、继承和多态
SimpleForest的博客
07-08 1230
多态指的是同一个函数名可以调用不同类型的函数，从而实现不同对象之间的差异性行为。静态多态是通过函数重载和运算符重载来实现的，而动态多态则是通过虚函数来实现的。多态的目的是实现代码的灵活性和可扩展性，使得程序可以更好地适应不同的应用场景。封装是指的是将数据和操作数据的方法封装在类中，使得数据和方法不能被外部直接访问，只能通过类的公共接口进行访问和修改。封装的目的是实现代码模块化和信息隐藏，提高代码的可维护性和可重用性。继承是指的是一个类（子类）通过继承另一个类（父类）的属性和方法，从而实现代码的扩展。
C++的封装、继承和多态
Qxxx11的博客
01-26 927
关于C++封装、继承和多态的一些总结，借鉴了很多篇文章，内容太多写不太完，就简单写了一下，详细的内容会有链接在里面，可以结合起来看
【C++】封装、继承和多态
晚安的博客
05-10 634
类的成员变量和成员函数占用内存大小，以下代码也说明了所有类的对象是共用静态成员变量和成员函数的。父类中所有非静态成员变量属性都会被字子类继承下去，父类中的私有属性，是被编译器给隐藏了，只是访问不到，是确实继承下去了，并且占有内存空间。继承中构造和析构的顺序如下：先构造父类，然后再有子类，最后先释放子类，然后释放父类。1、羊继承了动物的数据，骆驼同样继承了动物的数据，当草泥马使用数据时就会产生二义性。如果使用的是编译器默认提供的拷贝构造函数，会做浅拷贝。继承的方式一共有三种：公共继承，保护继承，私有继承。
C++的封装、继承、多态
Albert_weiku的博客
06-22 1609
C++封装、继承、多态总结
C++学习——面向对象三大特性：封装、继承、多态
mingyuexin235的博客
03-21 1349
今天来更新面向更新的三大特性，分别是封装、继承、多态，是C++面试中常考也是非常重要的面试题之一，如果最近有春招的宝可以关注我噢，我会定时分享C++相关常考的知识与面试题哒！
C++之三大特性 “封装”、“继承”、“多态”
qq_49613557的博客
10-25 9229
C++之三大特性 “封装”、“继承”、“多态” 目录封装继承继承的概念及定义基类和派生类对象赋值转换继承中的作用域派生类的默认成员函数继承与友元继承与静态成员复杂的菱形继承及菱形虚拟继承继承的总结和反思多态二级目录三级目录 封装 继承 继承的概念及定义 继承的概念 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特 性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触
使用C语言来实现C++的特性，封装继承多态的实例
06-07
下面是一个示例代码，演示了如何在C语言中实现封装、继承和多态的特性： ```c #include // 父结构体 typedef struct { int x; } Base; // 子结构体 typedef struct { Base base; // 嵌套父结构体 int y; } ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值