`this` pointer at runtime., C++ (vc++)

Language: Layout:

#include <iostream>
#include <cstdint>
  using std::uintptr_t;
#include <type_traits>

template<typename T>
uintptr_t addr_out(T* ptr) { return reinterpret_cast<uintptr_t>(ptr); }

struct S {
    int i;
    
    uintptr_t address() const { return addr_out(this); }
};

// -----

struct StandardBase {
    int i;

uintptr_t address() const { return addr_out(this); }
};

struct NonStandardDerived : StandardBase {
    virtual void f() {}

uintptr_t address() const { return addr_out(this); }
};

static_assert(std::is_standard_layout<StandardBase>::value, "Nyeh.");
static_assert(!std::is_standard_layout<NonStandardDerived>::value, ".heyN");

// -----

struct VBase {
    uintptr_t address() const { return addr_out(this); }
};
struct VDerived : virtual VBase {
    uintptr_t address() const { return addr_out(this); }
};

// -----

struct Base1 {
    int i;
    
    virtual uintptr_t address() const { return addr_out(this); }
    uintptr_t raw_address() { return addr_out(this); }
};

struct Base2 {
    short s;
    
    virtual uintptr_t address() const { return addr_out(this); }
    uintptr_t raw_address() { return addr_out(this); }
};

struct Derived : Base1, Base2 {
    bool b;
    
    uintptr_t address() const override { return addr_out(this); }
    uintptr_t raw_address() { return addr_out(this); }
};

// -----

#ifndef   HEX_OUT_H
#define   HEX_OUT_H

#include <type_traits>
#include <string>
#include <sstream>
#include <iomanip>
#include <climits>

namespace detail {
    constexpr int HEX_DIGIT_BITS = 4;
    
    template<typename T> struct is_char
      : std::integral_constant<bool,
                               std::is_same<T, char>::value ||
                               std::is_same<T, signed char>::value ||
                               std::is_same<T, unsigned char>::value> {};
}

template<typename T>
std::string hex_out_s(T val, bool disp0X = true) {
    using namespace detail;

std::stringstream sformatter;
    sformatter << std::hex
               << std::internal
               << (disp0X ? "0x" : "")
               << std::setfill('0')
               << std::setw(sizeof(T) * CHAR_BIT / HEX_DIGIT_BITS)
               << (is_char<T>::value ? static_cast<int>(val) : val);

return sformatter.str();
}

#endif // HEX_OUT_H

// -----

int main() {
    S s[2];
    
    std::cout << "\n---\nControl example: Two distinct instances of simple class.\n";
    std::cout << "s[0] address:\t\t\t\t\t"        << hex_out_s(addr_out(&s[0]))
              << "\n* s[0] this pointer:\t\t\t\t" << hex_out_s(s[0].address())
              << "\n\n";
    std::cout << "s[1] address:\t\t\t\t\t"        << hex_out_s(addr_out(&s[1]))
              << "\n* s[1] this pointer:\t\t\t\t" << hex_out_s(s[1].address())
              << "\n\n";
    
    // -----
    
    NonStandardDerived n;

std::cout << "Derived class with non-standard layout:"
              << "\n* n address:\t\t\t\t\t"                      << hex_out_s(addr_out(&n))
              << "\n* n this pointer:\t\t\t\t"                   << hex_out_s(n.address())
              << "\n* n this pointer (as StandardBase):\t\t"  << hex_out_s(n.StandardBase::address())
              << "\n* n this pointer (as NonStandardDerived):\t" << hex_out_s(n.NonStandardDerived::address())
              << "\n\n";
    
    // -----
    
    VDerived v;

std::cout << "Derived class with virtual base:"
              << "\n* v address:\t\t\t\t\t"              << hex_out_s(addr_out(&v))
              << "\n* v this pointer:\t\t\t\t"           << hex_out_s(v.address())
              << "\n* this pointer (as VBase):\t\t\t"    << hex_out_s(v.VBase::address())
              << "\n* this pointer (as VDerived):\t\t\t" << hex_out_s(v.VDerived::address())
              << "\n\n";

// -----
    
    Derived d;

std::cout << "Derived class with multiple inheritance:"
              << "\n  (Calling address() through a static_cast reference, then the appropriate raw_address().)"
              << "\n* d address:\t\t\t\t\t"               << hex_out_s(addr_out(&d))
              << "\n* d this pointer:\t\t\t\t"            << hex_out_s(d.address())                          << " (" << hex_out_s(d.raw_address())          << ")"
              << "\n* d this pointer (as Base1):\t\t\t"   << hex_out_s(static_cast<Base1&>((d)).address())   << " (" << hex_out_s(d.Base1::raw_address())   << ")"
              << "\n* d this pointer (as Base2):\t\t\t"   << hex_out_s(static_cast<Base2&>((d)).address())   << " (" << hex_out_s(d.Base2::raw_address())   << ")"
              << "\n* d this pointer (as Derived):\t\t\t" << hex_out_s(static_cast<Derived&>((d)).address()) << " (" << hex_out_s(d.Derived::raw_address()) << ")"
              << "\n\n";
}

Show compiler warnings [ + ] Compiler args [ + ] Show input
Compilation time: 2,02 sec, absolute running time: 1,48 sec, absolute service time: 3,51 sec