Использование класса оболочки как указателя на тип, который он обертывает?

Question

У меня есть простой класс обертки для целочисленных типов, определяемого следующим образом:

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; 
}; 

Что я хотел бы сделать, это передать класс выше функции, которая имеет подпись, как это: doSomething(int* value)

Если бы я использовать обычный INT, я мог бы просто сделать:

int value = 5; 
doSomething(&value); 

Однако при использовании класса обертки я не могу, так как он будет использовать указатель на класс, вместо фактического основного стоимость. Я знаю адресного оператора operator&, который я мог бы использовать для возврата указателя на значение, но это помешало бы мне получить указатель на сам класс, если мне это нужно.

Так что в идеале был бы способ, который позволил бы мне использовать &myclass, чтобы получить указатель на класс или базовое значение, в зависимости от того, что необходимо.

Есть ли такой способ?

Answer 1

Кажется, я смог решить свою проблему.

Я взял вдохновение от комментариев по @Arunmu и следующий вопрос: https://stackoverflow.com/a/9569120

Перегружая оператор operator&() (адрес-) и возвращает прокси-объект класса, который имеет неявные операторы преобразования для указателей и тип моего исходного класса и значение, которое он обертывает, я могу использовать синтаксис, который мне нужен.

я приведу пример для тех, кто сталкивается с той же проблемой:

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; 
}; 

Это позволяет использовать синтаксис, такие как:

Integer test = 5; 
doSomething(&test); 

Где & тестов могут быть использованы в качестве указателя объект Integer или как указатель на значение int, которое оно завершает.