【c++】cpp类的继承

已于 2024-07-03 13:33:48 修改
阅读量1.2k 收藏 30
点赞数 37
分类专栏： c/c++知识 文章标签： 开发语言 c语言 c++
于 2024-04-27 15:25:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hutaotaotao/article/details/138231909
版权

目录

（1）继承概念与语法

（2）派生类的访问控制

（3）继承中的构造和析构

1.类型兼容性原则

2.继承中的构造析构调用原则

3.继承与组合混搭下构造和析构调用原则

（4）同名成员(函数)的继承

（5）static成员的继承

（6）多继承与虚继承

1.多继承的语法

2.多继承的二义性

3.用虚继承解决二义性

4.虚继承的实现原理

5.虚继承解决二义性的作用也有限

（1）继承概念与语法

类之间的关系：has-A，uses-A 和 is-A

  • has-A   包含关系，⽤以描述⼀个类由多个“部件类”构成。实现has-A关系⽤类成员表示， 即⼀个类中的数据成员是另⼀种已经定义的类。
  • uses-A  ⼀个类部分地使⽤另⼀个类。通过类之间成员函数的相互联系，定义友员或对象参 数传递实现。
  • is-A   机制称为“继承”。关系具有传递性，不具有对称性。

继承是类之间定义的一种重要关系。一个B类继承A类，或称从类A派生类B。类A称为基类（父类），类B称为派生类（子类）。

继承的重要作用就在于随着业务的不断变化，提出了新的业务需求，需要开发新的类，但又仍需要父类的某些功能，因此有了继承这个概念，子类继承自父类，可以继续使用父类的某些属性或者功能，同时又能有专属自己的功能。

类继承的语法：

// 单继承
class 子类名: 访问控制关键字 父类名
{
    数据成员和成员函数声明
};

// 多继承
class 子类名: 访问控制关键字 父类名1, 访问控制关键字 父类名2, ...
{
    数据成员和成员函数声明
};

访问控制关键字表示子类对父类的继承方式：

public    公有继承
private   私有继承
protected 保护继承

继承重要说明：

  • ⼦类拥有⽗类的所有成员变量和成员函数
  • ⼦类可以拥有⽗类没有的⽅法和属性
  • ⼦类就是⼀种特殊的⽗类
  • ⼦类对象可以当作⽗类对象使用（比如函数参数要求传递父类对象，传递子类对象也可）

如何访问继承的成员或者函数：假设a是父类Parent的成员，child为Child的实例化对象，则可以通过这两种方式访问：

  • child.Parent::a
  • child.a

关于继承方式：采用不同的继承方式会影响从父类手中接盘资产的访问属性，这个将在下一节讲解，这里以public继承为例，子类将原封不动地接盘父类的全部资产，且资产属性不变。

示例代码

#include <iostream>

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

private:
    int a;
protected:
};

// 子类继承父类
// class Child : private Parent
// class Child : protected Parent
class Child : public Parent
{
public:
private:
    int c;
protected:
};

int main()
{
    Child c1;
    c1.print();
    std::cout << "c1.b = " << c1.b << std::endl;

    // 也可以这样访问继承的成员
    std::cout << "c1.b = " << c1.Parent::b << std::endl; 

    return 0;
}

运行结果

a = 0
b = 0
c1.b = 0
c1.b = 0

（2）派生类的访问控制

1.理解成员属性

  • public: 修饰的成员变量⽅法 ，在类的内部和类的外部都能使⽤
  • protected: 修饰的成员变量⽅法，在父类和子类的内部可⽤ ，在外部不能被使⽤
  • private: 修饰的成员变量⽅法，只能在类的内部使⽤，不能在类的外部，不可继承

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

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

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

注意：private成员在⼦类中依然存在，但是却⽆法访问到。不论种⽅式继承基类，派⽣类都不能直接 使⽤基类的私有成员。

项目开发中 一般情况下 是 class B : public A。

示例代码

#include <iostream>
#include <string>

class Parent
{
public:
    Parent()
    {
        name = "parent";
        password = 123;
        emotion_friend = 0;
    }
public:
    std::string name;    //老爹的名字
protected:
    int password;        //老爹的银行密码
private:
    int emotion_friend;   //老爹的情人 // 私有的无论怎样继承，儿子都没法访问
};

// 公有继承
class Child1 : public Parent
{
public:
    void useVar()
    {
        std::cout << name << std::endl;  // ok
        std::cout << password << std::endl;  // ok
        // std::cout << emotion_friend << std::endl;  // error
        return;
    }
};

// 私有继承
class Child2 : private Parent
{
public:
    void useVar()
    {
        std::cout << name << std::endl;  // ok
        std::cout << password << std::endl;  // ok
        // std::cout << emotion_friend << std::endl;  // error
        return;
    }
};

// 保护继承
class Child3 : protected Parent
{
public:
    void useVar()
    {
        std::cout << name << std::endl;  // ok
        std::cout << password << std::endl;  // ok
        // std::cout << emotion_friend << std::endl;  // error
        return;
    }
};


int main()
{
    // 1.公有继承
    std::cout << "----------------" << std::endl;
    Child1 c1;
    c1.name = "child1"; // ok
    // c1.password = 456; // err，因为protected不能外部访问
    // c1.emotion_friend = 1; // err，因为private不能外部访问

    c1.useVar();

    // 2.私有继承
    std::cout << "----------------" << std::endl;
    Child2 c2;
    // c2.name = "child1"; // err，因为private不能外部访问
    // c2.password = 456; // err，因为private不能外部访问
    // c1.emotion_friend = 1; // err，因为private不能外部访问

    c2.useVar();

    // 3.保护继承
    std::cout << "----------------" << std::endl;
    Child3 c3;
    // c3.name = "child1"; // err，因为protected不能外部访问
    // c3.password = 456; // err，因为protected不能外部访问
    // c3.emotion_friend = 1; // err，因为private不能外部访问
    
    c3.useVar();
    
    return 0;
}

运行结果

----------------
child1
123
----------------
parent
123
----------------
parent
123

（3）继承中的构造和析构

1.类型兼容性原则

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

类型兼容规则中所指的替代包括以下情况：

  • 子类对象可以当作父类对象使用
  • 子类对象可以直接赋值给父类对象
  • 子类对象可以直接初始化父类对象
  • 父类指针可以直接指向子类对象
  • 父类引⽤可以直接引用子类对象

在替代之后，派生类对象就可以作为基类的对象使⽤，但是只能使用从基类继承的成员。

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

#include <iostream>
#include <string>

class Parent
{
public:
    void printP()
    {
        std::cout << "I'm Parent" << std::endl;
    }
public:
    Parent()
    {
        std::cout << "Parent Normal Generate Func" << std::endl;
    }
    Parent(Parent &obj)
    {
        std::cout << "Parent Copy Generate Func" << std::endl;
    }
private:
    int a;
};

class Child : public Parent
{
public:
    void printC()
    {
        std::cout << "I'm Child" << std::endl;
    }
protected:
private:
    int c;
};

void PrintParent(Parent *p)
{
    p->printP();
}
void PrintParent(Parent &base)
{
    base.printP();
}

int main()
{
    Parent parent1;   // Parent Normal Generate Func
    parent1.printP(); // I'm Parent

    // 使用继承来的成员
    Child child1;    // Parent Normal Generate Func
    child1.printC(); // I'm Child
    child1.printP(); // I'm Parent

    //父类指针指向子类对象
    Parent *p = NULL;
    p = &child1;
    p->printP(); // I'm Parent

    //指针做函数参数
    PrintParent(&parent1); //I'm Parent
    PrintParent(p);   //I'm Parent

    //引用做函数
    PrintParent(child1); //I'm Parent
    PrintParent(parent1); //I'm Parent

    //子类对象 初始化 父类对象
    Parent parent2 = child1; // Parent Copy Generate Func
    parent2.printP();    //I'm Parent

    return 0;
}

2.继承中的构造析构调用原则

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

  • 在子类对象构造时，需要调用父类构造函数对其继承得来的成员进⾏初始化
    • 子类对象在创建时会首先调⽤父类的构造函数
    • 父类构造函数执行结束后，执行子类的构造函数
    • 当父类的构造函数有参数时，需要在子类的初始化列表中显示调⽤
  • 在子类对象析构时，需要调用父类析构函数对其继承得来的成员进行清理
    • 析构函数调⽤的先后顺序与构造函数相反

示例代码

#include <iostream>

class Parent
{
public:
    Parent(int a = 0, int b = 0)
    {
        this->a = a;
        this->b = b;
        std::cout << "Parent Normal Generate Func" << std::endl;
    }
    Parent(const Parent &obj)
    {
        std::cout << "Parent Copy Generate Func" << std::endl;
    }
    ~Parent()
    {
        std::cout << "Parent Destroyed Func" << std::endl;
    }
private:
    int a;
    int b;
};

class Child : public Parent
{
public:
    Child(int a, int b, int c):Parent(a, b)
    {
        this->c = c;
        std::cout << "Child Normal Generate Func" << std::endl;
    }
    ~Child()
    {
        std::cout << "Child Destroyed Func" << std::endl;
    }
protected:
private:
    int c;
};



int main()
{
    Child c1(1, 2, 5);

    return 0;
}

运行结果

Parent Normal Generate Func
Child Normal Generate Func
Child Destroyed Func
Parent Destroyed Func

3.继承与组合混搭下构造和析构调用原则

构造顺序：先祖宗类构造 → 父类构造 → 成员变量构造 → 再自己构造

关于成员变量构造：有多个成员变量需要构造时，按声明时的顺序进行构造，比如下面例子中声明时是先GrandParent gp1;然后GrandParent gp2;，所以先对gp1构造，然后对gp2构造

析构顺序：先自己析构 → 再成员变量析构（与构造时顺序相反） → 再父类析构 → 再祖宗类析构

示例代码

#include <iostream>


// 祖宗类
class GrandParent
{
public:
    GrandParent(int a, int b)
    {
        this->a = a;
        this->b = b;
        std::cout << "GrandParent Normal Generate Func: " 
                  << a << "," << b << std::endl;
    }
    ~GrandParent()
    {
        std::cout << "GrandParent Destroyed Func:"  << a << "," << b << std::endl;
    }
private:
    int a;
    int b;
};

// 父类，继承于祖宗类
class Parent: public GrandParent
{
public:
    Parent(char *p): GrandParent(1, 2)
    {
        this->p = p;
        std::cout << "Parent Normal Generate Func:  " << p << std::endl;
    }
    ~Parent()
    {
        std::cout << "Parent Destroyed Func: " << p << std::endl;
    }
private:
    char *p;
};

// 子类，继承于父类
class Child : public Parent
{
public:
    Child(char *p):Parent(p), gp1(3, 4), gp2(5, 6)
    {
        this->cp = p;
        std::cout << "Child Normal Generate Func:   " << p << std::endl;
    }
    ~Child()
    {
        std::cout << "Child Destroyed Func:  " << cp << std::endl;
    }
public:
protected:
    char *cp;
    GrandParent gp1;
    GrandParent gp2;
};



int main()
{
    char data[] = "test";
    std::cout << "-----------Generate-----------" << std::endl;
    Child c1(data);

    std::cout << "-----------Destroy-----------" << std::endl;

    return 0;
}

运行结果

-----------Generate-----------
GrandParent Normal Generate Func: 1,2
Parent Normal Generate Func:  test
GrandParent Normal Generate Func: 3,4
GrandParent Normal Generate Func: 5,6
Child Normal Generate Func:   test
-----------Destroy-----------
Child Destroyed Func:  test
GrandParent Destroyed Func:5,6
GrandParent Destroyed Func:3,4
Parent Destroyed Func: test
GrandParent Destroyed Func:1,2

（4）同名成员(函数)的继承

当子类成员变量与父类成员变量同名时

  • 子类依然从⽗类继承同名成员
  • 在⼦类中通过作⽤域分辨符 :: 进⾏同名成员区分。在⼦类外部⽤ childObj.Parent::name 和 childObj.Child::name，在⼦类内部⽤Parent::name和Child::name。
  • 同名成员变量和成员函数通过作⽤域分辨符进⾏区分。调⽤name默认是childObj.Child::name和 Child::name。
  • 同名成员存储在内存中的不同位置

示例代码

#include <iostream>

class Parent
{
public:
    Parent(int a = 0, int b = 0)
    {
        this->a = a;
        this->b = b;
    }
public:
    void print(){ std::cout << "print parent" << std::endl;}
    void get(){ std::cout << "a=" << a << ",b=" << b << std::endl;}
public:
    int a;
    int b;
};

class Child : public Parent
{
public:
    Child(int a=0, int b=0, int c=0):Parent(a, b)
    {
        this->b = b;
        this->c = c;
    }
public:
    void print(){ std::cout << "print child" << std::endl;}
    void get(){ std::cout << "a=" << a << ",b=" << b << ",c=" << c << std::endl;}
public:
    int b;
    int c;

};



int main()
{
    Child c1(1, 2, 3);

    // 1.同名变量
    std::cout << c1.b << std::endl;         // 2
    std::cout << c1.Child::b << std::endl;  // 2
    std::cout << c1.Parent::b << std::endl; // 2

    //修改父类的b
    c1.Parent::b = 100;
    std::cout << c1.Parent::b << std::endl; // 100
    std::cout << c1.Child::b << std::endl;  // 2
    std::cout << c1.b << std::endl;         // 2

    // 2.同名函数
    c1.print();         // print child
    c1.Child::print();  // print child //默认情况
    c1.Parent::print(); // print parent

    c1.get();         // a=1,b=2,c=3
    c1.Child::get();  // a=1,b=2,c=3
    c1.Parent::get(); // a=1,b=100

    return 0;
}

（5）static成员的继承

  • 基类定义的静态成员，将被所有派生类共享
  • 根据静态成员自身的访问特性和派生类的继承⽅式，在类层次体系中具有不同的访问性质 （遵守派生类的访问控制）
  • 在派生类的内部访问静态成员，直接变量名即可：
  • 在派生类中的外部访问静态成员，⽤以下形式：
    • 类名 :: 成员
    • 对象名 . 成员

示例代码

#include <iostream>


class Parent
{
public:
    Parent()
    {
        std::cout << "Parent generate func" << std::endl;
    }
public:
    void printa()
    {
        std::cout << "class Parent call: static a=" << a << std::endl;
    }
public:
    static int a;
    int b;
protected:
private:
};

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

class Child : private Parent
{
public:
    Child()
    {
        std::cout << "Child generate func" << std::endl;
    }
public:
    void printa()
    {
        std::cout << "class Child call: static a=" << a << std::endl;
    }
public:
    int b;
    int c;
protected:
private:
};

// 1 static关键字 遵守  派生类的访问控制规则
// 2 不是简单的变量赋值 更重要的是 要告诉C++编译器
// 你要给我分配内存 ,我再继承类中 用到了a 不然会报错..


void objplay()
{
    Parent parent1;         
    parent1.printa();  

    Child child1;        
    child1.printa();
    // child1.a = 200; //非法，因为是私有继承，只能在类的内部共享

    std::cout << Parent::a << std::endl;  // 访问同一个静态成员
    std::cout << parent1.a << std::endl;  // 访问同一个静态成员
    // std::cout << child1.a << std::endl;  // 将会error，因为私有继承
}

int main()
{
    objplay();

    return 0;
}

运行结果

Parent generate func
class Parent call: static a=100
Parent generate func
Child generate func
class Child call: static a=100
100
100

（6）多继承与虚继承

1.多继承的语法

多继承的派生类构造和访问
  • 多个基类的派生类构造函数可以用初始化列表调用基类构造函数初始化数据成员
  • 执⾏顺序与单继承构造函数情况类似。多个直接基类构造函数执⾏顺序取决于定义派⽣类时 指定的各个继承基类的顺序。
  • ⼀个派⽣类对象拥有多个直接或间接基类的成员。不同名成员访问不会出现⼆义性。如果不 同的基类有同名成员，派⽣类对象访问时应该加以识别。
示例代码 
#include <iostream>

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

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

class Child : public Base1, public Base2
{
public:
    Child(int b1, int b2, int c) : Base2(b2), Base1(b1)
    {
        std::cout << "Child generate func" << std::endl;
        this->c = c;
    }
    ~Child()
    {
        std::cout << "Child destroy func" << std::endl;
    }
    void printC()
    {
        std::cout << "c:" << c << std::endl;;
    }
protected:
private:
    int c;
};

int main()
{
    Child c1(1, 2, 3);

    c1.printC();
    c1.printB1();
    c1.printB2();

    return 0;
}

运行结果

Base1 generate func
Base2 generate func
Child generate func
c:3
b1:1
b2:2
Child destroy func
Base2 destroy func
Base1 destroy func

2.多继承的二义性

示例代码

#include <iostream>

class B
{
public:
    int b;
};

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


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

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

int main()
{

    C c1;
    c1.b1 = 100;
    c1.b2 = 200;
    c1.c = 300;
    
    // c1.b = 500; //这句会报错，因为二义性，
    //  到底是B1的的b，还是B2的b分不清

    return 0;
}

3.用虚继承解决二义性

  • 如果⼀个派生类从多个基类派⽣，⽽这些基类⼜有⼀个共同的基类，则在对该基类中声明的 名字进⾏访问时，可能产⽣⼆义性
  • 如果在多条继承路径上有⼀个公共的基类，那么在继承路径的某处汇合点，这个公共基类就 会在派生类的对象中产生多个基类子对象
  • 要 使这个公共基类在派生类中只产生⼀个子对象，必须对这个基类声明为虚继承，使这个基 类成为虚基类
  • 虚继承声明使用关键字：virtual

像下面这样

示例代码

#include <iostream>

class B
{
public:
    int b;
};

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;
};

int main()
{

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

    c1.b = 500; //因为virtual继承，这里将不会再报错
    std::cout << c1.B1::b << std::endl;  // 500

    c1.B1::b = 600;
    std::cout << c1.b << std::endl; // 600
    
    c1.B2::b = 700;
    std::cout << c1.b << std::endl; // 700

    c1.B::b = 1000;
    std::cout << c1.b << std::endl; // 1000

    return 0;
}

4.虚继承的实现原理

如果继承的多个基类有⼀个共同的基类，则⽤虚继承时只会把⽼祖宗的构造函数只只执⾏⼀次， 而不是执行多次使得产生⼆义性。

示例代码

#include <iostream>

class B
{
public:
    B()
    {
        std::cout << "B copy generate func" << std::endl;
    }
    int b;
};

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


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

class B3 : virtual public B
{
public:
    int b3;
};

class B4 : virtual public B
{
public:
    int b4;
};

class C1 : public B1, public B2
{
public:
    int c1;
};

class C2 : public B3, public B4
{
public:
    int c2;
};

int main()
{
    //加上virtual以后 , C++编译器会在给变量偷偷增加属性
    std::cout << "----------------------" << std::endl;
    std::cout << sizeof(B) << std::endl;
    std::cout << sizeof(B1) << std::endl;
    std::cout << sizeof(B2) << std::endl;
    std::cout << sizeof(B3) << std::endl;
    std::cout << sizeof(B4) << std::endl;

    std::cout << "----------------------" << std::endl;
    C1 c1;
    c1.b1 = 100;
    c1.b2 = 200;

    std::cout << "----------------------" << std::endl;
    C2 c2;
    c2.b3 = 500;
    c2.b4 = 600;
    c2.b = 700;

    c2.B3::b3 = 1000;
    c2.B::b = 99;

    return 0;
}

运行结果

----------------------
4
16
16
16
16
----------------------
B copy generate func
----------------------
B copy generate func

5.虚继承解决二义性的作用也有限

对于下图右边这种多继承，虚继承也无法解决⼆义性。

只能通过作用域符号来明确，c.B1::k，c.B2::k

end

hutaotaotao
关注
  • 37
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CPP中的继承关系
weixin_51599540的博客
12-10 436
//继承的好处：减少代码的重复率 /* * 语法：class 子类 ：继承方式 父类 子类 也称为派生类 基类 也称为基类 */ //继承中的对象模型 #include<iostream> using namespace std; class Base { public: int m_A; protected: int m_B; private: int m_C; }; class Son :public Base { public: int m_D; }; void
对于cpp的类的继承：
weixin_54095243的博客
11-03 291
继承的优先：如对于声明，如果类的继承先声明的先初始，析构相反； 虚基类最先初始化； 由图得对象I先调用其派生类(派生类又先调用其虚基类从左到右) 先调用F的间接虚基类C然后输出C而后是G先输出B中基类A在输出B然后输出G然后是H虽然H无虚基但是其D构成间接虚 调用D输出D然后调用C因为每个虚基调用一次，所以不调用C了然后开始剩下的（从左到右）AEABFH基类调用完毕 最后是I中的类E，F声明：类中有对象，先是基类然后是类中对象然后是构造...
cpp中的继承
zs3194068129的博客
11-15 384
也是很久没有更新了，最近都比较忙碌。好了，今天我们来看一看在c++面向对象里面的继承。继承是面向对象三大语法之一，继承的出现主要是可以收集不同类当中相同的部分，从而达到简化编程的目的。
第13章-cpp类继承
itzyjr的专栏
12-09 2124
面向对象编程的主要目的之一是提供可重用的代码。开发新项目，尤其是当项目十分庞大时，重用经过测试的代码比重新编写代码要好得多。使用已有的代码可以节省时间，由于已有的代码已被使用和测试过，因此有助于避免在程序中引入错误。另外，必须考虑的细节越少，便越能专注于程序的整体策略。 C++类提供了更高层次的重用性。目前，很多厂商提供了类库，类库由类声明和实现构成。因为类组合了数据表示和类方法，因此提供了比函.........
4.4 CPP 继承
霍迪迪的博客
10-25 250
4.4.1 语法 继承的最大好处就是减少重复性工作，使代码看起来更加简洁、 语法：class A pubilc B{ } A类称为子类或者派生类 （特性），B类称为父类或者基类（共性） #include<iostream> #include<algorithm> using namespace std; class MyClass { public: void school() { cout << "清华大学" << endl; } v
fushu.rar_c++类的继承
09-24
在C++编程语言中，类的继承是一种面向对象编程（OOP）的关键特性，它允许我们创建一个新类，该类不仅包含自身的属性和方法，还可以继承另一个已存在的类（称为基类或父类）的属性和方法。这种机制使得代码重用变得...
CPP.rar_多态 .cpp_继承与多态_继承与多态C++
09-23
标题中的"CPP.rar_多态 .cpp_继承与多态_继承与多态C++"表明这个压缩包文件包含了关于C++编程语言中多态性（Polymorphism）和继承（Inheritance）的概念示例。多态性和继承是面向对象编程（Object-Oriented ...
C++实现不能被继承的类实例分析
09-04
本文将详细讨论两种C++实现不可继承类的方法，并通过实例帮助初学者理解这些概念。 方法一：通过使构造函数私有化来阻止继承 在C++中，如果一个类的构造函数是私有的（`private`），那么其他类就不能实例化这个类...
类继承,构造函数,newint,阶乘实例.rar_C++_实例_类_继承
09-14
在C++编程语言中，类继承是面向对象编程的一个核心概念，它允许我们创建一个新类（子类或派生类）作为现有类（基类或父类）的扩展。这样，子类不仅可以继承基类的属性和方法，还可以添加新的特性或重写已有的方法。...
C++继承介绍及使用方法
10-09
在C++中，继承是实现面向对象编程的关键概念之一，它允许我们构建复杂、层次化的类结构。通过继承，子类（派生类）能够获取父类（基类）的特性，包括数据成员和成员函数，同时还能添加新的功能或者重写已有功能，以...
Cpp_继承
Jerry的专栏
02-29 2331
一、继承的基本概念第一级抽象：从具体的对象抽象出共同的属性和行为。学生：姓名、年龄、学号、吃饭、睡觉、学习 教师：姓名、年龄、工资、吃饭、睡觉、授课 第二级抽象：将类型之间共性抽取出来形成超集，将类型之间的个性具体化的不同子集中。人类：姓名、年龄、吃饭、睡觉 - 超集体现共性 - 基类 | 派生 ^ 学生是人类的一部分：学号、学习 \ 子集 - 子类 V
CPP继承方式
Jade1_的博客
02-19 450
继承中的对象模型。可以用cl /d1 reportSIngleClassLayout "cpp程序名"来看类的内存占用布局
cpp学习笔记：继承
ohhjack的博客
10-31 661
cpp学习
【Cpp】第十一章-继承
qq_41669298的博客
08-26 549
继承 什么是继承   继承是为了更好的使代码得以复用而产生的，同时呈现了面向对象程序设计中的层次结构，继承会使得我们写好的类可以得到扩展。简单来说继承可以增强我们的代码复用，包括可以复用类的层次结构，同时使程序复用层次和条理。 #include <iostream> #include <string> using namespace std; class Person { ...
cpp继承和多态
逐梦如风-毕康
10-21 1075
继承c++ 如果不写默认的私有继承继承的基础 继承的语法 class 派生类名：继承方式 基类名1， 继承方式 基类名2，...，继承方式 基类名n { 派生类成员声明； }; 支持多继承 继承后子类可以访问父类的非private方法和成员公有继承&私有继承&保护继承公有继承 当类的继承方式为公有继
CPP的继承-进阶
weixin_33862188的博客
07-26 164
2019独角兽企业重金招聘Python工程师标准>>> ...
c++中的类继承
sakura0908的博客
04-12 901
面向对象编程的主要目的是之一是提供可重用的代码。开发新项目，尤其是当项目十分庞大时，重用经过测试的代码比重新编写代码要好得多。使用已有的代码可以节省时间，由于已有的代码已被使用和测试过，因此有助于避免在程序中引入错误。另外，必须考虑的细节越少，便越能专注于程序的整体策略。c++类提供了更高层次的重用性。目前，很多厂商提供了类库，类库由类声明和实现构成。因为类组合了数据表示和类方法，因此提供了比函数库更加完整的程序包。通常，类库是以源代码的方式提供的，这意味这可以对其进行修改，以满足需求。
Cpp_继承&对象模型
Jasmine_yaoyao的博客
07-28 472
继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能。
c++ 继承java类
最新发布
01-12
C++可以继承Java类，但是需要注意一些细节和差异。在C++中，可以使用关键字`class`来定义一个类，并使用关键字`public`来指定继承关系。下面是一个示例： ```cpp class JavaClass { public: void javaMethod() { // Java类的方法实现 } }; class CppClass : public JavaClass { public: void cppMethod() { // C++类的方法实现 } }; ``` 在上面的示例中，`CppClass`继承了`JavaClass`，并且可以访问`JavaClass`中的公共成员函数`javaMethod()`。此外，`CppClass`还可以定义自己的成员函数`cppMethod()`。 需要注意的是，C++和Java在继承方面存在一些差异。其中一个主要的差异是C++支持多继承，而Java不支持。多继承是指一个类可以从多个父类继承属性和方法。这在某些情况下可以提供更大的灵活性，但也容易导致代码复杂性增加和潜在的冲突问题。 另一个差异是C++的继承关系可以是公有的、私有的或受保护的，而Java的继承关系始终是公有的。公有继承意味着派生类可以访问基类的公共成员，私有继承意味着派生类无法访问基类的成员，受保护继承意味着派生类可以访问基类的受保护成员。 总结起来，C++可以继承Java类，但需要注意多继承和访问权限的差异。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值