Język C++

Zacznijmy od przytoczenia kilku istotnych informacji dotyczących języka C++.

Operator ++ znajdujący się w nazwie języka C++ oznacza inkrementację, czyli kolejne ulepszenia – iteracje, które zostały wprowadzone w języku C.  Pamiętajmy, że C++ jest wstecznie zgodny z językiem C.

Język C++ pozwala korzystać z mechanizmów programowania obiektowego i m.in. tym różni się od C, który jest językiem imperatywnymjęzyk imperatywnyimperatywnym oraz strukturalnymjęzyk strukturalnystrukturalnym. Jednak dowolny kod napisany w języku C powinien się skompilować za pomocą kompilatora języka w C++.

Podczas nauki języka C++ dowiadujemy się m.in., czym są funkcjefunkcjafunkcje, wskaźnikiwskaźnikwskaźniki, operatoryoperatoroperatory i strukturystruktura danychstruktury.

Klasy i obiekty

Zanim przejdziemy do wyjaśnienia, czym jest programowanie obiektowe, omówmy pojęcia: klasa i obiekt.

Z przedstawionych uproszczonych definicji klasy i obiektu wynika, że jedno nie może istnieć bez drugiego (nie można stworzyć obiektu, nie implementując wcześniej klasy). Przeanalizujmy tę relację na przykładzie datownika.

Klasy i obiekty w języku C++

W języku C++ klasy definiujemy w sposób podobny do strukturP13NkhXOWstruktur.

class NazwaKlasy {
};

Po słowie kluczowym class podajemy nazwę klasy. Dobrym zwyczajem jest rozpoczynanie nazwy klasy wielką literą. Poza tym nazewnictwo klas podlega takim samym zasadom, jakie stosowane są podczas nadawania nazw funkcjom i zmiennym.

W definicji klasy możemy umieścić następujące elementy:

• atrybuty (pola) – elementy określające jakąś cechę lub daną przechowywaną wewnątrz obiektu; mogą nimi być dowolne zmienne, w tym obiekty klas albo tablice obiektów klas;

• metody – określają zachowanie obiektów; są to funkcje składowe (funkcje związane z klasą) mające dostęp do atrybutów klasy;

• informacje, z jakich klas dziedziczy definiowana klasa;

• konstruktory oraz destruktory – pierwsze służą do tworzenia instancji klasy, drugie uruchamiane są przed usunięciem obiektu; konstruktor musi nazywać się tak samo jak klasa; nazwa destruktora składa się z nazwy konstruktora poprzedzonej znakiem tyldy (~);

• specyfikatory dostępu – określające, kto ma dostęp do elementu klasy.

W uproszczeniu możemy porównać klasę do przepisu w książce kucharskiej, a obiekt do ugotowanej na jego podstawie potrawy.

Przeanalizujmy kod:

#include <iostream>
#include <cstdlib> 
#include <string>

using namespace std;

class NazwaKlasy {
	private:
		int atrybut;
	public:
		void metoda() {
			cout << "Cialo metody" << endl;
		}
		NazwaKlasy(int a) {
			atrybut = a;
			cout << "To jest konstruktor klasy" << endl;
		}
		~NazwaKlasy() {
			cout << "To jest destruktor klasy" << endl;
		}
};

int main(int argc, char** argv) {
	NazwaKlasy dowolnaNazwaObiektu(5);
	return 0;
}

Zdefiniowaliśmy klasę NazwaKlasy, a następnie utworzyliśmy obiekt o nazwie dowolnaNazwaObiektu, korzystając z konstruktora opisanego w linii 14.

Po uruchomieniu programu na ekranie pojawią się dwie linie:

To jest konstruktor klasy
To jest destruktor klasy

Wynika to z faktu, że przed zakończeniem programu (instrukcja return 0 w linii 25.) wszystkie obiekty są usuwane.

#include <iostream>
#include <cstdlib> 
#include <string>

using namespace std;

class Datownik {
	protected:
		int dzien;
		int miesiac;
		int rok;
	public:
		void zmienDate(int dzien, int miesiac, int rok) 
		{
			this->dzien = dzien;
			this->miesiac = miesiac;
			this->rok = rok;
		}
		Datownik(int dzien, int miesiac, int rok) 
		{
			this->dzien = dzien;
			this->miesiac = miesiac;
			this->rok = rok;
		}
		void odcisnijDate()
		{
		    cout<<"Data:"<<dzien<<"."<<miesiac<<"."<<rok <<"\n";
		}
};



int main(int argc, char** argv) {
	Datownik datownik1(10,10,2010);
	datownik1.odcisnijDate();
	return 0;
}

Dziedziczenie

Dziedziczenie jest procesem, podczas którego kopiuje się funkcjonalności oraz zastosowania klasy bazowej do klasy pochodnej (dziedziczącej).

#include <iostream>
#include <cstdlib> 
#include <string>

using namespace std;

class Pojazd {
	protected:
		int aktualnaPozycjaX;
		int aktualnaPozycjaY;
	public:
		void przemieszczenie(int oIleWx, int oIleWy) {
			aktualnaPozycjaX += oIleWx;
			aktualnaPozycjaY += oIleWy;
		}
		Pojazd(int aktualnaPozycjaX, int aktualnaPozycjaY) {
			this->aktualnaPozycjaX = aktualnaPozycjaX;
			this->aktualnaPozycjaY = aktualnaPozycjaY;
		}
};

class Motocykl : public  Pojazd {
	public:
		Motocykl(int aktualnaPozycjaX, int aktualnaPozycjaY):Pojazd(aktualnaPozycjaX, aktualnaPozycjaY) {
			cout << "Jestem motocyklem" << endl;
		};
		int pobierzAktualnaPozycjeX() {
			return aktualnaPozycjaX;
		}
		int pobierzAktualnaPozycjeY() {
			return aktualnaPozycjaY;
		}
};


int main(int argc, char** argv) {
	Motocykl honda(0, 0);
	honda.przemieszczenie(5, 10);
	cout << "Aktualna pozycja x: "<< honda.pobierzAktualnaPozycjeX() << endl;
	cout << "Aktualna pozycja y: " << honda.pobierzAktualnaPozycjeY() << endl;
	return 0;
}

Zasady dziedziczenia

Jeśli klasa, po której dziedziczymy, nie ma konstruktora bezparametrowego, należy jawnie wywołać konstruktor klasy bazowej (tak jak jest to widoczne w linii 24.  programu z przykładu 3). Podczas tworzenia obiektu klasy pochodnej zawsze uruchamiany jest konstruktor klasy bazowej, nawet jeśli dzieje się to niejawnie.

Dostępność elementów klasy bazowej w klasie pochodnej zależy od użytych specyfikatorów:

• jeśli danym lub metodom towarzyszy specyfikator private, to elementy te nie są dostępne w klasie pochodnej;

• jeśli danym lub metodom towarzyszy specyfikator public lub protected, są one dostępne w klasie pochodnej.

W linii 23. programu po dwukropku użyliśmy specyfikatora public. Warto pamiętać, że jeśli nie zastosujemy żadnego operatora, domyślnie zostanie użyty modyfikator private.  Specyfikator w tym miejscu służy do ograniczania widoczności w klasie. Jeśli zastosujemy w danej klasie specyfikator public, wszystkie jej elementy  również przyjmują typ public (mają najwyższą możliwą widoczność, czyli w praktyce nie zachodzi żadna zmiana w dostępności).

Modyfikator protected umożliwia dostęp do pola bądź metody w obrębie klasy bazowej oraz klas pochodnych (dziedziczących). Próba odwołania się do elementu, który został oznaczony protected, spoza wspomnianych wcześniej klas zakończy się błędem kompilacji.

Najbardziej restrykcyjnym modyfikatorem dostępu jest private. Uniemożliwia odwołanie się do elementu poprzez klasę dziedziczącą. Sprawa to, że tylko klasa, w której zostało utworzone pole bądź metoda, może korzystać z tak oznaczonego elementu.

#include <iostream>
using namespace std;
class Klasa1
{
    public:
    void test()
    {
        cout<<"test1";
    }
};
class Klasa2
{
    public:
    void test()
    {
        cout<<"test2";
    }
};
class Test : public Klasa1, public Klasa2
{
    public:
    Test(){
        test();
    }
};

int main()
{
    Test test;
    return 0;
}

main.cpp:34:9: error: reference to ‘test’ is ambiguous
   34 |         test();
      |         ^~~~
main.cpp:24:10: note: candidates are: ‘void Klasa2::test()’
   24 |     void test()
      |          ^~~~
main.cpp:15:10: note:                 ‘void Klasa1::test()’
   15 |     void test()
      |          ^~~~

Wskaźnik this

Wskaźnik this sygnalizuje początek obszaru pamięci zajmowanego przez obiekt (adres jego pierwszej komórki) i może służyć do jego jednoznacznej identyfikacji. Dwie różne instancje tej samej klasy będą miały dwa różne wskaźniki this, ponieważ są od siebie niezależne.

Widoczne jest tu podobieństwo do dwóch różnych zmiennych typu int. Mimo że obie zmienne mogą mieć taką samą wartość, to modyfikacja jednej z nich nie wpływa na wartość drugiej, ponieważ obie są zapisane pod innymi adresami w pamięci.

class Pojazd() {
	protected:
		int aktualnaPozycjaX;
		int aktualnaPozycjaY;
	public:
		Pojazd(int aktualnaPozycjaX, int aktualnaPozycjaY) {
			this->aktualnaPozycjaX = aktualnaPozycjaX;
			this->aktualnaPozycjaY = aktualnaPozycjaY;
		}
}

Użycie wskaźnika this (jawne lub niejawne) jest konieczne, jeśli chcemy zapisać dane w polach. Za każdym razem, gdy modyfikujemy atrybut w danym obiekcie, robimy to za pośrednictwem wskaźnika this. W poprzednim fragmencie kodu w linii 6. zdefiniowaliśmy argumenty nazwane tak samo jak atrybuty klasy, jednak dzięki użyciu wskaźnika this w 7. i 8. linii kompilator rozpoznał, do której komórki pamięci należy przypisać wartości.

Operowanie na obiektach

Obiekty klas – podobnie jak zmienne każdego typu podstawowego – możemy umieścić w tablicy oraz podawać jako argumenty funkcji.

Funkcje w języku C++ domyślnie operują na kopiach zmiennych, które są przekazywane jako parametry. Tak samo jest w przypadku obiektów.

Powinniśmy jednak pamiętać, że obiekty, które są przekazywane jako argumenty do metod i funkcji, są kopiowane jedynie płytkokopiowanie płytkiepłytko.

#include <iostream>
#include <cstdlib> 
#include <string>

using namespace std;

class NazwaKlasy {
	public:
		int a;
		int* tab;
		NazwaKlasy(int a, int * tab) {
			this->a = a;
			this->tab = tab;
		}
};

class DrugaKlasa {
	public:
		static void przykladowaMetoda(NazwaKlasy p) {
			p.tab[0] = 5;
		}
};

int main(int argc, char** argv) {
	int tab[5] = { 0, 1, 2, 3, 4 };
	NazwaKlasy przykladowaKlasa(5, tab);
	DrugaKlasa::przykladowaMetoda(przykladowaKlasa);
	cout << tab[0];
	return 0;
}

Wynikiem działania przedstawionego programu będzie wypisanie na ekrannie liczby „5”, ponieważ kopiowanie było płytkie i metoda statyczna przykladowaMetoda() operowała na oryginalnej tablicy.

Przy okazji zastosowaliśmy również metodę statyczną, może być ona użyta bez powoływania obiektów. Metody statyczne wywołuje się zgodnie z następującą formułą:

NazwaKlasy::nazwaMetody()

Słownik