Popełniłem pewien błąd w dużym projekcie i mam problem. Ilustracja tego problemu jest poniżej.
#include <iostream>
#include <list>
// Plik register.h
class RegisteredBase // od tej klasy pochodzi dużo różnych klas
{
public:
virtual ~RegisteredBase() {}
virtual void WhoAmI()const=0; // tylko do demonstracji że to działa poprawnie
};
class CreatorBase // bazowa klasa kreatora który potrafi stworzyć dowolną z tych "różnych klas"
{
public:
CreatorBase(); // konstruktor jest niżej
virtual RegisteredBase *create()=0; // metoda która tworzy dowolną z tych "różnych klas"
};
template<class BaseInherit> class Creator:public CreatorBase // wzorzec bazujący na powyższej klasie
{
public:
virtual RegisteredBase *create() { return new BaseInherit; } // właśnie tworzymy jedną z tych "różnych klas"
};
class Register // klasa do rejestracji tych "różnych klas"
{
private:
static std::list<CreatorBase*> RegisterList; // statyczna lista deklaracja
public:
static void add(CreatorBase *C) { RegisterList.push_back(C); } // metoda wkładająca obiekt wzorca do listy
typedef std::list<CreatorBase*>::iterator iterator; // uproszczony dostęp do iteratora listy
static iterator begin() { return RegisterList.begin(); } // iterator listy
static iterator end() { return RegisterList.end(); } // iterator listy
};
// Plik register.cpp
std::list<CreatorBase*> Register::RegisterList; // statyczna lista definicja, która musi wystąpić jak najwcześniej
CreatorBase::CreatorBase() { Register::add(this); } // konstruktor klasy tworzącej dodaje siebie do statycznej listy
// Plik A.h
class A:public RegisteredBase // jedna z tych "różnych klas
{
public:
A() {}
virtual void WhoAmI()const { std::cout<<"class A"<<std::endl; }
};
// Plik A.cpp
Creator<A> CreatorA; // wskaźnik na ten CreatorA zostaje dodany do statycznej listy
// Plik B.h
class B:public RegisteredBase // jeszcze jedna z tych "różnych klas
{
public:
B() {}
virtual void WhoAmI()const { std::cout<<"class B"<<std::endl; }
};
// Plik B.cpp
Creator<B> CreatorB; // wskaźnik na ten CreatorB zostaje dodany do statycznej listy
// Plik C.h
class C:public RegisteredBase // kolejna z tych "różnych klas
{
public:
C() {}
virtual void WhoAmI()const { std::cout<<"class C"<<std::endl; }
};
// Plik C.cpp
Creator<C> CreatorC; // wskaźnik na ten CreatorC zostaje dodany do statycznej listy
// Plik main.cpp
//std::list<CreatorBase*> Register::RegisterList; // symulacja złej kolejności linkowania
int main()
{
std::list<RegisteredBase*> Obj; // lista obiektów tych różnych klas
for(Register::iterator i=Register::begin();i!=Register::end();++i)
{
Obj.push_back((*i)->create()); // tworzymy obiekty zarejestrowanych klas i dodajemy do listy Obj
}
for(std::list<RegisteredBase*>::iterator i=Obj.begin();i!=Obj.end();++i)
{
(*i)->WhoAmI(); // sprawdzamy czy to jest nasza poprawna lista obiektów
delete *i; // usuwamy obiekt
}
std::cin.sync();
std::cin.get();
return 0;
}
Wszystko niby działa jak należy. Z tym że jak rozbijemy to na pliki jak opisano w komentarzach to w zależności od kolejności linkowania całość albo działa albo się zawiesza.
Jeżeli Register.cpp zostanie zalinkowany wcześniej niż każda z A.cpp,B.cpp,D.cpp to wszystko jest ok.
Tak się dzieje dla tego że w każdym innym przypadku następuje próba dodania do listy statycznej Register::RegisterList zanim uruchomi się jej konstruktor.
Oczywiście mam kilka rozwiązań tego problemu:
- ustawienie priorytetów linkowania
- przeniesienie wszystkich Creator<Cos> CreatorCos; do pliku register.cpp po definicji Register::RegisterList
Tylko że mnie nie podoba się żadne z tych rozwiązań. Chodzi o to że te pliki (A,B,C) .h+.cpp będą wykonywane przez zupełnie różnych programistów oraz dorzucane do projektu zdalnie. Więc wybrałem oczywiście pierwsze rozwiązanie. Ale tu też pojawił się problem przy przenoszeniu na inną platformę, oczywiście wszyscy zapomnieli o priorytetach.
Więc pytanie, może znacie jakiś sensowny sposób na załatwienie tego problemu?
(nie obstaje przy powyższym rozwiązaniu zagadnienia)
Wymagania:
- moduły (pliki) A,B,C, itp muszą "zarejestrować" w dowolny sposób klasy w nich znajdujące się.
- klasy w A,B,C mają tylko jedną wspólną cechę - pochodzą od klasy RegisteredBase, mają różna strukturę i rozmiary.
- w modułu Register.cpp muszę mieć możliwość stworzenia dowolnej ilości obiektów każdej z "zarejestrowanych" klas.
C++ 