Как я могу надежно получить адрес объекта, когда оператор & перегружен?

Рассмотрим следующую программу:

struct ghost
{
    // ghosts like to pretend that they don't exist
    ghost* operator&() const volatile { return 0; }
};

int main()
{
    ghost clyde;
    ghost* clydes_address = &clyde; // darn; that's not clyde's address :'( 
}

Как я могу получить clydeадрес?

Я ищу решение, которое будет одинаково хорошо работать для всех типов объектов. Решение на C ++ 03 было бы неплохо, но я также заинтересован в решениях на C ++ 11. Если возможно, давайте избегать поведения, специфичного для реализации.

Мне известен std::addressofшаблон функции C ++ 11 , но я не заинтересован в его использовании здесь: я хотел бы понять, как разработчик стандартной библиотеки может реализовать этот шаблон функции.

Обновление: в C ++ 11 можно использовать std::addressofвместо boost::addressof.

Давайте сначала скопируем код из Boost, за исключением работы компилятора с битами:

template<class T>
struct addr_impl_ref
{
  T & v_;

  inline addr_impl_ref( T & v ): v_( v ) {}
  inline operator T& () const { return v_; }

private:
  addr_impl_ref & operator=(const addr_impl_ref &);
};

template<class T>
struct addressof_impl
{
  static inline T * f( T & v, long ) {
    return reinterpret_cast<T*>(
        &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
  }

  static inline T * f( T * v, int ) { return v; }
};

template<class T>
T * addressof( T & v ) {
  return addressof_impl<T>::f( addr_impl_ref<T>( v ), 0 );
}

Что произойдет, если мы передадим ссылку на функцию ?

Примечание: addressofнельзя использовать с указателем на функцию

В C ++, если void func();объявлено, то funcэто ссылка на функцию, не имеющую аргумента и не возвращающую результата. Эта ссылка на функцию может быть тривиально преобразована в указатель на функцию - из @Konstantin: согласно 13.3.3.2 и то T &и другое, и T *они не различимы для функций. Первым является преобразование Identity, а вторым является преобразование функции в указатель, оба из которых имеют ранг «точное совпадение» (13.3.3.1.1 таблица 9).

Ссылка на функцию проходит через addr_impl_ref, существует неопределенность в разрешении перегрузки для выбора f, которая решается благодаря фиктивному аргументу 0, который является intпервым и может быть повышен до long(интегрального преобразования).

Таким образом мы просто возвращаем указатель.

Что произойдет, если мы передадим тип с оператором преобразования?

Если оператор преобразования выдает a, T*то у нас есть неоднозначность: для f(T&,long)Integral Promotion требуется второй аргумент, в то время как для f(T*,int)оператора преобразования вызывается первый (спасибо @litb)

Именно тогда и addr_impl_refначинается. Стандарт C ++ требует, чтобы последовательность преобразования могла содержать не более одного пользовательского преобразования. Оборачивая тип addr_impl_refи заставляя уже использовать последовательность преобразования, мы «отключаем» любой оператор преобразования, с которым поставляется тип.

Таким образом, f(T&,long)перегрузка выбрана (и Интегральное продвижение выполнено).

Что происходит для любого другого типа?

Таким образом, f(T&,long)перегрузка выбрана, потому что там тип не соответствует T*параметру.

Примечание: из замечаний в файле относительно совместимости с Borland массивы не распадаются на указатели, а передаются по ссылке.

Что происходит в этой перегрузке?

Мы хотим избежать применения operator&к типу, так как он может быть перегружен.

Стандарт гарантирует, что он reinterpret_castможет быть использован для этой работы (см. Ответ @Matteo Italia: 5.2.10 / 10).

Boost добавляет некоторые тонкости с constи volatileквалификаторами, чтобы избежать предупреждений компилятора (и правильно используйте a const_castдля их удаления).

• Приведение T&кchar const volatile&
• Раздеть constиvolatile
• Обратитесь к &оператору, чтобы получить адрес
• Откинь назад к T*

const/ volatileЖонглирование немного черной магия, но это упростит работу (а не предоставление 4 перегрузок). Обратите внимание, что, поскольку Tмы безоговорочно, если мы передаем a ghost const&, то T*есть ghost const*, таким образом, квалификаторы действительно не были потеряны.

РЕДАКТИРОВАТЬ: перегрузка указателя используется для указателя на функции, я несколько исправил выше объяснение. Я до сих пор не понимаю, почему это необходимо, хотя.

Следующий вывод идеона несколько суммирует это.

Использование std::addressof.

Вы можете думать об этом как о следующих действиях:

1. Переосмыслить объект как ссылку на символ
2. Возьмите адрес этого (не вызовет перегрузку)
3. Приведите указатель обратно к указателю вашего типа.

Существующие реализации ( в том числе Boost.Addressof) делать то , что, только принимая дополнительный уход constи volatileквалификацию.

Уловка позади boost::addressofи реализация, обеспеченная @Luc Danton, полагается на волшебство reinterpret_cast; Стандарт в §5.2.10 ¶10 прямо заявляет, что

Выражение типа lvalue T1может быть приведено к типу «ссылка на T2», если выражение типа «указатель на T1» можно явно преобразовать в тип «указатель на T2» с помощью a reinterpret_cast. То есть, ссылка литой reinterpret_cast<T&>(x)имеет тот же эффект, что и преобразование *reinterpret_cast<T*>(&x)с помощью встроенного &и *операторов. Результатом является lvalue, который ссылается на тот же объект, что и исходное lvalue, но с другим типом.

Теперь это позволяет нам преобразовать произвольную ссылку на объект в char &(с квалификацией cv, если ссылка квалифицирована как cv), потому что любой указатель может быть преобразован в (возможно, квалифицированную cv) char *. Теперь, когда у нас есть char &, перегрузка оператора на объекте больше не актуальна, и мы можем получить адрес с помощью встроенного &оператора.

Реализация boost добавляет несколько шагов для работы с cv-квалифицированными объектами: первый reinterpret_castвыполняется const volatile char &, иначе обычное char &приведение не будет работать constи / или volatileссылки ( reinterpret_castне могут быть удалены const). Затем constи volatileудаляется с const_cast, адрес берется с &, и окончательный reinterpet_castк «правильному» типу делается.

const_castНеобходимо , чтобы удалить const/ , volatileкоторые могли быть добавлены к неконстантному / летучим ссылкам, но это не «вреду» , что было const/ volatileссылкой на первом месте, потому что окончательные reinterpret_castбудет повторно добавить резюме-квалификацию , если это было там на первом месте ( reinterpret_castне может удалить, constно может добавить его).

Что касается остального кода в addressof.hpp, кажется, что большая часть этого для обходных путей. static inline T * f( T * v, int ), Кажется, нужно только для компилятора Borland, но его присутствие вводит необходимость addr_impl_ref, в противном случае типов указателей будут пойманы второй перегрузкой.

Редактировать : различные перегрузки имеют разные функции, см. @Matthieu M. Отличный ответ .

Ну, я больше не уверен в этом; Я должен дополнительно изучить этот код, но сейчас я готовлю ужин :), я посмотрю его позже.

Я видел реализацию addressofсделать это:

char* start = &reinterpret_cast<char&>(clyde);
ghost* pointer_to_clyde = reinterpret_cast<ghost*>(start);

Не спрашивайте меня, как это соответствует!

Посмотрите на boost :: addressof и его реализацию.