Verwenden einer Wrapper-Klasse als Zeiger auf den Wrapper-Typ?

Question

ich eine einfache Wrapper-Klasse für Integer-Typen haben, wie so definiert:

class Integer { 
    public: 
     Integer() { 
     } 

     Integer(const int& value) { 
      this->value = value; 
     } 

     int toInt() const { 
      return value; 
     } 

     operator int() const { 
      return toInt(); 
     } 

    private: 
     int value = 0; 
}; 

Was ich möchte, zu tun ist, um die Klasse oben an eine Funktion, die eine Signatur wie folgt hat: doSomething(int* value)

Wenn ich einen normalen int verwenden waren, konnte ich einfach tun:

int value = 5; 
doSomething(&value); 

Wenn jedoch die Wrapper-Klasse verwendet, kann ich nicht da wäre es einen Zeiger auf die Klasse verwenden, anstelle der tatsächlichen zugrundeliegenden Wert. Ich kenne den Adressoperator , den ich verwenden könnte, um einen Zeiger auf den Wert zurückzugeben, aber es würde verhindern, dass ich einen Zeiger auf die Klasse selbst bekommen würde, wenn ich es brauchte.

Also idealerweise gäbe es einen Weg, der es mir erlauben würde, &myclass zu verwenden, um einen Zeiger auf die Klasse oder den zugrunde liegenden Wert zu bekommen, je nachdem, was benötigt wird.

Gibt es so einen Weg?

Answer 1

Es scheint, ich konnte mein eigenes Problem lösen.

nahm ich Inspiration aus einem Kommentar von @Arunmu und die folgenden Frage: https://stackoverflow.com/a/9569120

Durch die operator&() (Adress-of) Betreiber Überlastung und ein Proxy-Klasse-Objekt zurückgegeben, die implizite Konvertierung Betreiber Zeiger beider hat der Typ meiner ursprünglichen Klasse und der Wert, den es umhüllt, kann ich die Syntax verwenden, die ich brauchte.

ich ein Beispiel für jedermann zur Verfügung stellt, die das gleiche Problem auftritt:

class IntegerPointer { 
public: 
    IntegerPointer(int& value, Integer& wrapper) : value(value), wrapper(wrapper) { 
    } 

    operator int*() { 
     return &value; 
    } 

    operator Integer*() { 
     return std::addressof(wrapper); 
    } 

private: 
    int& value; 
    Integer& wrapper; 
}; 

class Integer { 
public: 
    Integer() { 
    } 

    Integer(const int& value) : value(value) { 
    } 

    Integer(const Integer& value) : Integer(value.value) { 
    } 

    IntegerPointer operator&() { 
     return IntegerPointer(value, (*this)); 
    } 

protected: 
    int value; 
}; 

Auf diese Weise können Sie Syntax verwenden wie:

Integer test = 5; 
doSomething(&test); 

Wo & Test als Zeiger verwendet werden können, um das Integer-Objekt oder als Zeiger auf den int-Wert, den es umschließt.