W dniu 2012-01-04 08:37, Paweł Kierski pisze:
> W dniu 2012-01-03 18:12, Szyk pisze:
>>
>>>> Czy są takie systemy operacyjne w których programy (i biblioteki
>>>> współdzielone) kompilowane różnymi kompilatorami C++ są ze sobą
>>>> kompatybilne?
>>>
>>> Najlepiej przyjąć, że najmniejszym wspólnym mianownikiem jest interfejs
>>> typu C. Do tego każde zwolnienie zasobów powinno nastąpić w tym module,
>>> w którym zostały zaalokowane. Wtedy ma duże szansę zagrać bez względu
>>> na kompilator.
>>
>> Czyli wzorzec fabryka obiektów się kłania?
>
> Tyle, że oprócz fabryki potrzebna jest zazwyczaj "niszczarka".

Czemu fabryka nie mogła by mieć funkcji niszczącej? Przecież tak było by
chyba najwygodniej.

Przykładowo:

class MyFactory : public QObject
{
protected:
MyFactory();

public:
static MyFactory* instance();

MyObject* createObject(QString aType, int aID);
void deleteObject(MyObject* aMyObject);

// inne funkcje pomocnicze:
void removeObject(MyObject* aMyObject); // do usuwania obiektu
// z bazy
MyObject* cloneObject(MyObject* aMyObject);
void saveObject(MyObject* aMyObject);
signals:
void objectChange(MyObject* aMyObject);
void objectRemoved(MyObject* aMyObject);
};

> Najlepiej
> opakować to po stronie klienta w sprytne uchwyty/wskaźniki (chyba, że
> cały obiekt po stronie klienta jest takim uchwytem na wewnętrzne
> zasoby).

Masz zapewne na myśli dedykowany sprytny wskaźnik, a nie std::auto_ptr?
Czyli chodzi Ci o coś w stylu:

template<class tFactory, class tObject> class MySmartPtr
{
public:
MySmartPtr(QString aType, int aID)
{
mObject = tFactory::instance()->createObject(aType, aID);
}

~MySmartPtr()
{
tFactory::instance()->deleteObject(mObject);
mObject = 0;
}
tObject* operator->()
{
return mObject;
}
protected:
tObject* mObject;
}

void FactoryClient::someFunction()
{
MySmartPtr<MyFactory, MyObject> lPtr("MyType", 100);
}