0Wykład 1
1Wprowadzenie do programowania obiektowego w C++
2
3Literatura
4Stroustrup B. Język C++
5Delannoy C. Ćwiczenia z języka C++, programowanie obiektowe 6Grębosz J. Symfonia C++
7Holzner S. Programowanie w Borland C++
8Kisilewicz J. Język C++, programowanie obiektowe 9Ledgard H.F. Mała księga programowania obiektowego 10Coad P., Nicola J. Programowanie obiektowe
11
12Omówione zagadnienia
13Główne zasady programowania obiektowego: hermetyzacja, dziedziczenie, polimorfizm
14Pojęcie klasy: sposoby deklarowania i definiowania składowych klasy, 15Atrybuty dostępu do składowych - private, protected i public wspierające hermetyzację
16Obiekty automatyczne, statyczne i dynamiczne 17Konstruktory i destruktory
18Zmienne referencyjne, przekazywanie parametrów przez referencję 19Składowe klasy typu static
20Pliki nagłówkowe, dyrektywy preprocesora, programy wielo-plikowe
21
22
23
24
25
26
27 28
29
30
Dane
wejściowe Algorytm
(przepis)
Narzędzia Wykonawca (Oprogramowanie) (Sprzęt)
Dane wyjściowe Poziom oprogramowania
Poziom koncepcji 31Definicje algorytmu:
32reguła przekształcania wyrażeń matematycznych przez przetwarzanie tych samych działań na kolejno otrzymywanych wynikach działań poprzednich 33dokładny przepis wykonania szeregu operacji w celu rozwiązania określonego zagadnienia, a może być wykorzystany do rozwiązania całej grupy problemów należących do określonej klasy.
34 Algorytm zawiera opis: danych wejściowych, wyjściowych, działań i scenariusza wykonania tych działań, zrealizowany za pomocą:
35instrukcji sterujących i wyrażeń, 36typów danych.
W wersji obiektowej w opisie algorytmu stosuje się:
typ danych = klasy (wzorzec danych) oraz dane (zmienne) = obiekty działania = metody dołączone do klasy (część składowa klasy)
Dane i funkcje (metody) przetwarzające te dane tworzą klasy/obiekty.
Program obiektowy operuje na klasach/obiektach.
Program stanowi rozwiązanie konkretnego problemu i jest realizowany za pomocą sekwencji wywołań metod poszczególnych klas/obiektów.
1. Główne zasady programowania obiektowego
1.2. Hermetyzacja (enkapsulacja)- ochrona przed bezpośrednim dostępem do danych zawartych w klasie/obiekcie.
Realizacja:
37Do danych umieszczonych w klasie należy się odwołać jedynie za pośrednictwem metod tej klasy/obiektu
38Dostęp do składowych klasy można ograniczać specyfikatorami dostępu: private, protected, public (p.3)
Część prywatna i chroniona klasy/obiektu -
dane i metody Część publiczna klasy/obiektu - metody
1.2. Dziedziczenie
Budowa nowych klas (nadklas) na podstawie własności klas istniejących (podklas): D1 - A1, B1; E2 - A2, B2, C2 itp
Przykłady:
Drzewo prostego menu programu: A1-okno; B1-przycisk, C1-przycisk zwykły, D1-przycisk wyboru, E1-tekst, F1-opis statyczny przycisku, G1-opis sparametryzowany przycisku
Drzewo pojazdów: A2-pojazd, B2-samochód, C2-samochod osobowy, D2-łódź, E2-motorówka, F2-amfibia
Drzewo hierarchii stanowisk: B3-czasowy, F3-konsultatnt, A3-pracownik, C3-projektant, E3-czasowy projektant, D3-kierownik, G3-dyrektor
A1
E1 B1
C1 D1 F1 G1
A2
D2 B2
C2 F2 E2
C3 B3
E3
A3
D3 G3 dziedziczenie
Uogólnianie pewnych cech na poziomie korzenia drzewa dziedziczenia w celu uproszczenia obsługi klas/obiektów z całej rodziny.
Przykład
Model rysunku składającego się ze zbioru figur. W klasie Figura uogólniona została metoda Rysuj(). Klasa Rysunek składa się z 1..p różnych Figur, którymi mogą być Koła, Linie, Wielokąty złożone z 1..m Linii lub Grupy_figur złożonych z 1..n Figur, którymi mogą być Koła, Linie, Wielokąt, który.... oraz Grup_figur, które... itd. Wszystkie te przypadki może reprezentować klasa Figura dzięki polimorfizmowi (czyli wirtualnej metodzie Rysuj()). Podczas działania programu każda z wymienionych figur dostarcza własną metodę Rysuj(), stąd Rysunek nie musi jawnie rozróżniać swoich figur.
Przy braku polimorfizmu obiekt Rysunek musi jawnie rozróżniać należące do niego figury
Figura
Rysuj()
Grupa_figur
Rysuj()
Wielokąt
Rysuj()
Linia
Rysuj()
Kolo
Rysuj() położenie
1
1..n
1..m 1
Rysunek 1..p 1
Dziedziczenie + polimorfizm
2. Pojęcie klasy
39Klasa jest typem danych definiowanym przez użytkownika
40Klasa stanowi połączenie innych typów danych (predefiniowanych lub definiowanych przez użytkownika) oraz funkcji przeznaczonych do przetwarzania tych danych (metody)
41 Składnia klasy:
class"|| "struct"|| "union nazwa klasy [:lista klas bazowych]
{ lista składowych klasy};
lista klas bazowych - opcjonalna lista klas, od których dziedziczy dana klasa lista składowych klasy - deklaruje składowe klasy, czyli dane i metody
3. Specyfikatory dostępu do składowych - private, protected i public wspierające hermetyzację
3.1. Deklaracje dostępu do poszczególnych sekcji klasy:
lista składowych klasy ® [specyfikator dostępu :] lista składowych klasy private: sekcja prywatna (domyślna dla class) - składowe klasy są widoczne tylko w obrębie składowych danej klasy oraz w funkcjach/ klasach zaprzyjaźnionych
protected: sekcja zabezpieczona - składowe są widoczne jedynie tylko w obrębie innych składowych klasy, składowych klas dziedziczących
oraz w funkcjach/ klasach zaprzyjaźnionych
public: sekcja publiczna (domyślna dla struct i union)- składowe są widoczne w całym programie
3.2. Deklaracje dostępu do klas bazowych (wykład 6)
:lista klas bazowych ® specyfikator dostępu lista klas bazowych gdzie specyfikator dostępu:
private: publiczne i chronione składowe klasy podstawowej są prywatnymi składowymi klasy pochodnej, natomiast prywatne stają się niedostępne (wyjątek: klasa pochodna jest zadeklarowana jako friend w klasie podstawowej)
public: publiczne oraz chronione składowe klasy podstawowej są publicznymi oraz chronionymi składowymi klasy pochodnej.
4. Obiekty automatyczne, statyczne i dynamiczne Rodzaje zmiennych typu obiektowego - obiektów:
42automatyczne - są definiowane (tworzone) wewnątrz dowolnego bloku funkcji. Są usuwane, gdy wychodzi się z danego bloku lub z funkcji.
43statyczne - definiowane poza funkcjami jako zmienne globalne (o zasięgu wieloplikowym lub jako zmienne typu static o zasięgu jednoplikowym) albo wewnątrz dowolnej funkcji, gdy definicja jest poprzedzona słowem static (dostępne są tylko wewnątrz działającej funkcji z zachowaniem wartości wyznaczonych podczas poprzedniego wywołania). Istnieją przez cały czas działania programu i usuwane są po jego zakończeniu.
44dynamiczne - tworzone jawnie w czasie działania programu na stercie (heap) za pomocą operatora new i usuwane za pomocą operatora delete
5. Konstruktory i destruktory - inicjacja i porządki
Konstruktory - metody o nazwie klasy, wywoływane zawsze podczas tworzenia obiektu.
Są to metody zadeklarowane o różnej liście parametrów lub domyślne.
Domyślny konstruktor bezparametrowy:
nazwa_klasy();
oraz domyślny konstruktor kopiujący:
nazwa_klasy(nazwa_klasy&);.
Jawny konstruktor kopiujący jest tylko jeden i wymaga identycznej definicji.
Konstruktor kopiujący jawny lub domyślny jest wywołany podczas:
45przekazywania obiektów przez wartość do funkcji/metody 46zwracania obiektu przez wartość jako wyniku funkcji/metody 47inicjowania definiowanego obiektu obiektem tej samej klasy.
Pozostałe konstruktory (domyślny lub jawne) są wywoływane podczas:
48definiowania zmiennych obiektowych
49alokacji pamięci za pomocą operatora new.
50
51Destruktor - tylko jedna metoda bezparametrowa o nazwie 52 ~nazwa_klasy()
53wywoływana zawsze podczas usuwania obiektu z pamięci. Może być zdefiniowany jawnie lub jest domyślny. Jawna definicja jest wymagana do zwolnienia pamięci przeznaczonej na dynamiczne składowe klasy lub wykonania pewnych czynności związanych z usuwanym obiektem.
54Przykłady programów
5556Przykład 1.1 - obsługa ekranu za pomocą obiektowej wersji standardowego wyjścia cout i operatora wyjścia <<
57
58#include <iostream.h> // cout
59/*dołączenie pliku z deklaracjami klas obsługującymi standardowe WE/WY*/
60void main() 61{
62 cout <<"Prosty program\n";
63/* na ekranie pojawi się napis “Prosty program” i następnie kursor przejdzie do następnej linii (‘\n’)
*/
64 } 65 6667
68Przykład 1.2 - obsługa klawiatury za pomocą obiektowej wersji standardowego wejścia cin oraz operatora wejścia >>.
69
70#include <iostream.h> //cout, cin 71#include <conio.h> //getch();
72void main() 73{
74 int liczba;
75
76 cout << "Podaj liczbe całkowita: "; /* na ekranie pojawi się napis
77“Podaj liczbe całkowita: ”*/
78 cin >> liczba; /*można wprowadzić klawiatury
79 liczbę całkowitą np. 5*/
80 cout << ”Podano liczbe: ” << liczba << ’\n’;
81/* na ekranie pojawi się napis: “Podano liczbe: 5”, a następnie kursor 82przejdzie na początek następnej linii */
83 getch();
84 }
85Przykład 1.3 - przykład deklaracji klasy połączonej z definicją metod otrzymującym dzięki temu niejawnie atrybut inline (funkcji otwartych). Kod tych metod może być dopisany przez kompilator w miejscu wywołania, eliminując czynności związane z wywoływaniem funkcji. Zastosowanie funkcji otwartych poprawia efektywność czasową i często pamięciową programu
86#include <iostream.h>
87class punkt 88{
89 float x, y; /*część prywatna klasy - pola są niedostępne poza klasą */
90 public: /*jawnie określona część publiczna klasy - wszystkie składowe klasy są dostępne*/
91punkt (float xx, float yy) /*metoda typu konstruktor wywoływana w miejscu deklaracji obiektu
92tej klasy; ustawia wstępnie wartości pól x i y za pomocą wartości dx
93i dy przekazywanych przez wartość*/
94 {
95 x = xx;
96 y = yy;
97 }
98void przesun (float dx, float dy) 99 {
100 x +=dx //x =x + dx;
101 y +=dy //y =y + dy;
102 }
103void wyswietl() /*metoda o charakterze doraźnym - pola należy wyświetlać za 104 pomocą obiektów wyspecjalizowanych w wyświetlaniu*/
105 {
106 cout <<"Moje wspolrzedne: " << x << " "<< y << ’\n’;
107 } 108 };
109void main() 110{
111 punkt p(1.26, 2.6); /*definicja i deklaracja obiektu p - miejsce wywołania konstruktora
*/
112 p.wyswietl(); /* wywołanie metody obiektu p klasy punkt za pomocą operatora wyboru*/
113 p.przesun(2.1, 3.4);
114 p.wyswietl();
116Przykład 1.4 - przykład deklaracji klasy z definicjami metod umieszczonymi poza blokiem deklaracji
117
118#include <iostream.h>
119class punkt 120{
121 float x, y;
122 public:
123 punkt (float, float);
124 void przesun (float, float);
125 void wyswietl();
126};
127punkt::punkt(float xx, float yy) /*definicja metody wymaga zastosowania
128operatora zakresu :: poprzedzonego nazwą klasy*/
129 {
130 x = xx;
131 y = yy;
132 }
133void punkt::przesun(float dx, float dy) 134 {
135 x += dx;
136 y += dy;
137 }
138void punkt::wyswietl() 139{
140 cout <<"Moje wspolrzedne: " << x << " "<< y << ’\n’;
141}
142
143void main() 144{
145 punkt p(1.26, 2.6);
146 p.wyswietl();
147 /*cout <<"Moje wspolrzedne: " << p.x << " "<< p.y << ’\n’;
148 błąd hermetyzacji przy próbie dostępu do składowych prywatnych*/
149 p.przesun(2.1, 3.4);
150 p.wyswietl();
151}
154Przykład 1.5 - zastosowanie metod publicznych dostępu do prywatnych pól w celu pobrania kopii ich wartości np. do wyświetlenia na ekranie
155#include <iostream.h>
156class punkt 157{
158 float x, y;
159 public:
160 punkt (float, float);
161 void przesun (float, float);
162 float odcieta(); // metoda dostępu do pola x
163 float rzedna(); // metoda dostępu do pola y
164};
165punkt::punkt(float xx, float yy) 166 { x = xx; y = yy; }
167void punkt::przesun(float dx, float dy) 168 { x += dx; y += dy; }
169 float punkt::odcieta()
170 { return x;} //metoda zwraca wartość (wyrażenia) za pomocą instrukcji return
171float punkt::rzedna() 172 { return y; }
173
174void wyswietl(punkt& p); /*prototyp funkcji - czyli deklaracja definicji funkcji znajdującej
175 się w innym miejscu - informacja dla kompilatora*/
176void main() 177{
178 punkt p(1.26, 2.6);
179 wyswietl(p);
180 p.przesun(2.1, 3.4);
181 wyswietl(p);
182}
183
184void wyswietl(punkt& p)
185{ /*zachowanie hermetyzacji dzięki publicznym metodom dostępu do pól prywatnych; obiekt p jest przekazywany prze referencję */
186 cout <<"Moje wspolrzedne: " << p.odcieta() << " "<< p.rzedna() <<
’\n’;
1896. Zmienne referencyjne, przekazywanie parametrów przez referencję 190 191Zmienna referencyjna jest to zmienna tożsama z inną zmienną np.:
192
· int zmienna_1;
int& ref_zmienna_1 = zmienna_1;
Zmienna zmienna_1 jest dostępna pod dwiema nazwami: zmienna_1 oraz ref_zmienna_1 .
· const int& ref_stała = 1;
Zmienna ref_stała ma dostęp do wartości 1 umieszczonej w zmiennej tymczasowej.
Przekazywanie parametrów w funkcji/metodzie przez wartość i referencję.
Przykład 1.6
void f (int wart, long& ref, const float& st) {
wart++; /*podczas wywołania funkcji f, wart++ zwiększa na stosie lokalną kopię pierwszego argumentu aktualnego - przekazywanie przez wartość*/
ref++; /*ref++ zwiększa wartość parametru aktualnego za pośrednictwem
adresowania pośredniego - przekazywanie przez referencję polega na umieszczaniu adresu parametru aktualnego na stosie*/
cout << st <<’\n’; /*zmienna st przekazywana jest przez referencję,lecz nie można zmienić jej
wartości*/
}
void main () { int i = 1;
long j = 1;
float k = 3;
f(i, j, k); /* wartość zmiennej i oraz k nie ulegnie zmianie po wykonaniu funkcji f,
natomiast wartość zmiennej j zmieni się i będzie równa 2*/
f(j, i, k); /*Niebiepieczeństwo! - zmienna i typu int podstawiona pod paramentr ref przekazywany jako parametr long przez referencję nie ulegnie zmianie, gdyż operacja została wykonana na
7. Składowe klasy typu static
Składowe typu static istnieją przez cały czas działania programu niezależnie od istnienia obiektu tej klasy. Wszystkie obiekty danej klasy mają wspólne skladowe typu static (przykład 1.7).
W celu osiągnięcia wieloużywalności kodu oddzielono definicję klasy od definicji składowych klasy oraz programu korzystającego z obiektów klasy stosując plik nagłówkowy punkt.h, plik modułowy punkt.cpp, plik programu proba.cpp. Kod wynikowy programu utworzono po wykonaniu kompilacji wieloplikowej (p.8).
· definicja klasy punkt umieszczona w pliku nagłówkowym punkt.h Przykład 1.7
#ifndef PUNKT
/*wykonanie definicji PUNKT po pierwszej kompilacji, stąd wyklucza się wystąpienie wielokrotnej definicji przez uniemożliwienie ponownego dołączenia pliku nagłówkowego (podczas kompilacji kolejnego pliku) za pomocą dyrektywy #include */
#define PUNKT class punkt
{ static int ile_punktow; /*deklaracja pola statycznego istniejącego niezależnie od obiektów tej klasy i wspólnego dla wszystkich obiektów -w roli licznika obiektów klasy punkt*/
float x, y; // prywatne pola dostępne dla składowych klasy i obiektu
public:
punkt (float, float); //konstruktor zwykły - może być ich kilka; brak jawnego // konstruktora kopiowania
~punkt(); //destruktor, może być tylko jeden
static int liczba_punktow(); /*metoda statyczna do obsługi pola statycznego, dostępna niezależnie od istnienia obiektów,
wykorzystana w aplikacji do liczenia obiektów klasy punkt obecnych w danej chwili w
programie*/
void przesun (float, float);
float odleglosc(punkt&);
float odcieta();
float rzedna();
};
#endif
· definicja składowych klasy punkt umieszczona w pliku punkt.cpp
#include "punkt.h"
#include <iostream.h>
#include <math.h>
//konstruktor: ustawia pola i wyznacza liczbę tworzonych obiektów
punkt::punkt(float xx, float yy)
{ cout<<"Konstruktor zwykly\ z parametrami\n";
x = xx; y = yy; ile_punktow++; }
//destruktor: aktualizuje liczbę obiektów po każdym usunięciu
punkt::~punkt()
{ cout<<"Destruktor\n"; ile_punktow--;}
/*definicja pola statycznego istniejącego niezależnie od obiektów klasy, zajmującego
jedno miejsce w pamięci i wspólnego dla wszystkich obiektów danej klasy*/
int punkt::ile_punktow = 0;
/*definicja metody statycznej dostępnej niezależnie od istnienia obiektów danej klasy; metoda dostępu do pola typu static*/
int punkt::liczba_punktow() { return ile_punktow;}
void punkt::przesun(float dx, float dy) { x += dx; y += dy;}
/*przekazywanie przez referencje; w ciele metody można bezpośrednio odwołać się do atrybutów prywatnych obiektu tej samej klasy, do której należy definiowana metoda*/
float punkt::odleglosc(punkt& p)
{ return sqrt(pow(x - p.x, 2) + pow(y - p.y, 2));}
float punkt::odcieta() { return x;}
float punkt::rzedna() { return y;}
· program w pliku proba.cpp
#include <iostream.h>
#include "punkt.h"
void wyswietl_punkt(punkt&); /*przekazanie obiektu przez referencję nie powoduje utworzenie obiektu automatycznego na stosie- prawidłowo liczone obiekty
- w przypadku przekazania przez wartość tworzony jest obiekt automatyczny przez wywołanie niejawnego konstruktora kopiowania, który nie zwiększa wartości pola statycznego ile_punktow, natomiast jedyny destruktor wywołany przy zakończeniu funkcji przy usuwaniu obiektu automatycznego zmniejsza o 1 wartość pola statycznego - w efekcie licznik obiektów zawiera nieprawidłową liczbę obiektów */
void wyswietl_float(float);
void wyswietl_int(int);
void main() {
{ wyswietl_int(punkt::liczba_punktow()); // 0 - nie ma obiektów
punkt p1(1, 2), p2(2, 3);
wyswietl_int(punkt::liczba_punktow()); // 2 obiekty
wyswietl_punkt(p1); wyswietl_punkt(p2);
wyswietl_int(punkt::liczba_punktow()); // 2 obiekty
wyswietl_float(p1.odleglosc(p2)); // 2 obiekty
wyswietl_int(punkt::liczba_punktow()); // 2 obiekty
wyswietl_float(p2.odleglosc(p1)); // 2 obiekty
wyswietl_int(punkt::liczba_punktow()); // 2 obiekty
}
wyswietl_int(punkt::liczba_punktow()); // 0 - obiekty zostały usunięte
}
void wyswietl_punkt(punkt& p)
{ cout <<"Wspolrzedne: " << p.odcieta()<< " "<< p.rzedna() <<’\n’;}
void wyswietl_float(float w)
{ cout <<"Odleglosc: " << w << ’\n’;}
void wyswietl_int(int w)
{ cout <<"Liczba punktow: " << w << ’\n’;}
8. Pliki nagłówkowe, dyrektywy preprocesora, programy wielo-plikowe 8.1. Pliki nagłówkowe powinny zawierać:
· stałe jawne #define TRUE 1
· funkcje makra #define MAX(x, y) ((x) > (y) ? (x) : (y))
· dyrektywy #include <iostream.h>
· prototypy funkcji np. void wyswietl_float(float);
· deklaracje definicyjne typów np.
class punkt
{ float x, y;
public: punkt (float, float);
void przesun (float, float);
};
· definicje stałych const int max = 3;
· definicje funkcji typu inline
inline int Większy(int x, int y) {return x > y; }
· deklaracje nazw class kolo;
· deklaracje zmiennych extern int a;
· wyliczenia enum Boolean {False, True};
· szablony funkcji i klas template <class T>
193 class stos { // ...}
194Uwaga:
195Nie należy nigdy wstawiać do pliu nagłówkowego:
196
197definicji zwykłych funkcji: int Większy(int x, int y) {return x > y; } 198definicji zmiennych: int zmienna;
199definicji stałych agregatów (tablica, obiekt bez konstruktorów, składowych prywatnych i chronionych, klas podstawowych i funkcji wirtualnych): const char tab[]
=”aaa”;
200
2018.2. Główne dyrektywy preprocesora związane z kompilacją wieloplikową:
44956 202 Polecenia dla preprocesora:
203204Dyrektywa #include <stdio.h> oznacza dołączenie w miejscu wystąpienia polecenia standardowego pliku nagłówkowego z deklaracjami typów, funkcji itp, natomiast #include ”tablica1.h” dołączenie pliku nagłówkowego użytkownika
205Klauzula #define nazwa oznacza makrodefinicję, #undef nazwa unieważnia makrodefinicję
206Polecenia kompilacji warunkowej pozwalają na kompilację tylko jednej z sekcji instrukcji:
207
208#if wyrażenie1
209 sekcja _instrukcji1 210 #elif wyrażenie2
211 sekcja _instrukcji2 212 ....
213#else
214 końcowa_sekcja_instrukcji 215#endif
216
2174) Polecenia warunkowej kompilacji uniemożliwiają wielokrotne dołączanie tego samego pliku nagłówkowego lub jego fragmentu podczas kompilacji wieloplikowej:
218
219#ifndef nazwa 220#define nazwa
221 deklaracje //deklaracje czyta kompilator tylko raz, podczas definiowania makro nazwa
222 #endif,
223224#ifdef nazwa
225 deklaracje //kompilator czyta te deklaracje, gdy zdefiniowano makro nazwa
226 #endif
2278.3. Tworzenie projektu umożliwiającego kompilację oraz łączenia plików
228
229Uruchom Borland C++ i wybierz opcję Open Project z menu Project.
Wpisz nazwę pliku projektowego w poli Open Project File z rozszerzeniem PRJ, np proba.prj. Nazwa nadana plikowi PRJ będzie nada programowi wynikowemu EXE czyli proba.exe. Po nadaniu nazwy należy nacisnąć klawisz ENTER. U dołu ekranu pojawi się okno o nazwie Project Proba 230
231Aby dodać pliki do projektu należy nacisnąć klawisz INSERT lub wybrać opcję Add Item z menu Project. Pojawi się okno o nazwie Add to Project List. W polu Name należy wpisać nazwy plików (przez wybór z listy), które należy dodać do projektu. Nie należy dodawać plików nagłówkowych! Po zakończeniu należy nacisnąć przycisk Done w oknie Add to Project List.
232
233Aby skompilować i połączyć pliki źródłowe podane w projekcie, należy wybrać opcję Make z menu Compile lub nacisnąć klawisz F9. Nastąpi kompilacja i utworzenie plików OBJ, a następnie połączenie tych plików i utworzenie programu wynikowego proba.exe.
234
235Można uruchomić program w środowisku za pomocą polecenia Run z menu Run lub gotowego programu proba.exe na poziomie systemu operacyjnego.
236Predefiniowane typy danych
237Typy podstawowe reprezentujące zmienne różnych rozmiarów:
2381. całkowite
· char
· short int
· int
· long int
2. zmiennopozycyjne :
· float
· double
· long double
3. całkowite bez znaku:
· unsigned char
· unsigned short int
· unsigned long int
4. z jawnie zadeklarowanym znakiem:
· signed char
· signed short int
· signed int
· signed long int
239240Gwarancje rozmiarów:
2411 º sizeof (char) £ sizeof(short) £ sizeof(int) £ sizeof(long) 242sizeof (float) £ sizeof(double) £ sizeof(long double)
243sizeof (I) º sizeof (signed I) º sizeof(unsigned I), 244gdzie I może być:
245char (³8 bitów), short(³16 bitow), int(³16 bitów), long(³32 bitów) 246247Uwaga:
248Typy całkowite i całkowite ze znakiem są równoważne za wyjątkiem typów: signed char, unsigned char oraz char (zależnie od sprzętu bez znaku lub ze znakiem)
249 250251 252253
254Operatory
255:: 256zasięg 257nazwa_klasy::składowe
258:: 259globalne 260::nazwa
261. 262wybór składowej 263obiekt, składowa
264 ® 265wybór składowej 266wskaźnik®składowa
267[] 268indeksowanie 269wskaźnik[wyrażenie]
270() 271wywołanie funkcji 272wyrażenie(lista_wyrażeń) 273() 274konstrukcja wartości 275typ(lista_wyrażeń) 276size
of 277rozmiar obiektu 278sizeof wyrażenie
279size
of 280rozmiar typu 281sizeof(typ)
282++ 283przyrostkowe zwiększanie o
1 284L-wartość++
285++ 286przedrostkowe zwiększanie
o 1 287++L-wartość
288-- 289przyrostkowe zmniejszanie
o 1 290L-wartość--
291-- 292przedrostkowe zmniejszanie
o 1 293--L-wartość
294~ 295negacja bitowa 296-wyrażenie
297! 298negacja logiczna 299! wyrażenie
300- 301minus jednoargumentowy 302-wyrażenie 303+ 304plus jednoargumentowy 305+wyrażenie 306& 307adres argumentu 308&L-wartość
309* 310wyłuskanie 311*wyrażenie
312new 313utwórz (przydziel pamięć) 314new typ 315dele
te 316usuń (zwolnij pamięć) 317delete wskaźnik 318dele
te[] 319usuń tablicę 320delete[] wskaźnik
321() 322rzutowanie(konwersja typu) 323(typ) wyrażenie
324.* 325wybór składowej 326obiekt.*wskaźnik-do-składowej 327®* 328wybór składowej 329wskaźnik®do_składowej
330* 331mnożenie 332wyrażenie*wyrażenie
333/ 334dzielenie 335wyrażenie/wyrażenie
336% 337modulo (dzielenie z resztą) 338wyrażenie%wyrażenie
345<< 346przesuwanie w lewo 347wyrażenie<<wyrażenie 348>> 349przesuwanie w prawo 350wyrażenie>>wyrażenie
351< 352mniejszy 353wyrażenie<wyrażenie
354<= 355mniejszy lub równy 356wyrażenie<=wyrażenie 357> 358większy 359wyrażenie>wyrażenie 360>= 361większy lub równy 362wyrażenie >= wyrażenie
363
364
365== 366równy 367wyrażenie == wyrażenie
368!= 369nie równy 370wyrażenie != wyrażenie
371& 372koniunkcja bitowa 373wyrażenie & wyrażenie 374^ 375różnica symetryczna 376wyrażenie ^ wyrażenie
377| 378alternatywa bitowa 379wyrażenie | wyrażenie 380&& 381iloczyn logiczny 382 wyrażenie && wyrażenie
383|| 384suma logiczna 385wyrażenie || wyrażenie 386? : 387wyrażenie warunkowe 388wyrażenie ? wyrażenie :
wyrażenie
389= 390proste przypisanie 391L-wartość = wyrażenie 392*= 393pomnóż i przypisz 394L-wartość *= wyrażenie
395/= 396podziel i przypisz 397L-wartość /= wyrażenie 398%= 399weź modulo i przypisz 400L-wartość %= wyrażenie
401+= 402dodaj i przypisz 403L-wartość += wyrażenie 404-= 405odejmij i przypisz 406L-wartość -= wyrażenie 407<<= 408przesuń w lewo i przypisz 409L-wartość <<= wyrażenie 410>>= 411przesuń w prawo i przypisz 412L-wartość >>= wyrażenie
413&= 414koniunkcja bitowa i
przypisz 415L-wartość &= wyrażenie 416| = 417alternatywa bitowa i
przypisz 418L-wartość | = wyrażenie 419^= 420różnica bitowa i przypisz 421L-wartość ^= wyrażenie 422thr
ow 423zgłoś wyjątek 424throw wyrażenie
425, 426przecinek (ustal kolejność) 427wyrażenie, wyrażenie 428Uwagi:
· operatory jednoargumentowe i operatory przypisania mają prawostronną łączność, a wszystkie pozostałe są lewostronnie łączne
np. a = b = c oznacza a = (b = c), a + b + c oznacza (a + b) + c, *p++ oznacza *(p++)
· operatory umieszczone w tej samej części tabeli mają ten sam priorytet
· operator umieszczony w wyższej części tabeli ma wyższy priorytet np. a + b * c oznacza a + (b * c)
a + b - c oznacza (a + b) - c
Instrukcje
· instrukcja etykietowana nazwa : instrukcja
case wyrażenie-stałe : instrukcja default : instrukcja
· instrukcja złożona {lista-instrukcji}
· instrukcje wyboru
if (wyrażenie) instrukcja
if (wyrażenie) instrukcja else instrukcja switch (wyrażenie)
case wyrażenie stałe: instrukcja; break;
...
default : instrukcja
· instrukcje iteracji
while (wyrażenie) instrukcja do instrukcja while (wyrażenie);
for (instrukcja-inic-for; wyrażenie_1; wyrażenie_2) instrukcja
gdzie instrukcja-inic-for: instrukcja wyrażenia, instrukcja deklaracji
· instrukcje skoku:
break;
continue;
return wyrażenie;
goto identyfikator;
· instrukcja deklaracji 429 deklaracja
430np. for (int i=0; i<100; i++) 431 for (int j = 0; j<100; j++)
432 {/*zmienna j jest niszczona przy każdym obrocie pętli sterowanej zmienną i*/
433 }
434 if (j!=100) //błąd - dostęp do zmiennej jest niemożliwy
435
