C++类继承基础1——基类和派生类的恩恩怨怨

掘根

已于 2024-06-19 21:50:16 修改

阅读量936

点赞数 28

分类专栏： C++的类文章标签： c++ 开发语言 java 服务器 windows 数据库

于 2024-02-15 12:26:41 首次发布

本文链接：https://blog.csdn.net/2301_80224556/article/details/136118618

版权

C++的类专栏收录该内容

21 篇文章

订阅专栏

1.面向对象程序设计

在很多程序中都存在着一些相互关联但是有细微差别的概念。

例如，书店中不同书籍的定价策略可能不同：有的书籍按原价销售，有的则打折销售。

有时，我们给那些购买书籍超过一定数量的顾客打折：

另一些时候，则只对前多少本销售的书籍打折，之后就调回原价，等等。

面向对象的程序设计(OOP)适用于这类应用。

面向对象程序设计的核心思想是数据抽象、继承和动态绑定。

通过使用数据抽象，我们可以将类的接口与实现分离；
使用继承，可以定义相似的类型并对其相似关系建模；
使用动态绑定，可以在一定程度上忽略相似类型的区别，而以统一的方式使用它们的对象。

2.继承

通过继承联系在一起的类构成一种层次关系。

通常在层次关系的根都有一个基类(base class)，其他类则直接或间接地从基类继承而来，这些继承得到的类称为派生类(derived class)。

基类负责定义在层次关系中所有类共同拥有的成员，而每个派生类定义各自特有的成员。

在C++语言中，基类将类型相关的函数与派生类不做改变直接继承的函数区分对待。对于某些函数，基类希望它的派生类各自定义适合自身的版本，此时基类就将这些函数声明成虚函数(virtual function)。

派生类必须通过使用类派生列表(class derivation list)明确指出它是从哪个(哪些)基类继承而来的。类派生列表的形式是：首先是一个冒号，后面紧跟以逗号分隔的基类列表，其中每个基类前面可以有访问说明符：

3.定义基类和派生类

class base
{
public:
virtual int a()
{
}
int b()
{
}
};
class dev:public base
{
int a()
{
}
}:

基类通常都应该定义一个虚析构函数，即使该函数不执行任何实际操作也是如此。

4.成员函数与继承

派生类可以继承其基类的成员，然而当遇到如a这样与类型相关的操作时。派生类必须对其重新定义。换句话说，派生类需要对这些操作提供自己的新定义以覆盖从基类继承而来的旧定义。

在C++语言中，基类必须将它的两种成员函数区分开来：

一种是基类希望其派生类进行覆盖的函数;
另一种是基类希望派生类直接继承而不要改变的函数。

对于前者，基类通常将其定义为虚函数(virtual)。当我们使用指针或引用调用虚函数时，该调用将被动态绑定。根据引用或指针所绑定的对象类型不同，该调用可能执行基类的版本，也可能执行某个派生类的版本。

基类通过在其成员函数的声明语句之前加上关键字virtual使得该函数执行动态绑定。
任何构造函数之外的非静态函数都可以是虚函数。
关键字virtual 只能出现在类内部的声明语句之前而不能用于类外部的函数定义。
如果基类把一个函数声明成虚函数，则该函数在派生类中隐式地也是虚函数。
成员函数如果没被声明为虚函数，则其解析过程发生在编译时而非运行时。

对于b成员来说这正是我们希望看到的结果。b函数的执行与派生类的细节无关，不管作用于base对象还是dev对象，b函数的行为都一样。

在我们的继承层次关系中只有一个b函数，因此也就不存在调用b()时到底执行哪个版本的疑问。

5.访问控制与继承

派生类可以继承定义在基类中的成员，但是派生类的成员函数不一定有权访问从基类继承而来的成员。
和其他使用基类的代码一样，派生类能访问公有成员，而不能访问私有成员。不过在某些时候基类中还有这样一种成员，基类希望它的派生类有权访问该成员，同时禁止其他用户访问。我们用受保护的(protected)访问运算符说明这样的成员。

6.定义派生类

派生类必须通过使用类派生列表明确指出它是从哪个(哪些)基类继承而来的。类派生列表的形式是：首先是一个冒号，后面紧跟以逗号分隔的基类列表，其中每个基类前面可以有以下三种访问说明符中的一个：public、protected或者private。

class 派生类名:访问说明符 基类名
{
}

派生类必须将其继承而来的成员函数中需要覆盖的那些重新声明，

因此，我们的dev类必须包含一个a()成员：

class base
{
public:
virtual int a()
{
}
int b()
{
}
};
class dev:public base
{
int a()
{
}
}:

6.1派生类中的虚函数

派生类经常(但不总是)覆盖它继承的虚函数。

如果派生类没有覆盖其基类中的某个虚函数，则该虚函数的行为类似于其他的普通成员，派生类会直接继承其在基类中的版本.

派生类可以在它覆盖的函数前使用virtual关键字，但不是非得这么做。

C++11新标准允许派生类显式地注明它使用某个成员函数覆盖了它继承的虚函数。具体做法是在形参列表后面、或者在const 成员函数的const关键字后面、或者在引用成员函数的引用限定符后面添加一个关键字override。

7.派生类对象及派生类向基类的类型转换

一个派生类对象包含多个组成部分：

派生类自己特有的(非静态)成员的部分，
该派生类继承的基类对应的部分，如果有多个基类，那么这样的基类部分也有多个。

我们举个例子

class Quote
{
int bookNo;
int price;
}
class Bulk_quote:public Quote
{
int min_qty;
int discount;
}

因此，一个Bulk_quote对象将包含四个数据元素：它从Quote继承而来的bookNo和price数据成员，以及Bulk_quote自己定义的min_qty和discount成员。

C++标准并没有明确规定派生类的对象在内存中如何分布，但是我们可以认为Bulk_quote的对象包含它特有的部分和它从基类继承来的部分。

在一个派生类对象中，继承自基类的部分和派生类自定义的部分不一定是连续存储的。

因为在派生类对象中含有与其基类对应的组成部分，所以我们能把派生类的对象当成基类对象来使用，而且我们也能将基类的指针或引用绑定到派生类对象中的基类部分上。

Quote item; // 基类对象
Bulk_quote bulk; // 派生类对象
Quote*p= &item; // p指向Quote对象
P=&bulk; // p指向bulk的Quote部分
Quote &r = bulk; // r绑定到bulk的Quote部分

这种转换通常称为派生类到基类的类型转换。和其他类型转换一样，机译器会隐式地执行派生类到基类的转换。

这种隐式特性意味着我们可以把派生类对象或者派生类对象的引用的地方。

同样的，我们也可以把派生类对象的指针用在需要基类指针的地方。

在派生类对象中含有与其基类对应的组成部分，这一事实是继承的关键所在。

8.派生类构造函数

尽管在派生类对象中含有从基类继承而来的成员，但是派生类并不能直接初始化这些和其他创建了基类对象的代码一样，派生类也必须使用基类的构造函数来初始化它的基类部分。

每个类控制它自己的成员初始化过程。

派生类对象的基类部分与派生类对象自己的数据成员都是在构造函数的初始化阶段执行初始化操作的。

类似于我们初始化成员的过程，派生类构造函数同样是通过构造函数初始化列表来将实参传递给基类构造函数的。

例如，接受四个参数的Bulk quote构造函数如下所示：

Bulk quote(int book, int p,
                int gty, int disc):
                     Quote(book, p), min_gty(gty), discount (disc) {}
// 与之前一致

该函数将它的前两个参数传递给Quote的构造函数，由Quote的构造函数负责初始化Bulk quote的基类部分(即bookNo成员和price成员)。
当(空的)Quote构造函数体结束后，我们构建的对象的基类部分也就完成初始化了。
接下来初始化由派生类直接定义的min_gty成员和discount成员。最后运行Bulk_quote构造函数的(空的)函数体。

除非我们特别指出，否则派生类对象的基类部分会像数据成员一样执行默认初始化。

如果想使用其他的基类构造函数，我们需要以类名加圆括号内的实参列表的形式为构造函数提供初始值。这些实参将帮助编译器决定到底应该选用哪个构造函数来初始化派生类对象的基类部分。

首先初始化基类的部分，然后按照声明的顺序依次初始化派生类的成员。

不用成员初始化列表初始化基类

有人想问了啊，如果我不用成员初始化列表来初始化基类，难道我就不能创建派生类了吗？

当然不是，但是是有条件的，就是基类必须有一个默认构造函数，系统自动提供的也好，自己定义的也罢，如果没有默认构造函数，我们就不能直接创建派生类

我们看看下面这个例子

系统自动提供的默认构造函数

#include<iostream>
using namespace std;
class AA
{
private:
	int a_;
public:
	void print1()
	{
		cout << a_ << endl;
	}
};
class BB :public AA
{
private:
	int b_;
public:
	BB(int b)//没有使用成员列表初始化
	{
		b_ = b;
	}
	void print2()
	{
		cout << b_ << endl;
	}
};
int main()
{
	BB e(2);
	e.print1();//派生类继承了基类的公有方法
	e.print2();
}

自己定义的默认构造函数

#include<iostream>
using namespace std;
class AA
{
private:
	int a_;
public:
	AA(int a=9)//默认构造函数
	{
		a_ = a;
	}
	void print1()
	{
		cout << a_ << endl;
	}
};
class BB :public AA
{
private:
	int b_;
public:
	BB(int b)
	{
		b_ = b;
	}
	void print2()
	{
		cout << b_ << endl;
	}
};
int main()
{
	BB a(2);//可以
	AA b(3);//可以
}

#include<iostream>
using namespace std;
class AA
{
private:
	int a_;
public:
	AA()
	{
	}
	void print1()
	{
		cout << a_ << endl;
	}
};
class BB :public AA
{
private:
	int b_;
public:
	BB(int b)
	{
		b_ = b;
	}
	void print2()
	{
		cout << b_ << endl;
	}
};
int main()
{
	BB a(2);//可以
    AA b(3);/不可以
}

非默认构造函数

#include<iostream>
using namespace std;
class AA
{
private:
	int a_;
public:
	AA(int a )//默认构造函数
	{
		a_ = a;
	}
	void print1()
	{
		cout << a_ << endl;
	}
};
class BB :public AA
{
private:
	int b_;
public:
	BB(int b)
	{
		b_ = b;
	}
	void print2()
	{
		cout << b_ << endl;
	}
};
int main()
{
	BB a(2);//不可以
	AA b(3);//可以
}

派生类基类构造函数和析构函数调用顺序

注意：创建派生类对象时，程序首先调用基类构造函数，然后调用派生类构造函数。基类构造函数负责初始化继承的数据成员；派生类构造函数主要用于初始化新增的数据成员。派生类的构造函数总是调用一个基类构造函数。可以使用初始化列表语法指明要使用的基类构造函数，否则将使用默认基类构造函数。

9.派生类使用基类的成员

派生类可以访问基类的公有成员和受保护成员：

我们举个例子

class Quote
{
int bookNo;
int price;
}
class Bulk_quote:public Quote
{
int min_qty;
int discount;

void a()
{
cout<<bookNo<<endl;//使用基类的成员
}

关键概念：遵循基类的接口
必须明确一点：每个类负责定义各自的接口。要想与类的对象交互必须使用该类的接口，即使这个对象是派生类的基类部分也是如此。

因此，派生类对象不能直接初始化基类的成员。尽管从语法上来说我们可以在派生类构造函数体内给它的公有成受保护的基类成员赋值，但是最好不要这么做。

和使用基类的其他场合一样，派生类应该遵循基类的接口，并且通过调用基类的构造函数来初给化那些从基类中继承而来的成员。

10.继承与静态成员

如果基类定义了一个静态成员，则在整个继承体系中只存在该成员的唯一定义。不论从基类中派生出来多少个派生类，对于每个静态成员来说都只存在唯一的实例。

class Base {
public:
static void statmem();
};
class Derived : public Base {

void f(const Derived&);
}

静态成员遵循通用的访问控制规则，如果基类中的成员是private的，则派生类无权访问它。

假设某静态成员是可访问的，则我们既能通过基类使用它也能通过派生类使用它：

void Derived::£(const Derived &derived _obj)
{
Base::statmem()； // 正确：Base定义了statmem
Derived::statmem()； // 正确：Derived 继承了 statmem
// 正确：派生类的对象能访问基类的静态成员
derived_obj.statmem(); // 通过 Derived 对象访问
statmem(); //通过this对象访问
}

11.派生类的声明

派生类的声明与其他类差别不大，声明中包含类名但是不包含它的派生列表；

class Bulk_quote : public Quote： //错误：派生列表不能出现在这里
class Bulk_quote; //正确：声明派生类的正确方式

一条声明语句的目的是令程序知晓某个名字的存在以及该名字表示一个什么样的实体，如一个类、一个函数或一个变量等。

派生列表以及与定义有关的其他细节必须与类的主体一起出现。

12.定义基类和派生类

如果我们想将某个类用作基类，则该类必须已经定义而非仅仅声明：

class Quote;    // 声明但未定义
// 错误：Quote必须被定义
class Bulk_quote : public Quote{...};

这一规定的原因显而易见：派生类中包含并且可以使用它从基类继承而来的成员，为了使用这些成员，派生类当然要知道它们是什么。

因此该规定还有一层隐含的意思，即一个类不能派生它本身。

一个类是基类，同时它也可以是一个派生类：

class Base {/*...*/}；
class Dl: public Base{ /*...*/ }；
class D2: public D1 { /*...*/}；

在这个继承关系中，Base是D1的直接基类，同时是D2的间接基类。

直接基类出现在派生列表中，而间接基类由派生类通过其直接基类继承而来。

每个类都会继承直接基类的所有成员。

对于一个最终的派生类来说，它会继承其直接基类的成员；该直接基类的成员又含有其基类的成员；依此类推直至继承链的顶端。因此，最终的派生类将包含它的直接基类的子对象以及每个间接基类的子对象。

13.防止继承的发生

有时我们会定义这样一种类，我们不希望其他类继承它，或者不想考虑它是否适合作为一个基类。

为了实现这一目的，C++11新标准提供了一种防止继承发生的方法，即在类名后跟一个关键字 final:

final在C++中主要有两个用途，一是修饰类，二是修饰类的成员函数。

13.1修饰类

当final修饰一个类时，表示这个类不能被继承。也就是说，其他的类不能从这个类派生出新的子类。这样可以确保类的设计不被意外地改变或破坏。

class NoDerived final{ }； // NoDerived 不能作为基类
class Base {};
// Last是final的；我们不能继承Last
class Last final : Base  {}； // Last不能作为基类
class Bad : NoDerived{}; // 错误：NoDerived是final的
classBad2 : Last {}; //错误：Last是final的

13.2修饰成员函数

修饰成员函数：当final修饰一个类的成员函数时，表示这个成员函数在子类中不能被重写（override）。这通常用于确保某个特定的行为在类的继承体系中保持不变。

class Base {
public:
    virtual void func() {
        // ...
    }

    virtual void finalFunc() final {
        // ...
    }
};

class Derived : public Base {
public:
    void func() override {  // 可以重写func函数
        // ...
    }

    void finalFunc() override {  // 编译错误！finalFunc函数不能被重写
        // ...
    }
};

14.类型转换与继承

理解基类和派生类之间的类型转换是理解C++语言面向对象编程的关键所在。

通常情况下，如果我们想把引用或指针绑定到一个对象上，则引用或指针的类型应与对象的类型一致，或者对象的类型含有个可接受的const类型转换规则。

存在继承关系的类是个重要的例外：我们可以将基类的指针或引用绑定到派生类对象上。

例如，我们可以用指向一个Bulk quote对象，也可以把一个Bulk_quote对象的地址赋给一个Quoter*。

可以将基类的指针或引用绑定到派生类对象上有一层极为重要的含义：当使用基类的引用(或指针)时，实际上我们并不清楚该引用(或指针)所绑定对象的真实类型。该对象可能是基类的对象，也可能是派生类的对象。

和内置指针一样，智能指针类也支持派生类向基类的类型转换，这意味着我们可以将一个派生类对象的指针存储在一个基类的智能指针内。

15.静态类型与动态类型

当我们使用存在继承关系的类型时，必须将一个变量或其他表达式的静态类型与该表达式表示对象的动态类型区分开来。

表达式的静态类型在编译时总是已知的，它是变量声明时的类型或表达式生成的类型；
动态类型则是变量或表计式表示的内存中的对象的类型。动态类型直到运行时才可知。

假设我们有一个基类Animal和两个派生类Dog和Cat：

class Animal {
public:
    virtual void makeSound() = 0;
};

class Dog : public Animal {
public:
    void makeSound() {
        cout << "Woof!" << endl;
    }
};

class Cat : public Animal {
public:
    void makeSound() {
        cout << "Meow!" << endl;
    }
};

现在我们可以创建一个Animal类型的指针，根据实际的对象类型来调用不同的成员函数：

int main() {
    Animal* animal1 = new Dog();
    animal1->makeSound(); // 输出：Woof!

    Animal* animal2 = new Cat();
    animal2->makeSound(); // 输出：Meow!

    delete animal1;
    delete animal2;

    return 0;
}

在这个例子中，animal1和animal2都是Animal类型的指针，但在运行时它们分别指向了Dog对象和Cat对象。

通过调用makeSound()函数，可以根据实际的对象类型来输出不同的声音。这就是动态类型的体现，根据实际的对象类型来决定调用哪个函数。

在编译时确定animal1和animal2的静态类型为Animal*，并进行类型检查。

运行时得出Animal1的动态类型是Dog*，而Animal2的动态类型是Cat*

即Animal1的静态类型和静态类型不同，Animal2也是这样

如果表达式既不是引用也不是指针，则它的动态类型永远与静态类型一致。

基类的指针或引用的静态类型可能与其动态类型不一致，读者一定要理解其中的原因。

16.不存在从基类向派生类的隐式类型转换

之所以存在派生类向基类的类型转换是因为每个派生类对象都包含一个基类部分，而基类的引用或指针可以绑定到该基类部分上。

一个基类的对象既可以以独立的形式存在，也可以作为派生类对象的一部分存在。

如果基类对象不是派生类对象的一部分，则它只含有基类定义的成员，而不含有派生类定义的成员。

因为一个基类的对象可能是派生类对象的一部分，也可能不是，所以不存在从基类向派生类的自动类型转换：

class base{};
class Bulk_quote:public base{};


Quote base;
Bulk_ quote* bulkP =&base;//错误：不能将基类转换成派生类

Bulk_quote& bulkRef = base;// 错误：不能将基类转换成派生类

除此之外还有一种情况显得有点特别，即使一个基类指针或引用绑定在一个派生类对象上，我们也不能执行从基类向派生类的转换：

Bulk_quote bulk;
Quote *itemP = &bulk; //正确：动态类型是Bulk_quote
Bulk_quote *bulkp= itemp;// 错误：不能将基类转换成派生类

编译器在编译时无法确定某不特定的转换在运行时是否安全，这是因为编译器只能通过检查指针或引用的静态类型来推断该转换是否合法。

如果在基类中含有一个或多个虚函数，我们可以使用 dynamic_cast 请求一个类型转换，该转换的安全检查将在运行时执行。

同样，如果我们已知某个基类向派生类的转换是安全的，则我们可以使用static_cast来强制覆盖掉编译器的检查工作。

17.在对象之间不存在类型转换

派生类向基类的自动类型转换只对指针或引用类型有效，在派生类类型和基类类型之间不存在这样的转换。

很多时候，我们确实希望将派生类对象转换成它的基类类型，但是这种转换的实际发生过程往往与我们期望的有所差别。

请注意，当我们初始化或赋值一个类类型的对象时，实际上是在调用某个函数。

当执行初始化时，我们调用构造函数；而当执行赋值操作时，我们调用赋值运算符。

这些成员通常都包含一个参数，该参数的类型是类类型的const版本的引用。因为这些成员接受引用作为参数，所以派生类向基类的转换允许我们给基类的拷贝/移动操作传递一个派生类的对象。

这些操作不是虚函数。当我们给基类的构造函数传递一个派生类对象时，实际运行的构造函数是基类中定义的那个，显然该构造函数只能处理基类自己的成员。

类似的，如果我们将一个派生类对象赋值给一个基类对象，则实际运行的层值运算符也是基类中定义的那个，该运算符同样只能处理基类自己的成员

Bulk_quote bulk;//派生类对象
Quote item(bulk)；//使用Quote：:Quote (const Quote&)构造函数

item = bulk;//调用Quote::operator=(const Quote&)

当构造item时，运行Quote的拷贝构造函数。该函数只能处理bookNo和price两个成员，它负责拷贝bulk中Quote部分的成员，同时忽略掉bulk中Bulk_quote 部分的成员。

类似的，对于将bulk赋值给item的操作来说，只有bulk中Quote部分的成员被赋值给item。

因为在上述过程中会忽略Bulk_quote部分，所以我们可以说bulk的Bulk_quote部分被切掉了

当我们使用一个派生类对象为一个基类对象初始化或者赋值时，只有改派生类对象中的基类部分会被拷贝、移动或赋值，它的派生类部分将被忽略掉

关键概念：存在继承关系的类型之间的转换规则

要想理解在具有继承关系的类之间发生的类型转换，有三点非常重要：

从派生类向基类的类型转换只对指针或引用类型有效
基类向派生类不存在隐式类型转换。
和任何其他成员一样，派生类向基类的类型转换也可能会由于访问受限而变得不可行。

尽管自动类型转换只对指针或引用类型有效，但是继承体系中的大多数类仍然(显式或隐式地)定义了拷贝控制成员。

因此，我们通常能够将一个派生类对象拷贝、移动或赋值给一个基类对象。不过需要注意的是，这种操作只处理派生类对象的基类部分。