Jaki kompilator - zgodny z visual studio 2005

[salmon]

Ok z mojej strony eot

Z mojej też

[PremierDix]

1 pytanko o co chodzi z tą klasą pochodną B?? czy tam nie powinnien być "prostokąt" zamiast "prostokątna"??

klasa pochodna A powinna reprezentować falę piłokształtną a klasa pochodna B - falę prostokątną

[dawideo]

Też tak myślałem że chodzi o tzry osobne przebiegi . W sumie mógłnym się skontaktować z wykładowcą na zajęciach ale to by było 15 grudnia:P straciłbym sporo czasu czekając do tego pięknego dnia

[ Dodano: 2007-11-30, 21:33 ]
Witam ponownie. Już napisałem program Ale martwi mnie jedno. Prowadzący zaznaczył że dziedziczenia ma być NIETRYWIALNE (co kolwiek to znaczy), po skontaktowaniu się z nim i prośbie wytłumaczenia co dla niego znaczy nietrywialnie. Odpowiedział:
"Dziedziczenie nie ma być banalne"
i na tym się skączyło.
Zwracam się z prośbą może ktoś mi doradzi co bym mógł zmienić w kodzie aby te dziedziczenie nie było trywialne. No chyba żenic nie trzeba zmieniac :P
A oto mój kod (pisany niestety spod Windows z wiadomych przyczyn)

Kod: Zaznacz cały

#include <iostream.h>
#include <conio.h>
#include <math.h>

// Klasa bazowa - Fala
class Fala
{
protected:                                 //sekcja chroniona
        double y_max, y_min, H_fal;
public:                                     //sekcja publiczna
        Fala()                              //Pierwszy konstruktor domyslny (0,0)
        {
                y_max=0;
                y_min=0;
        };
        Fala (double yy_max, double yy_min):y_min(yy_min), y_max(yy_max) //drugi konstruktor
        {
                H_fal = y_max - y_min;
        };

        ~Fala(){};   //destruktor

        //Funkcje wirtualne
        virtual void Wypisz();

        //funkcje zaprzyjaźnione
        friend Fala operator*(Fala, Fala);
        friend Fala operator/(Fala, Fala);
};


//Klasa pochodna - Piła
class Pila:Fala
{
private:                            //sekcja prywatna
        double y_max2, y_min2, H_pi;
public:                            //sekcja publiczna
        Pila()              //pierwszy konstruktos
        {
        y_max2 = y_max;
        y_min2=y_min;
        };

        Pila(double yy_max,double yy_min):Fala(yy_max,yy_min) //drugi konstruktor
        {
        y_max2=2*y_max;
        y_min2= (y_min/2);
        H_pi= y_max2-y_min2;
        };

        ~Pila(){};     //destruktor

        //Funkcje wirtualne
        virtual void Wypisz();

        //Funkcje zaprzyjaźnione
        friend Pila operator*(Pila, Pila);
        friend Pila operator/(Pila, Pila);
        };
//Klasa pochodna - Prostokąt
class Prostokat:Fala
{
private:                                             //sekcja prywatna
        double y_max2, y_min2, y_max3, y_min3, H_pr;
public:                                              //sekcja publiczna
        Prostokat()
        {
        y_max3 = y_max;
        y_min3=y_min;
        };
        Prostokat (double yy_max, double yy_min):Fala(yy_max, yy_min) //drugi konstruktor
        {

        y_max3= 3*y_max;
        y_min3= y_min/3;
        H_pr=y_max3-y_min3;
        };

        ~Prostokat(){};       //destruktor

        //Funkcje wirtualne
        virtual void Wypisz();

        //Funkcje zaprzyjaźnione
        friend Prostokat operator*(Prostokat, Prostokat);
        friend Prostokat operator/(Prostokat, Prostokat);
};

//Przeładowanie '*' dla Fala
Fala operator*(Fala a, Fala b)
{
Fala nowy;
double nowa_H;
nowy=(a.H_fal)*(b.H_fal);
nowy.H_fal=nowa_H;
return nowy;
}

//Przeładowanie '/' dla Fala
Fala operator/(Fala a, Fala b)
{
Fala nowy;
double nowa_H;
nowa_H=(a.H_fal)*(b.H_fal);
nowy.H_fal=nowa_H;
return nowy;
}
//Przeładowanie '*' dla Pila
Pila operator*(Pila a, Pila b)
{
Pila nowy;
double nowa_H;
nowa_H=(a.H_pi)*(b.H_pi);
nowy.H_pi=nowa_H;
return nowy;
}

//Przeładowanie '/' dla Pila
Pila operator/(Pila a, Pila b)
{
Pila nowy;
double nowa_H;
nowa_H=(a.H_pi)/(b.H_pi);
nowy.H_pi=nowa_H;
return nowy;
}


//Przeładowanie '*' dla Prostokat
Prostokat operator*(Prostokat a, Prostokat b)
{
Prostokat nowy;
double nowa_H;
nowa_H=(a.H_pr)*(b.H_pr);
nowy.H_pr=nowa_H;
return nowy;
}


 //Przeładowanie '/' dla Prostokąt
Prostokat operator/(Prostokat a, Prostokat b)
{
Prostokat nowy;
double nowa_H;
nowa_H=(a.H_pr)/(b.H_pr);
nowy.H_pr=nowa_H;
return nowy;
}

int main()
{
Fala A (4,4);          //obiekty klasy Fala
Fala B (13,2);
Fala C;

Pila A2 (6,4);          //obiekty klasy pila
Pila B2 (8,2);
Pila C2;

Prostokat A3 (9,9);    //obiekty klasy prostokat
Prostokat B3 (9,9);
Prostokat C3;


A.Wypisz();
cout<<"\n" ;
B.Wypisz();
cout<<"\n";
C= A*B;
C.Wypisz();
cout<<"\n";
C= A/B;
C.Wypisz();
cout<<"\n";

A2.Wypisz();
cout<<"\n" ;
B2.Wypisz();
cout<<"\n";
C2= A2*B2;
C2.Wypisz();
cout<<"\n";
C2= A2/B2;
C2.Wypisz();
cout<<"\n";

A3.Wypisz();
cout<<"\n" ;
B3.Wypisz();
cout<<"\n";
C3= A3*B3;
C3.Wypisz();
cout<<"\n";
C3= A3/B3;
C3.Wypisz();
cout<<"\n";

        getch();
return 0;
}


void Fala::Wypisz()                        //Funkcje wyswietlajace wyniki dla poszczegolnych klas
{
cout<<"Dane fali: ("<<y_max<<","<<y_min<<")"<<endl;
cout<<"Wysokosc fali:"<<H_fal<<endl;
}

void Pila::Wypisz()
{
cout<<"Dane pily: ("<<y_max2<<","<<y_min2<<")"<<endl;
cout<<"Wysokosc piły:"<<H_pi<<endl;
}

  void Prostokat::Wypisz()
{
cout<<"Dane prostokatu: ("<<y_max3<<","<<y_min3<<")"<<endl;
cout<<"Wysokosc prostokątu:"<<H_pr<<endl;

}