17多继承

最新推荐文章于 2024-02-27 09:36:37 发布
最新推荐文章于 2024-02-27 09:36:37 发布
阅读量355 收藏
点赞数
分类专栏： C++

多继承

1.基础知识

1.1 类之间的关系

has-A，uses-A 和 is-A

has-A

包含关系，用以描述一个类由多个“部件类”构成。实现has-A关系用类成员表示，即一个类中的数据成员是另一种已经定义的类。
常和构造函数初始化列表一起使用

uses-A

一个类部分地使用另一个类。通过类之间成员函数的相互联系，定义友元函数友元类或对象参数传递实现。

is-A

机制称为继承。关系具有传递性,不具有对称性。

1.2 继承概念
万事万物都有继承

1.3 继承示例代码

注意：C++中的继承方式（public、private、protected）会影响子类的对外访问属性。

#include <iostream>
using namespace std;

class Parent
{
public:
    void print()
    {
        a = 0;
        b = 0;
        cout<<"a"<<a<<endl;
        cout<<"b"<<b<<endl;
    }

    int b;
protected:
private:
    int a;
};

//class Child : private Parent
//class Child :  protected Parent public
class Child :  public Parent
{
public:
protected:
private:
    int c;
};

void main11()
{

    Child c1;
    //c1.c = 1;//err
    //c1.a = 2;//err
    c1.b = 3;

    c1.print();
    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

1.4 重要说明

1、子类拥有父类的所有成员变量和成员函数
4、子类可以拥有父类没有的方法和属性
2、子类就是一种特殊的父类
3、子类对象可以当作父类对象使用

2.派生类的访问控制

派生类继承了基类的全部成员变量和成员方法（除了构造和析构之外的成员方法），但是这些成员的访问属性，在派生过程中是可以调整的。

2.1 单个类的访问控制

1、类成员访问级别（public、private、protected）
2、思考：类成员的访问级别只有public和private是否足够？


#include <iostream>
using namespace std;

//public 修饰的成员变量 方法 在类的内部 类的外部都能使用
//protected: 修饰的成员变量方法,在类的内部使用 ,在继承的子类中可用 ;其他 类的外部不能被使用
//private: 修饰的成员变量方法 只能在类的内部使用 不能在类的外部

//派生类访问控制的结论
//1 protected 关键字 修饰的成员变量 和成员函数 ,是为了在家族中使用 ,是为了继承
//2 项目开发中 一般情况下 是 public
//3


class Parent
{
public:
            int a; //老爹的名字
protected:
            int b; //老爹的银行密码
private:
            int c; //老的情人
};


//保护继承
class Child3 : protected Parent
{
public:
protected:
private:
public: 
    void useVar()
    {
        a = 0; // ok
        b = 0; // ok //b这这里 写在了子类Child3的内部  2看protected 3密码===>protected
        //c = 0; //err
    }
};

void main()
{
    Child3 c3;
    //c3.a = 10; //err
    //c3.b = 20; //err
    //c3.c = 30;//err

}



//私有继承
class Child2 : private Parent
{
public:
    void useVar()
    {
        a = 0; //ok
        b = 0; //ok
        //c = 0; // err
    }

protected:
private:
};

void main22()
{
    Child2 c2;
    //c1.a = 10; err
    //c2.b = 20; err
    //c3.b = 30;
}



class Child : public Parent
{
public:
    void useVar()
    {
        a = 0; //ok
        b = 0; //ok
        //c = 0; // err
    }

protected:
private:
};


/*
C++中的继承方式（public、private、protected）会影响子类的对外访问属性 
    判断某一句话，能否被访问
    1）看调用语句，这句话写在子类的内部、外部
    2）看子类如何从父类继承（public、private、protected）  
    3）看父类中的访问级别（public、private、protected）
*/
//共有继承 
void main21()
{
    Parent t1, t2;
    t1.a  = 10; //ok
    //t1.b = 20; //err
    //t2.c = 30 ; //err

    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

2.2 不同的继承方式会改变继承成员的访问属性

1）C++中的继承方式会影响子类的对外访问属性

public继承
父类成员在子类中保持原有访问级别
private继承
父类成员在子类中变为private成员
protected继承
父类中public成员会变成protected
父类中protected成员仍然为protected
父类中private成员仍然为private

2）private成员在子类中依然存在，但是却无法访问到。不论种方式继承基类，派生类都不能直接使用基类的私有成员 。

3）C++中子类对外访问属性表

继承方式父类成员访问级别
publicprotectedprivate
publicpublicprotectedprivate
protectedprotectedprotectedprivate
privateprivateprivateprivate


2.3 “三看”原则

C++中的继承方式（public、private、protected）会影响子类的对外访问属性
判断某一句话，能否被访问

1）看调用语句，这句话写在子类的内部、外部
2）看子类如何从父类继承（public、private、protected）
3）看父类中的访问级别（public、private、protected）

2.4 派生类类成员访问级别设置的原则

思考：如何恰当的使用public，protected和private为成员声明访问级别？
1、需要被外界访问的成员直接设置为public
2、只能在当前类中访问的成员设置为private
3、只能在当前类和子类中访问的成员设置为protected，protected成员的访问权限介于public和private之间。

示例代码


//类的继承方式对子类对外访问属性影响

#include <cstdlib>
#include <iostream>

using namespace std;

class A
{
private:
    int a;
protected:
    int b;
public:
    int c;

    A()
    {
        a = 0;      b = 0;      c = 0;
    }

    void set(int a, int b, int c)
    {
        this->a = a;        this->b = b;        this->c = c;
    }
};
class B : public A
{
public:
    void print()
    {
        //cout<<"a = "<<a; //err
        cout<<"b = "<<b; //ok
        cout<<"c = "<<endl; //ok
    }
};

class C : protected A
{
public:
    void print()
    {
        //cout<<"a = "<<a; //err
        cout<<"b = "<<b; // ok
        cout<<"c = "<<endl; //ok
    }
};

class D : private A
{
public:
    void print()
    {
        //cout<<"a = "<<a; //err
        cout<<"b = "<<b<<endl;  //ok
        cout<<"c = "<<c<<endl; // ok
    }
};

int main()
{

    A aa;
    B bb;
    C cc;
    D dd;

    aa.c = 100;  //ok
    bb.c = 100; // ok
    //cc.c = 100; // err 保护的
    //dd.c = 100;  // err

    aa.set(1, 2, 3); //ok
    bb.set(10, 20, 30); //ok
    //cc.set(40, 50, 60); // err
    //dd.set(70, 80, 90);  //err


    bb.print(); //ok
    cc.print(); //ok
    dd.print(); //


    /**/
    system("pause");
    return 0;
}

3.继承中的构造和析构

3.1 类型兼容性原则

类型兼容规则是指在需要基类对象的任何地方，都可以使用公有派生类的对象来替代。通过公有继承，派生类得到了基类中除构造函数、析构函数之外的所有成员。这样，公有派生类实际就具备了基类的所有功能，凡是基类能解决的问题，公有派生类都可以解决。类型兼容规则中所指的替代包括以下情况：

  • 子类对象可以当作父类对象使用
  • 子类对象可以直接赋值给父类对象
  • 子类对象可以直接初始化父类对象
  • 父类指针可以直接指向子类对象
  • 父类引用可以直接引用子类对象
  • 在替代之后，派生类对象就可以作为基类的对象使用，但是只能使用从基类继承的成员。
  • 类型兼容规则是多态性的重要基础之一。

总结：子类就是特殊的父类 (base *p = &child;)


#include <iostream>
using namespace std;

class Parent
{
public:
    void printP()
    {
        cout<<"我是爹..."<<endl;
    }

    Parent()
    {
        cout<<"parent构造函数"<<endl;
    }

    Parent(const Parent &obj)
    {
        cout<<"copy构造函数"<<endl;
    }

private:
    int a;
};

class child : public Parent
{
public:
    void printC()
    {
        cout<<"我是儿子"<<endl;
    }
protected:
private:
    int c;
};



/*
兼容规则中所指的替代包括以下情况：
    子类对象可以当作父类对象使用
    子类对象可以直接赋值给父类对象
    子类对象可以直接初始化父类对象
    父类指针可以直接指向子类对象
    父类引用可以直接引用子类对象
    */



//C++编译器 是不会报错的 .....
void howToPrint(Parent *base)
{
    base->printP(); //父类的 成员函数 

}

void howToPrint2(Parent &base)
{
    base.printP(); //父类的 成员函数 
}
void main()
{
    //

    Parent p1;
    p1.printP();

    child c1;
    c1.printC();
    c1.printP();


    //赋值兼容性原则 
    //1-1 基类指针 (引用) 指向 子类对象
    Parent *p = NULL;
    p = &c1;
    p->printP();  

    //1-2 指针做函数参数

    howToPrint(&p1);
    howToPrint(&c1); 

    //1-3引用做函数参数
    howToPrint2(p1);
    howToPrint2(c1); 


    //第二层含义

    //可以让子类对象   初始化   父类对象
    //子类就是一种特殊的父类
    Parent p3 = c1;


    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

3.2 继承中的对象模型

  • 类在C++编译器的内部可以理解为结构体
  • 子类是由父类成员叠加子类新成员得到的


问题：如何初始化父类成员？父类与子类的构造函数有什么关系

  • 在子类对象构造时，需要调用父类构造函数对其继承得来的成员进行初始化
  • 在子类对象析构时，需要调用父类析构函数对其继承得来的成员进行清理
#include <cstdlib>
#include <iostream>
using namespace std;

class Parent04
{
public:
    Parent04(const char* s)
    {
        cout<<"Parent04()"<<" "<<s<<endl;
    }

    ~Parent04()
    {
        cout<<"~Parent04()"<<endl;
    }
};

class Child04 : public Parent04
{
public:
    Child04() : Parent04("Parameter from Child!")
    {
        cout<<"Child04()"<<endl;
    }

    ~Child04()
    {
        cout<<"~Child04()"<<endl;
    }
};

void run04()
{
    Child04 child;
}

int main_04(int argc, char *argv[])
{
    run04();

    system("pause");
    return 0;
}

3.3 继承中的构造析构调用原则

1、子类对象在创建时会首先调用父类的构造函数
2、父类构造函数执行结束后，执行子类的构造函数
3、当父类的构造函数有参数时，需要在子类的初始化列表中显示调用
4、析构函数调用的先后顺序与构造函数相反


#include <iostream>
using namespace std;

//结论
//先 调用父类构造函数 在调用 子类构造函数
//析构的顺序  和构造相反

/*
1、子类对象在创建时会首先调用父类的构造函数
    2、父类构造函数执行结束后，执行子类的构造函数
    3、当父类的构造函数有参数时，需要在子类的初始化列表中显示调用
    4、析构函数调用的先后顺序与构造函数相反
*/

class Parent
{
public:
    Parent(int a, int b)
    {
        this->a = a;
        this->b = b;
        cout<<"父类构造函数..."<<endl;
    }
    ~Parent()
    {
        cout<<"析构函数..."<<endl;
    }

    void printP(int a, int b)
    {
        this->a = a;
        this->b = b;
        cout<<"我是爹..."<<endl;
    }
private:
    int a;
    int b;
};


class child : public Parent
{
public:
    child(int a, int b, int c) : Parent(a, b)
    {
        this->c = c;
        cout<<"子类的构造函数"<<endl;
    }
    ~child()
    {
        cout<<"子类的析构"<<endl;
    }
    void printC()
    {
        cout<<"我是儿子"<<endl;
    }
protected:
private:
    int c;
};


void playObj()
{
    child c1(1, 2, 3);
}
void main()
{
    //Parent p(1, 2);
    playObj();


    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

3.4 继承与组合混搭情况下，构造和析构调用原则

  • 先构造父类，再构造成员变量、最后构造自己
  • 先析构自己，在析构成员变量、最后析构父类

#include <iostream>
using namespace std;

class Object
{
public:
    Object(int a, int b)
    {
        this->a = a;
        this->b = b;
        cout<<"object构造函数 执行 "<<"a"<<a<<" b "<<b<<endl;
    }
    ~Object()
    {
        cout<<"object析构函数 \n";
    }
protected:
    int a;
    int b;
};


class Parent : public Object
{
public:
    Parent(char *p) : Object(1, 2)
    {
        this->p = p;
        cout<<"父类构造函数..."<<p<<endl;
    }
    ~Parent()
    {
        cout<<"析构函数..."<<p<<endl;
    }

    void printP(int a, int b)
    {
        cout<<"我是爹..."<<endl;
    }

protected:
    char *p;

};


class child : public Parent
{
public:
    child(char *p) : Parent(p) , obj1(3, 4), obj2(5, 6)
    {
        this->myp = p;
        cout<<"子类的构造函数"<<myp<<endl;
    }
    ~child()
    {
        cout<<"子类的析构"<<myp<<endl;
    }
    void printC()
    {
        cout<<"我是儿子"<<endl;
    }
protected:
    char *myp;
    Object obj1;
    Object obj2;
};


void objplay()
{
    child c1("继承测试");
}
void main()
{
    objplay();
    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

3.5 继承中的同名成员变量处理方法

1、当子类成员变量与父类成员变量同名时
2、子类依然从父类继承同名成员
3、在子类中通过作用域分辨符::进行同名成员区分（在派生类中使用基类的同名成员，显式地使用类名限定符）
4、同名成员存储在内存中的不同位置

总结：同名成员变量和成员函数通过作用域分辨符进行区分



#include <iostream>
using namespace std;


class A
{
public:
    int a;
    int b;
public:
    void get()
    {
        cout<<"b "<<b<<endl;
    }
    void print()
    {
        cout<<"AAAAA "<<endl;
    }
protected:
private:
};

class B : public A
{
public:
    int b;
    int c;
public:
    void get_child()
    {
        cout<<"b "<<b<<endl;
    }
    void print()
    {
        cout<<"BBBB "<<endl;
    }
protected:
private:
};

void main()
{
    B b1;
    b1.print(); 

    b1.A::print();
    b1.B::print(); //默认情况

    system("pause");
}

//同名成员变量
void main71()
{

    B b1;
    b1.b = 1; //
    b1.get_child();

    b1.A::b = 100; //修改父类的b
    b1.B::b = 200; //修改子类的b 默认情况是B

    b1.get();


    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

3.6 派生类中的static关键字

继承和static关键字在一起会产生什么现象哪？
理论知识

  • 基类定义的静态成员，将被所有派生类共享
  • 根据静态成员自身的访问特性和派生类的继承方式，在类层次体系中具有不同的访问性质 （遵守派生类的访问控制）
  • 派生类中访问静态成员，用以下形式显式说明：
    类名 :: 成员
    或通过对象访问 对象名 . 成员


总结：
1> static函数也遵守3个访问原则
2> static易犯错误（不但要初始化，更重要的显示的告诉编译器分配内存）
3> 构造函数默认为private


#include <iostream>
using namespace std;

//单例
class A
{
    A()
    {
        cout<<"A的构造函数"<<endl;
    }
public:
    /*
    static int a;
    int b;
    */
public:
    /*
    void get()
    {
        cout<<"b "<<b<<endl;
    }
    void print()
    {
        cout<<"AAAAA "<<endl;
    }
    */
protected:
private:
};

//int A::a = 100; //这句话 不是简单的变量赋值 更重要的是 要告诉C++编译器 你要给我分配内存 ,我再继承类中 用到了a 不然会报错..


/*
class B : private A
{

public:
    int b;
    int c;
public:
    void get_child()
    {
        cout<<"b "<<b<<endl;
        cout<<a<<endl;
    }
    void print()
    {
        cout<<"BBBB "<<endl;
    }
protected:
private:
};
*/

//1 static关键字 遵守  派生类的访问控制规则

//2  不是简单的变量赋值 更重要的是 要告诉C++编译器 你要给我分配内存 ,我再继承类中 用到了a 不然会报错..

//3 A类中添加构造函数 
    //A类的构造函数中   A的构造函数是私有的构造函数 ... 
    //被别的类继承要小心....
    //单例场景 .... UML

void main()
{
    A a1;
    //a1.print();

     //B b1;
    // b1.get_child();
    system("pause");
}

void main01()
{
    // B  b1;
     //b1.a = 200;
    system("pause");
}

4.多继承

4.1 多继承概念

一个类有多个直接基类的继承关系称为多继承

  • 多继承声明语法
    class 派生类名 : 访问控制 基类名1 , 访问控制 基类名2 , … , 访问控制 基类名n
    {
    数据成员和成员函数声明
    }；

  • 类 C 可以根据访问控制同时继承类 A 和类 B 的成员，并添加自己的成员 


#include <iostream>
using namespace std;

class Base1
{
public:
    Base1(int b1)
    {
        this->b1 = b1;
    }
    void printB1()
    {
        cout<<"b1:"<<b1<<endl; 
    }
protected:
private:
    int  b1;
};

class Base2
{
public:
    Base2(int b2)
    {
        this->b2 = b2;
    }
    void printB2()
    {
        cout<<"b2:"<<b2<<endl; 
    }
protected:
private:
    int  b2;
};

class B : public Base1, public Base2
{
public:
    B(int b1, int b2, int c): Base1(b1), Base2(b2)
    {
        this->c = c;
    }
    void printC()
    {
        cout<<"c:"<<c<<endl; 
    }
protected:
private:
    int c;
};

void main()
{
    B b1(1, 2, 3);
    b1.printC();
    b1.printB1();
    b1.printB2();
    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

4.2 多继承的派生类构造和访问

  • 多个基类的派生类构造函数可以用初始式调用基类构造函数初始化数据成员
  • 执行顺序与单继承构造函数情况类似。多个直接基类构造函数执行顺序取决于定义派生类时指定的各个继承基类的顺序。
  • 一个派生类对象拥有多个直接或间接基类的成员。不同名成员访问不会出现二义性。如果不同的基类有同名成员，派生类对象访问时应该加以识别。

4.3 简单应用

4.4 虚继承
如果一个派生类从多个基类派生，而这些基类又有一个共同的基类，则在对该基类中声明的名字进行访问时，可能产生二义性

分析如下：


#include <iostream>
using namespace std;

class B
{
public:
    int b;
protected:
private:

};

class B1 : virtual public B
{
public:
    int b1;

};

class B2 : virtual  public B
{
public:
    int b2;
};

class C : public B1, public B2
{
public:
    int c;
};

void main()
{

    C  c1;
    c1.b1 = 100;
    c1.b2 = 200;
    c1.c = 300;

    c1.b = 500; //继承的二义性 和 虚继承解决方案
    //c1.B1::b = 500;
    //c1.B2::b = 500;


    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

小结：
1)如果一个派生类从多个基类派生，而这些基类又有一个共同
的基类，则在对该基类中声明的名字进行访问时，可能产生二义性
2)如果在多条继承路径上有一个公共的基类，那么在继承路径的某处汇合点，这个公共基类就会在派生类的对象中产生多个基类子对象
3)要使这个公共基类在派生类中只产生一个子对象，必须对这个基类声明为虚继承，使这个基类成为虚基类。
4)虚继承声明使用关键字 virtual


4.5 总结

  • 继承是面向对象程序设计实现软件重用的重要方法。程序员可以在已有基类的基础上定义新的派生类。
  • 单继承的派生类只有一个基类。多继承的派生类有多个基类。
  • 派生类对基类成员的访问由继承方式和成员性质决定。
  • 创建派生类对象时，先调用基类构造函数初始化派生类中的基类成员。调用析构函数的次序和调用构造函数的次序相反。
  • C++提供虚继承机制，防止类继承关系中成员访问的二义性。
  • 多继承提供了软件重用的强大功能，也增加了程序的复杂性。
小帅比simon
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++多继承（多重继承）详解
Elanie1024的博客
03-26 811
C++多继承（多重继承）详解
C++ 多继承
Chroniccandy的博客
10-05 998
要深入多继承的概念,首先要了解 继承的三种方式: 公有继承(public),私有继承(private),保护继承(protected) 三种继承方式的说明,如下表所示：
C++多继承(多重继承)
TT的博客
09-18 1万+
派生类都只有一个基类，称为单继承。除此之外，C++也支持多继承，即一个派生类可以有两个或多个基类。 多继承的语法也很简单，将多个基类用逗号隔开。 例如已声明了类A、类B和类C，那么可以这样来声明派生类D： class D: public A, private B, protected C { //类D新增加的成员 } D 是多继承形式的派生类，它以公有的方式继承 A 类，以私有的方式继承 B 类，以保护的方式继承 C 类。D 根据不同的继承方式获取 A、B、C 中的成员，确定它们在派生类中的访问权
C++：多重继承带来的问题及解决方法
最新发布
weixin_62946182的博客
02-27 1531
使用多继承经常会出现二义性问题，必须十分小心。上面的例子是简单的，如果继承的层次再多一些，关系更复杂一些，程序员就很容易陷人迷魂阵，程序的编写、调试和维护工作都会变得更加困难
Hibernate教程17_继承映射
04-13
不过，需要注意的是，随着类继承层次的加深，单表继承可能会导致表中出现很多不必要的字段，这对于大型系统可能会造成空间浪费和查询效率下降。因此，在选择继承映射策略时，应根据具体的应用场景和需求来权衡。 在...
java 17 window 安装包
12-02
- **开关表达式增强**：现在开关语句可以处理更多类型的值，包括字符串，并且可以用模式匹配，使得代码更简洁。 - **内存模型增强**：JEP 394改进了内存模型，提高了并发编程的效率和一致性。 2. **性能提升**： ...
Java中继承的特点、好处
06-29
Java中继承的特点、好处
jdk17-java17
06-14
Java 17引入了密封类的概念，允许开发者限制其他类可以继承它们。这有助于控制类层次结构，增强代码的封装性和安全性。 2. **记录类（Record Classes）**： 记录类是一种特殊的类，用于表示不可变的数据集。它们...
jdk17 windows x64 压缩包
08-01
1. **增强型弃用特性（Sealed Classes）**：JDK 17引入了密封类，允许开发者更好地控制类和接口的继承，增加了代码的安全性和封装性。 2. **记录类（Records）**：这是Java 14引入的一种新语法糖，用于创建无状态的...
【C++】多继承
weixin_42761454的博客
01-24 1024
多继承多继承菱形继承虚继承 多继承 C++允许一个类可以有多个父类（不建议使用，会增加程序设计复杂度） struct Student { int m_score; void study() { cout << "Student::study() - score = " << m_score << endl; } }; struct Worker { int m_salary; void work(
IS-A、HAS-A和USE-A关系
徐伯莱
06-11 1万+
IS-A、HAS-A和USE-A都是用来便是类与类之间的关系IS-A表示继承。父类与子类，具有很高的耦合度。HAS-A表示组合。是整体与部分的关系，同时它们的生命周期都是一样的。USE-A表示依赖。依然是其中一个拥有另外一个，但是不负责销毁，也就是声明周期不一样。简单的讲一些名词怎么能少得了例子呢？在IOS中，你要实现一个遥控器，通常都是继承与UIViewController的，你自己的遥控和UI...
C++中类与类之间的关系：is-a、has-a、uses-a
✍Snoring cat
05-13 2668
一、认识三种关系 1. 继承关系【is-a】 “is-a”：派生类对象也是一个基类对象，基类对象能够做的任何操作，派生类对象也能够做。如公有继承就是 “is-a” 继承关系。 <耦合度最高> 举例：苹果是一种特定的水果。 注意： 公有继承不能建立 is-impleme...
c++多继承
ZH0314的博客
09-22 792
1、  多继承 （1）概念：一个类有多个直接基类的继承关系称为多继承   （2）多继承声明语法 class 派生类名 : 访问控制 基类名1 ,  访问控制  基类名2 ,  … , 访问控制  基类名n     {         数据成员和成员函数声明     }；   类 C 可以根据访问控制同时继承类A 和类 B 的成员，并添加自己的成员 （3）多继承的派生类
C++多继承
cxx11111的博客
07-28 162
多继承时派生类的声明： class 派生类名：继承方式1 基类名1， 继承方式2 基类名2，... { 成员声明； } 例： class A { public: void setA(int); void showA() const; private: int a; }; class B { public: void setB(int); void showB() const; private: int b; }; class C : public A, private...
【C++】多重继承的顺序理解
qq_45532226的博客
04-02 2231
多重继承的顺序理解
C++ 基类中静态成员初始化问题、基类头文件中定义类外变量重定义问题的解决过程
a553455的博客
08-09 3013
今天需要在基类中定义一个静态list以供所有继承此基类的成员使用，去掉无关函数，简单示例如下 //基类头文件 #pragma once #include <list> class base { public: static std::list<void*> deleteptr; }; //继承类A头文件 #pragma once #include "base.h" cl...
C++ Struct 也可以继承
热门推荐
u012422855的专栏
02-27 2万+
最开始，就让我们来讨论一下一个最最基本，也最最容易被人忽视掉的问题——C++中的struct和class有什么区别？ 如果谈到C中的struct和C++中的class的区别，你应该会告诉我很多。但我现在说的是C++中的struct，你还会依然那样告诉我吗？你会认为C中的struct和C++中的struct是一样的吗？ 被我这样问道，或许你会吱吱呜呜的说：不一样吧。的确，是不一样，那么区别在
C++程序设计课件：第17章 多重继承.ppt
05-29
在C++程序设计的第17章——多重继承中，我们深入探讨了这一关键概念及其在实际编程中的应用。多重继承允许一个派生类从多个基类中继承特性，就像现实生活中的两用沙发既是床也是沙发一样。本章内容分为几个核心部分...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值