C++ 类继承的深入理解

原创已于 2025-04-30 12:56:20 修改 · 1.4k 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #继承

于 2018-03-01 20:27:51 首次发布

C++language and related 专栏收录该内容

45 篇文章

订阅专栏

本文解析了在面向对象编程中，子类继承父类时常见的几个误区，包括如何正确理解和使用继承下来的属性与方法，如何在子类中重写父类方法等。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

说起继承，就是对现有的类的方法和字段进行重复的使用

这里只是想总结下初学的时候的一些思想误区，供刚入门的小白参考下：

我这里只说公有继承，public的形式，其他形式不进行讲解，也基本用不到。

误区1：子类继承父类以后总是在考虑这个属性和方法，是归谁所有，是不是继承到子类了，还是归父类所有，只是我们能够使用？以及访问属性的问题

具体解答如下：

（1）公有继承父类的方法，继承完父类所有的属性，都继承到了子类，这些字段都是子类的了，

不存在是父类的，还是子类的字段，都是子类的。只是子类能否用自己继承的方法进行访问而已。继承下来的方法，其实不用考虑是否继承，因为方法不像属性字段，方法就一份，只是可不可以调用方法而已。

对于父类的私有成员，虽然子类可以继承这个方法，但是要依靠父类的方法，进行访问自己继承下来的字段。

上面的这些总结有点饶口，重新梳理下，简单的解释如下：在公有继承的方式下

在父类的访问属性	在子类中的访问属性
public(公用)	public
private(私有)	不可访问
protected(保护)	protected

这里有一点一定要明确，子类继承了父类的私有成员，包括，私有的数据成员和成员函数，在子类的访问属性是不可访问是

指在子类中的新增成员函数，或者是重写的成员函数里，不能够进行访问，从父类继承过来的成员函数，还是可以访问的。

这个一定要分清，从父类继承过的函数，是代码的公用。

class ICommandRunnable :virtual public IRunable
{
public:
ICommandRunnable();
virtual ~ICommandRunnable();
public:
virtual void PushCommand(BaseCommand *cmd, bool front = false);
protected:
virtual void ClearCommand();
virtual BaseCommand *PopCommand();
private:
std::deque<BaseCommand*> _cmds;
CLock _cmds_lock;

};

像上面这个类，是一个父类，但是它的_cmds字段，子类继承以后是访问不了的，需要借助继承到自身子类的父类方法进行访问。

class TestICommand :public ICommandRunnable
{
public:
TestICommand();
~TestICommand();
//线程执行函数
//virtual void PushCommand(BaseCommand *cmd, bool front = false);
void run();
private:
//线程启动锁
bool m_bIsRunning;
CLock m_lkRunLock;
SegEvent m_evtWait;

};

void TestICommand::run()
{
while (m_bIsRunning)
{

BaseCommand* pCmd = NULL;
PushCommand(pCmd); //这里只是代码的构成，并不是真实的写法，只是为了解释而进行的代码书写
if ((pCmd = (BaseCommand*)PopCommand()) == NULL)
{
m_evtWait.wait(3000);
continue;
}
}

}

像上面的两个方法，一个是父类的公有成员函数 PushCommand，一个是父类的受保护成员函数PopCommand，

（受保护的成员函数在父类里相当于私有成员，只是继承到子类的时候，子类内部可以访问，该成员，在类外是不能访问的，这里在强调下什么是类内，就是在定义类的时候，类的成员函数可以进行访问，而外部直接定义一个类对象，然后直接访问对象的成员属性是访问不了的。）

子类继承了这个方法，然后是可以直接使用的，来访问继承到自身的，父类的私有成员，_cmds，如果你把父类的两个方法改成private那就不行了，子类虽然继承过来这个方法，但是不能访问，像上面那样调用就会报错了。

误区2：子类继承父类以后，如果继承了父类的方法，然后只想在方法上进行相应的操作，就是不完全重写，怎么办？

而另外还有一种方式，就是你想继承父类的方法，你感觉你除了要做父类的事以外，你还想要干点其它的事，也就是说父类写的方法，pushcommand不能够满足你的需求了，那就可以对父类的方法进行重写。

如下所示：

class TestICommand :public ICommandRunnable
{
public:
TestICommand();
~TestICommand();
//线程执行函数
virtual void PushCommand(BaseCommand *cmd, bool front = false);
void run();
private:
//线程启动锁
bool m_bIsRunning;
CLock m_lkRunLock;
SegEvent m_evtWait;

};

void TestICommand::PushCommand(BaseCommand *cmd, bool front = false)
{
//_cmds.push_front(cmd);

ICommandRunnable::PushCommand(cmd);

m_evtWait.set();

}

我在pushcommand后想让线程跑起来，就得添加一个m_evtWait.set();而原来的父类的函数就满足不了需求了，

就可以采用两种方式来处理这个问题

（1）我就要对这个方法进行重写，也就是多态，然而我会先不调用父类父类的方法，我想直接按照红色部分操作，这是不可以的，因为这个字段在父类那里是私有的，子类自己写的方法是不能进行访问的，所以要用父类的方法进行访问，所以应该写成第二种绿色的形式，进行访问，然后后面再加上额外的操作。

（2）不用对父类的方法进行重写，原来继承下来的方法继续使用，新定于一个方法，Start.

如下代码所示：

class Threadimpl
{
public:
Threadimpl();
virtual ~Threadimpl();
void startimpl(IRunable* prunable);
void joinImpl();
bool joinImpl(int milliseconds);
bool isRunningImpl() const;
static void sleepImpl(int milliseconds);
#if defined(_USRDLL)
typedef DWORD(WINAPI *Entry)(LPVOID);
#else
typedef unsigned(__stdcall *Entry)(void*);
#endif
protected:
void threadCleanup();

private:
IRunable* _pRunnableTarget;
int _stackSize;
int _nParam;
HANDLE _thread;
};
inline void Threadimpl::sleepImpl(int milliseconds)
{
Sleep(DWORD(milliseconds));
}

class Thread : public Threadimpl
{
public:
Thread();
virtual ~Thread();
void start(IRunable* prunable);//下面的所有函数都是直接调用父类的函数
void join();
bool join(int milliseconds);
bool isRunning() const;
static void sleep(int milliseconds);
};

class TestICommand :public ICommandRunnable,public Thread
{
public:
TestICommand();
~TestICommand();
//线程执行函数
bool Start();
bool Stop();
void run();
private:
//线程启动锁
bool m_bIsRunning;
CLock m_lkRunLock;
SegEvent m_evtWait;

};

bool TestICommand::Start()
{
if (!m_bIsRunning)
{
m_evtWait.reset();
m_bIsRunning = true;
start(this);
}
return true;
}

bool TestICommand::Stop()
{
if (m_bIsRunning)
{
m_bIsRunning = false;
m_evtWait.set();
join();
}
return true;
}

函数里调用继承的函数，然后再添加自己想要的处理，这样也可以满足需求。这个是针对TestICommand 继承Thread来举例说明的

误区3：子类继承父类以后，我在子类中使用了父类的方法,用father::method进行操作的时候，使用到了this指针修改属性的值了，这个时候修改的是谁呢？是父类的值还是子类的值呢？

这个分不清楚，主要还是第一点不是特别清晰，就是继承到的父类方法，是共用的一段代码而已，里面的this指针是对象传进来的，具体看下我写的demo就会清楚了。

#include<iostream>
#include<string>
using namespace std;


class father
{
public:
	father(string name)
	{
		this->name = name;
		cout << "constructor father name:" << this->name << endl;
	}
	~father()
	{
	}
	void set(string name)
	{
		this->name = name;
	}
	void get()
	{
		cout << "father get "<<this->name << endl;
	}
public:
	string name;
};

class son :public father
{
public:
	son() :father("father")
	{
	}
	~son()
	{
	}
	void set(string name);
	void get();
};
void son::set(string name)
{
	father::set(name);//调用父类的方法，相当于把父类方法代码粘贴到此处 this指子类的这个对象
/*
上面的father::set(name);相当于换成下面的这句，this指针指的是谁就清楚了吧
        //void set(string name)
	//{
		this->name = name;
	//
*/
}
void son::get()
{
	cout << "son get "<<this->name << endl;
	father::get();//调用父类的方法，相当于把父类方法代码粘贴到此处 this指子类的这个对象
}
int main()
{
	son test = son();
	test.set("son");
	test.get();
}

输出的结果是下面的截图