Wie man Freund für abgeleitete Klassen propagiert

Freundschaft ist weder geerbt, noch transitiv, wie hier beschrieben: Freund Klasse mit Vererbung.

Nach ein wenig Experimentieren, und die Nutzung dieser hack Wie einrichten eines globalen container (C++03)?, ich glaube, ich habe einen Weg gefunden, den "factory" - Rechte zum einmaligen erstellen der Objekte.

Hier ist eine quick-and-dirty code. (Scrollen Sie nach unten, um zu sehen, der hack.)

class Object {};

class Factory {
public:
    //factory is a singleton
    //make the constructor, copy constructor and assignment operator private.
    static Factory* Instance() {
        static Factory instance;
        return &instance;
    }

    public: typedef Object* (*CreateObjectCallback)(); 
    private: typedef std::map<int, CreateObjectCallback> CallbackMap; 

public: 
    //Derived classes should use this to register their "create" methods.
    //returns false if registration fails
    bool RegisterObject(int Id, CreateObjectCallback CreateFn) {
        return callbacks_.insert(CallbackMap::value_type(Id, createFn)).second; 
    }

    //as name suggests, creates object of the given Id type
    Object* CreateObject(int Id) {
        CallbackMap::const_iterator i = callbacks_.find(Id); 
        if (i == callbacks_.end()) { 
            throw std::exception(); 
        } 
        //Invoke the creation function 
        return (i->second)(); 
    }

    private: CallbackMap callbacks_; 
};

class Foo : public Object {
    private: Foo() { cout << "foo" << endl; }
    private: static Object* CreateFoo() { return new Foo(); }


public:
    static void RegisterFoo() {
        Factory::Instance()->RegisterObject(0, Foo::CreateFoo);     
    }
};

class Bar : public Object {
    private: Bar() { cout << "bar" << endl; }
    private: static Object* CreateBar() { return new Bar(); }

public:
    static void RegisterBar() {
        Factory::Instance()->RegisterObject(1, Bar::CreateBar);     
    }
};

//use the comma operator hack to register the create methods
int foodummy = (Foo::RegisterFoo(), 0);
int bardummy = (Bar::RegisterBar(), 0);

int main() {
    Factory::Instance()->CreateObject(0); //create foo object
    Factory::Instance()->CreateObject(1); //create bar object
}

InformationsquelleAutor der Antwort Masked Man

Wie die anderen schon gesagt, Freundschaft ist nicht vererbbar.

dieser sieht aus wie ein guter Kandidat "Abstract Factory" - Muster.

übernehmen "SomeClass"es-abgeleitet von der Basisklasse polymorph verwendet werden.
deklarieren Sie eine abstrakte Fabrik-Basis, die schafft Base Objekte.
ableiten jedem konkreten Werk von base, überschreiben Sie die Basis-Methode zur Erstellung von...

sehen http://en.wikipedia.org/wiki/Abstract_factory_pattern für Beispiele

InformationsquelleAutor der Antwort

Für die Zukunft, eine andere Idee, die kam aus dem chat zwischen OP und mir, die funktioniert mit nur einem Einsatz von friend als die OP wollte. Natürlich, dies ist nicht eine Universelle Lösung, aber es kann in einigen Fällen hilfreich sein.

Code unten ein minimal eine, die zeigt die wesentlichen Ideen. Diese muss "integriert" in den rest der Factory code.

class Factory;

class Top { //dummy class accessible only to Factory
private:
    Top() {}
friend class Factory;
};

class Base {
public:    
    //force all derived classes to accept a Top* during construction
    Base(Top* top) {}  
};

class One : public Base {
public:    
    One(Top* top) : Base(top) {}
};

class Factory {
    Factory() {
        Top top;  //only Factory can create a Top object
        One one(&top);  //the same pointer could be reused for other objects
    }
};

InformationsquelleAutor der Antwort Masked Man