Wie berechnet man den Offset eines Klassenmitglieds zur Kompilierzeit?

Question 1

Gegeben eine Klassendefinition in C++

class A
{
  public:
    //methods definition
    ....

  private:
    int i;
    char *str;
    ....
}

Ist es möglich, den Offset eines Klassenmitglieds zur Kompilierzeit mithilfe der C++-Template-Metaprogrammierung zu berechnen? Die Klasse ist kein POD und kann virtuelle Methoden, primitive und Objektdatenelemente haben.

Question 2

Basierend auf der Antwort von Matthieu M., aber kürzer und ohne Makros:

template<typename T, typename U> constexpr size_t offsetOf(U T::*member)
{
    return (char*)&((T*)nullptr->*member) - (char*)nullptr;
}

Und es heißt so:

struct X { int a, b, c, d; }

std::cout << "offset of c in X == " << offsetOf(&X::c);

Bearbeiten:

Jason Reis hat recht. Dadurch wird in C++11 kein tatsächlicher konstanter Ausdruck erzeugt. Es sieht nicht möglich aus angesichts der Einschränkungen in http://en.cppreference.com/w/cpp/language/constant_expression — insbesondere kein Zeigerunterschied und reinterpret_castkann in einem konstanten Ausdruck sein.

Question 3

Nun, in C++11 können Sie solche Offsets tatsächlich direkt mit normalen C++-Funktionen berechnen (dh ohne an einen bestimmten intrinsischen Compiler zu delegieren).

In Aktion bei Live-Arbeitsplatz:

template <typename T, typename U>
constexpr int func(T const& t, U T::* a) {
     return (char const*)&t - (char const*)&(t.*a);
}

Dies beruht jedoch auf t ein Verweis auf a . sein constexpr Instanz hier, die möglicherweise nicht auf alle Klassen zutrifft. Es verbietet nicht T von einem haben virtual Methode, noch nicht einmal ein Konstruktor, solange es a . ist constexpr Konstrukteur.

Dennoch ist dies ein ziemliches Hindernis. In unevaluierten Kontexten könnten wir tatsächlich gebrauchen std::declval<T>() um zu simulieren, ein Objekt zu haben; während Sie keine haben. Dies stellt daher keine besonderen Anforderungen an den Konstrukteur eines Objekts. Andererseits gibt es nur wenige Werte, die wir aus einem solchen Kontext extrahieren können… und sie stellen auch Probleme mit aktuellen Compilern dar… Nun, lass es uns vortäuschen!

In Aktion bei Live-Arbeitsplatz:

template <typename T, typename U>
constexpr size_t offsetof_impl(T const* t, U T::* a) {
    return (char const*)t - (char const*)&(t->*a) >= 0 ?
           (char const*)t - (char const*)&(t->*a)      :
           (char const*)&(t->*a) - (char const*)t;
}

#define offsetof(Type_, Attr_)                          
    offsetof_impl((Type_ const*)nullptr, &Type_::Attr_)

Das einzige Problem, das ich vorhersehe, ist mit virtual Vererbung aufgrund seiner Laufzeitplatzierung des Basisobjekts. Gerne werde ich mit weiteren Mängeln konfrontiert, falls vorhanden.

Question 4

Nein, nicht generell.

Das Makro offsetof existiert für POD-Strukturen (Plain Old Data) und kann mit C++0x leicht auf Standard-Layout-Strukturen (oder andere ähnliche geringfügige Erweiterungen) erweitert werden. Für diese eingeschränkten Fälle haben Sie also eine Lösung.

C++ bietet Compiler-Autoren viele Freiheiten. Ich kenne keine Klausel, die verhindern würde, dass einige Klassen variable Offsets zu Mitgliedern der Klasse haben – ich bin mir jedoch auch nicht sicher, warum ein Compiler dies tun würde. 😉

Ein Ansatz, um Ihren Code-Standards konform zu halten und dennoch Offsets zu haben, wäre, Ihre Daten in eine POD-Unterstruktur (oder eine C++0x-Erweiterung) zu stecken, auf der offsetof funktioniert, und dann an diesem Unterbau zu arbeiten. struct statt auf die gesamte Klasse. Oder Sie könnten auf die Einhaltung von Standards verzichten. Der Offset Ihrer Struktur innerhalb Ihrer Klasse wäre nicht bekannt, aber der Offset des Members innerhalb der Struktur.

Eine wichtige Frage ist: “Warum will ich das und habe ich wirklich einen guten Grund”?

Question 5

In dem 1996 erschienenen Buch “Inside the C++ Object Model”, das von Stanley B. Lippman, einem der ursprünglichen C++-Designer, geschrieben wurde, verweist er in Kapitel 4.4 auf Pointer-to-Member-Funktionen

Der zurückgegebene Wert, wenn die Adresse eines nicht statischen Datenmembers genommen wird, ist der Bytewert der Position des Members im Klassenlayout (plus 1). Man kann es sich als unvollständigen Wert vorstellen. Es muss an die Adresse eines Klassenobjekts gebunden werden, bevor auf eine tatsächliche Instanz des Members zugegriffen werden kann.

Obwohl ich mich vage an +1 aus irgendeinem früheren Leben erinnere, habe ich diese Syntax noch nie zuvor gesehen oder verwendet.

class t
{
public:
    int i;
    int j;
};
int (t::*pmf)() = &t::i;

Zumindest der Beschreibung nach scheint dies eine coole Möglichkeit zu sein, “fast” den Offset zu bekommen.

Aber es scheint zumindest in GCC nicht mehr zu funktionieren. Ich bekomme ein

Cannot initialize a variable of type 'int (t::*) with an rvalue of type "int t:: *'

Hat jemand eine Geschichte hinter dem, was hier vor sich geht? Ist so etwas noch möglich?

Problem mit dem Internet – veraltete Bücher sterben nie…