class A
{
public:
   void f1();
   void f2();
protected:
   void f3();
};

class B
{
protected:
   A* m_pA;
public:
// чтобы каким-нибудь макросом сгенерировались методы
   void f1() { return m_pA->F1(); };
   void f2() { return m_pA->F1(); };
// и притом только public - методы класса A
};

class B : public A
{
...
};

C>class A
C>{
C>public:
C>   void f1();
C>   void f2();
C>protected:
C>   void f3();
C>};

C>class B
C>{
C>protected:
C>   A* m_pA;
C>public:
C>// чтобы каким-нибудь макросом сгенерировались методы
C>   void f1() { return m_pA->F1(); };
C>   void f2() { return m_pA->F1(); };
C>// и притом только public - методы класса A
C>};
C>

class B
{
protected:
A* m_pA;
public:
const A* GetA() { return m_pA; }
};

class A
{
public:
   void f1();
   void f2();
protected:
   void f3();
};

class B : public A
{
protected:
//   A* m_pA;
public:
// чтобы каким-нибудь макросом сгенерировались методы
//   void f1() { return m_pA->f1(); };
//   void f2() { return m_pA->f2(); };
// и притом только public - методы класса A
};

C>>class A
C>>{
C>>public:
C>>   void f1();
C>>   void f2();
C>>protected:
C>>   void f3();
C>>};

C>>class B
C>>{
C>>protected:
C>>   A* m_pA;
C>>public:
EX>
EX>  A* operator->(){return m_pA;}
EX>
C>>// чтобы каким-нибудь макросом сгенерировались методы
C>>   void f1() { return m_pA->F1(); };
C>>   void f2() { return m_pA->F1(); };
C>>// и притом только public - методы класса A
C>>};
C>>

EX>например так

EX>тогда методы A будут вызываться через ->, а методы B через .

class A
{
public:
   void f1();
   void f2();
protected:
   void f3();
};

class B
{
protected:
   A* m_pA;
public:
operator A*() { return m_pA; }
};

class A
{
public:
    void f1();
    void f2();
};

class B
{
    OUTER_METHOD(meth_name);
protected:
    A* m_pA;
};

B::meth_name
{
    return m_pA->meth_name
}

////////////////////////////////////////////////////////////////////////////////

#include <iostream>

////////////////////////////////////////////////////////////////////////////////

// интерфейс 
struct some_interface
{
    virtual void foo() = 0;
    virtual void bar() = 0;
};

////////////////////////////////////////////////////////////////////////////////

// реализация интерфейса
struct some_interface_impl : some_interface
{
    void foo() { std::cout << "some_interface_impl::foo()\n"; }
    void bar() { std::cout << "some_interface_impl::bar()\n"; }
};

////////////////////////////////////////////////////////////////////////////////

// делегирует вызовы интерфейса члену
template<class Base, class Implementor, Implementor Base::*member>
struct redirect_some_interface_to_member : Base, some_interface
{
    void foo() { (this->*member).foo(); }
    void bar() { (this->*member).bar(); }
};

////////////////////////////////////////////////////////////////////////////////

// агрегат
class some_aggregate
{
private:
    // агрегирует реализацию
    some_interface_impl implementor_;

    // нужно, чтобы отложить взятие адреса члена внутри определения класса
    template<class T>
    struct some_aggregate_typedef
    {
        typedef redirect_some_interface_to_member
        <
            T,
            some_interface_impl,
            &T::implementor_
        > type;
    };

    friend struct some_aggregate_typedef<some_aggregate>;

public:
    typedef some_aggregate_typedef<some_aggregate>::type type;
};

////////////////////////////////////////////////////////////////////////////////

int main()
{
    some_aggregate::type a;

    a.foo();
    a.bar();

    return 0;
}

////////////////////////////////////////////////////////////////////////////////

class A
{
};

class B
{
   A* m_pA;
}