一、继承的概念及定义

1.继承的概念

继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。

//基类/父类
class Person
{
public:
  void Print()
  {
    cout << "name:" << _name << endl;
    cout << "age:" << _age << endl;
  }
protected:
  string _name = "peter"; // 姓名
  int _age = 18; // 年龄
};
//派生类/子类
class Student : public Person
{
protected:
  int _stuid; // 学号
};
//派生类/子类
class Teacher : public Person
{
protected:
  int _jobid; // 工号
};

继承后，父类的Person的成员（成员函数+成员变量）都会变成子类的一部分。这里体现出了Student和Teacher复用了Person的成员。

2.继承的定义

1.定义格式

下面我们看到Person是父类，也称作基类。Student是子类，也称作派生类。

2.继承关系和访问限定符

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

上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private。

基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。

基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。

使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。

在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。

二、基类和派生类对象的赋值转换

当派生类对象赋值给父类的对象、基类的指针和基类的引用时，这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。

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

基类的指针可以通过强制类型转换赋值给派生类的指针。但是必须是基类的指针是指向派生类对象时才是安全的。

class Person
{
protected:
  string _name; // 姓名
  string _sex;  // 性别
  int _age;     // 年龄
};
class Student : public Person
{
public:
  int _No;      // 学号
};
int main()
{
  Student s;
  // 子类对象可以赋值给父类对象/指针/引用
  Person p = s;
  Person* ptr = &s;
  Person& ref = s;
}

子类赋值给父类：就是将子类中父类的那一部分切割出来赋值给父类

三、继承中的作用域

1. 在继承体系中基类和派生类都有独立的作用域。

2. 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用基类::基类成员显示访问）

3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。

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

// Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是非常容易混淆
class Person
{
protected:
  string _name = "小李子"; // 姓名
  int _num = 111; // 身份证号
};
class Student : public Person
{
public:
  void Print()
  {
    cout << " 姓名:" << _name << endl;
    cout << " 身份证号:" << Person::_num << endl;
    cout << " 学号:" << _num << endl;
        /*子类继承父类之后，子类中就有两个_num,编译器在访问时就会采用就近原则，如果想要访问父类中的_num就需要指定类域*/
  }
protected:
  int _num = 999; // 学号
};
int main()
{
  Student s1;
  s1.Print();
  return 0;
}

例题：有以下程序，判断1和2的函数调用有什么样的结果？

A、A和B的func构成函数重载

B、编译报错

C、运行报错

D、A和B构成函数隐藏

class A {
public:
  void fun()
  {
    cout << "func()" << endl;
  }
};
class B : public A 
{
public:
  void fun(int i)
  {
    cout << "func(int i)->" << i << endl;
  }
};
void Test()
{
  B b;
  b.fun(10); //1
    b.fun();   //2
};

解析：

b.fun(10); ---- 构成函数隐藏

b.fun( ); ---- 编译报错；因为调用不明确

四、派生类的默认成员函数

6个默认成员函数，“默认”的意思就是指我们不写，编译器会变我们自动生成一个，那么在派生类中，这几个成员函数是如何生成的呢？

//父类
class Person
{
public:
    //构造函数
  Person(const char* 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;
  }
protected:
  string _name; // 姓名
};
//子类
class Student : public Person
{
public:
    //构造函数
  Student(const char* name, int num)
    : Person(name) //调用父类的构造函数初始化基类的那一部分成员
    , _num(num)    //初始化子类的成员
  {
    cout << "Student()" << endl;
  }
    //拷贝构造函数
  Student(const Student& s)
    : Person(s)    //调用父类的拷贝构造函数完成基类成员的拷贝构造
    , _num(s._num) //拷贝构造子类的成员
  {
    cout << "Student(const Student& s)" << endl;
  }
    //赋值重载函数（同上）
  Student& operator = (const Student& s)
  {
    cout << "Student& operator= (const Student& s)" << endl;
    if (this != &s)
    {
      Person::operator =(s);
      _num = s._num;
    }
    return *this;
  }
    //析构函数
  ~Student()
  {
    cout << "~Student()" << endl;//子类的析构函数会在被调用完成后自动调用父类的析构函数
  }
protected:
  int _num; //学号
};

总结以下几点：

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

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

3. 派生类的operator=必须要调用基类的operator=完成基类的复制。

4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。

5. 派生类对象初始化先调用基类构造再调派生类构造。

6. 派生类对象析构清理先调用派生类析构再调基类的析构。

五、继承与友元

友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员。

class Student;
class Person
{
public:
    friend void Display(const Person& p, const Student& s);
protected:
    string _name; // 姓名
};
class Student : public Person
{
protected:
    int _stuNum; // 学号
};
void Display(const Person& p, const Student& s) 
{
    cout << p._name << endl;   //可以访问
    cout << s._stuNum << endl; //不可以访问 --- 除非给子类加上友元
}
void main()
{
    Person p;
    Student s;
    Display(p, s);
}

六、继承与静态成员

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

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; // 研究科目
};
void TestPerson()
{
  Student s1;
  Student s2;
  Student s3;
  Graduate s4;
  cout << " 人数 :" << Person::_count << endl;//4
  Student::_count = 0;
  cout << " 人数 :" << Person::_count << endl;//0
    /*通过对个类中的_count地址的打印看出，确实静态成员单独存在*/
  cout << &Person::_count << endl;   //008FE3D8
  cout << &Student::_count << endl;  //008FE3D8
  cout << &Graduate::_count << endl; //008FE3D8
}

【C++】—— 继承(1)

一、继承的概念及定义

1.继承的概念

2.继承的定义

1.定义格式

2.继承关系和访问限定符

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

二、基类和派生类对象的赋值转换

三、继承中的作用域

四、派生类的默认成员函数

五、继承与友元

六、继承与静态成员

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

【C++】—— 继承(1)

一、继承的概念及定义

1.继承的概念

2.继承的定义

1.定义格式

2.继承关系和访问限定符

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

二、基类和派生类对象的赋值转换

三、继承中的作用域

四、派生类的默认成员函数

五、继承与友元

六、继承与静态成员

热门文章

最新文章

相关课程

相关电子书

相关实验场景