Доступ к данным при наследовании

namespace Singl {
class CObs {};
 
template<typename T>
class A {
public:
    virtual ~A() { delete variables; }
    static T* Instance() {
        if(variables)
            return variables;
        else
            return new T();
    }
 
protected:
    static T* variables;
    A() {}
};
 
template<typename T>
T* A<T>::variables = nullptr;
 
 
class B : public A<B> {
protected:
    B() {}
    std::vector<int> data;
};
 
class C : public B {
public:
    void foo(CObs*) {
        auto a = variables->data;
    }
};
}

Singl::C::Instance();
    Singl::CObs obs;
    std::bind(&Singl::C::foo, Singl::C::Instance(), &obs)();

#include <iostream>
using namespace std;
 
// так как функции-члены на самом деле точно такие же "свободные функции"
// то технически, мы можем запустить функцию-член, не как метод класса
// а как самую обычную свободную функцию
// проиллюстрируем это:
 
 
struct Example
{
    // мы будем запускатьэтот метод не как метод, 
    // а как обычную свободную функцию
    void foo(int) { cout<<"Example::foo(int);\n"; }
};
 
int main()
{
    std::cout << "Hello, world!\n";
    
    typedef 
        void(*Free)(Example*, int);
    typedef 
        void(Example::*Method)(int);
    
    //для того, что бы запустить метод, как свободную функцию
    //нужно выполнить преобразования метода в свободную функцию
    
    Method m= &Example::foo;
    
    //для этого возьмем адрес функции-члена таким образом,
    //что бы компилятор забыл изначальный тип функции-члена
    //это позволит обойти защиту компилятора при некорректном 
    //с точки зрения компилятора преобразовании типов функции-члена к функции
    void* proxy = (void*)&m;
 
 
    //теперь извлекаем объект обратно, преобразовывая его тип к типу функции
    Free f = *((Free*)proxy);
    
    Example ex;
    
    
    //теперь, если наша теория верна, мы можем запустить функцию, 
    //передав первым аргументом тот самый "не видимый" параметр this
    //а следом все прочие аргуметы
    f(&ex,10);  
}

class A
{
protected:
    int a;
};
 
class B : public A
{
public:
    void foo(A * p)
    {
        this->a = 10; // подобъект базового класса
        p->a = 11;    // черт знает кто
    }
};

template <typename T>
class Singleton
{
public:
    static T & Instance() 
    {
        static T instance;
        return instance;
    }
 
protected:
    Singleton() {}
};

class С : public Singleton<С>
{
//...........
};

template <typename T>
class B : public Singleton<T>
{
};
 
class C : public B<C>
{
};

Singl::C::Instance(); // создали объект 
Singl::C::some_method(); // этот метод от интерфейса пришел к нам, но его не получится так вызвать т.к. виртуальный
Singl::C c;
c.some_method();    //но так сделать не можем т.к. конструктор не публичный у C(чтобы нельзя было сколько угодно создавать объектов)

#include <memory>
#include <iostream>
 
template <typename T>
class Singleton 
{
public:
    template <typename Policy>
    static T & instance() 
    {
        static T instance(std::make_unique<Policy>());
        return instance;
    }
 
protected:
    Singleton() {}
    
    Singleton(Singleton const &);
    Singleton & operator=(Singleton const &);
};
 
class BasePolicy
{
public:
    // interface
    
    virtual void foo() = 0;
};
 
 
class B : public Singleton<B>
{
public:
    explicit B(std::unique_ptr<BasePolicy> p)
        : m_policy(std::move(p))
    { }
    
    // proxy interface
    
    void foo()
    {
        m_policy->foo();
    }
    
private:
    std::unique_ptr<BasePolicy> m_policy;
};
 
class C : public BasePolicy
{
public:
    void foo()
    {
        std::cout << "foo\n";
    }
};
 
int main()
{
    B & inst = B::instance<C>();
    
    inst.foo();
}

class C : public BasePolicy
{
    friend B & Singleton<B>::instance<C>();
public:
    void foo()
    {
    }
    
private:
    C() {}
};