Mój problem wyglada tak że potrzebuje stworzyć dwie klasy w której jedna będzie dziedziczyła publicznie po drugiej. Wenatrz zdefiniowanych klas musze umiescic operatory zgodne z klasa na ktora pracuja ( np dzialanie ojciec+ojciec wywoluje operator ojca, a syn+syn operator syna). Wszystko byloby cacy gdybym mogl pracować na obiektach tych klas. W poleceniu widnieje że mogę zdefiniować sobie jedynie wskaznik do klasy macierzystej i za pomoca operatora new tworzyc sobie obiekt jaki na dany moment potrzebuje ( oszczędnosc pamięci ). Pomyslalem ze moglbym uzyc operatora wirtualnego przy operatorze w macierzystej ale co mi to da jezeli operatory i tak przyjmuja inne wartosci. Pomozcie bo juz zglupialem i nie moge sie tego nigdzie po ksiazkach i forach doszukac.

Zamieszczam kod:
ojciec.h

#pragma once

class ojciec
{
int wiek_ojca;
public:
virtual void zrob_cos();
virtual int JegoWiek(){return(wiek_ojca);}
virtual void UstawWiek(int nowy){wiek_ojca=nowy;}
virtual const ojciec operator+(const ojciec &) const;
ojciec(void);
virtual ~ojciec(void);
};
ojciec::ojciec(void)
{
wiek_ojca=10;
cout<<"tworze ojca"<<endl;
}

ojciec::~ojciec(void)
{
}
void ojciec::zrob_cos(){
cout<<"Jestem ojcem"<<endl;
}
const ojciec ojciec::operator +(const ojciec &other) const{
ojciec result = *this;
ojciec drugi = other;

result.UstawWiek((result.JegoWiek()+drugi.JegoWiek()));
return (result);
}

syn.h

#pragma once
#include "ojciec.h"

class syn : public ojciec
{

int wiek_syna;

public:
int JegoWiek(){return(wiek_syna);}
void UstawWiek(int nowy){wiek_syna=nowy;}
virtual const syn operator+(const syn &other) const;
void zrob_cos();
syn(void);
~syn(void);
};
syn::syn(void)
{
wiek_syna=6;
cout<<"tworze syna"<<endl;
}

syn::~syn(void)
{
}
void syn::zrob_cos(){

cout<<"jestem synem"<<endl;
}

const syn syn::operator+(const syn &other) const{
syn result = *this;
syn drugi = other;

result.UstawWiek((result.JegoWiek()+drugi.JegoWiek()));
return (result);

}

main.cpp

#include "stdafx.h"
#include <iostream>
#include "ojciec.h"
#include "syn.h"
using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{

{
ojciec *jeden,*dwa,*trzy;
jeden=new ojciec;
dwa=new ojciec;
trzy=new ojciec;
*trzy=(*jeden+*dwa); // zostaje wywolany operator ojca czyli tak
cout<<trzy->JegoWiek(); // jak byc powinno
cout<<endl<<"Nastepne dzialanie";
}

{
ojciec *jeden,*dwa,*trzy;
jeden=new syn;
dwa=new syn;
trzy=new syn;
*trzy=(*jeden+*dwa); // tutaj zostaje wywolany znow operator ojca
cout<<trzy->JegoWiek(); // zamiast przeciazanego operatora wewnatrz klasy syn
}

return 0;
}