C++ 상속 받은 클래스가 스택에 만들어지지 않도록 강제하는 방

그걸로 부족해서 드리는 질문입니다. 소멸자를 protected 로 한다고 해도 상속받은 클래스의 소멸자가 public 이라면 상속 받은 크래스를 스택에 만들 수 있다는 문제 때문입니다.

네, 그렇게 하면 되는데 사용자들이 그렇게 안할 확률이 엄청 높다는게 문제라서요.

스택에 만들어지는 것을 강제할 수는 없지만 소용없도록 하는 것을 다음과 같이 만들어 보았습니다. 목표는 라이브러리 사용자가 쓰레드를 생성하는 객체를 스택에 만드는 실수를 방지하는 것입니다.

라이브러리의 다른 파일들과 엮여있어서 바로 컴파일은 안되겠지만 의미만 한번 보시고 같이 고민 부탁드립니다.

ThreadStart 자체를 좀 더 개선하면 스택 크기를 담는 홀더 객체를 이용해서 디폴트 인자 비슷하게 흉내도 내보고 싶고, ThreadStart 의 리턴값이 생날짜의 쓰레드 핸들이 아니라 좀 더 의미있는 ThreadControl 같은 클래스의 생성자 인자 정도를 지원해서 detach 나 join 같은 것을 구현해보려고 합니다.

--- thread.h
#include <ptk/ptk.h>
#include <boost/noncopyable.hpp>


namespace ptk {

#if defined( _WIN32 )
	typedef unsigned long ThreadType;
	typedef unsigned ThreadReturnType;
#elif defined( PTHREAD )
	typedef pthread_t ThreadType;
	typedef void* ThreadReturnType;
#else
#	error
#endif

class ThreadExecutor : private boost::noncopyable
{
public:
	ThreadExecutor();

protected:
	virtual ~ThreadExecutor();

private:
	virtual ThreadReturnType operator()() = 0;

	friend ThreadReturnType IF_WIN32( __stdcall ) ThreadProc( void* arg );
};

ThreadType ThreadStart_( ThreadExecutor* e, unsigned stackSize );

template< typename T >
ThreadType ThreadStart( unsigned stackSize )
{
	return ThreadStart_(  new T, stackSize ); 
}

template< typename T, typename P1 >
ThreadType ThreadStart( P1 p1, unsigned stackSize )
{
	return ThreadStart_( new T( p1 ), stackSize ); 
}

template< typename T, typename P1, typename P2 >
ThreadType ThreadStart( P1 p1, P2 p2, unsigned stackSize )
{
	return ThreadStart_( new T( p1, p2 ), stackSize ); 
}

template< typename T, typename P1, typename P2, typename P3 >
ThreadType ThreadStart( P1 p1, P2 p2, P3 p3, unsigned stackSize )
{
	return ThreadStart_( new T( p1, p2, p3 ), stackSize ); 
}

} // namespace ptk

--- thread.cpp
#include <ptk/win32.h>
#if defined( _WIN32 )
#	include <process.h>
#endif
#include <ptk/pthread.h>
#include <ptk/thread.h>
#include <ptk/exception.h>
#include <ScopeGuard.h>

using namespace std;

namespace ptk {

ThreadExecutor::ThreadExecutor()
{
}

ThreadExecutor::~ThreadExecutor()
{
}

static ThreadReturnType IF_WIN32( __stdcall ) ThreadProc( void* arg )
{
	ThreadExecutor* e = reinterpret_cast<ThreadExecutor*>(arg);

	ThreadReturnType r = (*e)();

	delete e;

	return r;
}

ThreadType ThreadStart_( ThreadExecutor* e, unsigned stackSize )
{
#if defined( _WIN32 )

	unsigned threadId = 0;
	ThreadType thread_ = _beginthreadex( NULL, stackSize, ThreadProc, e, 0, &threadId );
	if( thread_ <= 0 )
		throw crtl_error( PTK_WHERE, "_beginthreadex" );

#elif defined( PTHREAD )

	pthread_attr_t attr;
	pthread_attr_init( &attr );
	ON_BLOCK_EXIT( pthread_attr_destroy, &attr );
	pthread_attr_setstacksize( &attr, stackSize );

	ThreadType thread_;
	if( pthread_create( &thread_, attr, threadProc, e ) != 0 )
		throw crtl_error( PTK_WHERE, "pthread_create" );

#else

#	error

#endif

	return thread_;
}

} // namespace ptk

--- test_thread.cpp
#include <ptk/win32.h>
#include <ptk/thread.h>
#include <iostream>

using namespace std;
using namespace ptk;

class TestThread : public ThreadExecutor
{
public:
	explicit TestThread( int count ) :
		count_( count )
	{
	}

private:
	ThreadReturnType operator()()
	{
		for( int i = 0; i < count_; ++i )
		{
			Sleep( 1000 );
			cout << "TestThread" << endl;
		}

		return 0;
	}

private:
	int count_;
};

bool testThread()
{
	TestThread a(1); // 의미없음

	// 쓰레드 실행자를 동적으로 만들고 실행하도록 한다.
	//
	ThreadStart<TestThread>( 5, 0 );

	// 이 함수가 종료되더라도 쓰레드를 만든 객체는 힙상에 존재

	return 0;
}