C++: Verwendung von Template für Zeiger mit Pfeil Überlastung (->) Operator

Question

Ich schrieb diese Template-Klasse für Zeiger Verwendung (I intelligente Zeiger müssen, aber ich kann nicht boost oder C++ 11):

template<class T> 
class TreePointer{ 
public: 
    TreePointer(){ 
     isRefOnly=false; 
     data=NULL; 
    }; 
    TreePointer(T* data){ 
     this->data=data; 
     this->isRefOnly=false; 
    } 
    TreePointer(const TreePointer& anotherPtr){ 
     this->data=anotherPtr.data; 
     this->isRefOnly=true; 
    } 
    virtual ~TreePointer(){ 
     if (!isRefOnly){       
      delete data; 
     }   
    }  
    T* operator->() const{ 
     return data; 
    } 
    void operator=(const TreePointer &anotherPtr){ 
     this->data=anotherPtr.data; 
     this->isRefOnly=true; 
    }   
private: 
    T* data; 
    bool isRefOnly; 
}; 

Und ich habe große Klasse mit vielen Methoden, wie folgt aus:

class WrittenBigClassWithManyMethods{ 
public: 
    WrittenBigClassWithManyMethods(int v){ 
     this->v=v; 
    }  
    int sum(WrittenBigClassWithManyMethods* a){ 
     return v+a->v; 
    } 
    int v; 
}; 

diese Nutzung meiner Smart Pointer perfekt funktionieren:

TreePointer<WrittenBigClassWithManyMethods> tp(new WrittenBigClassWithManyMethods(5)); 
WrittenBigClassWithManyMethods* simpleClass=new WrittenBigClassWithManyMethods(5); 
cout << tp->sum(simpleClass); 

Aber es Nutzung funktioniert nicht:

TreePointer<WrittenBigClassWithManyMethods> tp2(new WrittenBigClassWithManyMethods(5)); 
cout << tp->sum(tp2); 

Wie ich meine Vorlage für Zeiger ändern kann, um den Aufruf methrod Summe der Klasse WrittenBigClassWithManyMethods mit Parametern vom Typ TreePointer, ohne Änderungen für die Klasse WrittenBigClassWithManyMethods und seine irgendwelche Verwendungen? Wenn das nicht möglich ist, wie minimiere ich die Änderungen für Klasse WrittenBigClassWithManyMethods und deren Verwendung?

Answer 1

Normalerweise sollten Sie auch den unären Operator * (de-referenz) überladen und eine T& zurückgeben. Dann können Sie sowohl eine Referenz haben und den ursprünglichen Zeiger durch die Adresse des Ergebnisses unter:

tp1->method_that_takes_ref(*tp2); // With operator*() 
tp1->method_that_takes_ptr(&*tp2); // Works, but syntax might be a bit surprising 

Ein anderer Weg, um den Zeiger zu bekommen innen wäre operator -> direkt zu nennen, aber das wäre ein wenig umständlich sein. Sie sind wahrscheinlich besser dran, eine Art von „get“ Verfahren, wie das in unique_ptr Bereitstellung, dass einfach die Rohzeiger zurückgibt:

tp1->method_that_takes_ptr(tp2.operator->()); // Works, but ugh 
tp1->method_that_takes_ptr(tp2.get()); // Much clearer 

Answer 2

einen Umwandlungsoperator zu T* hinzufügen:

operator T*() { 
    return data; 
} 

Nun ist die Compiler wird es aufrufen, wann immer es eine in eine SomeClass* konvertieren will.