当前位置：首页 > news >正文

【语法】C++继承中遇到的问题及解决方法

news 来源：原创 2025/4/30 6:27:35

1.子类构造函数中初始化父类成员

2.子类显式调用父类的析构函数

第一种说法：重定义

反驳：

第二种说法：operator~

3.因编译器版本过低而出现错误

贴主在学习C++的继承时，遇到了很多问题，觉得很变态，特此发帖分享

1.子类构造函数中初始化父类成员

众所周知，在子类的构造函数中是不能初始化父类成员的，必须调用父类的构造函数来完成初始化

#include <iostream>
using namespace std;
class base
{
public:base():_a(0){cout << "constructor base \n";}
protected:int _a;
};class derived : public base
{
public:derived():_a(0)//报错，因为_a是父类成员{cout << "constructor derived \n";}
};

但有一种情况可能会被误认为是初始化

#include <iostream>
using namespace std;
class base
{
public:base():_a(0){cout << "constructor base \n";}
protected:int _a;
};class derived : public base
{
public:derived()//:base()这里已经隐式调用了base的构造函数了{_a = 0;cout << "constructor derived \n";}
};

这确实可以运行，但这里其实并不是初始化(initialization)，而是赋值(assignment)，这里看似没有调用父类的初始化，但其实会隐式调用构造函数

可以看到，base的构造函数还是被调用了，这就是隐式调用了base的构造函数

那拷贝构造函数呢？若子类不定义默认构造函数的话，拷贝构造时确实会调用父类的拷贝构造函数完成父类函数的初始化

#include <iostream>
using namespace std;
class base
{
public:base():_a(0){cout << "constructor base \n";}base(const base& b):_a(b._a){cout << "copy constructor base \n";}
protected:int _a;
};class derived : public base
{
public:derived():base(){cout << "constructor derived \n";}
};int main()
{derived a;cout << "\n";derived b(a);return 0;
}

输出结果：

可以看到在拷贝构造时，隐式调用了父类的拷贝构造

但如果子类有用户定义的拷贝构造函数，如果没有显式调用父类的拷贝构造函数，编译器就会隐式调用父类的构造函数

#include <iostream>
using namespace std;
class base
{
public:base():_a(0){cout << "constructor base \n";}base(const base& b):_a(b._a){cout << "copy constructor base \n";}
protected:int _a;
};class derived : public base
{
public:derived():base(){cout << "constructor derived \n";}derived(const derived& d)//子类拷贝构造不显式调用父类的拷贝构造，会隐式调用父类的构造函数完成父类成员初始化{cout << "copy constructor derived \n";}
};int main()
{derived a;cout << "\n";derived b(a);return 0;
}

输出结果：

可以看到，在拷贝构造时，编译器先隐式调用了父类的构造函数

2.子类显式调用父类的析构函数

众所周知，子类的析构函数会在被调用完成后自动调用父类的析构函数清理父类成员。因为这样才能保证子类对象先清理子类成员再清理父类成员的顺序。

#include <iostream>
using namespace std;
class base
{
public:base(){cout << "constructor base \n";}~base(){cout << "destructor base \n";}
};class derived : public base
{
public:derived(){cout << "constructor derived \n";}~derived(){~base();cout << "destructor derived \n";}//会报错
};int main()
{derived a;return 0;
}

报错：

当然，对于99%的情况来说，根本用不到显式调用析构函数，剩下的1%就是placement new 管理内存的情况

对于这里的报错，我目前知道两种说法

第一种说法：重定义

这里的~base和~derived构成重定义(隐藏)，但他们两个函数名不相同啊？这是因为经过编译器处理后所有的析构函数都会被处理成destructor(为了支持多态)，那他们两个析构函数就是重名函数了，父类的析构函数就会被重定义,此时要想让编译器知道你要调用的是父类的析构，就要在前面加上作用域限定符

int main()
{cout << int() <<endl;return 0;
}

反驳：

“隐藏”是非限定名查找的一部分。而析构函数的查找方式有所不同，因此不存在隐藏关系。也没有所谓的“转换为特殊名称 destructor（析构函数）”这样的过程作为名称查找的目的。

如果有大佬知道到底对不对的，欢迎评论区解答！！！

第二种说法：operator~

这里的报错和是不是继承没有关系，因为下面代码也会报同样的错误

class base
{~base(){cout << "~base \n";}void func(){~base();}
};

这段代码的执行顺序其实是先base()，再~

base()会先构造一个base的临时对象。这里其实不难理解，就例如int()，会调用int的默认构造函数创建临时的int变量，它的值是0

int main()
{cout << int() <<endl;return 0;
}

输出：0

所以base()也一样，会调用base的默认构造函数来构建一个临时的base对象

然后会试图调用base对象的operator~重载，如下图

#include <iostream>
using namespace std;
class base
{
public:base(){cout << "constructor base \n";}~base(){cout << "destructor base \n";}void operator~(){cout << "operator ~ \n";}
};class derived : public base
{
public:derived(){cout << "constructor derived \n";}~derived(){base::~base();cout << "destructor derived \n";}
};
int main()
{~base();cout <<"\n";base().operator~();//第一行就相当于这么调用return 0;
}

输出结果：

如上图，第一个和第一行和第三行的代码输出结果相同

所以报错的原因就是base类没有operator~重载

流程：先构造一个临时的base对象，再调用临时base对象的operator~运算符，最后析构这个临时的base对象

3.因编译器版本过低而出现错误

根据第二个问题可以得知，当写出~base()时，会先构造一个临时的base对象，然后调用该对象的operator~操作符，最后析构这个临时base对象。

而如果要直接在子类中调用父类析构函数，可以这样

class derived : public base
{
public:derived(){cout << "constructor derived \n";}~derived(){base::~base();cout << "destructor derived \n";}
};

给~base()的前面加上作用域限定符，这样编译器就知道你是要调用父类的析构函数，而不是operator~重载。

但如果在父类有operator~重载时，在子类中调用base::~base();呢？

#include <iostream>using namespace std;
class base
{
public:base(){cout << "constructor base \n";}~base(){cout << "destructor base \n";}void operator~(){cout << "operator ~ \n";}
};class derived : public base
{
public:derived(){cout << "constructor derived \n";}~derived(){base::~base();cout << "destructor derived \n";}
};
int main()
{derived d;return 0;
}

上面代码在我之前的编译器中，就会编译错误

error:

cmd /c chcp 65001>nul && C:\mingw64\bin\g++.exe -fdiagnostics-color=always -g "D:\Valkyrie-text\simple text\text.cpp" -o "D:\Valkyrie-text\simple text\text.exe"
D:\Valkyrie-text\simple text\text.cpp: In destructor 'derived::~derived()':
D:\Valkyrie-text\simple text\text.cpp:15:28: error: no matching function for call to 'derived::~derived()'~derived(){base::~base();cout << "destructor derived \n";}^
D:\Valkyrie-text\simple text\text.cpp:7:5: note: candidate: 'base::~base()'~base(){cout << "destructor base \n";}^
D:\Valkyrie-text\simple text\text.cpp:7:5: note:   candidate expects 1 argument, 0 provided

后来发现，这是编译器在抱怨缺少参数

在前面加上thts->就可以了