Dziedziczenie operatorów

Witam
Mam problem ze zrozumieniem dziedziczenie przeładowanych operatorów.

W przykładowym programie mam klasę:

 
class cwiczenie
{
    public:
    int a;
    float b;
    string d;
public:
    cwiczenie();
    cwiczenie(int a,float b,string d);
    friend ostream& operator<<(ostream& os, const cwiczenie& c)
{
    os << c.a << '/' << c.b << '/' << c.d;
    return os;
}

cwiczenie operator+(const cwiczenie &p)
{
    cwiczenie temp;
    temp.a=a+p.a;
    temp.b=b+p.b;
    temp.d=d+" "+p.d;


    return temp;
}


};
cwiczenie::cwiczenie ()
{
    a=10;
    b=5.2;
    d="jpeg";
}
cwiczenie::cwiczenie(int f,float g,string h)
{
    a=f;
    b=g;
    d=h;
}

oraz klasę dziedziczącą z niej:

 

class pochodna:public cwiczenie
{
    public:
        int k;
    pochodna(int j,int k,string l,int l):cwiczenie(a,b,d)
    {
       k=l;
    }
    pochodna():cwiczenie()
    {
       k=0;
    }
 
 
 
 
friend ostream & operator <<(ostream & os, const pochodna & x )
{
    os << reinterpret_cast < const cwiczenie &>( x );
    os << "k = " << x.k <<endl;
    return os;
};

Nie rozumiem jak korzystać z odziedziczonych operatorów,jeśli klasa pochodna jest rozszerzona o zmienne,ktorych nie posiada klasa bazowa.

Udało mi się wyszukać w internecie rozwiązanie problemu z operatorem << i faktycznie w ten sposób działa,ale jak rozwiązać problem z operatorem+,żeby dodawał również zmienne "k",których brak w klasie bazowej,bez ponownego deklarowania operatora?

Z góry dzięki za poświęcony czas i odpowiedź

Jak chcesz korzystać ze zmiennych klasy to musisz wiedzieć, że z obiektem jej typu masz do czynienia.

Jak na razie wkleiłeś kod, który się albo nie kompiluje, albo robi nie to co chciałeś (jeśli masz zmienne globalne o nazwach a, b i d o odpowiednich typach)

funkcja main wygląda następująco:

 
int main()
{
    cwiczenie c1,c3;
    cwiczenie c2(45,5.6,"ok");
    c3=c1+c2;
    cout<<c3;
    pochodna p1,p2,p3;
     p1.k=123;
     p2.k=23;
     p3=p1+p2;


    cout<<p1<<endl;




    return 0;
}

W linii p3=p1+p2 kompilator pokazuje taki błąd:
//error: no match for 'operator=' in 'p3 = cwiczenie::operator+(const cwiczenie&)(((const cwiczenie)(& p2.pochodna::<anonymous>)))'|

Chciałbym rozszerzyć dla klasy pochodnej operator+ dziedziczony z klasy bazowej o zmienną int k,którą dopisałem w klasie pochodnej.Nie mam żadnych zmiennych globalnych.

Pokaż cały kod bo w tym co pokazałeś nie ma wzmianki o cwiczenie::operator+

Jest,zadeklarowałem go wewnątrz klasy cwiczenie

#include <iostream>


using namespace std;

class cwiczenie
{
    public:
    int a;
    float b;
    string d;
public:
    cwiczenie();
    cwiczenie(int a,float b,string d);
    friend ostream& operator<<(ostream& os, const cwiczenie& c)
{
    os << c.a << '/' << c.b << '/' << c.d;
    return os;
}

cwiczenie operator+(const cwiczenie &p)
{
    cwiczenie temp;
    temp.a=a+p.a;
    temp.b=b+p.b;
    temp.d=d+" "+p.d;


    return temp;
}


};
cwiczenie::cwiczenie ()
{
    a=10;
    b=5.2;
    d="jpeg";
}
cwiczenie::cwiczenie(int f,float g,string h)
{
    a=f;
    b=g;
    d=h;
}
class pochodna:public cwiczenie
{
    public:
        int k;
    pochodna(int j,int k,string l,int g):cwiczenie(a,b,d)
    {
        k=g;
    }
    pochodna():cwiczenie()
    {
       k=0;
    }




friend ostream & operator <<(ostream & os, const pochodna & x )
{
    os << reinterpret_cast < const cwiczenie &>( x );
  //  os << "jp = " << x.jp <<endl;
    return os;
}

};
int main()
{
    cwiczenie c1,c3;
    cwiczenie c2(45,5.6,"ok");
    c3=c1+c2;
    cout<<c3;
    pochodna p1,p2,p3;
     p1.k=123;
     p2.k=23;
     p3=p1+p2;//error: no match for 'operator=' in 'p3 = cwiczenie::operator+(const cwiczenie&)((*(const cwiczenie*)(& p2.pochodna::<anonymous>)))'|


    cout<<p1<<endl;




    return 0;
}

 

Dobra, zmyliło mnie formatowanie (polecam http://format.krzaq.cc jeśli to dla Ciebie problem)

Tak jak napisałem, powinieneś przeładować dla pochodna w tym przypadku

Czyli muszę od Nowa przeladowac operator zawierajac w nim jeszcze raz zmienne klasy bazowej? Nie da się w jakiś sposób odwołać do operatora z klasy bazowej dodając tylko to co doszło w pochodnej?

Dla idiomatycznego operatora += to by miało sens, ale tutaj zwracasz nowy obiekt, więc nie bardzo.

Dzięki wielkie. Ostatnie pytanie

Jeżeli w ten sposób zadeklaruje operator +=

cwiczenie &operator+=(const cwiczenie &p) {
  this->a += p.a;
  this->b += p.b;
  this->d += " " + p.d;

  return *this;
} 

to w jaki sposób mogę się do niego odwołać w klasie pochodnej?

pochodna & operator+=(const pochodna &p)
{

//co tu dodac?
    this->k+=p.k;
    return *this;
}
 

pochodna & operator+=(const pochodna &p)
{
    static_cast<cwiczenie&>(*this) += p;
    this->k+=p.k;
    return *this;
}

Tak swoją drogą, polecam lekturę: http://en.cppreference.com/w/cpp/language/operators (tutaj w szczególności implementacja operatora @ w oparciu o @=)