C++, oop, 클래스 목록 (클래스 유형) 및 그 인스턴스 생성

Question

클래스가 많이 선언되어 있고, 모두 기본 클래스 (상속 클래스)로부터 상속됩니다. 내가 사용하고 싶습니다 일반적인 방법 ...

지금, 나중에, 클래스 (하지 개체)의 목록을 가지고 루프에서 그들의 인스턴스를 만들고 일반적인 언급 호출하는 인스턴스를 사용할 필요가 방법 ...

의사 코드

class Abstract { 
void Something(); 
} 

class TaskOne : public Abstract { 
void Something(); // method implemented somewhere below 
} 

class TaskTwo : public Abstract { 
void Something(); // method implemented somewhere below 
} 


... 

list<Abstract> lst; 

lst.push_back(TaskOne); // passing class type, not instance! 
lst.push_back(TaskTwo); 

Abstract tmpObject = new lst[0]; //I know its wrong, just a way of expressing what I'd like to do to have instance of TaskOne! 

,536,

팁을주세요 ...

Answer 1

당신은 템플릿 공장 개체를 만들 수 있습니다

struct IFactory { virtual IBaseType* create() = 0; }; 

template< typename Type > struct Factory : public IFactory { 
    virtual Type* create() { 
     return new Type(); 
    } 
}; 

struct IBaseType { /* common methods */ virtual ~IBaseType(){} }; 

IFactory* factories[] = { 
    new Factory<SubType1> 
, new Factory<SubType2> 
// ... 
}; 

std::vector<IBaseType*> objects; 
objects.push_back(factories[1]->create()); // and another object! 

// don't forget to delete the entries in the 
// vector before clearing it (leak leak) 

Answer 2

당신은 abstract 타입의 포인터 목록을 가지고 있어야합니다. null에 대한 모든 포인터를 초기화하고 나중에 올바른 클래스로 구성하십시오. 미리 포인터를 미리 입력 할 필요가 없습니다. 후자는 RTTI에만 의존 할 수 있습니다.

유형을 미리 입력하기 전에 사전 입력해야하는 경우 유형에 enum ~ Abstract을 추가하십시오. 상속 된 클래스가 클 경우 메모리를 절약 할 수 있습니다. 하지만 당신은 유형의 열거 형을 유지해야합니다. 일을하는 가장 우아한 방법이 아닙니다.

초기화하고 사전 입력해야하는 경우 기본 생성자를 사용하여 클래스를 초기화하면됩니다. 그러나이 방법은 필요하지 않을 때 메모리를 사용하고 있습니다. 여기 RTTI가 당신의 친구가 될 것입니다.

Answer 3

공장 패턴 (예를 들어 http://en.wikipedia.org/wiki/Factory_method_pattern 참조) 일할 수 있습니다.

#define stringify(a) #a 
static int hashstr(const char* s) {/*hash fn of choice*/} 

list<int> types; 

lst.push_back(hashtr(stringify(TaskOne))); // passing class type, not instance! 
lst.push_back(hashtr(stringify(TaskTwo))); 

static Abstract* Instance(int classid) 
{ 
    switch(id) 
    { 
    case hashstr(stringify(TaskOne)): 
    return new TaskOne; 
    //etc 
    } 
} 

추가 작업으로 상당히 우아해질 수 있습니다. static int로 클래스 선언에 클래스 ID를 임베드하는 것은 종종 좋은 시작입니다.

Answer 4

저는 공장 기반 디자인을 사용하는 것이 좋습니다. 당신의리스트는 많은 factory 인스턴스들을 저장하고, 당신은 올바른 factory 메소드를 호출함으로써 Abstract-derived 인스턴스를 생성 할 수 있습니다. 예를 들어

:

class Abstract 
{ 
    virtual void Something() = 0; 
}; 

class TaskOne : public Abstract 
{ 
    void Something(); 
}; 

class AbstractFactory 
{ 
public: 
    Abstract* CreateInstance(); 
}; 

template <class T> class Factory : public AbstractFactory 
{ 
public: 
    Abstract* CreateInstance() 
    { 
     return new T(); 
    } 
}; 

... 

std::vector<AbstractFactory*> Factories; 

Factories.push_back(new Factory<TaskOne>()); 

... 

Abstract *Instance = Factories[ 0 ]->CreateInstance(); 

Answer 5

내가 xtofl proposed처럼 템플릿 공장으로 이동하지만, 여기에 대답 자사의 사용

struct IFactory { virtual IBaseType* create() = 0; }; 

template< typename Type > struct Factory : public IFactory { 
    virtual Type* create() { 
     return new Type(); 
    } 
}; 

list<IFactory*> lst; 

lst.push_back(new Factory<TaskOne>); 
lst.push_back(new Factory<TaskTwo>); 

Abstract *tmpObject = lst[0]->create(); 

// don't forget to delete all the factory instances! 

Answer 6

Boost.MPL을 단순화한다. 하산시에 들리지 마.

예 :

이

namespace mpl=boost::mpl; 
typedef mpl::vector< CLASS1, CLASS2,...,CLASSN > class_list_a; 
typedef mpl::push_back< class_list_a ANOTHER_CLASS>::type class_list_b; 
typedef mpl::push_back< 
    typename mpl::push_back< 
     class_list_b, 
     ANOTHER_TYPE_1>::type, 
    ANOTHER_TYPE_2>::type 
class_list; 

struct functor { 
    template<class U> void operator(U& u) { 
     u.something(); 
    } 
}; 
... 
// in some function 
boost::mpl::for_each<class_list>(functor()); 

편집 :

int foo = 1; 
TYPE_1() . someThing(foo); \ 
TYPE_2() . someThing(foo); \ 
TYPE_N() . someThing(foo);