C++继承

已于 2023-12-14 11:37:59 修改
阅读量36 收藏
点赞数
文章标签： c++ 开发语言
于 2023-12-13 14:43:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45760139/article/details/134968137
版权

继承

继承的基本语法

class 子类 : 继承方式1 基类1, 继承方式2 基类2, ... 
{  
	…
};

继承方式有以下三种：
	公有继承：public
	保护继承：protected
	私有继承：private

三种继承方式的共同特点

继承所要达到的目的：

（1）子类对象包含基类子对象
（2）子类内部可以直接访问基类的所有非私有成员

继承的本质：

基类的非私有成员在子类中仅仅为可见，而非拥有

注意：对于继承切忌不要理解为基类的成员变为子类的成员，继承不会改变类成员的作用域，基类的成员永远都是基类的成员，并不会因为继承而变成子类的成员

#include <iostream>
using namespace std;
class Base//基类
{
public: 
    int m_a;
    void foo() { cout << "Base::foo" << endl; }
protected:
    int m_b;
    void bar() { cout << "Base::bar" << endl; }
private:
    int m_c;
    void hum() { cout << "Base::hum" << endl; }
};

class Derived : public Base//派生类
{
public:
    void fun()
    {   
        /*子类内部可以直接访问基类的多有非私有成员*/
        m_a = 100;// ok
        foo();    // ok
        m_b = 200;// ok
        bar();    // ok
        /*
        基类内部的私有成员不能在子类中访问
        m_c=300;//error
        hum();//error
        */
    }   
private:
    int m_d;
};

int main(void)
{
    Base b;
    cout << "基类对象b的大小:" << sizeof(b) << endl; // 12

    Derived d;//子类对象包含基类子对象
    cout << "子类对象d的大小:" << sizeof(d) << endl; // 16
    return 0;
}

运行结果：
在这里插入图片描述

尽管基类的公有和保护成员在子类中直接可见，但仍然可以在子类中重新定义这些名字，子类中的名字会隐藏所有基类中的同名定义。
如果需要在子类内部访问一个在基类中定义却被子类标识符所隐藏的名字，可以借助作用域限定操作符 :: 实现
因为作用域的不同，分别在子类和基类中定义的同名成员函数(包括静态成员函数)，并不构成重载关系，相反是一种隐藏关系.
任何时候，在子类的内部，总可以通过作用域限定操作符 :: ，显式地调用那些在基类中定义却被子类所隐藏的成员

#include <iostream>
using namespace std;
class Base 
{
public:
    int m_a;
    void foo() { cout << "Base::foo" << endl; }
protected:
    int m_b;
    void bar() { cout << "Base::bar" << endl; }
private:
    int m_c;
    void hum() { cout << "Base::hum" << endl; }
};

class Derived : public Base {
public:
    void fun()
    {   
        m_a = 100;
        foo();//出现同名foo()函数,基类中的foo 被 子类的foo 隐藏
        m_b = 200;
        Base::bar();//基类中的bar 虽 被 子类中的bar隐藏,但可以通过作用域限定符强行调用基类bar
    }   
private:
    int foo() {cout << "Derived::foo" << endl;}
    int bar() {cout << "Derived::bar" << endl;}
private:
    int m_d;
};

int main(void)
{
    Derived d;
    d.fun();
    return 0;
}

运行结果
在这里插入图片描述

三种继承的差别

基类中的公有、保护和私有成员，在子类中将对这些基类成员的访问控制限定进行重新标记
在这里插入图片描述
当“通过”子类访问其所继承的基类的成员时，需要考虑因继承方式对访问控制限定的影响。

#include <iostream>
using namespace std;
class Base 
{
public:
    int m_a;//原始标记为public
    void foo() { cout << "Base::foo" << endl; }
protected:
    int m_b;//原始标记为protected
    void bar() { cout << "Base::bar" << endl; }
private:
    int m_c;//原始标记为private
    void hum() { cout << "Base::hum" << endl; }
};

class Derived : public Base 
{
/*
    子类对基类的成员重新标记防控限定
    m_a/foo重新标记防控限定是public
    m_b/bar重新标记防控限定是protected
    m_c/hum重新标记防控限定是private
*/
public:
    void fun()
    {   
        m_a = 100;
        foo();
        m_b = 200;
        bar();
    }   
private:
    int m_d;
};

运行结果：
在这里插入图片描述

class Derived : protected Base 
{
/*
    子类对基类的成员重新标记防控限定
    m_a/foo重新标记防控限定是protected
    m_b/bar重新标记防控限定是protected
    m_c/hum重新标记防控限定是private
*/
public:
    void fun()
    {   
        m_a = 100;
        foo();
        m_b = 200;
        bar();
    }   
private:
    int m_d;
};


class Derived : private Base   
{
/*
    子类对基类的成员重新标记防控限定
    m_a/foo重新标记防控限定是private
    m_b/bar重新标记防控限定是private
    m_c/hum重新标记防控限定是private
*/
public:
    void fun()
    {   
        m_a = 100;
        foo();
        m_b = 200;
        bar();
    }   
private:
    int m_d;
};

公有成员独有特点

子类对象在类外可以访问基类公有成员（其他继承方式不可以）
如果被子类同名标识符隐藏也可以借助作用域限定符 :: 指定访问基类的公有成员
子类类型的指针或引用 和 基类类型的指针或引用可以进行转换（其他继承方式不可以）

#include <iostream>
#pragma pack(1)

using namespace std;

class Human
{
public:
    int m_age;
    string m_name;
};

class Student : public Human
{
public:
    int m_no;
};

int main(void)
{
    Human h;
    cout << "Human类对象h的大小:" << sizeof(h) << endl;
    Student s;
    cout << "Student类对象s的大小:" << sizeof(s) << endl;

    //以下两种访问范围缩小是安全的
    Human* ph = &s;//Student* --> Human*
    Human& rh = s;
    //以下两种,访问范围扩大有风险,虽然通过强转可以成功,但风险依然存在
    Student* ps = static_cast<Student*>(&h);
    Student& rs = static_cast<Student&>(h);
    
    //以下两种转换毫无风险
    Student* pps = static_cast<Student*>(ph);//Human* --> Student*
    Student& rrs = static_cast<Student&>(h);
    return 0;
}

运行结果
在这里插入图片描述

子类的构造、析构

构造

子类没有定义构造函数，编译器为子类提供的默认无参构造函数

定义基类子对象，并调用其基类的无参构造函数，构造该子类对象中的基类子对象。

子类定义构造函数但没有在初始化表中指明基类部分构造方式

定义基类子对象，并调用其基类的无参构造函数，构造该子类对象中的基类子对象。

子类定义构造函数并在初始化表中指明基类部分构造方式

定义基类子对象并调用指明的其基类的构造函数。

子类对象的构造过程：构造基类子对象->构造成员变量->执行构造代码

阻断继承：

子类的构造函数无论如何都会调用基类的构造函数，构造子类对象中的基类子对象
如果把基类的构造函数定义为私有，那么该类的子类就永远无法被实例化为对象，在C++中可以用这种方法阻断一个类被扩展

析构

子类没有定义析构函数编译器将提供一个默认析构函数

析构完所有的成员变量以后，会自动调用其基类的析构函数.

子类定义析构函数

子类的析构函数在执行完自身析构代码，并析构完所有的成员变量以后，会自动调用其基类的析构函数.

子类对象的析构过程：执行析构代码->析构成员变量->析构基类子对象

拷贝构造

子类没有定义拷贝构造函数，编译器为子类提供的默认拷贝构造函数

定义基类子对象，并调用其基类的拷贝构造函数，构造该子类对象中的基类子对象

子类定义了拷贝构造函数，但没有在初始化表指明其基类部分的构造方式

定义基类子对象，并调用其基类的无参构造函数，构造该子类对象中的基类子对象

子类定义了拷贝构造函数，同时初始化表中指明了其基类部分以拷贝方式构造

定义基类子类对象，并调用其基类的拷贝构造函数，
构造该子类对象中的基类子对象

拷贝赋值

子类没有定义拷贝赋值函数编译器为子类提供的缺省拷贝赋值函数

会自动调用其基类的拷贝赋值函数，复制该子类对象中的基类子对象

子类定义了拷贝赋值函数，但没有显式调用其基类的拷贝赋值函数

子类对象中的基类子对象将得不到复制

子类定义了拷贝赋值函数，同时显式调用了其基类的拷贝赋值函数

子类对象中的基类子对象将得到复制

代码

#include <iostream>
using namespace std;

class Human
{
public:
    Human(int age=0,const char* name="wr"):m_age(age),m_name(name)
    {   
        cout << "Human类的缺省构造函数被调用" << endl;
    }   
    Human(const Human& that):m_age(that.m_age),m_name(that.m_name)
    {   
        cout << "Human类拷贝构造函数被调用" << endl;
    }   

    Human& operator=(const Human& that)
    {   
        cout << "Human类的拷贝赋值函数被调用" << endl;
        this->m_age=that.m_age;
        this->m_name=that.m_name;
        return *this;
    }   

    void getinfo()
    {   
        cout << "姓名:" << this->m_name << ",年龄:" <<this->m_age;
    }   
    ~Human()
    {   
        cout << "Human类的析构函数被调用" << endl;
    }   
private:
    int m_age;
    string m_name;
};

class Student:public Human
{
public:
    Student(int age=0,const char* name="wr",float score=0.0,const char* remark="w")
        :Human(age,name),m_score(score),m_remark(remark)
    {
        cout << "Student类的缺省构造函数被调用" << endl;
    }
    Student(const Student& that):Human(that),m_score(that.m_score),m_remark(that.m_remark)
    {
        cout << "Student类的拷贝构造函数被调用" << endl;
    }
    Student& operator=(const Student& that)
    {
        cout << "Student类的拷贝赋值函数被调用" << endl;
        Human& rh = *this;
        rh=that;
        this->m_score=that.m_score;
        this->m_remark=that.m_remark;
        return *this;
    }
    void getinfo()
    {
        Human::getinfo();
        cout << ",成绩:" << m_score << ",评语:" << m_remark << endl;
    }
    ~Student()
    {
        cout << "Student类的析构函数被调用" << endl;
    }
private:
    float m_score;
    string m_remark;
};
int main(void)
{
    cout << "---------------s1的创建信息---------------" << endl;
    Student s1(23,"Tom",88.8,"良好");
    s1.getinfo();
    cout << "---------------s2的创建信息---------------" << endl;
    Student s2(s1);
    s2.getinfo();
    cout << "---------------s3的创建信息---------------" << endl;
    Student s3;
    cout << "s3被赋值前---";
    s3.getinfo();
    s3=s2;
    cout << "s3被赋值后---";
    s3.getinfo();
    cout << "---------------main will be over---------------" << endl;

    return 0;
}

运行结果
在这里插入图片描述

多重继承

多重继承的内存布局

子类对象中的多个基类子对象，按照继承表的顺序依次被构造，析构的顺序则与构造严格相反，各个基类子对象按照从低地址到高地址排列

#include <iostream>
using namespace std;

class A
{
public: 
    int m_a;
    A() {cout << "A()" << endl;}
    ~A() {cout << "~A()" << endl;}
};

class B
{
public:
    int m_b;
    B() {cout << "B()" << endl;}
    ~B() {cout << "~B()" << endl;}
};

class C
{
public:
    int m_c;
    C() {cout << "C()" << endl;}
    ~C() {cout << "~C()" << endl;}
};

class D:public A, public B, public C//汇聚子类
{
public:
    D() {}
    ~D() {}
    int m_d;
};

int main(void)
{
    D d;
    cout << "汇聚子对象d的大小:" << sizeof(d) << endl;

    D* pd=&d;
    cout << "整个汇聚子类对象的首地址D* pd:" << pd << endl;

    cout << "A基类子对象的首地址:" << &d.m_a << endl;
    cout << "B基类子对象的首地址:" << &d.m_b << endl;
    cout << "C基类子对象的首地址:" << &d.m_c << endl;
    cout << "D基类子对象的首地址:" << &d.m_d << endl;
    return 0;
}

运行结果：
在这里插入图片描述

多重继承的类型转换

1.将多重继承的子类对象的指针，隐式转换为它的基类类型，编译器会根据各个基类子对象在子类对象中的内存位置，进行适当的偏移计算。以保证指针的类型与其所指向目标对象的类型一致
2.反之，将任何一个基类类型的指针静态转换为子类类型，编译器同样会进行适当的偏移计算
3.无论在哪个方向上，重解释类型转换(reinterpret_cast)都不进行任何偏移计算
4.引用的情况与指针类似，因为引用的本质就是指针

#include <iostream>
using namespace std;
class A
{
public: 
    int m_a;
};
class B
{
public: 
    int m_b;
};
class C
{
public: 
    int m_c;
};
class D : public A, public B, public C//汇聚子类
{ 
public: 
    int m_d;
};
int main( void ) { 
    D d;  
    cout << "汇聚子类对象d的大小:" << sizeof(d) << endl; // 16
    D* pd = &d; 
    cout << "整个汇聚子类对象的首地址 D* pd:" << pd << endl;

    cout << "A基类子对象的首地址:" << &d.m_a << endl;
    cout << "B基类子对象的首地址:" << &d.m_b << endl;
    cout << "C基类子对象的首地址:" << &d.m_c << endl;
    cout << "D类自己的成员  &m_d:" << &d.m_d << endl;

    cout << "-------------隐式转换-------------------" << endl;
    A* pa = pd; 
    cout << "D* pd--->A* pa:" << pa << endl;
    B* pb = pd; 
    cout << "D* pd--->B* pb:" << pb << endl;
    C* pc = pd;
    cout << "D* pd--->C* pc:" << pc << endl;

    cout << "-------------静态转换-------------------" << endl;
    D* p1 = static_cast<D*>(pa);
    cout << "A* pa--->D* p1:" << p1 << endl;
    D* p2 = static_cast<D*>(pb);
    cout << "B* pb--->D* p2:" << p2 << endl;
    D* p3 = static_cast<D*>(pc);
    cout << "C* pc--->D* p3:" << p3 << endl;

    cout << "-------------重解释类型转换-------------------" << endl;
    pa = reinterpret_cast<A*>(pd);
    cout << "D* pd--->A* pa:" << pa << endl;
    pb = reinterpret_cast<B*>(pd);
    cout << "D* pd--->B* pb:" << pb << endl;
    pc = reinterpret_cast<C*>(pd);
    cout << "D* pd--->C* pc:" << pc << endl;
    return 0;
}

运行结果：
在这里插入图片描述

多重继承的名字冲突

如果在子类的多个基类中，存在同名的标识符，那么任何试图通过子类对象，或在子类内部访问该名字的操作，都将引发歧义。
名字冲突问题解决方法：
（1）子类隐藏该标识符
（2）通过作用域限定操作符“::”显式指明所属基类

#include <iostream>
using namespace std;
class A 
{
public:
    int m_a;
    int m_c; 
};
class B
{ 
public:
    int m_b;
    int m_c; 
};
class D : public A, public B
{ 
public:
    int m_d;
    int m_c;
    void foo()
    {   
        A::m_c = 300; 
    }   
};
int main( void )
{
    D d;  
    cout << "汇聚子类对象d的大小:" << sizeof(d) << endl; 
    d.B::m_c = 100;
    d.foo();
    cout << "d.A::m_c=" << d.A::m_c << endl;
    cout << "d.B::m_c=" << d.B::m_c << endl;
    d.m_c=200;
    cout << "d.D::m_c=" << d.m_c << endl;
    return 0;
}

运行结果：
在这里插入图片描述

钻石继承

概念：一个子类继承自多个基类，而这些基类又源自共同的祖先，这样的继承结构称为钻石继承(菱形继承)
在这里插入图片描述
钻石继承的问题：
1.公共基类子对象，在汇聚子类对象中，存在多个实例
2.在汇聚子类内部，或通过汇聚子类对象，访问公共基类的成员，会因继承路径的不同而导致匹配歧义

#include <iostream>
#pragma pack(1)
using namespace std;

class A//公共基类
{
public:
    int m_a;
};

class X:public A//中间子类
{
public:
    int m_x;
};

class Y:public A//中间子类
{
public:
    int m_y;
};

class Z:public X,public Y//汇聚子类
{
public:
    int m_z;
    void foo()
    {   
        X::m_a=20;//没有访问限定符,将会引发歧义
    }   
};
int main(void)
{
    Z z;// |   X中间子类子对象  |   Y中间子类子对象  |m_z| --->
        // |A公共基类子对象  m_x|A公共基类子对象  m_y|m_z| --->
        // |     m_a      m_x|      m_a      m_y|m_z|
    cout << "汇聚子类对象z的大小:" << sizeof(z) << endl;
    z.Y::m_a=20;//没有访问限定符,将会引发歧义
    return 0;
}

运行结果
在这里插入图片描述

虚继承与虚函数

虚继承

虚继承可以用来解决钻石继承带来的问题，方法如下：
（1）在继承表中使用virtual关键字
（2）虚继承可以保证：
①公共虚基类子对象在汇聚子类对象中仅存一份实例
②公共虚基类子对象被多个中间子类子对象所共享
虚继承实现原理：汇聚子类对象中的每个中间子类子对象都持有一个指针，通过该指针可以获取 中间子类子对象的首地址 到 公共虚基类子对象的首地址的 偏移量

#include <iostream>
#pragma pack(1)
using namespace std;

class A//公共基类
{
public: 
    int m_a;
};

class X:virtual public A//中间子类
{
public: 
    int m_x;
    void SetAge(/*X* this*/int age)
    {
        this->m_a=age;//
    }
};

class Y:virtual public A//中间子类
{
public:
    int m_y;
    int GetAge(/*Y* this*/)
    {   
        return this->m_a;
    }   
};
class Z:public X,public Y//汇聚子类
{
public:
    int m_z;
    void foo()
    {
        m_a=20;
    }
};


int main(void)
{
    Z z;// |   X中间子类子对象  |   Y中间子类子对象  |m_z|A公共基类子对象| --->
        // |   指针1   m_x    |   指针2   m_y     |m_z|    m_a      |
    cout << "汇聚子类对象z的大小:" << sizeof(z) << endl;//32
    z.m_a=20;
    z.SetAge(28);//SetAge(&z,28)
    cout << z.GetAge() << endl;
    return 0;
}

运行结果：
在这里插入图片描述

虚函数和覆盖

(1)虚函数

形如
class 类名 
{   
	virtual 返回类型 函数名 (形参表) { … }
};的成员函数，称为虚函数或方法

(2)覆盖：如果子类的成员函数和基类的虚函数具有相同的函数签名，那么该成员函数就也是虚函数，无论其是否带有virtual关键字，且与基类的虚函数构成覆盖关系
(3)通过基类类型指针调用虚函数

	①如果基类型指针指向基类对象，调用基类的原始版本虚函数。
	②如果基类型指针指向子类对象，调用子类的覆盖版本虚函数。

#include <iostream>

using namespace std;

class Shape
{
public:
    virtual void Draw() { cout << "Shape::Draw" << endl; }//虚函数 原始版本
    int m_x;
    int m_y;
};

class Rect:public Shape
{
public:
    void Draw() { cout << "Rect::Draw" << endl; }//虚函数(编译器补virtual)覆盖版本
    int m_rx;
    int m_ry;
};

class Circle:public Shape
{
public:
    virtual void Draw() { cout << "Circle::Draw" << endl; }//虚函数(编译器不补virtual) 覆盖版本
    int m_radius;
};
int main(void)
{
    cout << "------利用对象 调用 虚成员函数------" << endl;
    // 哪个类对象 就调用 哪个类 虚成员函数--对象的自洽性
    Shape s;
    s.Draw();
    Rect r;
    r.Draw();
    Circle c;
    c.Draw();
    cout << "------利用指针 调用 虚成员函数--------" << endl;
    // 根据 指针指向的对象的类型 来确定 调用哪个类 虚 成员函数
    Shape* ps = &s;
    ps->Draw();
    ps=&r;
    ps->Draw();
    ps = &c;
    ps->Draw();
    return 0;
}

运行结果：
在这里插入图片描述

Attend$戒
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
c++继承构造函数
digitalkee的博客
12-18 1万+
【1】为什么需要继承构造函数？ 首先，看看如下代码片段： 1 struct A 2 { 3 A(int i) 4 {} 5 }; 6 7 struct B : A 8 { 9 B(int i) : A(i) 10 {} 11 }; 在C++中非常常见：B派生于A，B在构造函数中调用A的构造函数，从而完成构造函数的“传递”。 有时候，基类可能拥有数量众多的不同版本的构造函数（这样的情况并不少见）。 那么，倘若基类中有大量的构造函数
C++继承介绍
09-05
总结来说，C++继承是实现代码复用和创建类层次结构的重要手段。通过选择适当的继承类型、访问修饰符和虚函数，开发者可以构建灵活且强大的类体系，同时确保类型安全和多态性。理解和熟练运用这些概念对于编写高效、...
C++ 继承详解
热门推荐
TABE_的博客
02-21 1万+
C++ 继承继承语法继承方式改变访问权限名字遮蔽继承时的对象模型无变量遮蔽有变量遮蔽 继承语法 继承的一般语法为： class 派生类名:［继承方式］ 基类名{ 派生类新增加的成员 }; 继承方式 继承方式包括 public（公有的）、private（私有的）和 protected（受保护的），此项是可选的，如果不写，那么默认为 private。不同的继承方式会影响基类成员在派生类中的访问权限。 （1）public继承方式 基类中所有 public 成员在派生类中为 public 属性； 基类中
C++ 继承
qq_58724706的博客
05-04 2816
都说C++难学，其中继承这一块的语法就是其中一个体现，像别的语言java就简化了继承这一块的语法(删去了多继承这个语法,就不存在菱形继承的问题)，C++中尤其菱形继承(由多继承衍生出来的菱形继承场景)和虚函数、多态结合才是能让人从入门到放弃~ 不过这有什么可怕的？只要我们迎难而上，只有难学的知识我们把它搞懂了，才能体现我们和其他人的差距。今天博主来给大家详细剖析C++继承这个语法~ 目录 继承的概念 继承的定义 定义格式 继承关系和访问限定...
C++继承详解
DR5200的博客
10-14 2624
文章目录一.继承的概念和定义二.基类和派生类对象赋值转换三.继承中的作用域四.派生类的默认成员函数五.继承和友元六.继承与静态成员七.菱形继承及菱形虚拟继承八.C++编译器如何通过虚继承解决数据冗余和二义性 一.继承的概念和定义 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的
C++继承的使用
JayceSun的博客
04-17 1839
定义 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特 性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。 ...
C++继承[万字详解]
weixin_47257473的博客
03-16 3766
本文非常详细介绍了C++中的继承，包括继承的定义，介绍，方式。以及继承后派生类构造函数和析构函数的调用顺序，继承中的切片等问题，继承后静态成员，友元关系的变化，以及多继承中的菱形继承和菱形虚拟继承，对继承的一些总结。继承和组合的介绍以及关系.
C++继承方式
m0_50313114的博客
05-20 911
C++继承分为，公有(public)、保护(protected),私有(private)三种继承方式， 公有继承：基类共有成员（函数、属性）、保护成员在派生类中依旧为共有成员、保护成员；基类私有成员物理上在派生类中继承了，不过不能通过派生类对象（指针、引用）访问，只能通过基类中公有函数来间接访问基类私有成员。 保护继承：基类共有成员（函数、属性）、保护成员在派生类中均为在派生类中“”保护成员，私有成员在“派生类中不可见”，可通过基类共有函数间接访问。 私有继承：基类公有、保护、私有在派生类中均“不可见
c++ 继承构造函数
SWX230162的博客
10-11 5102
c++ 继承构造函数 class TestA { public: TestA(string i): a(i) {} ~TestA() {} string geta() { return a; } virtual string getb() = 0; private: string a; }; class TestB: public TestA{ public: TestB(string i):TestA(i),b(i) {}
c++继承
小陈的博客
04-19 4530
目录继承继承方式父类和子类对象赋值转换 继承 继承机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。 继承不仅继承父类的成员变量，还继承父类的成员函数 继承是类设计层次的复用 简单来说，继承就是让子类使用父类的成员 class Person//父类 { public: void print() { cout << "name:" << _name << endl; cout
c++继承分类
04-28
C++继承是面向对象编程（OOP）中的一个核心概念，它允许我们创建新的类，这些新类可以扩展已存在的类的功能。在这个“c++继承分类”主题中，我们将深入探讨C++中的继承机制，以及如何在Qt环境中利用这一特性进行开发...
C++ 继承详解及实例代码
12-31
C++继承可以是单一继承或多重继承，每一个继承连接可以是public,protected,private也可以是virtual或non-virtual。然后是各个成员函数选项可以是virtual或non-virtual或pure virtual。本文仅仅作出一些关键点的验证...
c++继承的视频
04-28
C++继承是面向对象编程（OOP）中的一个核心概念，它允许一个类（子类或派生类）从另一个类（基类或父类）继承特性，从而实现代码的重用和扩展。在Qt框架中，C++的继承机制同样被广泛应用，以构建丰富的用户界面和...
c++继承描述
01-05
c++继承描述
STL中的迭代器失效（vector为例）
2302_80190394的博客
08-08 257
STL中的迭代器失效（vector为例）
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
最新发布
qq_19319481的博客
08-09 147
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
c++ error: ‘*’ does not name a type； did you mean ‘**’?
xiaozhi
08-08 182
c++ error: ‘*’ does not name a type； did you mean ‘**’?
C++ - 函数重载
jiaowenjie的专栏
08-06 289
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
C++继承与派生详解
"继承与派生是C++中面向对象编程的重要概念，它允许我们创建新的类（派生类）基于已存在的类（基类），以实现代码的重用和扩展。继承使得派生类能够继承基类的属性和方法，同时可以添加新的特性或者覆盖原有的行为。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值