Dotaz: Virtuální metody

[Jardík]

Mám problém s voláním virtuálních metody jedné třídy: Thread:

class Thread{
private:
	pthread_t m_tHandle;
	unsigned int m_nStatus;
	Mutex m_tMutex;
public:
	enum Status{
		NotRunning = 0,
		Running = 1,
		Suspended = 2,
		Zombie = 3
	};
	Thread();
	virtual ~Thread();
	void run();
	void kill();
	void wait();
	pthread_t handle() const { return m_tHandle; };
	void handle( pthread_t handle ) { m_tHandle = handle; }
	void lock() { m_tMutex.lock(); }
	void unlock(){ m_tMutex.unlock(); }
	bool tryLock(){ return m_tMutex.tryLock(); }
	void status( unsigned int status );
	unsigned int status() const { return m_nStatus; }
	virtual void start();
	virtual void stop();
	static void waitForAll();
};

static void *entry_point(void *thread_)
{
	Thread* thread = reinterpret_cast<Thread*>(thread_);
	signal(SIGQUIT, signal_handler_SIGQUIT);
	thread_list_mutex.lock();
	thread_list.insert( std::make_pair(pthread_self(), thread) );
	thread_list_mutex.unlock();
	thread->handle(pthread_self());
	thread->start();
	thread->stop();
	thread->status(Thread::Zombie);
	pthread_exit(NULL);
	return NULL;
}

void Thread::run()
{
	if( status() == NotRunning )
	{
	label_create:
		status(Running);
		pthread_create(&m_tHandle, NULL, &entry_point, this);
	}
	else if( status() == Zombie ){
		wait();
		goto label_create;
	}
}

Ve funkci static void *entry_point(void *thread_) volám thread->start(). Problém je, že se vždy zavolá metoda start() třídy Thread a né metoda odvozené třídy MujThread:

class MujThread: public Thread{
public:
	MujThread(){}
	virtual ~MujThread(){}
	virtual void start()
	{
		printf("MujThread start()\n");
		while(true);
	}
	virtual void stop()
	{
		printf("MujThread stop()\n");
	}
};

Odpovědi

[volca]

Nejsem si jisty, ale neni na vine reinterpret_cast? nemel by tam byt static_cast?

[volca]

Jak tak premyslim tak to ani ten static_cast nezachrani. Problem bude asi v tom, ze kastujes z void*, a kompilator se tak nedozvi byvaly typ. Asi to bude chtit nekoho zkusenejsiho, ale muj posledni typ je dynamic_cast (diky RTTI)

[Jardík]

Jsem samozřejmě zkoušel také. Zkoušel jsem i (Thread*)thread_, bezúspěšně. Vím ale, že ten kód ještě nedávno fungoval. Pomalu bych řekl, že přestal fungovat po aktualizaci gcc.

[Luboš Doležel (Doli)]

Zkuste udělat tu metodu Thread::start pure virtual, jak se to zachová.

[Jardík]

pure virtual method called
terminate called without an active exception
./testutk: line 4:  6543 Neúspěšně ukončen (SIGABRT)

[Luboš Doležel (Doli)]

Tohle by se správně nemělo nikdy stát

Nemáte dohromady ty verze GCC smíchané (že by kus kódu byl zkompilovaný se starou verzí)?

[Jardík]

Určitě ne. Před novou kompilací jsem provedl make clean.

[Michal Kubeček]

Zkusil bych tu metodu MujThread::start() nedávat jako inline. Kompilátor by sice měl být dost chytrý, aby buď ignoroval evidentní chybu programátora, nebo protestoval, jenže právě to ignorování chyby lze provést dvěma způsoby: buď bude ignorovat virtual nebo inline (zde implicitní). Musel bych se podívat, co v takové situaci předepisuje specifikace jazyka, ale v každém případě bude jistější nepožadovat po překladači něco, co je principiálně nemožné.

[Jardík]

I když nedám metodu MujThred::start() jako inline, nefunguje to. Mám jinou třídu (Application):

class Application{
	....
public:
	....
	virtual bool onInit() { return true; }
	virtual void onQuit() {}
	....
};

Od té odvozuji TestApplication:

class TestApplication: public Application{
protected:
	MujThread t;
public:
	virtual bool onInit()
	{
		...
		t.run();
		return true;
	}
	
	virtual void onQuit()
	{
		t.kill();
	}
};

Zde však volání virtuálních metod funguje správně, což popírá vaši domněnku. (Už jste viděl zdrojový kód Qt knihovny? Je tam toho plno.) Problém bude nejspíš jinde. A jak říkám výše, ten kód fungoval naprosto bezchybně, když jsem ho před časem použil (ale na jiné distribuci, s jiným kernelem - 2.6.17, teď 2.6.18 - a s trochu nižší verzí GCC).

[Michal Marek (twofish)]

Hmm, taková hloupá otázka, ale odkud se volá ta metoda entry_point()? Pokud by se volala z konstruktoru Thread, tak by to vysvětlovalo to chování.

[Jardík]

Z konstruktoru volána není. Volá se z Thread::run() (viz. kód výše), konkrétně se zavolá po vytvoření nového vlákna: pthread_create(&m_tHandle, NULL, &entry_point, this).