c++中的10种常见继承

最新推荐文章于 2023-04-10 22:51:59 发布
最新推荐文章于 2023-04-10 22:51:59 发布
阅读量451 收藏 2
点赞数
分类专栏： C/C++
原文链接：https://blog.csdn.net/zhaori/article/details/1700356
版权 
下面的代码部分可能存在错误，主要是理解继承的思想。

	普通公有派生
#include <iostream.h>
class Base
{
private:
    int b_number;

public:
    Base() {}
    Base(int i) : b_number(i) {}
    int get_number() { return b_number; }
    void print() { cout << b_number << endl; }
};
class Derived : public Base
{
private:
    int d_number;

public:
    // constructor, initializer used to initialize the base part of a Derived object.
    Derived(int i, int j) : Base(i), d_number(j){};
    // a new member function that overrides the print( ) function in Base
    void print()
    {
        cout << get_number() << " ";
        // access number through get_number( )
        cout << d_number << endl;
    }
};
int main()
{
    Base a(2);
    Derived b(3, 4);
    cout << "a is ";
    a.print(); // print( ) in Base
    cout << "b is ";
    b.print(); // print( ) in Derived
    cout << "base part of b is ";
    b.Base::print(); // print( ) in Base
    return 0;
}

没有虚析构函数，继承类没有析构
#include <iostream.h>
#include <string.h>
class Thing
{
public:
    virtual void what_Am_I() { cout << "I am a Thing./n"; }
    ~Thing() { cout << "Thing destructor" << endl; }
};
class Animal : public Thing
{
public:
    virtual void what_Am_I() { cout << "I am an Animal./n"; }
    ~Animal() { cout << "Animal destructor" << endl; }
};
void main()
{
    Thing *t = new Thing;
    Animal *x = new Animal;
    Thing *array[2];
    array[0] = t; // base pointer
    array[1] = x;
    for (int i = 0; i < 2; i++)
        array->what_Am_I();
    delete array[0];
    delete array[1];
    return;
}

纯虚函数，多态
#include <iostream.h>
#include <math.h>
class Point
{
private:
    double x， y;

public:
    Point(double i, double j) : x(i), y(j) {}
    void print() const
    {
        cout << "(" << x << ", " << y << ")";
    }
};
class Figure
{
private:
    Point center;

public:
    Figure(double i = 0, double j = 0) : center(i, j) {}
    Point &location() { return center; } // return an lvalue
    void move(Point p)
    {
        center = p;
        draw();
    }
    virtual void draw() = 0; // draw the figure
    virtual void rotate(double) = 0;
    // rotate the figure by an angle
};
class Circle : public Figure
{
private:
    double radius;

public:
    Circle(double i = 0, double j = 0, double r = 0) : Figure(i, j), radius(r) {}
    void draw()
    {
        cout << "A circle with center ";
        location().print();
        cout << " and radius " << radius << endl;
    }
    void rotate(double)
    {
        cout << "no effect./n";
    } // must be defined
};
class Square : public Figure
{
private:
    double side;  // length of the side
    double angle; // the angle between a side and the x-axis
public:
    Square(double i = 0, double j = 0, double d = 0, double a = 0) : Figure(i, j), side(d), angle(a) {}
    void draw()
    {
        cout << "A square with center ";
        location().print();
        cout << " side length " << side << "./n"
             << "The angle between one side and the X-axis is " << angle << endl;
    }
    void rotate(double a)
    {
        angle += a;
        cout << "The angle between one side and the X-axis is " << angle << endl;
    }
    void vertices()
    {
        cout << "The vertices of the square are:/n";
        // calculate coordinates of the vertices of the square
    }
};
int main()
{
    Circle c(1, 2, 3);
    Square s(4, 5, 6);
    Figure *f = &c, &g = s;
    f->draw();
    f->move(Point(2, 2));
    g.draw();
    g.rotate(1);
    s.vertices();
    // Cannot use g here since vertices( ) is not a member of Figure.
    return 0;
}
```cpp
多继承
#include <iostream.h>
class A
{
private:
    int a;

public:
    A(int i) : a(i) {}
    virtual void print() { cout << a << endl; }
    int get_a() { return a; }
};
class B
{
private:
    int b;

public:
    B(int j) : b(j) {}
    void print() { cout << b << endl; }
    int get_b() { return b; }
};
class C : public A, public B
{
    int c;

public:
    C(int i, int j, int k) : A(i), B(j), c(k) {}
    void print()
    {
        A::print();
        B::print();
    }
    // use print( ) with scope resolution
    void get_ab() { cout << get_a() << " " << get_b() << endl; }
    // use get_a( ) and get_b( ) without scope resolution
};
int main()
{
    C x(5, 8, 10);
    A *ap = &x;
    B *bp = &x;
    ap->print(); // use C::print( );
    bp->print(); // use B::print( );
    //        bp -> A::print( );                // as if x is inherited from B only,
    // cannot access A::print( );
    x.A::print(); // use A::print( );
    x.get_ab();
    return 0;
}

共同基类的多继承
#include <iostream.h>
class R
{
    int r;

public:
    R(int anInt) { r = anInt; };
    printOn() { cout << "r=" << r << endl; };
};
class A : public R
{
    int a;

public:
    A(int int1, int int2) : R(int2) { a = int1; };
};
class B : public R
{
    int b;

public:
    B(int int1, int int2) : R(int2) { b = int1; };
};
class C : public A, public B
{
    int c;

public:
    C(int int1, int int2, int int3) : A(int2, int3), B(int2, int3) { c = int1; }
};
int main()
{
    int i;
    R rr(10);
    A aa(20, 30);
    B bb(40, 50);
    C cc(5, 7, 9);
    rr.printOn();
    aa.printOn(); //inherits R printOn
    bb.printOn(); //inherits R printOn
    //cc.printOn();                  //would give error
    return 0;
}

虚基类
#include <iostream.h>
class R
{
    int r;

public:
    R(int x = 0) : r(x) {} // constructor in R
    void f() { cout << "r=" << r << endl; }
    void printOn() { cout << "printOn R=" << r << endl; }
};
class A : public virtual R
{
    int a;

public:
    A(int x, int y) : R(x), a(y) {} // constructor in A
    void f()
    {
        cout << "a=" << a << endl;
        R::f();
    }
};
class B : public virtual R
{
    int b;

public:
    B(int x, int z) : R(x), b(z) {} // constructor in B
    void f()
    {
        cout << "b=" << b << endl;
        R::f();
    }
};
class C : public A, public B
{
    int c;

public:
    // constructor in C, which constructs an R object first
    C(int x, int y, int z, int w) : R(x), A(x, y), B(x, z), c(w) {}
    void f()
    {
        cout << "c=" << c << endl;
        A::f();
        B::f();
    }
};
void main()
{
    R rr(1000);
    A aa(2222, 444);
    B bb(3333, 111);
    C cc(1212, 345, 123, 45);
    cc.printOn(); //uses R printOn but only 1 R..no ambiguity
    cc.f();       // shows multiple call of the R::f()
}

私有继承
#include <iostream.h>
class Base
{
private:
    int priv;

protected:
    int prot;
    int get_priv() { return priv; }

public:
    int publ;
    Base();
    Base(int a, int b, int c) : priv(a), prot(b), publ(c) {}
    int get_prot() { return prot; }
    int get_publ() { return publ; }
};
class Derived1 : private Base // private inheritance{
                 public : Derived1(int a, int b, int c) : Base(a, b, c)
{
} int get1_priv() { return get_priv(); }
// priv not accessible directly
int get1_prot() { return prot; }
int get1_publ() { return publ; }
}
;
class Leaf1 : public Derived1
{
public:
    Leaf1(int a, int b, int c) : Derived1(a, b, c) {}
    void print()
    {
        cout << "Leaf1 members: " << get1_priv() << " "
             //                        << get_priv( )        // not accessible
             << get1_prot() << " "
             //                        << get_prot( )         // not accessible
             //                        << publ         // not accessible
             << get1_publ() << endl;
    } // data members not accessible.  get_ functions in Base not accessible
};
class Derived2 : protected Base // protected inheritance
{
public:
    Derived2(int a, int b, int c) : Base(a, b, c) {}
};
class Leaf2 : public Derived2
{
public:
    Leaf2(int a, int b, int c) : Derived2(a, b, c) {}
    void print()
    {
        cout << "Leaf2 members: " << get_priv() << " "
             //                        << priv                 // not accessible
             << prot << " "
             << publ << endl;
    } // public and protected data members accessible.  get_ functions in Base accessible.
};
class Derived3 : public Base // public inheritance
{
public:
    Derived3(int a, int b, int c) : Base(a, b, c) {}
};
class Leaf3 : public Derived3
{
public:
    Leaf3(int a, int b, int c) : Derived3(a, b, c) {}
    void print()
    {
        cout << "Leaf3 members: " << get_priv() << " "
             << prot << " "
             << publ << endl;
    } // public and protected data members accessible.  get_ functions in Base accessible
};
int main()
{
    Derived1 d1(1, 2, 3);
    Derived2 d2(4, 5, 6);
    Derived3 d3(7, 8, 9);
    //        cout << d1.publ;                // not accessible
    //        cout << d1.get_priv( );        // not accessible
    //        cout << d2.publ;                // not accessible
    //        cout << d2.get_priv( );        // not accessible
    cout << d3.publ;       // OK
    cout << d3.get_prot(); // OK
    Leaf1 lf1(1, 2, 3);
    Leaf2 lf2(4, 5, 6);
    Leaf3 lf3(7, 8, 9);
    //         cout << lf1.publ << endl;                    // not accessible
    //         cout << lf2.publ << endl;                // not accessible
    cout << lf3.publ << endl; // OK
    return 0;
}

多级继承
#include <iostream.h>
// THE POINT CLASS
class Point
{
    friend ostream &operator<<(ostream &, Point &);

public:
    //  constructor
    Point(double xval = 0, double yval = 0)
    {
        x = xval;
        y = yval;
    };

protected: // accessed by derived class
    double x;
    double y;
};
ostream &operator<<(ostream &os,
                    Point &apoint)
{
    cout << " Point:X:Y: " << apoint.x << ","
         << apoint.y << "/n";
    return os;
}
//The Circle class  inherits from class Point
class Circle : public Point
{
    friend ostream &operator<<(ostream &, Circle &);

public:
    Circle(double r = 0, double xval = 0, double yval = 0)
        : Point(xval, yval), radius(r)
    {
        //radius = r;
    }
    double area()
    {
        return (3.14159 * radius * radius);
    }

protected:
    double radius;
};
//note casting circle to point
ostream &operator<<(ostream &os, Circle &aCircle)
{
    cout << "Circle:radius:" << aCircle.radius;
    os << aCircle.x << "/n";
    os << aCircle.y << "/n";
    return os;
}
// THE CYLINDER CLASS
class Cylinder : public Circle
{
    friend ostream &operator<<(ostream &, Cylinder &);

public:
    Cylinder(double hv = 0, double rv = 0,
             double xv = 0, double yv = 0)
        : Circle(xv, yv, rv)
    {
        height = hv;
    }
    double area();

protected: // may have derived classes
    double height;
};
double Cylinder ::area()
{ // Note that cylinder area uses Circle area
    return 2.0 * Circle::area() + 2.0 * 3.14159 * radius * height;
}
ostream &operator<<(ostream &os,
                    Cylinder &acylinder)
{
    cout << "cylinder dimensions: ";
    cout << "x: " << acylinder.x;
    cout << "  y: " << acylinder.y;
    cout << "  radius: " << acylinder.radius;
    cout << "  height: " << acylinder.height
         << endl;
    return os;
}
int main(void)
{
    Point p(2, 3);
    Circle c(7, 6, 5);
    Cylinder cyl(10, 11, 12, 13);
    cout << p;
    cout << c;
    cout << "area of cirle:" << c.area() << endl;
    cout << cyl;
    cout << "area of cylinder:" << cyl.area() << endl;
    cout << "area of cylinder base is "
         << cyl.Circle::area() << endl;
    return 0;
}

protected
访问控制属性在继承的意义
#include <iostream.h>
// THE POINT CLASS
class Point
{
    friend ostream &operator<<(ostream &, Circle &);

public:
    Point(double xval = 0, double yval = 0)
    {
        x = xval;
        y = yval;
    };

public:
    void print()
    {
        cout << " Point:X:Y: " << x << "," << y << "/n";
    }

protected: // accessed by derived class
    double x;
    double y;
};
ostream &operator<<(ostream &os, Point &apoint)
{
    cout << " Point:X:Y: " << apoint.x << "," << apoint.y << "/n";
    return os;
}
//The Circle class  inherits from class Point
class Circle : public Point
{
    friend ostream &operator<<(ostream &, Circle &);

public:
    Circle(double r = 0, double xval = 0, double yval = 0) : Point(xval, yval)
    {
        radius = r;
    };
    void print()
    {
        cout << "Circle:radius:" << radius << endl;
        cout << " Point:X:Y: " << x << "," << y << "/n";
    }
    double area()
    {
        return (3.14159 * radius * radius);
    };

protected:
    double radius;
};
//note casting circle to point
ostream &operator<<(ostream &os, Circle &aCircle)
{
    cout << "Circle:radius:" << aCircle.radius;
    cout << (Point)aCircle << "/n";
    return os;
}
//We will look at a few main programs based on previous class definitions. Casting and assignments
void main(void)
{
    Point p(2, 3);
    cout << "Point P=  " << p;
    Point pp(0, 0);
    cout << "Point PP=  " << pp;
    Circle c(7, 6, 5);
    cout << "Circle c=  " << c; //radius =7
    pp = p;
    cout << "Point PP=  " << pp; //built in assign =
    // a circle is a member of the point class so assign a circle to a point.
    pp = c; //legal; also assignment O.K.
    cout << "Point PP=  " << pp;
    pp = (Point)c;               // but better  use the cast
    cout << "Point PP=  " << pp; //note we get only the point part of the Circle
    //c = (Circle) pp;   //  illegal Cannot convert 'class Point' to 'class Circle'
    //c=pp;                 //illegal assignment not defined
    Point *p;
    p = &c;
    P->print(); //call base class print
    ((Circle *)p)->print();
    Point &r = c;
    r.print();
    ((Circle &)r).print();
}

类的兼容性规则
#include <iostream.h>
class Base
{
public:
    void func()
    {
        cout << "Base class function./n";
    }
};
class Derived : public Base
{
public:
    void func()
    {
        cout << "Derived class function./n";
    }
};
void foo(Base b)
{
    b.func();
}
int main()
{
    Derived d;
    Base b;
    Base *p = &d;
    Base &br = d;
    b = d;
    b.func();
    d.func();
    p->func();
    foo(d);
    br.func();
    return 0;
}

虚析构函数，防止内存泄露
#include <iostream.h>
#include <string.h>
class Base
{
protected:
    int id;
    char *name;

public:
    // default constructor
    Base(int a = 0, char *s = "") : id(a)
    {
        if (!s)
        {
            name = NULL;
        }
        else
        {
            name = new char[strlen(s) + 1];
            strcpy(name, s);
        }
        cout << "base default constructor/n";
    }
    // copy constructor
    Base(const Base &b) : id(b.id)
    {
        if (!b.name)
        {
            name = NULL;
        }
        else
        {
            name = new char[strlen(b.name) + 1];
            strcpy(name, b.name);
        }
        cout << "base copy constructor/n";
    }
    // destructor
    ~Base()
    {
        if (name != NULL)
            delete[] name;
        cout << "base destructor/n";
    }
    const Base &operator=(const Base &b);
    friend ostream &operator<<(ostream &, const Base &);
};
const Base &Base : perator = (const Base &b)
{
    if (this != &b) // Check if an object is assigned to itself.
    {
        id = b.id;
        delete[] name; //  Destroy the old object.
        if (!b.name)
        {
            name = NULL;
        }
        else
        {
            name = new char[strlen(b.name) + 1];
            strcpy(name, b.name);
        }
    }
    cout << "base assignment operator/n";
    return *this;
}
ostream &operator<<(ostream &out, const Base &b)
{
    out << "Base member id = " << b.id << endl;
    out << "Base member name = " << b.name << endl;
    return out;
}
class Derived : public Base
{
private:
    float f;
    char *label;

public:
    // default constructor
    Derived(int a = 0, char *s = "", float x = 0, char *t = "") : Base(a, s), f(x)
    {
        if (!t)
        {
            label = NULL;
        }
        else
        {
            label = new char[strlen(t) + 1];
            strcpy(label, t);
        }
        cout << "derived default constructor/n";
    }
    // copy constructor
    Derived(const Derived &d) : Base(d), f(d.f)
    // d used as an instance of Base
    {
        if (!d.label)
        {
            label = NULL;
        }
        else
        {
            label = new char[strlen(d.label) + 1];
            strcpy(label, d.label);
        }
        cout << "derived copy constructor/n";
    }
    // destructor
    ~Derived()
    {
        delete[] label;
        cout << "derived destructor/n";
    }
    const Derived &operator=(const Derived &d);
    friend ostream &operator<<(ostream &, const Derived &);
};
const Derived &Derived : perator = (const Derived &d)
{
    if (this != &d)
    {
        delete[] label;
    Base:
        perator = (d); //  Assign the Base part of d to the Base
        // part of the object that calls this operator;
        f = d.f;
        if (!d.label)
        {
            label = NULL;
        }
        else
        {
            label = new char[strlen(d.label) + 1];
            strcpy(label, d.label);
        }
        cout << "derived assignment operator/n";
    }
    return *this;
}
ostream &operator<<(ostream &out, const Derived &d)
{
    out << (Base)d; // Convert d to Base object to output Base members.
    out << "Derived member f = " << d.f << endl;
    out << "Derived member label = " << d.label << endl;
    return out;
}
int main()
{
    Derived d1;
    Derived d2(d1);
    return 0;
}
xioacd99
关注
专栏目录
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++中的各种继承方式规则
nijianluck的专栏
06-05 346
<br />1、C++中的继承方式有：<br />  public、private、protected三种（它们直接影响到派生类的成员、及其对象对基类成员访问的规则）。<br />  （1）public（公有继承）：继承时保持基类中各成员属性不变，并且基类中private成员被隐藏。派生类的成员只能访问基类中的public/protected成员，而不能访问private成员；派生类的对象只能访问基类中的public成员。<br />  （2）private（私有继承）：继承时基类中各成员属性均变为priv
c++ 继承（详细）
听雨居
03-29 1083
原文地址：继承（太详细了！！！）" style="text-decoration:none; color:rgb(88,122,100)">c++ 继承（太详细了！！！）作者：时光翅膀 c++继承经典例子 #include  class Base { private:         int b_number; public:         Base( ){}
C++ 一篇搞懂继承的常见特性
小林coding
01-01 1857
C++ 继承常见的特性
C++ 类访问控制（public/protected/private）
weixin_34228617的博客
08-01 258
C++中 public，protected， private 访问标号小结 第一：private, public, protected 访问标号的访问范围。 private：只能由1.该类中的函数、2.其友元函数访问。 不能被任何其他访问，该类的对象也不能访问。 protected：可以被1.该类中的函数、2.子类的函数、以及3.其友元函数访问。 但不能被该类的对象访问。 ...
C++学习之继承inherit
wangwl1998的博客
10-16 433
继承的自我学习总结
关于C++中菱形继承和虚继承的问题总结
08-29
继承是C++中的一种重要机制，它允许一个类继承另一个类的成员和方法，使得程序设计更加灵活和高效。但是在继承中，存在一些使用方面的问题需要注意，下面这篇文章主要给大家总结介绍了关于C++中菱形继承和虚继承的...
C++中如何使类不能继承
12-22
在C++编程语言中，有时候为了设计上的考虑或者安全性的需求，我们可能希望阻止一个类被其他类继承。Java中有`final`关键字可以达到这样的效果，而在C++中，实现这个目标则需要采取一些技巧。这里我们将探讨如何在C++...
C++继承介绍及使用方法
最新发布
10-09
C++中的继承有三种访问级别：公有（public）、保护（protected）和私有（private）。访问修饰符决定了基类成员在派生类中的可见性。 1. **公有继承（public inheritance）**：基类的公有和保护成员对派生类都是可见...
关于C++中虚拟继承的一些总结分析
09-05
虽然在实际开发中不常见，但理解其工作原理对于深入掌握C++的继承机制至关重要。 1. 虚拟继承的引入原因 虚拟继承的引入主要是为了解决多重继承中的一个特殊问题，即钻石继承（Diamond Inheritance）。在钻石继承中...
C++——Inherit && Derive
qq_41958529的博客
06-28 1281
继承：实现了代码的可重用性。 类的继承， 是新的类从已有类那里得到已有的特性。 或从已有类产生新类的过程就是类的派生。 原有的类称为基类或父类， 产生的新类称为派生类或子类。派生与继承， 是同一种意义两种称谓。 继承：Is a 的关系 public； 语法： 1、单继承 Class Derive ：public Base {} 2、 多继承 Class Derive：publi...
c 语言继承的方式,C++语言学习（十）——继承与派生
weixin_34574003的博客
05-24 454
C++语言学习(十)——继承与派生一、类之间的关系1、类之间的组合关系组合关系是整体与部分的关系。组合关系的特点：A、将其它类的对象作为当前类的成员使用B、当前类的对象与成员对象的生命周期相同C、成员对象在用法上与普通对象相同Computer类由其它多个部件类组合而成，当Computer销毁时，其它部件对象同时销毁。#include using namespace std;class Memory...
C++继承
IT_iverson的博客
09-08 616
一，继承相关概念 二.派生类的定义 代码举例如下： class Parent//基类 { private: int a; public: void print() { cout << "a=" << a << endl; } protected: }; class Child :public Parent//派生类，这里的public 可以也可以是private或
c ++ 继承_了解C ++中的继承概念
从零开始的教程世界
07-13 496
c ++ 继承Hi! This time we are here with the topic – Inheritance in C++. 嗨！ 这次我们将讨论主题– C ++中的继承 。 As we know Inheritance is a very important concept or aspect in Object-Oriented Programming. 众所周知，继承是面向对...
C ++之继承浅析
luoyu2249758976的博客
11-13 3449
最近学习到C++中的的派生类，讲到了一个面向对象的继承，然后看书上的例子就感觉有一些熟悉，因为在C语言求struct的时候就有类似的东西，把一个结构体作为另一个结构体的成员，#include <stdio.h>struct A { int a; int b; };struct B { int c; struct A; };int main() { printf
C++ 继承(基类与派生类)详解附代码
yn_zi的博客
04-10 3953
继承是C++语言的三大特性之一，通过继承联系在一起的类构成一种层次关系。通常在层次关系的根部有一个基类，其他类则直接或间接地从基类继承而来，这些继承得到的类称为派生类。继承机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类型特性的基础上进行扩展，增加功能。一、继承的实例演示继承的三种方式继承的方式有三种：公有继承、私有继承、保护继承基类的private成员在派生类中不可见，如上述例子中Person中的_age成员在派生类Student中不可见。
(C/C++学习笔记) 十八. 继承和多态
aa123kk78011的专栏
01-29 133
十八. 继承和多态 ● 继承的概念 继承(inheritance): 以旧类为基础创建新类, 新类包含了旧类的数据成员和成员函数(除了构造函数和析构函数), 并且可以派生类中定义新成员. 形式: class <派生类名>: <继承方式1> <基类名1> <继承方式2&gt...
C++的protected
图像学习之旅
02-01 3402
基类成员在派生类中的访问权限不得高于继承方式中指定的权限。例如，当继承方式为 protected 时，那么基类成员在派生类中的访问权限最高也为 protected，高于 protected 的会降级为 protected，但低于 protected 不会升级。再如，当继承方式为 public 时，那么基类成员在派生类中的访问权限将保持不变。 也就是说，继承方式中的 public、protected、private 是用来指明基类成员在派生类中的最高访问权限的。 2) 不管继承方式如何，基类中的 privat
c++继承经典例子
热门推荐
coding life
07-20 7万+
  c++继承经典例子#include class Base{private:        int b_number;public:        Base( ){}        Base(int i) : b_number (i) { }        int get_number( ) {return b_number;}        void print( ) {cout
C++继承谱系设计：挑战与常见错误
在C++编程中，继承谱系设计是构建可扩展和可维护的代码库的关键部分。在"继承谱系设计问题"这一主题中，我们聚焦于如何有效地设计类层次结构，以满足未来的需求变化，同时保持稳定性和易于理解性。设计继承谱系时，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值