Erstellen eines neuen Objekts aus den Informationen des dynamischen Typs

Clone-Methode

Es ist nichts vorgesehen, durch die Sprache, die Abfragen geben und können Sie konstruieren, dass die Informationen, aber Sie können die Möglichkeit bieten, für Ihre Klasse bietet verschiedene Möglichkeiten, die einfachste davon ist die Verwendung einer virtuellen Methode:

struct Base {
  virtual ~Base();
  virtual std::auto_ptr<Base> clone(/*desired parameters, if any*/) const = 0;
};

Dieser etwas tut, etwas anders: clone das aktuelle Objekt. Dies ist oft, was Sie wollen, und ermöglicht es Ihnen, um die Objekte herum, als Vorlagen, die Sie dann Klonen und ändern Sie wie gewünscht.

Erweiterung auf Tronic, können Sie auch generieren die Klon-Funktion.

Warum auto_ptr? So können Sie neue zu reservieren das Objekt der übertragung des Eigentums ausdrücklich ist, und der Anrufer hat keine Zweifel, dass löschen müssen ausplanen. Zum Beispiel:

Base& obj = *ptr_to_some_derived;
{ //since you can get a raw pointer, you have not committed to anything
  //except that you might have to type ".release()"
  Base* must_free_me = obj.clone().release();
  delete must_free_me;
}
{ //smart pointer types can automatically work with auto_ptr
  //(of course not all do, you can still use release() for them)
  boost::shared_ptr<Base> p1 (obj.clone());
  auto_ptr<Base>          p2 (obj.clone());
  other_smart_ptr<Base>   p3 (obj.clone().release());
}
{ //automatically clean up temporary clones
  //not needed often, but impossible without returning a smart pointer
  obj.clone()->do_something();
}

Objekt Fabrik

Wenn Sie es vorziehen, zu tun, was Sie fragte und bekommen eine Fabrik, die verwendet werden können, die unabhängig von Instanzen:

struct Factory {}; //give this type an ability to make your objects

struct Base {
  virtual ~Base();
  virtual Factory get_factory() const = 0; //implement in each derived class
    //to return a factory that can make the derived class
    //you may want to use a return type of std::auto_ptr<Factory> too, and
    //then use Factory as a base class
};

Viel von der gleichen Logik und Funktionalität kann verwendet werden, als für eine clone-Methode, wie get_factory erfüllt, die Hälfte der gleichen Rolle, und der return-Typ (und seine Bedeutung) ist der einzige Unterschied.

Habe ich auch abgedeckt Fabriken ein paar mal schon. Sie konnte sich mein SimpleFactory Klasse, so dass Sie Ihren factory-Objekt (zurückgegeben von get_factory) ein Verweis auf eine Globale Fabrik und die Parameter übergeben zu erstellen (z.B. die Klasse der registrierten Namen—überlegen, wie sich zu bewerben boost::function und boost::bind, um diese einfach zu bedienen).

InformationsquelleAutor der Antwort

Gibt es nur einige hacky Möglichkeiten, dies zu tun.

Die erste und IMHO das hässlichste ist:

Base * newObjectOfSameType( Base * b )
{
  if( dynamic_cast<Foo*>( b ) ) return new Foo;
  if( dynamic_cast<Bar*>( b ) ) return new Bar;
}

Beachten Sie, dass dies nur funktioniert, wenn Sie haben RTTI aktiviert und die Basis enthält einige virtuelle Funktion.

Zweiten ein ordentlicher version ist eine Reine virtuelle Klon-Funktion der Basisklasse

struct Base { virtual Base* clone() const=0; }
struct Foo : public Base { Foo* clone() const { return new Foo(*this); }
struct Bar : public Base { Bar* clone() const { return new Bar(*this); }

Base * newObjectOfSameType( Base * b )
{
  return b->clone();
}

Dies ist viel ordentlicher.

Eine Coole/interessante Sache über dieses ist, dass
Foo::clone gibt eine Foo*, während Bar::clone gibt eine Bar*. Man könnte erwarten, dass diese Dinge brechen, aber alles funktioniert durch ein feature von C++ aufgerufen kovariante Rückgabetypen.

Leider kovariante Rückgabetypen arbeiten nicht für smart-Pointer, also mit sharted_ptrs würde der code wie folgt Aussehen.

struct Base { virtual shared_ptr<Base> clone() const=0; }
struct Foo : public Base { shared_ptr<Base> clone() const { return shared_ptr<Base>(new Foo(*this) ); }
struct Bar : public Base { shared_ptr<Base> clone() const { return shared_ptr<Base>(new Bar(*this)); }

shared_ptr<Base> newObjectOfSameType( shared_ptr<Base> b )
{
  return b->clone();
}

InformationsquelleAutor der Antwort Michael Anderson

Können Sie z.B. typeid Abfrage ein Objekt den dynamischen Typ, aber ich kenne keine Möglichkeit, direkt zu instanziieren ein neues Objekt vom Typ Informationen.

Jedoch, abgesehen von der clone Ansatz oben erwähnt, könnte man eine Fabrik:

#include <typeinfo>
#include <iostream>

class Base
{
public:
    virtual void foo() const
    {
        std::cout << "Base object instantiated." << std::endl;
    }
};


class Derived : public Base
{
public:
    virtual void foo() const
    {
        std::cout << "Derived object instantiated." << std::endl;
    }
};


class Factory
{
public:
    static Base* createFrom( const Base* x )
    {
        if ( typeid(*x) == typeid(Base) )
        {
            return new Base;
        }
        else if ( typeid(*x) == typeid(Derived) )
        {
            return new Derived;
        }
        else
        {
            return 0;
        }
    }
};


int main( int argc, char* argv[] )
{
    Base* X = new Derived;
    if ( X != 0 )
    {
        std::cout << "X says: " << std::endl;
        X->foo();
    }

    Base* Y = Factory::createFrom( X );
    if ( Y != 0 )
    {
        std::cout << "Y says: " << std::endl;
        Y->foo();
    }

    return 0;
}

P. S.: Der wesentliche Teil dieses code-Beispiel ist natürlich die Factory::createFrom Methode. (Es ist wohl nicht die schönen C++ - code, da meine C++ hat da ein wenig rostig. Die factory-Methode wahrscheinlich sollte nicht statisch sein, auf den zweiten Gedanken.)

InformationsquelleAutor der Antwort stakx

class Base
{
public:
 virtual ~Base() { }
};

class Foo : public Base
{

};

class Bar : public Base
{

};

template<typename T1, typename T2>
T1* fun(T1* obj)
{
 T2* temp = new T2();
 return temp;
}

int main()
{
  Base* b = new Foo();
  fun<Base,Foo>(b);
}

InformationsquelleAutor der Antwort Jagannath