1.
class Samolot { public:  float paliwo;  float dystans;  float x, y, z;  float wysokosc; };

int main(int argc, char *argv[]) {


 Samolot s1;  s1.dystans = 10;  zad5(s1);  Samolot s2 = s1;  zad5(s2);  Samolot s3(s2);  zad5(s3);  Samolot *s4 = new Samolot;  (*s4).dystans = 15;  zad5(*s4); (*s4).~Samolot();  return 0; }

Z powyższego kodu wynika:
- konstruktor bezargumentowy utworzyl sie sam - konstruktor wieloargumentowy nie utworzyl sie sam - konstruktor kopiujacy utworzyl sie sam - operator przypisania utworzyl sie sam - destruktor utworzyl sie sam

2.
Samolot(float paliwo, float dystans, float x, float y, float z, float wysokosc) {   this->paliwo = paliwo;   this->dystans = dystans;   this->x = x;   this->y = y;   this->z = z;   this->wysokosc = wysokosc;  }
- konstruktur bezargumentowy nie utworzyl sie sam - tworzy sie wtedy, gdy nie jest zdefiniowany zaden konstuktor





3.
Samolot() = default
Reszta zadania została wykonana już wcześniej (poprzednie punkty)
- konstruktor kopiujacy utworzyl sie sam - konstruktor przenoszacy nie utworzyl sie sam - operator przypisania utworzyl sie sam - destruktor utworzyl sie sam

4.
Już w punkcie 1 zostało pokazane istnienie destruktora wygenerowanego automatycznie
5.

void zad5(Samolot samolot) {  std::cout << "Dystans: " << samolot.dystans << std::endl;  std::cout << "Paliwo: " << samolot.paliwo << std::endl;  std::cout << "wysokosc: " << samolot.wysokosc << std::endl;  std::cout << std::endl; }

Zaimplementowanie funkcji nie zmieniło stanu z poprzednich zadań.
6.
Samolot zad6(Samolot samolot, float korekta) {  Samolot s = samolot;  s.wysokosc -= korekta;  return s; }
Zaimplementowanie tej funkcji również nie zmieniło stanu z poprzednich zadań
7.
int main(int argc, char *argv[]) {


 Samolot s1(10, 20, 30, 40, 50, 60);  Samolot s2;  s1 = s2;  zad5(s1);  zad5(s2);

 return 0; }
kod ten wyrzuca błąd – uninitialized local variable ‘s2’ used. Natomiast po zaimplementoaniu (przeciążeniu domyślnego) operatora przypisania:



Samolot &operator=(const Samolot &s) {   if (this != &s) {
   this->paliwo = s.paliwo;    this->dystans = s.dystans;    this->x = s.x;    this->y = s.y;    this->z = s.z;    this->wysokosc = s.wysokosc;   }   else     return *this; }

Atrybuty obiektu s1 przyjmuja śmieciowe wartości (takie same jak obiektu s2)

8.
class Samolot { public:  float paliwo;  float dystans;  float wysokosc; private:  float x;  float y;  float z; public:  inline float getX() {   return x;  }  inline float getY() {   return y;  }  inline float getZ() {   return z;  }  Samolot(float paliwo, float dystans, float x, float y, float z, float wysokosc);  Samolot() = default;  Samolot &operator=(const Samolot &s); };

int main(int argc, char *argv[]) {


 Samolot s1(10, 20, 30, 40, 50, 60);  Samolot s2 = s1;  std::cout << s2.getX() << ", " << s2.getY() << ", " << s2.getZ() << std::endl;

 return 0; }
Atrybuty x,y,z obiektu s2 przyjely wartości odpowiednio 30, 40 i 50.




9.
class Samolot { public:  float paliwo;  float dystans;  float wysokosc;  float x;  float y;  float z;  char *sygnatura;

 Samolot(float paliwo, float dystans, float x, float y, float z, float wysokosc, char *syg);  Samolot() = default; };
Samolot::Samolot(float paliwo, float dystans, float x, float y, float z, float wysokosc, char *syg) {  this->paliwo = paliwo;  this->dystans = dystans;  this->x = x;  this->y = y;  this->z = z;  this->wysokosc = wysokosc;  sygnatura = new char[strlen(syg) + 1];  strcpy_s(sygnatura, strlen(syg) + 1, syg); }

Przetestowane dla:
int main(int argc, char *argv[]) {


 Samolot s1(10, 20, 30, 40, 50, 60, "test");  Samolot s2;  s2 = s1;  Samolot s3(s2);  Samolot *s4 = new Samolot;  (*s4).~Samolot();

 return 0; }
Widzimy, że nic się nie zmieniło względem punktu 1.

10.
Po dodaniu stałego pola w klasie, nic się nie zmienia poza tym, że nie generuje się domyślny operator przypisania.





11.
class Silnik { public:  bool stan;  int szybkosc;  int identyfikator; private:  Silnik &operator=(const Silnik &sil); };

Silnik &Silnik::operator=(const Silnik &sil) {  if (this != &sil) {   this->stan = sil.stan;   this->szybkosc = sil.szybkosc;   this->identyfikator = sil.identyfikator;  }  else   return *this; }
Konstruktor bezargumentowy generuje się automatycznie, kopiujący tak samo. Destruktor również wygenerował się automatycznie, natomiast jako, że przeciążyliśmy domyślny operator przypisania, ale jest on prywatny, nie mamy możliwości jego użycia (poza klasa).
12.
class Samolot { public:  float paliwo;  float dystans;  float wysokosc;  float x;  float y;  float z;  char *sygnatura;  const int masa = 100;  Silnik psilnik; };

Po dodaniu obiektu klasy Silnik do klasy Samolot, konstruktor kopiujący w dalszym ciągu generuje się automatycznie, podobnie konstruktor bezargumentowy, oraz destruktor.
W dalszym ciągu konstruktor wieloargumentowy nie generuje się automatycznie, tak jak operator przypisania

13.
class Radio { public:  bool stan;  int kanal; };



14.
class Samolot { public:  float paliwo;  float dystans;  float wysokosc;  float x;  float y;  float z;  char *sygnatura;  Radio &radio; };
Po dodaniu Radio &radio przestając być generowane wszelkie konstruktory, oraz operator przypisania. Przekazując przez referencje, przekazywany obiekt musi być zainizjalizowany!



15.
Operator przeniesienia, oraz konstruktor przenoszący są generowane automatycznie, do czasu, gdy nie zostanie zaimplementowane jedno z: operator przeniesienia, konstruktor przenoszący, konstruktor kopiujący, destruktor lub operator przypisania.