унаследование, как реализовать?

class TParent
{
     TSon* son1;
     TSon* son2;
     TSon* son3;
};

#include <iostream>
 
class TParent
{
protected:
    TParent* p;
    
public:
    TParent(TParent* ptr = NULL)
        : p(ptr) {}
    
    virtual void run()
    {
        p->run();
    }
};
 
class TSon: public TParent
{
public:
    TSon() {}
    
    void run()
    {
        std::cout << "In TSon" << std::endl;
    }
};
 
int main()
{
    TSon son;
    TParent parent(&son);
    parent.run();
    return 0;
}

TParent(TParent* ptr = NULL) : p(ptr) {}

class TSon;
class TParent {
    TSon *s1, *s2, *s3;
};
 
class TSon: public TParent {};

 //  program.h
class TSon;
class TParent {
public:
    TParent(TSon* son): s(son) {}
    void foo();
private:
    TSon *s;
};
 
class TSon: public TParent {
public:
    TSon(TSon* son): TParent(son) {}
    void bar();
};
 
//  program.cpp
void TParent::foo()
{
    s->bar();
}

class TSon;
class TParent {
public:
    TParent(TSon* son): s(son) {}
    void foo();
private:
    TSon *s;
};
 
 //метод не после описания производного
 //  program.cpp
void TParent::foo()
{
    s->bar();
}
 
 
class TSon: public TParent {
public:
    TSon(TSon* son): TParent(son) {}
    void bar(){}
};

#include <iostream.h>
#include <conio.h>
class TSon;
class TParent
{
    public:
    TSon *son;
    int test_number ;
};
 
class TSon: public TParent
{
        public:
        void print(int i)
        {
                test_number = i;
                cout << test_number << endl;
        }
};
int main()
{
        TParent* parent = new TParent();
        TSon* _son = new TSon();
        parent->son = _son;
        parent->son->print(16);
        getch();
        return 0;
}