＜C++＞ 继承

已于 2024-03-10 23:32:41 修改
阅读量171 收藏 1
点赞数 1
分类专栏： C++ 文章标签： c++
于 2023-08-28 17:04:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ikun66666/article/details/132542837
版权

1.继承的概念和定义

继承是面向对象其中的一个核心概念之一，继承允许一个类（称为子类或派生类）从另一个类（称为父类或基类）继承属性和行为，以便在子类中重用已有的代码并添加新的功能。通过继承，可以建立类之间的层次关系，使代码更加模块化、可维护和可扩展。

继承可以通过以下方式来定义：

class BaseClass {
    // 父类的成员变量和成员函数声明
};

class SubClass : [访问权限] BaseClass {
    // 子类的成员变量和成员函数声明
};

其中，BaseClass 是父类的名称，SubClass 是子类的名称。[访问权限] 是继承关系的访问权限修饰符，可以是 public、protected 或 private，分别对应公有继承、保护继承和私有继承。使用不同的访问权限修饰符会影响子类对父类成员的访问权限。

以下代码中Student类和Teacher类就继承了Person类。

//父类
class Person {
public:
    void Print() {
        cout << "name:" << _name << endl;
        cout << "age:" << _age << endl;
    }

protected:
    string _name = "张三";//姓名
    int _age = 18;        //年龄
};
//子类
class Student : public Person {
protected:
    int _stuid;//学号
};
//子类
class Teacher : public Person {
protected:
    int _jobid;//工号
};

在这里插入图片描述

继承后，父类Person的成员，包括成员函数和成员变量，都会变成子类的一部分，也就是说，子类Student和Teacher复用了父类Person的成员。

2.继承基类成员访问方式的变化

继承的访问权限修饰符（public、protected、private）会影响派生类对基类成员的访问方式。以下是继承基类成员访问方式的变化：

  • 公有继承：
    • 公有成员：在派生类中仍然保持公有权限。可以在派生类内部和外部直接访问。
    • 受保护成员：在派生类中变为保护权限。可以在派生类内部访问，但在外部无法直接访问。
    • 私有成员：无法在派生类中直接访问。
  • 保护继承：
    • 公有成员和受保护成员：在派生类中变为保护权限。可以在派生类内部访问，但在外部无法直接访问。
    • 私有成员：无法在派生类中直接访问。
  • 私有继承：
    • 公有成员、受保护成员：在派生类中变为私有权限。可以在派生类内部访问，但在外部无法直接访问。
    • 私有成员：无法在派生类中直接访问。

总结：

  1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
  2. 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。 这也是protected和private的唯一区别
  3. 实际我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private。
  4. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
  5. 在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。

示例：

#include <iostream>

class Animal {
public:
    void eat() {
        std::cout << "Animal is eating." << std::endl;
    }

protected:
    void sleep() {
        std::cout << "Animal is sleeping." << std::endl;
    }

private:
    void move() {
        std::cout << "Animal is moving." << std::endl;
    }
};

class PublicInheritance : public Animal {
public:
    void accessBase() {
        eat();  // 可访问基类的公有成员 -> public成员
        sleep();// 可访问基类的保护成员 -> protected成员
        move(); // err 不可访问基类的私有成员 -> private成员
    }
};

class ProtectedInheritance : protected Animal {
public:
    //保护继承从基类继承下来的公有和保护都为保护，私有不变
    void accessBase() {
        eat();  // 可访问基类的公有成员 -> protected成员
        sleep();// 可访问基类的受保护成员 -> protected成员
        move(); // err  不可访问基类的私有成员 -> private成员
    }
};

class PrivateInheritance : private Animal {
public:
    //私有继承成员都变为私有成员
    void accessBase() {
        eat();  // 可访问基类的私有成员   -> private成员
        sleep();// 可访问基类的私有成员   -> private成员
        move(); // 不可访问基类的私有成员 -> private成员
    }
};

//保护和私有继承在继续派生观察区别
class Protected : public ProtectedInheritance {
public:
    //
    void access() {
        eat();  //可以访问基类的保护成员
        sleep();//可以访问基类的保护成员
        move(); //不可以访问基类的私有成员
    }
};

class Privated : public PrivateInheritance {
public:
    void access() {
        eat();  //err 不可以访问基类的私有
        sleep();//err 不可以访问基类的私有
        move(); //err 不可以访问基类的私有
    }
};

3.基类和派生类对象赋值转换

派生类对象可以赋值给基类的对象 / 基类的指针 / 基类的引用。

例如，对于以下基类及其派生类。

//基类
class Person {
protected:
    string _name;//姓名
    string _sex; //性别
    int _age;    //年龄
};
//派生类
class Student : public Person {
protected:
    int _stuid;//学号
};

int main(){
    Student s;
	Person p = s;     //派生类对象赋值给基类对象
	Person* ptr = &s; //派生类对象赋值给基类指针
	Person& ref = s;  //派生类对象赋值给基类引用
	return 0;
}

对于这种做法，有个形象的说法叫做切片/切割，寓意把派生类中基类那部分切来赋值过去。

派生类对象赋值给基类对象图示：

在这里插入图片描述

赋值给指针和引用同理

示例：

#include <iostream>
using namespace std;
//基类
class Person {
public:
    string _name;//姓名
    string _sex; //性别
    int _age;    //年龄
};
//派生类
class Student : public Person {
public:
    int _stuid;//学号
};

int main() {
    Student s;
    Person p = s;//派生类对象赋值给基类对象

    cout << p._name << endl;
    cout << s._stuid << endl;
    cout << p._stuid << endl;//err 只能访问基类的成员

    return 0;
}

基类对象不能赋值给派生类对象。

示例：

int main() {
    Student s;
    Person p = s;//派生类对象赋值给基类对象

    s = p;  //err 基类不能赋值给派生类

    return 0;
}

基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用RTTI的dynamic_cast来进行识别后进行安全转换。

示例：

int main() {
    Student s;
    Person p = s;//派生类对象赋值给基类对象

    Person *pp = &s;
    Student *st = (Student *) pp;//这种情况转换时可以的
    st->_stuid = 10;

    pp = &p;
    Student *st2 = (Student *) pp;// 这种情况转换时虽然可以，但是会存在越界访问的问题

    st2->_stuid = 10;
    return 0;
}

4.继承中的隐藏

在继承体系中的基类和派生类都有独立的作用域。若子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。

例如，对于以下代码，访问成员num时将访问到子类当中的num。

#include <iostream>
#include <string>
using namespace std;
//父类
class Person {
protected:
    int _num = 111;
};
//子类
class Student : public Person {
public:
    void fun() {
        cout << _num << endl;
    }

protected:
    int _num = 999;
};

int main() {
    Student s;
    s.fun();//999
    return 0;
}

若此时我们就是要访问父类当中的_num成员，我们可以使用作用域限定符进行指定访问。

class Student : public Person {
public:
    void fun() {
        cout << Person::_num << endl;//指定访问父类当中的_num成员
    }

protected:
    int _num = 999;
};

例如，对于以下代码，调用成员函数fun时将直接调用子类当中的fun，若想调用父类当中的fun，则需使用作用域限定符指定类域。

#include <iostream>
#include <string>
using namespace std;
//父类
class Person {
public:
    void fun(int x) {
        cout << x << endl;
    }
};
//子类
class Student : public Person {
public:
    void fun(double x) {
        cout << x << endl;
    }
};

int main() {
    Student s;
    s.fun(3.14);      //直接调用子类当中的成员函数fun
    s.Person::fun(20);//指定调用父类当中的成员函数fun
    return 0;
}

代码当中，父类中的fun和子类中的fun不是构成函数重载，因为函数重载要求两个函数在同一作用域，而此时这两个fun函数并不在同一作用域。

成员函数的隐藏，只需要函数名相同就构成隐藏。

在实际中在继承体系里面最好不要定义同名的成员。

5.派生类的默认成员函数

默认成员函数，即我们不写编译器会自动生成的函数，类当中的默认成员函数有以下六个：

在这里插入图片描述

下面我们看看派生类当中的默认成员函数，与普通类的默认成员函数的不同之处。

例如，我们以下面这个Person类为基类。

class Person {
public:
    //构造函数
    Person(const string &name = "peter")
        : _name(name) {
        cout << "Person()" << endl;
    }
    //拷贝构造函数
    Person(const Person &p)
        : _name(p._name) {
        cout << "Person(const Person& p)" << endl;
    }
    //赋值运算符重载函数
    Person &operator=(const Person &p) {
        cout << "Person& operator=(const Person& p)" << endl;
        if (this != &p) {
            _name = p._name;
        }
        return *this;
    }
    //析构函数
    ~Person() {
        cout << "~Person()" << endl;
    }

private:
    string _name;//姓名
};

我们用该基类派生出Student类，Student类当中的默认成员函数的基本逻辑如下：

class Student : public Person {
public:
    //构造函数
    Student(const string &name, int id)
        : Person(name)//调用基类的构造函数初始化基类的那一部分成员
          ,
          _id(id)//初始化派生类的成员
    {
        cout << "Student()" << endl;
    }
    //拷贝构造函数
    Student(const Student &s)
        : Person(s)//调用基类的拷贝构造函数完成基类成员的拷贝构造
          ,
          _id(s._id)//拷贝构造派生类的成员
    {
        cout << "Student(const Student& s)" << endl;
    }
    //赋值运算符重载函数
    Student &operator=(const Student &s) {
        cout << "Student& operator=(const Student& s)" << endl;
        if (this != &s) {
            Person::operator=(s);//调用基类的operator=完成基类成员的赋值
            _id = s._id;         //完成派生类成员的赋值
        }
        return *this;
    }
    //析构函数
    ~Student() {
        cout << "~Student()" << endl;
        //派生类的析构函数会在被调用完成后自动调用基类的析构函数
    }

private:
    int _id;//学号
};

派生类与普通类的默认成员函数的不同之处概括为以下几点：

  1. 派生类的构造函数被调用时，会自动调用基类的构造函数初始化基类的那一部分成员，如果基类当中没有默认的构造函数，则必须在派生类构造函数的初始化列表当中显示调用基类的构造函数。

  2. 派生类的拷贝构造函数必须调用基类的拷贝构造函数完成基类成员的拷贝构造。

  3. 派生类的赋值运算符重载函数必须调用基类的赋值运算符重载函数完成基类成员的赋值。

  4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。

  5. 派生类对象初始化时，会先调用基类的构造函数再调用派生类的构造函数。

  6. 派生类对象在析构时，会先调用派生类的析构函数再调用基类的析构函数。

在编写派生类的默认成员函数时，需要注意以下几点：

  1. 派生类和基类的赋值运算符重载函数因为函数名相同构成隐藏，因此在派生类当中调用基类的赋值运算符重载函数时，需要使用作用域限定符进行指定调用。
  2. 由于多态的某些原因，任何类的析构函数名都会被统一处理为destructor();。因此，派生类和基类的析构函数也会因为函数名相同构成隐藏，若是我们需要在某处调用基类的析构函数，那么就要使用作用域限定符进行指定调用。
  3. 在派生类的拷贝构造函数和operator=当中调用基类的拷贝构造函数和operator=的传参方式是一个切片行为，都是将派生类对象直接赋值给基类的引用。

在这里插入图片描述

说明一下：

  • 基类的构造函数、拷贝构造函数、赋值运算符重载函数我们都可以在派生类当中自行进行调用，而基类的析构函数是当派生类的析构函数被调用后由编译器自动调用的，我们若是自行调用基类的析构函数就会导致基类被析构多次的问题。

  • 我们知道，创建派生类对象时是先创建的基类成员再创建的派生类成员，编译器为了保证析构时先析构派生类成员再析构基类成员的顺序析构，所以编译器会在派生类的析构函数被调用后自动调用基类的析构函数。

6.继承和友元

友元关系不能继承，也就是说基类的友元可以访问基类的私有和保护成员，但是不能访问派生类的私有和保护成员。

例如，以下代码中Display函数是基类Person的友元，当时Display函数不是派生类Student的友元，即Display函数无法访问派生类Student当中的私有和保护成员。

#include <iostream>
#include <string>
using namespace std;
class Student;
class Person {
public:
    //声明Display是Person的友元
    friend void Display(const Person &p, const Student &s);

protected:
    string _name;//姓名
};
class Student : public Person {
protected:
    int _id;//学号
};
void Display(const Person &p, const Student &s) {
    cout << p._name << endl;//可以访问
    cout << s._id << endl;  //无法访问
}
int main() {
    Person p;
    Student s;
    Display(p, s);
    return 0;
}

若想让Display函数也能够访问派生类Student的私有和保护成员，只能在派生类Student当中进行友元声明。

class Student : public Person {
public:
    //声明Display是Student的友元
    friend void Display(const Person &p, const Student &s);

protected:
    int _id;//学号
};

7.继承与静态成员

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例。

示例：

#include <iostream>
using namespace std;
class Person {
public:
    Person() { ++_count; }

protected:
    string _name;// 姓名
public:
    static int _count;// 统计人的个数。
};

int Person ::_count = 0;

class Student : public Person {
protected:
    int _stuNum;// 学号
};

class Graduate : public Student {
protected:
    string _seminarCourse;// 研究科目
};

int main() {
    Student s1;
    Student s2;
    Student s3;
    Graduate s4;
    cout << " 人数 :" << Person ::_count << endl;   //4
    Student ::_count = 0;
    cout << " 人数 :" << Person ::_count << endl;  //0

    return 0;
}

8.继承的方式

单继承：一个子类只有一个直接父类时称这个继承关系为单继承

在这里插入图片描述

多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承

在这里插入图片描述

菱形继承：菱形继承是多继承的一种特殊情况。
在这里插入图片描述

菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。 在Assistant的对象中Person成员会有两份。

#include <string>
using namespace std;


class Person {
public:
    string _name;// 姓名
};

class Student : public Person {
protected:
    int _num;//学号
};

class Teacher : public Person {
protected:
    int _id;// 职工编号
};

class Assistant : public Student, public Teacher {
protected:
    string _majorCourse;// 主修课程
};

void Test() {
    // 这样会有二义性无法明确知道访问的是哪一个
    Assistant a;
    a._name = "peter";   //err "Assistant::_name" 不明确
}

Assistant对象是多继承的Student和Teacher，而Student和Teacher当中都继承了Person，因此Student和Teacher当中都有name成员，若是直接访问Assistant对象的name成员会出现访问不明确的报错。

对于此，我们可以显示指定访问Assistant哪个父类的_name成员。

// 需要显示指定访问哪个父类的成员可以解决二义性问题
a.Student::_name = "xxx";
a.Teacher::_name = "yyy";

虽然该方法可以解决二义性的问题，但仍然不能解决数据冗余的问题。因为在Assistant的对象在Person成员始终会存在两份。

在这里插入图片描述

菱形虚拟继承

虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在Student和Teacher的继承Person时使用虚拟继承，即可解决问题。需要注意的是，虚拟继承不要在其他地方去使用。

在这里插入图片描述

代码如下：

#include <iostream>
#include <string>
using namespace std;
class Person {
public:
    string _name;//姓名
};

class Student : virtual public Person//虚拟继承
{
protected:
    int _num;//学号
};

class Teacher : virtual public Person//虚拟继承
{
protected:
    int _id;//职工编号
};

class Assistant : public Student, public Teacher {
protected:
    string _majorCourse;//主修课程
};

int main() {
    Assistant a;
    a._name = "peter";//无二义性
    return 0;
}

此时就可以直接访问Assistant对象的name成员了，并且之后就算我们指定访问Assistant的Student父类和Teacher父类的name成员，访问到的都是同一个结果，解决了二义性的问题。

cout << a.Student::_name << endl; //peter
cout << a.Teacher::_name << endl; //peter

而我们打印Assistant的Student父类和Teacher父类的_name成员的地址时，显示的也是同一个地址，解决了数据冗余的问题。

cout << &a.Student::_name << endl; //0136F74C
cout << &a.Teacher::_name << endl; //0136F74C

菱形虚拟继承原理

为了研究虚拟继承原理，我们给出了一个简化的菱形继承继承体系，再借助内存窗口观察对象成员的模型。

class A {
public:
    int _a;
};

class B : public A{
//class B : virtual public A {
public:
    int _b;
};
class C : public A{
//class C : virtual public A {
public:
    int _c;
};

class D : public B, public C {
public:
    int _d;
};

int main() {
    D d;
    d.B::_a = 1;
    d.C::_a = 2;
    d._b = 3;
    d._c = 4;
    d._d = 5;
    return 0;
}

下图是菱形继承的内存对象成员模型：这里可以看到数据冗余

在这里插入图片描述

下图是菱形虚拟继承的内存对象成员模型：这里可以分析出D对象中将A放到的了对象组成的最下面，这个A同时属于B和C，那么B和C如何去找到公共的A呢？这里是通过了B和C的两个指针，指向的一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的A。
在这里插入图片描述
当使用虚拟继承时，每个对象需要包含一个或多个虚基表指针（vpointer），指向一个虚基表（vtable）。虚基表中存储了用于访问虚基类成员的信息，这允许在继承层次中的任何位置对虚基类进行正确的访问。也就意味着，使用虚拟继承会引入额外的内存开销

下面是上面的Person关系菱形虚拟继承的原理解释：
在这里插入图片描述

9.继承和组合

组合（Composition） 是另一种对象关系，其中一个类包含另一个类的实例作为其成员变量。这种关系允许在一个类中使用另一个类的功能，但不会继承其接口。组合关系更加灵活，可以在运行时动态选择成员对象，同时避免了多继承可能引发的问题。

继承是一种is-a的关系，也就是说每个派生类对象都是一个基类对象；而组合是一种has-a的关系，若是B组合了A，那么每个B对象中都有一个A对象。

例如，车类和宝马类就是is-a的关系，它们之间适合使用继承。

class Car {
protected:
    string _colour;//颜色
    string _num;   //车牌号
};

class BMW : public Car {
public:
    void Drive() {
        cout << "this is BMW" << endl;
    }
};

而车和轮胎之间就是has-a的关系，它们之间则适合使用组合。

class Tire {
protected:
    string _brand;//品牌
    size_t _size; //尺寸
};

class Car {
protected:
    string _colour;//颜色
    string _num;   //车牌号
    Tire _t;       //轮胎
};

若是两个类之间既可以看作is-a的关系，又可以看作has-a的关系，则优先使用组合。

原因如下：

  1. 继承允许你根据基类的实现来定义派生类的实现，这种通过生成派生类的复用通常被称为白箱复用。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对于派生类可见，继承一定程度破坏了基类的封装，基类的改变对派生类有很大的影响，派生类和基类间的依赖性关系很强，耦合度高。
  2. 组合是类继承之外的另一种复用选择，新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口，这种复用风格被称之为黑箱复用，因为对象的内部细节是不可见的，对象只以“黑箱”的形式出现，组合类之间没有很强的依赖关系，耦合度低，优先使用对象组合有助于你保持每个类被封装。
  3. 实际中尽量多使用组合，组合的耦合度低，代码维护性好。不过继承也是有用武之地的，有些关系就适合用继承，另外要实现多态也必须要继承。若是类之间的关系既可以用继承，又可以用组合，则优先使用组合。
ikun66666
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
＜C++＞初识类的继承，用三行情诗打开继承的大门
微凉秋意的博客
06-15 1466
躲起来的星星也在努力发光 你也要加油。🎉目录类的继承具体实现注意事项 继承的三种方式 具体实现继承中的对象模型具体实现 🎉总结 继承的好处：减少重复代码的使用，使程序简洁。 小时候暗恋一个遥不可及的人，心里有一首情诗迟迟无法传递给她，于是我把这些话封存到一个Base类里，通过无返回值的shqs1方法可以调用。长大后我再也遇不到他了，心里惆怅，于是乎把第二首情诗通过shqs2放到了Base类里面。但是我想把从小到大的心中所想表达出来，于是两个类，I类和DI......
＜C++＞多态的实战，详解三个具体案例
微凉秋意的博客
06-28 1845
历尽岁月沧桑，也愿你始终相信人间值得✨写在前面✨目录案例一：计算器案例要求代码实现代码解释 运行效果案例二：制作饮品案例要求代码实现代码解释运行效果 案例三：电脑组装案例要求代码实现代码解释运行效果✨总结 代码解释 运行效果 代码解释 运行效果 代码解释 运行效果 在最后庆祝C++多态完美学习结束，学习完知识再完成练习的学习方法真的很赞，希望给大家带来了帮助，下篇博客不见不散！！！.........
计算机程序设计c++ 10-5：类的实例——Person
uncle_ll的博客
12-05 2685
Person 类的定义 class Person { char Name[9]; char Sex; int Age; public: Person( ) // 构造函数 { strcpy(Name,"XXX"); Age = 0; Sex = ' '; } ~Person( ) // 析构函数 {cout<<"Now destroying Person"<<endl; } void Register(char *na
C++ 类与对象（二）
kjl167的博客
08-11 962
C++ 类与对象（二）
C++Person类继承
weixin_46457597的博客
05-28 5097
定义Person类，由Person分别派生出Teacher类和Cadre(干部)类。要求如下： (1)数据成员： 1、在Person类中包含的数据成员有姓名(name)、年龄(age)、性别(sex)。 2、在Teacher类中包含数据成员职称(title)。 3、在Cadre类中包含数据成员职务(post)、工资(wages)。 (2)成员函数： 1、在类体中定义成员函数（根据实际情况包含构造、析构函数） 2、每个类都有显示信息函数(Show) (3)主函数测试： 主函数中分别定义Person类、 Tea
C++定义一个Person基类和Employee子类
m0_67839421的博客
05-21 3151
一个基类 Person，它有 3 个 protected 的数据成员：姓名 name(String 类型)、性别 sex(char 类型)、年龄 age(int 类型)； 创建 Person 类的公有派生类 Employee，增加两个数据成员基本工资 basicSalary（int 类型）请假天数 leaveDays（int 型）；
（已更新）【C++的万能超级无敌头文件 #include ＜bits/stdc++.h＞ 】| 附：＜iostream＞、 ＜string＞、＜vector＞、＜algorithm＞
追光者♂：记录、分享、总结、提升，现象级专栏《Python从入门到人工智能》作者，无惧黑暗，坚信曙光
11-03 3885
（已更新）【C++的万能超级无敌头文件 #include ＜bits/stdc++.h＞ 】| 附:：输入输出流操作、：字符串操作、：动态数组、：算法操作、：数学函数操作、：文件操作、：日期和时间操作、：高精度时间操作等内容。
<3>华为工程师 ，带你实战C++(2018版)
06-10
这是一套全面而系统的C++学习教程： 1，C++对C的全面提高(类型增强，函数重载，默认参数，引用，new/delete 内联函数，类型强转，命名空间，系统string类。2，封装，类与对象，友元，运算符重载。 3，继承与派生，...
设计Person类
热门推荐
梧秋的博客
04-27 1万+
题目内容： 设计一个Person类，包含name、age、sex属性以及对这些属性操作的方法。实现并测试这个类。 根据类的封装性要求，把name、age、sex声明为私有的数据成员，声明公有的成员函数Register()、ShowMe()来访问这些属性，在Register()函数中对数据成员进行初始化。person1通过cin来得到信息，person2通过Register(“Zhang3”, ...
C/C++---Person类、学生类、教师类和研究生类（多重继承）
xtcc的博客
12-14 9699
Person类、学生类、教师类和研究生类（多重继承） 研究生Graduate既有学生Student的属性，又有教师Teacher的属性，通过多重继承说明一个研究生类Graduate。 从前面实验题目完成的Person类派生出Teacher类，新增专业（dept）和月薪（salary）属性，并定义Teacher类的构造函数初始化新增的数据成员，showMe成员函数显示新增的数据成员的值。 再从Person类派生出Student类，新增班级（class）和学号（ID）属性，定义Student类的
C++创建People类--练习
weixin_34190136的博客
04-07 1365
题目描述 /*设计一个用于人事管理的People(人员)类。*/ /* 考虑到通用性，这里只抽象所有类型人员都具有的属性： number(编号)、sex(性别)、birthday(出生日期)、id(身份证号)等等。 其中“出生日期”定义为一个“日期”类内嵌子对象。 用成员函数实现对人员信息的录入和显示。 要求包括：构造函数和析构函数、拷贝构造函数、内联成员函数、聚集。 ...
C语言：刷题笔记
weixin_45930573的博客
09-04 393
c语言刷题记录
【C++】STL—vector的使用
2301_77112794的博客
09-04 686
本文介绍了vector重点函数接口的使用
【C++】vector的简单模拟实现
2303_80828380的博客
09-05 1099
vector的简单模拟实现！！！
C语言 ——— #define 定义宏
weixin_55341642的博客
09-04 821
a + b 的和 于 b - a 的差 做乘法，a + b = 8 ，b - a = 2。#define 机制包括了一个规定，允许把参数替换到文本中，这种实现通常称宏。在宏中的每个变量都加上了括号，加上括号的意义在哪，是否能去掉括号呢？所以在声明宏的时候，最好加上必要的括号，以免出现优先级问题。可以从代码验证中看出，不加括号的结果和预期的结果大相径庭。预期结果：8 * 2 = 16。
C语言 | Leetcode C语言题解之第389题找不同
最新发布
m0_59237910的博客
09-07 442
C语言 | Leetcode C语言题解之第389题找不同
QWidget(c++)嵌入window环境的exe
sunflower_2020的博客
09-05 237
QWidget(c++)嵌入window环境的exe
C++教程：详解如何重载<<和>>运算符
"本资源主要讲解了C++中的重载输出和输入运算符`<<`和`>>`，以及面向对象编程的基础知识。" 在C++编程中，重载运算符是让已有的运算符可以用于自定义类型的一种方式。对于`<<`和`>>`这两个运算符，它们在标准库中被...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值