if (cstr_)
      valueAllocator()->releaseMemberName( const_cast<char *>(cstr_);

S>if (cstr_)
S>      valueAllocator()->releaseMemberName( const_cast<char *>(cstr_);
S>

void* vfptr = *reinterpret_cast<void**>(valueAllocator());
if ( isValidVfptr(vfptr) ) // для проверки указателя можно запоминать его корректное значение.
  valueAllocator()->releaseMemberName( const_cast<char *>(cstr_);
else
  // oops... allocator is dead now...

struct Base
{
    virtual void foo();
};
struct Derived : Base
{
    virtual void foo() /*override*/;
};

int main()
{
    void (Base::*pf)() = &Base::foo;
    Derived d;
    (d.*pf)(); // вызовется Derived::foo
}

struct Foo { virtual ~Foo() {} }; // покажем, что у Foo есть виртуальные методы в принципе
// для джигитов: можно вообще сделать предобъявление - тогда вызов будет предельно обобщённым
struct Foo;

// чтоб компилятор не вздумал инлайнить
extern Foo* object;
extern void (Foo::*method)();

int main()
{
    (object->*method)();
}

tempvar = -4                        ; size = 4
_main    PROC
; 7    : {

    push ebp
    mov ebp, esp
    push ecx ; зарезервировали место для локальной переменной tempvar[ebp]

; 8    :     (object->*method)();

    cmp    DWORD PTR ?method+12, 0     ; это указатель на виртуальную функцию?
    jne    SHORT $LN3@main
                                    ; нет, на обычную
    mov    eax, DWORD PTR ?object      ; взяли адрес объекта
    add    eax, DWORD PTR ?method+4    ; прибавили смещение базы из указателя
    mov    DWORD PTR tempvar[ebp], eax ; запомнили адрес базы
    jmp    SHORT $LN4@main             ; и пошли вызывать

$LN3@main:                          ; а вот указатель на виртуальную функцию...

    mov    ecx, DWORD PTR ?object      ; берём указатель на объект
    add    ecx, DWORD PTR ?method+8    ; + смещение до vfptr = указатель на vfptr
    mov    edx, DWORD PTR ?object      ; компилятор зачем-то продублировал... ну, его дело
    add    edx, DWORD PTR ?method+8    ; = указатель на vfptr
    mov    eax, DWORD PTR [edx]        ; = vfptr
    mov    edx, DWORD PTR ?method+12   ; = индекс метода в таблице
    add    ecx, DWORD PTR [eax+edx]    ; = смещение виртуальной базы (если есть) - первый элемент vtbl
    add    ecx, DWORD PTR ?method+4    ; + смещение базы
    mov    DWORD PTR tempvar[ebp], ecx ; = адрес искомой базы

$LN4@main:
    mov    ecx, DWORD PTR tempvar[ebp]
    call    DWORD PTR ?method       ; вызвали метод (или диспетчер виртуальных методов)

; 9    : }

    xor    eax, eax
    mov    esp, ebp
    pop    ebp
    ret    0
_main    ENDP

struct X
{
    int x;
    void foo();
};
struct Y : X
{
    int y;
    virtual void bar();
    void buz();
};
struct Z : Y
{
    int z;
    void xyz();
};

ptrdiff_t delta(void const* a, void const* b) { return (char const*)a - (char const*)b; }

int main()
{
    Z z;
    ptrdiff_t dyz = delta(&z, &(Y&)z); // 0
    ptrdiff_t dxz = delta(&z, &(X&)z); // 4
    
    Y y;
    ptrdiff_t dxy = delta(&y, &(X&)y); // 4

    void (Y::*method)();
    
    method = &Y::buz; // method.base = 0
    (z.*method)(); // сперва приводим Z& к Y&, это +0, затем из method +0, получаем корректный вызов ((Y&)z).buz()
    
    method = &X::foo; // method.base = 4
    (z.*method)(); // Z& -> Y& +0, из method берём Y& -> X& +4, получаем корректный вызов ((X&)(Y&)z).foo()
}