Jak zbudowana jest klasa w C++

Klasa w bardzo dużym uogólnieniu przypomina definicję struktury. Jej zapis wygląda następująco: C/C++ 
class NazwaTwojejKlasy
{
    //w tym miejscu piszemy definicje typów, zmienne  i funkcje jakie mają należeć do klasy.
}; //tutaj średnik jest bardzo ważny!

Prawa dostępu do klasy

class TwojaKlasa
{
    int abc;
};

int main()
{
    TwojaKlasa nazwaZmiennej;
    nazwaZmiennej.abc = 10;
    return( 0 );
}

Słowa kluczowe private, protected, public

C++ umożliwia łatwe modyfikowanie praw dostępu do wybranych zmiennych i funkcji klasy. Służą do tego trzy słowa kluczowe: private, protected i public.

Słowo kluczowe private

Słowo kluczowe private oznacza dostęp do zmiennych i funkcji tylko z poziomu klasy. Nie są one widoczne poza klasą, więc użytkownik klasy nie będzie mógł uzyskać dostępu do zmiennej (lub funkcji) spoza klasy.

Słowo kluczowe protected

Słowo kluczowe protected ma takie same własności co słowo kluczowe private. Różnice pojawiają się tylko wtedy, gdy przyjdzie nam dziedziczyć klasy. Jeśli będziemy dziedziczyli klasę A do klasy B to zmienne oznaczone jako private w klasie A będą niewidoczne dla klasy B. Jeśli zmienne (i funkcje) klasy A będą miały prawo dostępu protected to takie zmienne (i funkcje) będą widoczne dla klasy B.

Słowo kluczowe public

Dostęp publiczny umożliwia uzyskiwanie dostępu do dowolnej zmiennej i funkcji z dowolnego miejsca w kodzie (jeśli oczywiście zachowana jest logika programowania w C++).

Jak się zmienia prawa dostępu w praktyce

Ustawianie praw dostępu jest bardzo prostą czynnością. Najprościej będzie to pokazać na przykładzie. 
#include <string>
class TwojaKlasa
{
public:
    double liczba; //prawo dostępu: publiczne
    char tablica[ 20 ]; //prawo dostępu: publiczne
    
private:
    int abc; //prawo dostępu: prytatne
    char znak; //prawo dostępu: prytatne
    std::string napis; //prawo dostępu: prytatne
};

int main()
{
    TwojaKlasa nazwaZmiennej;
    return( 0 );
}

Deklaracja funkcji wewnątrz klasy

Pierwszą, a zarazem najprostszą metodą na utworzenie funkcji w klasie jest napisanie jej wewnątrz klasy. Przykład: 
#include <cstdlib>
#include <iostream>
using namespace std;
class EksperymentCL
{
private:
    int TwojaPrywatnaFunkcja( int a, int b )
    {
        return( a - b + 2 );
    }
public:
    int TwojaPublicznaFunkcja( int a, int b )
    {
        return(( a + b ) * 2 );
    }
};
int main()
{
    EksperymentCL nazwaZmiennej;
	cout << nazwaZmiennej.TwojaPublicznaFunkcja(1,2) << endl;
    system("PAUSE");
    return EXIT_SUCCESS;
}
Funkcje, które zostały zadeklarowane jako publiczne, będą mogły być wywoływane spoza klasy. Funkcje prywatne mogą być wywołane tylko i wyłącznie wewnątrz klasy (we wszystkich funkcjach należących do klasy). Tworzenie funkcji prywatnych jest bardzo wygodne, ponieważ umożliwia nam dzielenie skomplikowanej, zazwyczaj publicznej funkcji na mniejsze elementy, które przy późniejszej analizie i nanoszeniu ewentualnych poprawek sprawia dużo mniej kłopotów niż modyfikacja jednego długiego kodu funkcji.

Definicja funkcji wewnątrz klasy, deklaracja poza klasą

Pierwsza metoda, która została przedstawiona jest bardzo wygodna w użyciu, jednak ma takie same minusy jakie miały funkcje pisane w bloku głównym - kompilator nie widzi funkcji, które są 'wyżej'. Jeśli więc chcielibyśmy wywołać z funkcji TwojaPrywatnaFunkcja(), funkcję TwojaPublicznaFunkcja () to kompilator wyrzuciłby nam błąd. Drugą wadą jest to, że czytelność kodu bardzo się obniża przez to, że nie widać czy dana funkcja należy do klasy czy też nie (nie wspominając o zmiennych). Aby temu zaradzić, ten sam kod co poprzednio można zapisać następująco: 
#include <cstdlib>
#include <iostream>
using namespace std;
class EksperymentCL
{
private:
    int TwojaPrywatnaFunkcja( int a, int b );
public:
    int TwojaPublicznaFunkcja( int a, int b );
};

int EksperymentCL::TwojaPrywatnaFunkcja( int a, int b )
{
    return( a - b + 2 );
}

int EksperymentCL::TwojaPublicznaFunkcja( int a, int b )
{
    return(( a + b ) * 2 );
}
int main()
{
    EksperymentCL nazwaZmiennej;
	cout << nazwaZmiennej.TwojaPublicznaFunkcja(1,2) << endl;
    system("PAUSE");
    return EXIT_SUCCESS;
}

Konstruktor klasy

Konstruktor jest specyficzną funkcją, która jest wywoływana zawsze gdy tworzony jest obiekt. Jeśli programista nie utworzy konstruktora dla klasy, kompilator automatycznie utworzy konstruktor, który nic nie będzie robił. Konstruktor nie pojawi się nigdzie w kodzie, jednak będzie on istniał w skompilowanej wersji programu i będzie wywoływany za każdym razem, gdy będzie tworzony obiekt klasy. Jeśli chcemy zmienić domyślne własności konstruktora jaki jest tworzony przez kompilator C++ wystarczy, że utworzymy własny konstruktor dla klasy. Poniższy przykład pokazuje jak zapisuje się konstruktor dla klasy. 
#include <cstdlib>
#include <iostream>
#include <string>
using namespace std;

class NazwaTwojejKlasy
{
public:
    NazwaTwojejKlasy(); //To jest definicja konstruktora
};

NazwaTwojejKlasy::NazwaTwojejKlasy()
{
    //Tu inicjujemy wartości zmiennych klasy
}
Pierwsze co rzuca się w oczy w przypadku konstruktora, to brak zwracanego typu danych. Druga istotna własność konstruktora to jego nazwa. Konstruktor musi nazywać się tak samo jak nazwa klasy. Konstruktorom możesz przekazywać parametry tak samo jak funkcjom. C++ umożliwia również tworzenie kilku konstruktorów dla jednej klasy (muszą się one jednak różnić parametrami wejściowymi tak jak w przypadku funkcji). 
#include <cstdlib>
#include <iostream>
#include <string>
using namespace std;
class JakasKlasa
{
    int a;
    char b;
    std::string c;
public:
	JakasKlasa(int a, char b, string c){
		a = a;
		b = b;
		c = c;
	}
    

};


int main()
{
	int a =2;
    JakasKlasa klas1(2,'x',"asd");
 

    system("PAUSE");
    return EXIT_SUCCESS;
}

Lista inicjalizacyjna

#include <cstdlib>
#include <iostream>
#include <string>
using namespace std;
class JakasKlasa
{
    int a;
    char b;
    string c;
public:
    JakasKlasa(int a, char b, string c) : a(a) , b(b) , c(c) {
		
    }
};


int main()
{
	int a =2;
    JakasKlasa klas1(2,'x',"asd");
 
    system("PAUSE");
    return EXIT_SUCCESS;
}

Funkcje

#include <cstdlib>
#include <iostream>
#include <string>
using namespace std;
class JakasKlasa
{
    int a;
    char b;
    string c;
public:
	JakasKlasa(int a, char b, string c):a(a),b(b),c(c){}
    
	void print(){
		cout <<a<<endl;
		cout<<b<<endl;
		cout<<c<<endl;
	}
};

int main()
{
	int a =2;
    JakasKlasa klas1(2,'x',"asd");
	klas1.print();

    system("PAUSE");
    return EXIT_SUCCESS;
}

Zadania

Zad. 1. (1 punkt)

W kodzie: 
#include 
using namespace std;
class I_6{
private:
	int i_1;
	int i_2;
	int i_3;
	int i_4;
	int i_5;
	int i_6;
public:
	I_6(int i_1, int i_2, int i_3, int i_4, int i_5, int i_6){
//*1

//*1
	}
	void write(){
//*2

//*2
	}
};
int main() {
	I_6 i = I_6(1,2,3,4,5,6);
	i.write();

    system("PAUSE");
    return EXIT_SUCCESS;
}
Na wyjściu powinno pojawić się: 
1
2
3
4
5
6

Zad. 2. (1 punkt)

W programie 

#include 
using namespace std;
class zmienne{
public:
	int i;
	int j;
};
int main() {

	
    system("PAUSE");
    return EXIT_SUCCESS;
}
do funkcji main nadaj zmiennej i oraz j wartość 1 i wypisz je.

Zad. 3. (2 punkt)

Proszę napisać klasę „Complex” liczb zespolonych.

Zad. 4. (2 punkt)

Proszę napisać klasę „osoba” .