Vtable

Реализуйте в C++17 шаблон функции inject, которая, получив два объекта (возможно, разных классов) S и T, реализующих общий интерфейс I, выполнит такую манипуляцию таблицей виртуальных методов (vtable) объекта-цели, чтобы вызовы методов интерфейса для этого объекта осуществлялись через объект, переданный как источник.

Как решение отправьте один заголовочный файл (с расширением .h). Вот его шаблон:

#ifndef INJECT_H_INCLUDED
#define INJECT_H_INCLUDED

#include <cstddef>
#include <type_traits>

template <class I, class S, class T,
    typename std::enable_if<                // включить этот шаблон только если:
        std::is_polymorphic<I>::value &&    // - I имеет vtable
        std::is_base_of<I,S>::value &&      // - S реализует I
        std::is_base_of<I,T>::value,        // - T реализует I
    int>::type = 0>
void inject(S & source, T & target)
{
    // внедряет реализацию интерфейса I из source в target,
    // так что вызов методов I на target приведет к их
    // вызову на source

    typedef ptrdiff_t * vtable;

}

#endif

Можно предположить, что:

• код будет компилироваться компилятором g++ с ABI, совместимым с версией 4.7;

• I — это класс, который имеет только виртуальные методы (без каких-либо полей);

• I не является абстрактным и имеет публичный конструктор по умолчанию;

• классы S и T являются фактическими (реальными) классами объектов source и target;

• классы S и T виртуально (возможно, опосредованно) наследуют от I;

• подобъект класса I не является строгим префиксом ни одного подобъекта объектов классов S или T;

• vtable (таблица виртуальных методов) класса I не является строгим префиксом vtable ни одного подобъекта объектов классов S или T.

Для предварительных тестов своего решения вы можете воспользоваться такой программой на языке 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;
}

Результатом приведенной выше программы должно быть:

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