Vtable

Zaimplementuj w C++17 szablon funkcji inject, która, otrzymawszy dwa obiekty (możliwe, różnych klas) S i T, które implementują wspólny interfejs I, wykona taką manipulację tabelą wirtualnych metod (vtable) obiektu docelowego, aby wywołania metod interfejsu dla tego obiektu były realizowane przez obiekt przekazany jako źródło.

Jako rozwiązanie prześlij jeden plik nagłówkowy (z rozszerzeniem .h). Oto jego szablon:

#ifndef INJECT_H_INCLUDED
#define INJECT_H_INCLUDED

#include <cstddef>
#include <type_traits>

template <class I, class S, class T,
    typename std::enable_if<                // włącz ten szablon tylko jeśli:
        std::is_polymorphic<I>::value &&    // - I ma vtable
        std::is_base_of<I,S>::value &&      // - S implementuje I
        std::is_base_of<I,T>::value,        // - T implementuje I
    int>::type = 0>
void inject(S & source, T & target)
{
    // wstrzykuje implementację interfejsu I z source do target,
    // tak, aby wywołania metod I na target skutkowały ich
    // wywołaniem na source

    typedef ptrdiff_t * vtable;

}

#endif

Można założyć, że:

• kod będzie kompilowany kompilatorem g++ z ABI, zgodnym z wersją 4.7;

• I — to klasa, która ma tylko wirtualne metody (bez żadnych pól);

• I nie jest abstrakcyjna i ma publiczny konstruktor domyślny;

• klasy S i T są rzeczywistymi (faktycznymi) klasami obiektów source i target;

• klasy S i T wirtualnie (możliwe, pośrednio) dziedziczą od I;

• podobiekt klasy I nie jest ścisłym prefiksem żadnego podobiektu obiektów klas S ani T;

• vtable (tabela wirtualnych metod) klasy I nie jest ścisłym prefiksem vtable żadnego podobiektu obiektów klas S ani T.

Do wstępnych testów swojego rozwiązania możesz skorzystać z następującego programu w języku C++17:

#include <iostream>
#include "inject.h"
using namespace std;

struct F
{
    virtual void f() { }
};

void callf(F & f)
{
    f.f();
}

struct Dummy
{
    virtual void dummy() { }
};

struct A : Dummy, virtual F
{
    virtual void f() { cout << "A::f()" << endl; }
};

struct B : Dummy, virtual F
{
    virtual void f() { cout << "B::f()" << endl; }
};

A a;
B b;

int main()
{
    callf(a);
    callf(b);
    inject<F>(a, b);
    callf(a);
    callf(b);
    return 0;
}

Wynikiem powyższego programu powinno być:

A::f()
B::f()
A::f()
A::f()