Wrapper zur Objekterzeugung für eine Vorlagenklasse

Question

Gegeben eine Vorlagenklasse als solche:

template <typename TYPE>
class SomeClass {
 public:
  typedef boost::intrusive_ptr<SomeClass<TYPE> > Client_t;
  inline Client_t GetClient() { return Client_t(this); }
};

SomeClass soll nur über Zeigerreferenzen verwendet werden, die von SomeClass::GetClient() zurückgegeben werden. Daher ist es naheliegend, eine Wrapper-Funktion um die Erstellung herum zu schreiben, wie diese:

template <typename TYPE>
SomeClass<TYPE>::Client_t New_SomeClass() { 
  return (new SomeClass<TYPE>)->GetClient(); 
}

Kompilieren des obigen Codes unter GCC 4.4:

SomeClass<int>::Client_t some_class = New_SomeClass();

Gibt den Fehler "'New_SomeClass' wurde nicht in diesem Bereich deklariert".

Jetzt bin ich kein Template-Assistent, so könnte es Details hier, die ich nicht bewusst sind, aber ich vermute, ich kann nicht ein Konstrukt dieser Art überhaupt aufgrund der Tatsache, dass C++ nicht Überladen auf Rückgabetyp erlaubt verwenden.

Ich schätze, ein... Zittern ... Makro würde das Problem lösen:

#define NEW_SOMECLASS(TYPE) ((new SomeClass<TYPE>)->GetClient())

auto some_class = NEW_SOMECLASS(int);

Aber es muss doch einen vernünftigen Weg geben, die Objekterzeugung einer Template-Klasse darzustellen, ohne auf Makros oder andere umständliche Konstrukte zurückzugreifen?

Answer 1

SomeClass<int>::Client_t some_class = New_SomeClass<int>();

Da die Template-Parameter für New_SomeClass nicht von einem Funktionsparameter abhängen, müssen Sie diese angeben. Die von Ihnen gemeldete Fehlermeldung ist jedoch etwas seltsam für dieses Problem, so dass Sie vielleicht etwas anderes haben.

Oder, meine Präferenz anstelle der Funktion New_SomeClass:

template<class T>
struct SomeClass {
  typedef boost::intrusive_ptr<SomeClass> Client;
  inline Client client() { return Client_t(this); }

  static Client create() { return (new SomeClass())->client(); }

private:
  SomeClass(); // can be public too, if you really need it accessible
};

//...
SomeClass<int>::Client some_class = SomeClass<int>::create();

Auch wenn es im Grunde nur die Funktion "in" die Klasse verschiebt, finde ich es im Allgemeinen sauberer.

Wenn Ihr Compiler 0x's 'auto' unterstützt, können Sie es auf jeden Fall verwenden:

auto some_class = SomeClass<int>::create();

Answer 2

Sie können versuchen, den Standardtyp für den Vorlagentyp-Parameter zu verwenden