Namespaces
Variants

std:: addressof

From cppreference.net
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
Definiert im Header <memory>
template < class T >
T * addressof ( T & arg ) noexcept ;
(1) (seit C++11)
(constexpr seit C++17)
template < class T >
const T * addressof ( const T && ) = delete ;
(2) (seit C++11)
1) Ermittelt die tatsächliche Adresse des Objekts oder der Funktion arg , selbst bei Vorhandensein eines überladenen operator & .
2) Die Rvalue-Überladung ist gelöscht, um die Adressnahme von const Rvalues zu verhindern.

Der Ausdruck std::addressof(e) ist ein konstanter Teilausdruck , falls e ein lvalue-konstanter Teilausdruck ist.

(since C++17)

Inhaltsverzeichnis

Parameter

arg - Lvalue-Objekt oder Funktion

Rückgabewert

Zeiger auf arg .

Mögliche Implementierung

Die untenstehende Implementierung ist nicht constexpr , da reinterpret_cast in einem konstanten Ausdruck nicht verwendet werden kann. Compiler-Unterstützung ist erforderlich (siehe unten). 

template<class T>
typename std::enable_if<std::is_object<T>::value, T*>::type addressof(T& arg) noexcept
{
    return reinterpret_cast<T*>(
               &const_cast<char&>(
                   reinterpret_cast<const volatile char&>(arg)));
}
template<class T>
typename std::enable_if<!std::is_object<T>::value, T*>::type addressof(T& arg) noexcept
{
    return &arg;
}
**Hinweis:** Der C++-Code innerhalb der ` 
`-Tags wurde gemäß den Anforderungen nicht übersetzt, da er technische Spezifikationen enthält, die in der Originalsprache belassen werden müssen.

Die korrekte Implementierung dieser Funktion erfordert Compiler-Unterstützung: GNU libstdc++ , LLVM libc++ , Microsoft STL .

Hinweise

Feature-Test Makro Wert Std Feature
__cpp_lib_addressof_constexpr 201603L (C++17) constexpr std::addressof

constexpr für addressof wurde durch LWG2296 hinzugefügt, und MSVC STL wendet die Änderung im C++14-Modus als Fehlerbericht an.

Es gibt einige seltsame Fälle, in denen die Verwendung des eingebauten operator & aufgrund von argument-dependent lookup fehlerhaft ist, selbst wenn er nicht überladen wurde, und std::addressof stattdessen verwendet werden kann. 

template<class T>
struct holder { T t; };
struct incomp;
int main()
{
    holder<holder<incomp>*> x{};
    // &x; // Fehler: Argumentabhängige Suche versucht holder<incomp> zu instanziieren
    std::addressof(x); // OK
}

Beispiel

operator & kann für eine Pointer-Wrapper-Klasse überladen werden, um einen Pointer auf Pointer zu erhalten:

Führe diesen Code aus 
#include <iostream>
#include <memory>
template<class T>
struct Ptr
{
    T* pad; // add pad to show difference between 'this' and 'data'
    T* data;
    Ptr(T* arg) : pad(nullptr), data(arg)
    {
        std::cout << "Ctor this = " << this << '\n';
    }
    ~Ptr() { delete data; }
    T** operator&() { return &data; }
};
template<class T>
void f(Ptr<T>* p)
{
    std::cout << "Ptr   overload called with p = " << p << '\n';
}
void f(int** p)
{
    std::cout << "int** overload called with p = " << p << '\n';
}
int main()
{
    Ptr<int> p(new int(42));
    f(&p);                // calls int** overload
    f(std::addressof(p)); // calls Ptr<int>* overload, (= this)
}

Mögliche Ausgabe: 

Ctor this = 0x7fff59ae6e88
int** overload called with p = 0x7fff59ae6e90
Ptr   overload called with p = 0x7fff59ae6e88

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
LWG 2598 C++11 std :: addressof < const T > konnte Adresse von Rvalues nehmen durch eine gelöschte Überladung verhindert

Siehe auch

der Standard-Allokator
(Klassentemplate)
[static]
erhält einen dereferenzierbaren Zeiger auf sein Argument
(öffentliche statische Elementfunktion von std::pointer_traits<Ptr> )