Klasy i obiekty II

Zasady rządzące życiem obiektu

Zapoznać się z regułami przedstawionymi w dokumentacji na stacku Zasada zera, zasada pięciu, zasada trzech.

XXX.h
#include <string>
#include <cstring>
#include <algorithm>
using ::std::swap;
 
class XXX {
public:
  //w zeszłym odcinku:
  //domyślny konstruktor
  XXX(); 
  //konstruktory parametryczne
  XXX(int param);
  XXX(const std::string name);
 
  //Rule of five://
  //1. konstruktor kopiujący
  XXX(const XXX &xxx);
  //2. konstruktor przenoszący
  XXX(XXX &&xxx);
  //3. operator przypisania kopiujący
  XXX &operator=(const XXX &xxx);
  //4. operator przypisania przenoszący
  XXX &operator=(XXX &&xxx);
  //5. Destruktor
  ~XXX();
};

Reguła 3 była stosowana dla C++03 przed wprowadzeniem referencji do r-wartości i obejmowała funkcje: 1, 3, 5. Reguła 5 mówi, że jeśli ktoś potrzebuje przedefiniować jedną z tych metod to najprawdopodobniej musi to zrobić z wszystkimi 5.

Za co właściwie odpowiadają te metody?

Metody te są wywoływane w trakcie życia obiektu w celu oddelegowania odpowiedzialności za zarządzanie zasobami do samego obiektu. Są to operacje konstruowania obiektu jeszcze nie istniejącego na podstawie innego (już zainicjalizowanego), przypisywanie innego obiektu do istniejącego gdy oba już są zainicjalizowane lub niszczenie obiektu.

Przykład:

main.cpp
int main() {
  //Konstrukcja obiektu za pomocą domyślnego konstruktora
  //nieciekawe
  XXX old_xxx {};
 
  //Konstrukcja obiektu na podstawie już zaincjalizowanego
  XXX new_xxx {old_xxx}; 
 
  //znowu nieciekawy konstruktor domyślny...
  XXX another_xxx {};
 
  //tutaj przypisujemy stan obiektu jednego do drugiego
  //ale obydwa są już zaincjalizowane...
  another_xxx = new_xxx;
 
  //tutaj kończy się zakres funkcji main i wszystkie trzy obiekty tracą ważność
  //zostają wywołane więc destruktory
}

A co z przenoszącymi wersjami z C++11

W przypadku kopiowania stary obiekt zostaje w nienaruszonym stanie (był zawsze przekazywany jako const &). Jeśli dokonujemy przenoszenia stary obiekt jest niszczony, a jego stan jest przenoszony do nowej lokalizacji, czyli liczba zasobów trzymanych w obiektach pozostaje stała…

Przykład:

main.cpp
XXX make_copy(XXX xxx) {
  return xxx;
}
 
int main() {
  //Konstrukcja obiektu za pomocą domyślnego konstruktora
  //nieciekawe
  XXX old_xxx {};
 
  //Konstrukcja obiektu na podstawie już zaincjalizowanego
  //z przeniesieniem old_xxx jest niszczony
  XXX new_xxx {move(old_xxx)}; 
 
  //znowu nieciekawy konstruktor domyślny...
  XXX another_xxx {};
 
  //tutaj przypisujemy stan obiektu jednego do drugiego
  //ale obydwa są już zaincjalizowane...
  //stan new_xxx teraz będzie w another_xxx, a sam new_xxx jest niszczony
  another_xxx = std::move(new_xxx);
 
  //tutaj zostanie wywoały konstruktor kopiujący (argument wysyłany przez wartość)
  //a następnie konstruktor przenoszący (bo wartość tymczasowa wytworzona przez funkcję make_copy()
  //i tak zaraz zginie
  XXX one_more = make_copy(another_xxx);
  //tutaj watość tymczasowa z funkcji make_copy już jest niszczona i wywoływany jest destruktor
 
  //...
 
  //tutaj kończy się zakres funkcji main i wszystkie trzy obiekty tracą ważność
  //zostają wywołane więc destruktory (na wszystkich trzech, ale tylko jeden ma ważny stan)
}

Co jest tymi zasobami?

Zasoby to wszystko co musi być najpierw zainicjalizowane, a następnie zniczone, ale nie przy użyciu konstruktora i destruktora. Np. pamięć jako surowy wskaźnik (inicjalizacja new, zwalnianie delete), uchwyt do pliku (open, close), połączenie z bazą danych, itp…

Jeśli obiekt nie posiada żadnych zasobów tylko składa się z typów prostych i kontenerów biblitecznych to można wykorzystać regułę 0 i polegać na powyższych funkcjach automatycznie wygenerowanych przez kompilator.

Jeśli jednak klasa XXX wygląda tak:

XXX.h
class XXX {
 private:
  char *name_;
};
XXX.cpp
XXX::XXX() : name_{new char[1024]} {
 
}

Brak destruktora powoduje wyciek pamięci, która nigdy nie jest zwalniana:

XXX.cpp
//5. destruktor:
XXX::~XXX() {
  delete [] name_;
}

Brak konstruktora może teraz doprowadzić do tragedii wielokrotnej próby zwolnienia tej samej pamięci:

main.cpp
int main() {
  XXX old;
  XXX new_xxx{old};
  //teraz zarówno old jak i new_xxx pokazują na ten sam fragment pamięci
  //... niedobrze bo zaraz zostanie uruchominy destruktor pierwsego i drugiego obiektu
  //i drugi destruktor będzie chciał zwolnić drugi raz ten sam fragment pamięci...
}

Więc:

XXX.cpp
//konstruktor kopiujący:
XXX::XXX(const XXX& xxx) {
    size_t sz = strlen(xxx.name_);
    name_ = new char[sz];
    strcpy(name_,xxx.name_);
    //Teraz nowy obiekt pokazuje na nowy fragment pamięci, 
    //ale ze skopiowaną informacją
  }
  //operator przypisania:
XXX & XXX::operator=(const XXX& xxx) {
    //jeśli ktoś wpadł na pomysł x = x;
    if (this == &xxx) {
      return *this;
    }
    //w przyciwynym wypadku mamy x = y;
    //musimy sami zwolnic pamięć po x (czyli this):
    delete[] name_;
    //i wreszcie kopiowanie, ten kod jest
    //jest identyczny więc można by go wydzielić do innej metody...
    size_t sz = strlen(xxx.name_);
    name_ = new char[sz];
    strcpy(name_,xxx.name_);
  }

I ostatnia poprawka:

XXX.cpp
  //konstruktor przenoszący:
XXX::XXX(XXX &&xxx) : name_{nullptr} {
    swap(name_,xxx.name_);
    //Bardzo popularna szutczka
    //wiemy, ze za chwilę xxx zostanie zniszczony 
    //za pomocą destrukotra, więc inicjalizujemy
    //this na nullptr i wymieniamy się z xxx
    //delete nullptr jest bezpieczna operacją i nic się nie stanie...
  }
 
//operator przenoszący:
XXX & XXX::operator=(XXX &&xxx) {
    //jeśli ktoś wpadł na pomsył x = move(x);
    if (this == &xxx) {
      return xxx;
    }
    //w przyciwynym wypadku mamy x = move(y);
    //musimy sami zwolnic pamięć po x (czyli this):
    delete[] name_;
    //i wreszcie przenosimy stan, ten kod jest
    //jest identyczny więc można by go wydzielić do innej metody...
    name_ = nullptr;
    swap(name_,xxx.name_);
  }

Usuwanie domyślnie generowanych funkcji

Usuwanie domyślnie generowanych funkcji w C++11 jest wyjątkowo prostym zadaniem wystarczy zadeklarować metodę a następnie przypisać jest delete.

class Y {
  Y(Y &&y) = delete;
  Y &operator=(Y &&y) = delete;
};

W tym momencie nie będzie możliwe przenoszenie obiektów klasy Y. W przypadku zwracania obiektów Y z funkcji kompilator zrezygnuje z optymalizacji przeniesienia i zastosuje kopiujące odpowiedniki metod.

Konstruktory z listą inicjalizacyjną

Istnieje jeszcze specjalny typ konstruktora przyjmujący listę inicjalizacyjną, przydatny przy inicjalizacji własnych kontenerów.

Counter.h
class Counter {
 public: 
  //strasznie długi typ...
  Counter(const std::initializer_list<std::pair<const std::string, unsigned int>> &elements) : counter_{elements} {
 
  }
 private:
  std::map<std::string, unsigned int> counter_;
};

Teraz można zainicjalizować obiekt Counter jako:

Counter cnt {{"abc", 14}, {"efg", 17}, {"hij",0}};

Klasy i const

Słowo kluczowe const ma różne znaczenie w zależności od kontekstu w jakim jest stosowane.

Metody const

W odniesieniu do metod klasy oznacza, że dana metoda nie może modyfikować elementów składowych klasy jak również nie może wywoływać innych metod niż te zdeklarowane jako const. Jeśli można, warto zadeklarować metodę jako const. Umożliwi to poprawne korzystanie z obiektów tej klasy zadeklarowanych jako stałe.

class Matrix{
  ...
  void Print() const;
  ...
};

Zmienne/obiekty const

W odniesieniu do zmiennych i obiektów i innych zmiennych, oznaczają że nie można modyfikować zmiennej/obiektu. Innymi słowy nie można wywoływać na rzecz danego obiektu innych metod niż zadeklarowane jako const

...
const Matrix m(["1 2 3; 1 2 3"]);
 
//Metoda ustawiająca wartość w komórce macierzy o indeksie (1,1)
//Wywołanie takiej metody wygeneruje błąd podczas kompilacji.
m.Set(1,1,12);  
 
//Gdyby metoda wyświetl nie była zadeklarowana jako const
//takie wywołanie też spowodowałoby błąd
m.Print();

Funkcje i klasy friend

Funkcja i klasy zaprzyjaźnione mają nieograniczony dostęp do wszystkich pól i metod klasy której są przyjaciółmi.

Funkcje zaprzyjaźnione

Funkcja zaprzyjaźniona definiowana jest poza zasięgiem klasy, ale informacja o tym że jest ona przyjacielem musi znaleźć się w klasie:

//Plkik Matrix.h
class Matrix{
  double** data;
  ...
  friend void wyzeruj(Matrix& m);
  ...
};
 
// Plik main.cpp
 
// Funkcja może modyfikować prywatne dane klasy
// Matrix, ponieważ została określona jako friend
void wyzeruj(Matrix& matrix){
  for(int r  = 0; r < matrix.rows; r++)
    for(int c  = 0; c < matrix.cols; c++)
      matrix.data[r][c] = 0;
}

Klasy zaprzyjaźnione

Analogicznie do funkcji klasy zaprzyjaźnione maja nieograniczony dostęp d wszystkich pól i metod klasy które są przyjaciłmi. Jeśli klasa Node ma być przyjacielem klasy Lista, to w tej drugiej należy umieścić następującą deklarację:

class Lista{
  ...
  friend class Node;
  ...
};

Słowo kluczowe static

Słowo kluczowe static może być stosowane zarówno w stosunku do pól klasy jak i jej metod, ale w obu przypadkach ma nieco inne znaczenie.

Pola statyczne

Pola statyczne są swego rodzaju zmiennymi globalnymi, należącymi jednak do zasięgu klasy. Zmienna statyczna jest współdzielona przez wszystkie obiekty klasy. Do zmiennych statycznych można odwoływać się nie mając utworzonego obiektu.

Słowo kluczowe static dodaje się tylko i wyłącznie podczas deklaracji zmiennej. Użycie słowa kluczowego static podczas inicjalizacji zmiennej powoduje błąd składniowy.

Deklaracja zmiennej statycznej w pliku nagłówkowym:

class Matrix{
  public:
    static int licznik;
    Matrix(){licznik++;}
   ~Matrix(){licznik--;}
};

Zmienna statyczna musi zostać zainicjalizowana w przestrzeni pliku. Nie można inicjalizować statycznej zmiennej w konstruktorze, lub innej funkcji. Inicjalizacja zmiennej statycznej w pliku cpp:

#include "Matrix.h"
 
int Matrix::licznik = 0;
...

Odwoływanie się do pól statycznych:

int main(){
  Matrix m;
  cout << Matrix::licznik <<endl;
  cout << Matrix.licznik << endl;
}

Metody statyczne

Metody statyczne można wywoływać bez konieczności tworzenia obiektów klasy. Można z tego wywnioskować, że metody statyczne nie posiadają wskaźnika this.

Nie można zatem wewnątrz metod statycznych wywoływać żadnych innych metod niestatycznych, ani odwoływać się do pól niestatycznych.

Metody statyczne należą jednak do zasięgu klasy i mają dostęp do wszystkich pól klasy:

class Matrix{
  ...
  static void wyswietl(Matrix& m);
};
 
void Matrix::wyswietl(Matrix & m){
  for(int r  = 0; r < matrix.rows; r++){
    for(int c  = 0; c < matrix.cols; c++)
      cout << matrix.data[r][c] << endl;
    cout << endl;
  }
}

Ćwiczenia

  1. [2 plusy] Przepisać program z klasą XXX z treści laboratoriów i prześledzić jego działanie w debuggerze. Ustawić pułapki debuggera na wszystkich 5 specjalnych funkcjach jak i przy funkcji main() następnie używając pracy krokowej (F8,F7,F9…) prześledzić zachowanie kodu
  2. [3 plusy] Alokacja dużych bloków pamięci na raz jest szybszym sposobem zarządzania pamięcią jeśli tylko mamy odpowiednie przesłanki profilu wykorzystania pamięci. Ale tym razem problem jest znacznie prostszy należy jedynie przygotować klasę MemoryChunk z konstruktorem parametrycznym przyjmującym rozmiar bloku pamięci do zaalokowania. Klasa powinna przechowywać uchwyt do bloku pamięci w postaci zwykłego wskaźnika na int8_t alokowanego przez operator new (żeby nie było za prosto)
    • Moduł: memorychunk
    • Pliki z implementacją: MemoryChunk.h/cpp
    • Używana struktura danych: MemoryChunk
    • Sygnatury metod w klasie MemoryChunk:
        Rule of Five
        MemoryChunk(size_t sz);
        int8_t *MemoryAt(size_t offset) const;
        size_t ChunkSize() const;
    • Przestrzeń nazw: memorychunk
    • Importy:
      #include <cstdint>
      #include <algorithm>
    • Przydatne metody:
      std::copy(from,from+size,to);
  3. [2 punkty] Pula łańcuchów znaków jest to jeden ze sposobów optymalizacji dużej ilości napisów w programie. Trick polega na tym, że powtarzające się napisy przechowujemy w tym samym miejscu pamięci. Obiektowi puli napisów można powierzyć przechowywanie konkretnego napisu za pomocą funkcji Intern w rezultacie dostajemy uchwyt do napisu, który jest już zarządzany przez obiekt puli. Jeśli kilka identycznych napisów zostanie wstawionych do puli to tylko jedna instancja napisu będzie przechowywana wewnątrz, a wszystkie zwracany uchwyty pokazują ciągle na ten sam napis wewnątrz puli. Niestety klasa string nie nadaje się do naszych celów zwracania uchwytu napisu, ponieważ to ona sama zarządza pamięcią i wymaga kopiowania napisu a ponadto pozwalałaby na modyfikowanie napisów przechowywanych w strukturze (jeśli kilka napisów wskazuje na ten sam obszar pamięci to byłoby straszne). W C++17 wchodzi typ string_view czyli niezmienny napis, który dodatkowo posiada metodę substr działającą w czasie stałym! Twoim zadaniem jest przygotowanie implementacji takie puli napisów.
    • Moduł: textpool
    • Pliki z implementacją: TextPool.h/cpp
    • Używana struktura danych: TextPool
    • Sygnatury metod w klasie TextPool:
        Rule of Five (z usuniętą możliwością kopiowania)
        domyślny konstruktor
        konstruktor z listą inicjalizacyjną
        std::experimental::string_view Intern(const std::string &str);
        size_t StoredStringCount() const;
    • Przestrzeń nazw: pool
    • Importy:
      #include <initializer_list>
      #include <string>
      #include <experimental/string_view>
      #include <set>
    • Przykład użycia:
      #include <iostream>
      #include "TextPool.h"
       
      using namespace pool;
      using namespace std;
       
      int main() {
        //Inicjalizacja wstępna puli za pomocą listy inicjalizacyjnej
        TextPool pool {"abc", "efg", "hij", "klmn", "oprst"};
       
        //wstawienie napisu do puli
        auto s1 = pool.Intern("efg");
       
        //wstawienie kolejnego napisu do puli (w obu przypadkach nie
        //powinien się zmienić rozmiar puli)
        auto s2 = pool.Intern("efg");
       
        cout << (s1 == s2 ? "True" : "False") << endl; //uchwyty są tymi samymi napisami co do wartości
        cout << pool.StoredStringCount() << endl; // w puli jest wciąż 5 napisów
        cout << (s1.begin() == s2.begin() ? "True" : "False") << endl; //na dodatek uchywyty s1 i s2 pokazują dokładnie na ten sam napis w puli (wskaźniki są identyczne)
      }
  4. [1 plus] Napisz dwie klasy: Rodzic i Dziecko. Klasa Rodzic powinna mieć takie pola jak imię, nazwisko, wiek, oraz dziecko (zakładamy dla uproszczenia, że rodzic ma tylko jedno dziecko :) ). Dziecko powinno mieć takie pola jak imię, nazwisko, wiek, szkoła. Zdefiniuj klasę Rodzic jako zaprzyjaźnioną klasy Dziecko. Przetestuj, czy można modyfikować zmienne prywatne klasy Dziecko z poziomu metod klasy Rodzic. Napisz na przykład metodę przepiszDoInnejSzkoly(string nazwa) która będzie zmieniać szkołę dziecka operując bezpośrednio na jego danych.
    Następnie usuń linijkę odpowiedzialną za określenie klasy zaprzyjaźnionej i spróbuj skompilować ponownie program.
  5. [3 plusy] Napisz klasę Marsjanin, która będzie miała statyczne pole liczbaMarsjan, określające liczbę stworzonych obiektów Marsjanin. Każdy Marsjanin powinien atakować gdy liczba wszystkich Marsjan jest większa od 5 i ukrywać się w przeciwnym wypadku.
    Napisz program który w pętli nieskończonej będzie tworzył lub usuwał obiekty klasy Marsjanin i wywoływał metodę atakuj dla wszystkich Marsjan. Obiekty powinny być przechowywane w liście (zobacz List).
  6. [3 punkty] Zaimplementuj klasę o nazwie Matrix, która będzie reprezentować macierz o dowolnych rozmiarach. Wymagania dotyczące klasy Matrix:
    • Moduł: matrix
    • Pliki z implementacją: Matrix.h/cpp
    • Używana struktura danych: Matrix
  • Klasa powinna wewnętrznie reprezentować macierz przy pomocy tablicy dwuwymiarowej obiektów typu std::complex<double>. Umawiamy się, że liczba zespolona zapisywana jest w następujący sposób:
    4.5i6

    Co oznacza w zapisie matematycznym

    4.5 + 6i
  • Klasa Matrix powinna posiadać konstruktor parometrowy określający jej wymiary, konstruktor bezparametrowy, oraz kopiujący. Dopisać konstruktor, który będzie przyjmować napis const char* (lub obiekt klasy string z biblioteki string.h) w notacji Matlaba i parsować go, aby można było stworzyć obiekt Matrix w taki sposób:
     Matrix m("[1i3 2i5 3; 3 4 5; 6 7 8]");
  • Klasa Matrix powinna udostępniać metody pozwalające na ustawianie/pobieranie jej elementów
  • Klasa Matrix powinna udostępniać metody umożliwiające następujące operacje:
    • Dodawanie macierzy. Metoda powinna klasy powinna pobierać jako parametr inny obiekt klasy Matrix i zwracać wynik będący sumą macierzy reprezentowanej przez obiekt na rzecz którego wywoływana jest metoda i macierzy reprezentowanej przez obiekt podany jako parametr. Przykładowe wywołanie:
      Matrix m("[1 2 3;3 4 5; 2 3 4]");
      Matrix m2("[3 2 1; 5 4 3; 7 6 5]");
      Matrix wynik = m.add(m2);
    • Odejmowanie macierzy (pozostałe analogicznie)
    • Mnożenie macierzy zarówno przez inna macierz jak i przez liczbę (w tym wypadku Complex)
    • Dzielenie macierzy zarówno przez inna macierz jak i przez liczbę (w tym wypadku Complex)
    • Podnoszenie macierzy do potęgi!
    • Metodę print wyświetlającą dana macierz w formacie Matlaba, z ładnym formatowaniem (podział na wiersze)
  • Zabezpiecz program przed sytuacjami wyjątkowymi! Na przykład: dodawanie macierzy o różnych wymiarach, mnożenie macierzy o nieodpowiednich wymiarach, odwracanie macierzy zerowej.
  • Napisz program który umożliwi testowanie klasy Matrix. Program powinien przyjmować jako parametr dwie macierze zapisane w formacie Matlaba. Funkcja main powinna wyglądać następująco:
    #include <iostream>
    #include "Matrix.h"
     
    int main(int argc, char* argv[]){
      Matrix m1(argv[1]);
      Matrix m2(argv[2]);
     
      cout << "Macierz pierwsza: " << m1.print() << endl;
      cour << "Macierz druga: " << m2.print() << endl;
     
      cout << "Dodawanie" << (m1.add(m2)).print() << endl;
      cout << "Odejmowanie" << (m1.sub(m2)).print() << endl;
      cout << "Mnożenie" << (m1.mul(m2)).print() << endl;
      cout << "Dzielenie" << (m1.div(m2)).print() << endl;
      cout << "Potęgowanie" << (m1.pow(2)).print() << endl;
      cout << "Potęgowanie" << (m2.pow(2)).print() << endl;
    }

Zabezpieczenie programu przed sytuacjami wyjątkowymi w „podstawowej” wersji, wymaganej na laboratorium, związane jest ze sprawdzeniem odpowiedniej wartości i wypisaniem komunikatu dla użytkownika. Bardziej profesjonalny sposób obsługi takich sytuacji związany jest z mechanizmem wyjątków. Więcej o nich dowiemy się na laboratorium Wyjątki.

pl/dydaktyka/jimp2/2017/labs/klasy2.txt · ostatnio zmienione: 2017/07/17 08:08 (edycja zewnętrzna)
www.chimeric.de Valid CSS Driven by DokuWiki do yourself a favour and use a real browser - get firefox!! Recent changes RSS feed Valid XHTML 1.0