Witam,
mam pewne zadanie, które nie rozumiem do końca. Chciałbym sie Państwa dopytać o parę szczegółów:
Moje zadanie z programowania brzmi tak:
Zmodyfikuj plik dziedziczenie.cpp tak, aby:
* kompilowal się bez ostrzeżeń,
* działał poprawnie i efektywnie czyli m.in.:
o odpowiednio inicjował klasę podstawową i składową, //1 pkt
o nie tworzył obiektów tymczasowych gdy nie jest to konieczne,
o umożliwiał przesyłanie obiektów stałych/tymczasowych tam gdzie to jest możliwe/celowe. //3 pkt
dziedziczenie.cpp
// Test dziedziczenia: konstruktor, destruktor, operator przypisania.
// Pawel Pilarczyk, 22.04.2004 (wersja II).
// Modyfikacja: Tomasz Kapela, 10.04.2005
#include <cstdlib>
#include <iostream>
using std::cout;
using std::endl;
class podstawowa
{
public:
int liczba;
podstawowa () : liczba(0) {
cout << "Konstruktor domyslny z klasy podstawowej.\n";
}
podstawowa (int w) : liczba(w) { //TU
cout << "Konstruktor specjalny z klasy podstawowej.\n";
}
podstawowa (podstawowa &wzor) : liczba(wzor.liczba) {
cout << "Konstruktor kopiujacy z klasy podstawowej.\n";
}
podstawowa &operator= (podstawowa wzor) {
cout << "Operator przypisania z klasy podstawowej.\n";
liczba = wzor. liczba;
return *this;
}
~podstawowa () {
cout << "Destruktor z klasy podstawowej: liczba = " << liczba << ".\n";
}
}; /* podstawowa */
class skladowa
{
public:
bool wartosc;
skladowa () : wartosc(false) {
cout << "Konstruktor domyslny z klasy skladowej.\n";
}
skladowa (bool w) : wartosc(w) {
cout << "Konstruktor specjalny z klasy skladowej.\n";
}
skladowa (skladowa wzor) : wartosc(wzor.wartosc) {
cout << "Konstruktor kopiujacy z klasy skladowej.\n";
}
skladowa &operator= (skladowa wzor) {
cout << "Operator przypisania z klasy skladowej.\n";
wartosc = wzor.wartosc;
return *this;
}
~skladowa () {
cout << "Destruktor z klasy skladowej: justowanie = " << wartosc << ".\n";
}
}; /* skladowo */
class pochodna: public podstawowa
{
public:
char znak;
skladowa justowanie;
pochodna () : znak('!') {
cout << "Konstruktor domyslny z klasy pochodnej.\n";
}
// pomimo tej kolejnosci na liscie inicjalizacyjnej
// najpierw wywola sie konstruktor klasy podstawowej
pochodna (int w, char z, bool j): znak(z) {
cout << "Konstruktor specjalny z klasy pochodnej.\n";
}
pochodna (pochodna & wzor) : znak(wzor. znak) {
cout << "Konstruktor kopiujacy z klasy pochodnej.\n";
}
pochodna &operator= (pochodna wzor) {
cout << "Operator przypisania z klasy pochodnej.\n";
justowanie = wzor.justowanie;
znak = wzor. znak;
return *this;
}
~pochodna () {
cout << "Destruktor z klasy pochodnej: liczba = " << liczba
<< ", znak = '" << znak << "', justowanie = " << justowanie.wartosc << "\n";
}
}; /* pochodna */
// Prosze sprawdzic co sie stanie jezeli nie uzyjemy referencji przy 'p'
std::ostream &operator << (std::ostream &str, pochodna p){
if(p.justowanie.wartosc)
str << p.liczba << p.znak;
else
str << p.znak << p.liczba;
return str;
}
void testuj (void) {
pochodna x (13, '%', true);
cout << "x = " << x << endl;
cout << "----------------------------------------------------------\n";
{
pochodna y (x);
cout << "y = " << y << endl;
}
cout << "----------------------------------------------------------\n";
{
podstawowa z (x);
cout << "z = " << z. liczba << endl;
}
cout << "----------------------------------------------------------\n";
return;
} /* testuj */
int main (void) {
cout << "Test dziedziczenia konstruktora, destruktora i opeartora=.\n";
cout << "----------------------------------------------------------\n";
testuj ();
cout << "----------------------------------------------------------\n";
return 0;
} /* main */
//==============================================/
Nie chodzi mi o to, by rozwiązać to zadanie, ale o to by z Państwem podzielić się paroma pytaniami, na które nie mogłem odnaleźć odpowiedzi w sieci
Otóż moje pytania:
- Co to za dziwna deklaracja nazwaklasy() : coś() { // definicja klasy} (jak TU)
- Co myślicie o punkcie 3?? Bo ja tego nie rozumiem, o co chodzi;
Z góry dzięki za odpowiedzi:D