求助，关于父类，子类的

[livelyimp]

#include <iostream>

using namespace std;

class a
{

public:
	a();
	virtual void init();
	virtual void run();
	virtual void EndSet();
};

class b : public a
{
public:
	b();
	void init();
	void run();
	void EndSet();
};

#include "a.h"

 a::a()
{
	cout<<"a构造函数"<<endl;
}

 b::b()
{
	cout<<"b构造函数"<<endl;
}

 void a::init()
 {
	 cout<<"a.Init"<<endl;
 }

 void a::run()
 {
	 cout<<"a.run"<<endl;
 }

 void a::EndSet()
 {
	 cout<<"a.endset"<<endl;
 }

void b::init()
{
	cout<<"b.Init"<<endl;
}

void b::run()
{
	cout<<"b.run"<<endl;
}

void b::EndSet()
{
	cout<<"b.endset"<<endl;
}

#include "a.h"

void main()
{
	a sta;
	sta.init();
	sta.run();
	sta.EndSet();
	system("pause");
}

问题是，我在main函数写的时候不知道b这个类，只知道自己声明的a这个类，而run，Init，endset等函数的实现是让用户自定义的子类来实现的，但我怎么在主程序中调用用户自定义的子类的实现函数呢？

[zhousitiaoda]

纯虚函数。。

[livelyimp]

纯虚函数用了，也要知道子类的名字才能实现吧？

[神奕]

不知道子类的名字是不行的，“动态绑定”需要将子类的对象绑定到基类的指针或引用上。

[神奕]

#include "a.h"
 
void main()
{
    a *sta = new b();
    sta->init();
    sta->run();
    sta->EndSet();
    system("pause");
}

[livelyimp]

对啊，我刚想补充问题，或者怎么能够在主程序里面知道子类的类名呢？

[神奕]

引用 5 楼 livelyimp 的回复:

对啊，我刚想补充问题，或者怎么能够在主程序里面知道子类的类名呢？

包含声明子类的头文件啊

[livelyimp]

extern "C" CStrategy __declspec(dllexport) *GetStr();

class __declspec(dllexport) CADX_RSI_IF_5Min :
	public CStrategy
{
public:
	CADX_RSI_IF_5Min(void);
	~CADX_RSI_IF_5Min(void);

	ST_WORD Run();
};

CStrategy* GetStr()
{	
	return (CStrategy*)(new CADX_RSI_IF_5Min());
}

#ifdef STRATEGY
//策略实现
#define BEGINDEC0(strat_name) extern "C" CStrategy __declspec(dllexport) *GetStr();\
	class __declspec(dllexport) strat_name : public CStrategy{ \
	public: //都定义为公有方法与成员														
#define BEGIN_DEC BEGINDEC0(STRATEGY)														//开始策略类声明
#define ENDDEC0(strat_name) 	ST_WORD Run();}; \
	CStrategy* GetStr() \
	{	\
		return (CStrategy*)(new strat_name##());\
	}															
#define END_DEC ENDDEC0(STRATEGY)															//结束策略类声明
#define CONSTRUCTOR_DEC STRATEGY(void);														//声明构造函数
#define BEGIN_CONS STRATEGY::STRATEGY(void){												//开始构造函数
#define END_CONS }																			//结束构造函数
#define DESTRUCTOR_DEC ~STRATEGY(void);														//声明析构函数
#define BEGIN_DES STRATEGY::~STRATEGY(void){												//开始析构函数
#define END_DES }																			//结束析构函数
#define ONORDER_DEC ST_WORD OnOrder(CThostFtdcOrderField * pOrder);							//声明OnOrder回调函数
#define BEGIN_ONORDER ST_WORD STRATEGY::OnOrder(CThostFtdcOrderField * pOrder){				//开始OnOrder回调函数
#define END_ONORDER return OK;}																		//结束OnOrder回调函数
#define ONTRADE_DEC ST_WORD OnTrade(CThostFtdcTradeField * pTrade);							//声明OnTrade回调函数
#define BEGIN_ONTRADE ST_WORD STRATEGY::OnTrade(CThostFtdcTradeField * pTrade){				//开始OnTrade回调函数
#define END_ONTRADE return OK;}																		//结束OnTrade回调函数
#define BEGINRUN0(strat_name) ST_WORD strat_name::Run(){										
#define BEGIN_RUN BEGINRUN0(STRATEGY)														//开始策略主体
#define END_RUN return OK;}																			//结束策略主体
#endif

我看到一个类似的解决问题的，但我看不懂那个在基类里面的定义方法。。

[livelyimp]

包含头文件也没有用啊，b这个类是用户写的，我的主体程序是不知道用户是定义成什么名字的，他完全有可能定义为 class c : public a { ... };

[baichi4141]

由用户传入基类指针，你直接使用 至于这个基类指向的实际上是哪个派生类的对象，你不需要知道也不该知道

[苏客达]

动态绑定是通过指针实现的。你应该让用户实现一个回调函数，传回用户生成的子类的指针，这样才能通过指针去调用用户定义的函数。不然连用户的实例都拿不到，怎么可能调到用户的函数。 main() { ... a *p = UserDefinedClass(); p->init(); ... } 用户的定义文件里面： a* UserDefinedClass() { return &b; }

[勤奋的小游侠]

#include "a.h" void func(a* sta) { sta->init(); sta->run(); sta->EndSet(); system("pause"); } void main() { b B; c C; a A; func(&B);//这里面无论你转入的是B,是C都没有关系，只要这个类是继承自a就可以了。你只需要提供这个函数接口则可以了。 func(&A); func(&C); }

[ranky2009]

同意#11楼以及以上楼层的观点。 楼主要改变自己的观点，既然是客户要写类来继承楼主写的类，调用楼主的逻辑。那么楼主，你的代码并不称其为主程序，只能成为接口与逻辑主体，而客户要调用你的逻辑，那么站在客户这边，客户写的代码才是主程序，才有main函数。

[ranky2009]

引用 12 楼 ranky2009 的回复:

同意#11楼以及以上楼层的观点。 楼主要改变自己的观点，既然是客户要写类来继承楼主写的类，调用楼主的逻辑。那么楼主，你的代码并不称其为主程序，只能成为接口与逻辑主体，而客户要调用你的逻辑，那么站在客户这边，客户写的代码才是主程序，才有main函数。

所以楼主要写两部分代码，一部分为固定的接口与逻辑，另一部分为main测试用例，客户参照楼主的main测试用例来继承楼主的逻辑并实现具体的方法内容。

[默伊清风]

子类对父类的虚函数进行了重写