Programowanie C++

Programowanie C++ 1

ProgramowanieC++

Obiekty,dziedziczenie,

polimorfizm,

funkcje wirtualne

i wiele innych rzeczy

Iwona Adamiec-Wójcik

Katedra Mechaniki i Inżynierskich

Metod Komputerowych

Politechnika Łódzka

Filia Bielsko-Biała

Programowanie C++ 2

Trochę historii...

W późnych latach 60-tych i na początku lat 70-tych Dennis Ritchie stworzył język C. W tym czasie A&AT Bell Labs zajmowało się systemem operacyjnym UNIX, który początkowo był tworzony w assemblerze. C był pomyślany jako język wyższego poziomu do programowania systemów operacyjnych. Poprzednik języka C, z którego Ritchie zaczerpnął wiele elementów nazywał się B.

W 1985 Bjarne Stroustrup również w Bell Labs stworzył język C++, poszerzając język C o abstrakcyjne typy danych i programowanie obiektowe...

Nazwa języka pochodzi od operatora inkrementacji z języka C (++), i oznacza, że język ten nie jest następcą C (w tym przypadku nazywałby się D) a tylko jego rozszerzeniem.

Programowanie C++ 3

Jeśli chcesz dowiedzieć się trochę więcej...

Literatura dostępna w naszej czytelni:

• Jerzy Grębosz: Symfonia C++• Bjarne Stroustrup: Projektowanie i rozwój języka C++• Paweł Chomicz, Robert Ulijasz: Programowanie w języku C i C++• Tony L. Hansen: C++ zadania i odpowiedzi• Adam Majczak: Od C do C++ Buildera w 48 godzin• Iwona Adamiec-Wójcik, Pedro Guerreiro: Elementy programowania

obiektowego w C++

Programowanie C++ 4

Jak szybko przejść od Pascala do C++

program p01;

{ oto twój pierwszy program}

begin

writeln(' Cześć');

write(' Uczymy się programowania w Pascalu')

end.

Blok w Pascalu jest ograniczany słowami

kluczowymi begin i end.

Każda instrukcja, oprócz tej występującej przed

słowem kluczowym end kończy się średnikiem.

Program główny jest blokiem zakończonym

kropką.

Komentarze zawierają się w nawiasach

klamrowych.

# include <iostream.h>

// oto twój pierwszy program

void main()

{

cout<<" Cześć\n”;

cout<<" Uczymy się programowania w C++”;

}

Blok w C++ jest ograniczany klamrami { }.

Każda instrukcja kończy się średnikiem.

Działanie programu rozpoczyna się od funkcji o

nazwie main.

Wszystkie znaki do końca linii po // są igno-

rowane, komentarz zawiera się pomiędzy /* */.

Programowanie C++ 5

Co widać na ekranie? Do wyświetlania komunikatów na ekranie w C++ możemy zastosować specjalny

obiekt cout wraz z operatorem << (przesyłania do strumienia). Operator << przesyła do strumienia wyjściowego znajdującego się po jego lewej stronie obiekty, które chcemy wyświetlić. Cout oznacza standardowe urządzenie wyjściowe - najczęściej ekran komputera.

Dyrektywa # include <iostream.h> jest konieczna by korzystać ze strumieni wejścia i wyjścia.

cout << wyrażenie << wyrażenie << ... << wyrażenie

cout<<"Cześć" = = cout<<"Cze"<<"ść" = = cout<<'C'<<'z'<<'e'<<'ś'<<'ć'

Wszystkie elementy wysyłane do strumienia są ustawiane w linii w takiej kolejności, w jakiej są przesyłane. Przejście do nowej linii uzyskuje się stosując symbol '\n' lub manipulator endl

cout<<" Cześć\n" = = cout<<" Cześć" <<endl

Programowanie C++ 6

Zmienne, obiekty i ich deklaracje

identyfikator,...,identyfikator : typ;

zm1,zm2,zm3:integer;

cena,koszt:real;

typ identyfikator,...,identyfikator;

int zm1,zm2,zm3;

float cena,koszt;

12345

wartość

(integer)

typ

zmienna

alfa identyfikator

Zmienna to symbol reprezentujący miejsce w pamięci komputera.

Informacja zawarta w tym miejscu pamięci to wartość zmiennej

Deklaracja zmiennej jest instrukcją informującą kompilator o danej zmiennej

C++ jest językiem obiektowo-zorientowanym. Zmienne są traktowane jako obiekty;

w tym kontekście mówi się, że deklaracja tworzy obiekt.

Programowanie C++ 7

Słowa kluczowe i identyfikatoryProgram (napisany w dowolnym języku programowania) składa się z pewnych

elementów składowych, którymi są: • - nazwy zmiennych (zm1,zm2,zm3),• - słowa kluczowe (main, void),• - operatory (<<, +, -),• - znaki punktacji ({, ;, }).

Słowa kluczowe w C++:asm auto break case catch char class const continue default

delete do double else enum extern float for friend goto

if inline int long new operator private protected publicregister

return short signed sizeof static struct switch template this throw

try typedef union unsigned virtual void volatile while

Identyfikatory:- ciąg znaków alfanumerycznych rozpoczynający się od litery bądź znaku podkreślenia,

- małe i duże litery są rozróżniane, - (Numer i numer są różnymi identyfikatorami),

- bez spacji,

- różne od słów kluczowych.

Programowanie C++ 8

Instrukcja przypisania, inicjalizacja zmiennych

Zmienna to miejsce w pamięci. Najczęściej nadanie wartości zmiennej odbywa się przy pomocy instrukcji przypisania.

Zmienna może być zainicjalizowana w momencie deklaracji

identyfikator : = wyrażenie;cena := 234; litera := 'z';

identyfikator = wyrażenie;cena = 234; litera = 'z';

W C++ znak = jest operatorem przypisania

Stała typowa

identyfikator :typ=wartość początkowa;i : integer =1;

Inicjalizacja w deklaracji

typ identyfikator = wyrażenie; int i = 1; int a,b; int sum = a+b;

W C++ inicjalizacja jest prawie tym samym co przypisanie.

Programowanie C++ 9

Przypisanie łańcuchowe

W C++ przypisanie jest wyrażeniem z określoną wartością.Wartością wyrażenia x = 22 jest 22

Tak jak każda inna wartość, również i ta może być użyta w innej instrukcji przypisania i wówczas otrzymujemy łączone przypisanie

y = ( x = 22 ); = = y = x = 22;


// Ten program pokazuje jak przypisanie łańcuchowe Uwaga: tego rodzaju przypisanie nie

// może być wykorzystane w większym wyrażeniu może być użyte jako

main ( ) inicjalizacja zmiennej

{ w deklaracji

int m, n;

m = ( n = 66 ) + 9;

cout<<m<<","<<n<<endl;

}

Programowanie C++ 10

Typy całkowite i proste operacje arytmetyczne

C++ posiada dziewięć następujących typów całkowitych:

char short int unsigned short int

signed char int unsigned int

unsigned char long int unsigned long int

Typy te różnią się między sobą zakresem dopuszczalnych wartości. Dopuszczalne

granice są stałymi, które znajdują się w pliku nagłówkowym <limits.h>

Operatory arytmetyczne dla liczb całkowitych:

+ dodawanie + m+n

- zmiana znaku (jednoargumentowy) - -n

- odejmowanie - m-n

* mnożenie * m*n

DIV dzielenie całkowite / m/n

MOD reszta z dzielenia całkowitego % m%n


Operatory inkrementacji i dekrementacji

Operator inkrementacji ++ oraz dekrementacji -- zamieniają zmienną w wyrażenie

będące instrukcją, które skraca specjalny rodzaj instrukcji przypisania.

#include <iostream.h>

// program pokazuje użycie operatorów ++ i --

main( )

{

int m = 44, n = 66;

cout<<"m = "<<m<<","<<" n = "<<n<<endl;

++m;

-- n;

cout<<"m = "<<m<<","<<" n = "<<n<<endl;

m++;

n--;

cout<<"m = "<<m<<","<<" n = "<<n<<endl;

}

m = 44, n = 66

m = 45, n = 65

m = 46, n = 64

Operatory pre i post inkrementacji( m++ oraz ++m) użyte jako samodzielne instrukcje mają taki sam efekt: dodają 1 do zmiennej; czyli są równoważne instrukcji: m = m+1;

Podobnie operatory pre i post dekrementacji

(n-- oraz --n) będące samodzielnymi instrukcjami mają taki sam efekt: n = n-1;


Operatory inkrementacji i dekrementacji c.d.

Operatory użyte jako podwyrażenia różnią się efektem działania.

Operator pre-inkrementacji (++m) zwiększa zmienną przed użyciem jej w

większym wyrażeniu, natomiast operator post-inkrementacji (m++) zwiększa

wartość zmiennej dopiero po użyciu jej w większym wyrażeniu. #include <iostream.h>

// program testuje operatory ++ i --

main( )

{

int m = 66, n ;

n = ++m;

cout<<"m = "<<m<<","<<" n = "<<n<<endl;

n = m++;

cout<<"m = "<<m<<","<<" n = "<<n<<endl;

cout<<"m = "<<m++ <<endl;

cout<<"m = "<<m<<endl;

cout<<"m = "<<++m<<endl;

}

m = 67, n = 67

m = 68, n = 67

m = 68

m = 69

m = 70

Użycie operatorów inkrementacji i dekrementacji w podwyrażeniach może być nieprzewidywalne ponieważ nie jest zdefiniowana jednoznacznie kolejność obliczania wyrażeń zawierających te operatory


Łączone instrukcje przypisaniaOperatory inkrementacji i dekrementacji nie są jedynymi skróconymi instrukcjami

przypisania. C++ pozwala na łączenie instrukcji przypisania z innymi operatorami

zmienna op= wyrażenie; == zmienna = zmienna op wyrażenie;

op jest dowolnym operatorem dwuargumentowym.

Operator Przykład Działanie+= i += 2 i = i + 2 - = i -= 2 i = i - 2*= i *= 2 i = i * 2/= i /= 2 i = i / 2

%= i %= 2 i = i % 2


main()

{ int n = 44;

n += 9;

cout<<n<<endl; 53

n - = 2; 51

cout<<n<<endl;

}


Priorytety i łączność operatorów

C++ posiada bardzo bogaty zbiór operatorów. Ponieważ w wyrażeniu może wystąpić więcej operatorów bardzo ważna jest informacja w jakiej kolejności następuje obliczanie wartości wyrażeń.

Łączność definiuje w jaki sposób są traktowane operatory o takim samym priorytecie.

Operator Opis Priorytet Łączność Argumenty Przykład

- Negacja 15 Prawostr. Jedno- - n

* Mnożenie 13 Lewostr. Dwu- m * n

/ Dzielenie 13 Lewostr. Dwu- m / n

% Reszta 13 Lewostr. Dwu- m % n

+ Dodawanie 12 Lewostr. Dwu- m + n

- Odejmowanie 12 Lewostr. Dwu- m – n

<< Wyjście 11 Lewostr. Dwu- cout<<m

= Przypisanie 2 Prawostr. Dwu- m = n


Rozmowa z komputerem czyli jak wprowadzać dane

W C++ operacje wejściowe są realizowane w podobny sposób jak operacje wyjścia. Dane wprowadzane są ze strumienia wejściowego cin (standardowo klawiatura) przy pomocy operatora wejścia >> (skierowania strumienia).

W jednej instrukcji wejściowej może być wczytywanych więcej zmiennych

Wczytując zmienne typu char cin ignoruje wszystkie spacje, znaki tabulacji i nowej linii.


main ( )

{

int age;

cout<<" Ile masz lat? ”;

cin>>age;

cout<<" Za 10 lat będziesz miał ”;

cout<<age+10<<endl;

}


main ( )

{

char first,last;

cout<<"Podaj swoje inicjały : ";

cin>>first>>last;

cout<<"Cześć "<<first<<'.'<<last<< '.'<<endl;

}


Podejmowanie decyzji - instrukcja if

Instrukcja if pozwala na warunkowe wykonywanie instrukcji

if wyrażenie logiczne then instrukcja;

if wyrażenie logiczne then instrukcja1

else instrukcja2;

if ( warunek ) instrukcja;

if ( warunek ) instrukcja1;

else instrukcja2;

W C++ nie ma typu logicznego; warunek jest wyrażeniem całkowitym. Instrukcja

będzie wykonywana jeśli wyrażenie ma wartość niezerową. main()

{ int n,d;

cout<<"Wprowadź dwie liczby całkowite: ";

cin>>n>>d;

if (n%d = = 0)

cout<<n<<" jest podzielne przez"<<d<<endl;

}

main()

{ int n,d;

cout<<"Wprowadź dwie liczby całkowite: ";

cin>>n>>d;

if (n%d = = 0)

cout<<n<<" jest podzielne przez"<<d<<endl;

else cout<<n<<" nie jest podzielne przez "<<d;

}


Wyrażenie logiczne w C++

OPERATOR ZNACZENIE= = = równe

<> ! = różne< < mniejsze> > większe

<= < = mniejsze lub równe>= > = większe lub równe

Operatory relacji zwracają wartość 0 dla oznaczenia fałszu oraz 1 dla prawdy.

W C++ dowolna wartość może wystąpić w miejscu

wyrażenia logicznego. Wartość niezerowa traktowana

jest jako prawda, jedynie 0 znaczy fałsz.

main(){ int n,d; cout<<"Wprowadź dwie liczby całkowite: "; cin>>n>>d; if (n%d ) cout<<n<<" nie jest podzielne przez"<<d<<endl; else cout<<n<<" jest podzielne przez "<<d<<endl;}


Instrukcja złożona Instrukcja złożona jest ciągiem instrukcji traktowanym jako pojedyncza instrukcja.

Zarówno program główny w Pascalu jak i funkcja main w C++ tworzą instrukcję złożoną zwaną blokiem.

var x,y,temp:integer;

begin

write(‘ Podaj dwie liczby ‘);

readln(x,y);

if x>y then begin temp:=x;

x:=y;

y:=temp

end;

writeln(x,’ ‘,y)

end.

main()

{

int x,y;

cout<<"Podaj dwie liczby ";

cin>>x>>y;

if (x>y) {

int temp = x;

x = y;

y = temp;

}

cout<<x<<" "<<y;

}


Operatory logiczne

OPERATOR ZNACZENIEnot ! negacja

and && koniunkcjaor || alternatywa

Operatory logiczne służą do

formułowania warunków złożonych.

W C++ wartość wyrażenia logicznego

obliczana jest dotąd, dopóki nie jest

pewne jaki będzie rezultat końcowy.

main(){ int n,d; cout<<"Wprowadź dwie liczby całkowite: "; cin>>n>>d; if (d>0 && n%d ) cout<<n<<" nie jest podzielne przez"<<d<<endl; else cout<<n<<" jest podzielne przez "<<d<<endl;}


Instrukcje zagnieżdżone

Każde else łączone jest z ostatnim wolnym if

var a,b,c,min3:integer;begin

write(‘Podaj trzy liczby ‘);

readln(a,b,c);

if a<=b then if a<=c then min3:=a

else min3:=c

else if b<=c then min3:=b

else min3:=c;

writeln(‘ Minimum wynosi ‘,min3)

end.

main()

{

int a,b,c,min3;

cout<<"Podaj trzy liczby ";

cin>>a>>b>>c;

if (a<=b) if (a<=c) min3 = a;

else min3 = c;

else if (b<=c) min3 = b;

else min3 = c;

cout<<"Minimum wynosi "<<min3;

}


Instrukcja wielowariantowaOdpowiednikiem instrukcji case z Pascala jest instrukcja switch

case wyrażenie of

stała1 : instrukcja1;

...

stałan:instrukcjan;

else:listainstrukcji

end;

case ocena of

5: writeln(’bardzo dobry’);

4: writeln(’dobry’);

3: writeln(’dostateczny’);

2: writeln(’niedostateczny’);

else writeln(’Błędne dane’);

end

switch ( wyrażenie) {case stała1 : lista instrukcji1;

...

case stałan : lista instrukcjin;

default :lista instrukcji

}

switch (ocena) {

case 5: cout<<"bardzo dobry"<<endl; break;

case 4: cout<<"dobry"<<endl; break;

case 3: cout<<"dostateczny"<<endl; break;

case 2: cout<<"niedostateczny"<<endl; break;

default: cout<<"Błędne dane”<<endl;

}


Wyrażenie warunkowe

W C++ istnieje wyrażenie, które jest skróconą formą instrukcji warunkowej if else

warunek ? wyrażenie1 : wyrażenie2

Wartością tego wyrażenia jest wartość wyrażenia1 jeśli warunek jest prawdziwy bądź wartość wyrażenia2 w przypadku przeciwnym.

main()// program oblicza minimum z dwóch liczb{ int n,m,min; cout<<"Wprowadź dwie liczby całkowite: "; cin>>n>>m; min = n<m ? n : m; cout<<" minimum wynosi "<<min<<endl;}


Instrukcje iteracyjne

Pętle pozwalają na cykliczne wykonywanie instrukcji.

while wyrażenie logiczne do instrukcja;

while ( warunek ) instrukcja;

Obliczana jest wartość warunku; instrukcja jest wykonywana tak długo dopóki wartość warunku jest różna od zera.

repeat ciąg instrukcji until warunek;

do instrukcja while ( warunek );

Najpierw wykonywana jest instrukcja a następnie sprawdzany warunek, którego wartość równa zero kończy wykonywanie instrukcji.

for identyfikator := wyrażenie1 to wyrażenie2 do instrukcja

for ( inicjalizacja ; warunek kontynuacji ;

wyrażenie) instrukcja ; Inicjalizowana jest zmienna sterująca pętli, następnie jeśli warunek jest spełniony to instrukcja jest wykonywana. Wyrażenie określa zmianę zmiennej.


Pętle while i do...while

Obie pętle wykonują instrukcję będącą ciałem pętli tak długo dopóki warunek jest prawdziwy czyli dopóki jego wartość jest różna od zera.

main( )

{ int age;

cout<<”Ile masz lat : ";

cin>>age;

while (age<=0) {cout<<"Wiek musi być >0\n”;

cout<<”Ile masz lat : ";

cin>>age;

}

}

main( )

{int age;

do {cout<<”Ile masz lat : ";

cin>>age;

} while (age<=0);

}

Pętla while wymaga by warunek

był określony, co czasami wiąże się

z koniecznością wykonania instrukcji

przed rozpoczęciem pętli.

Pętla do...while jest

wykonywana przynajmniej raz

a warunek sprawdzany jest po

wykonanej instrukcji.


Pętla for

Pętla for najczęściej używana jest do wykonywania określonej liczby powtórzeń.

W C++ instrukcja for jest jedynie bardziej zwartym zapisem pętli while.

Wszystkie trzy części występujące w nawiasie po słowie kluczowym for są opcjonalne.

Może wystąpić np. tylko

warunek:

Instrukcja inicjalizacji może zawierać deklarację zmiennej. Zmienna ta nie jest lokalna dla pętli: for (int i=1; i<=20; i++)

cout<< "Cześć”<<endl;

for ( i=1 ; i<=n ; i++ )

cout<<i<<endl;

i = 1;

while ( i <= n)

{

cout<< i <<endl;

i++;

}

while (age <=0)

cin<<age;

for ( ; age<=0; )

cin<<age;

while (1)

cout<<"Cześć”;

for ( ; ; )

cout<<"Cześć”;


Jeszcze o pętli for

W Pascalu zmienna sterująca pętli for musiała być typu porządkowego. W C++ ta

zmienna nie musi wystąpić, a jeśli się pojawia to może być dowolnego typu.

Pętla for może być również użyta dla więcej niż jednej zmiennej sterującej

#include <iostream.h>main(){ for (int m = 1, n = 8; m<n; m++,n--) cout<<"m = "<<m<<" , n = "<<n<<endl; }

m = 1 , n = 8m = 2 , n = 7m = 3 , n = 6m = 4 , n = 5


FunkcjeProgram w C++ jest zbiorem jednej lub większej liczby funkcji.

int jest domyślnym typem zwracanym przez dowolną

funkcję, dlatego nie trzeba go wymieniać.

function identyfikator(lista parametrów) : typ;

begin

lista instrukcji

identyfikator := wyrażenie

end;

procedure identyfikator(lista parametrów);

begin

lista instrukcji

end;

typ identyfikator ( lista parametrów)

{

lista instrukcji;

return wyrażenie;

}

void identyfikator ( lista parametrów) {

lista instrukcji;

}

int main()

{...

return 0;

}

void main()

{...

return;

}


Standardowe funkcje matematyczne

Funkcje matematyczne zdefiniowane są w pliku nagłówkowym <math.h>Niektóre z funkcji matematycznych:

Postać funkcji Działanie

acos(x)asin(x)atan(x)ceil(x)cos(x)exp(x)fabs(x)floor(x)

arccos(x) (w radianach)arcsin(x) (w radianach)arctg(x) (w radianach)zaokrąglenie w góręcos(x) (wartość kąta w radianach)e do potęgi xwartość bezwzględna z xzaokrąglenie w dół

log(x)log10pow(x,p)

logarytm naturalny z xlogarytm dziesiętny z xx do potęgi p

sin(x) sin(x)sqrt(x)tan(x)

pierwiastek kwadratowy z xtg (x)

Każda funkcja matematyczne zwraca

wartość typu double.

Jeśli parametr przesłany do funkcji

jest typu całkowitego najpierw dokony-

wana jest konwersja typu.

Wartości funkcji używane są jak zwykłe

zmienne w wyrażeniach.

y = sqrt(2);

cout<<2*sin(x)*cos(x);

y = sqrt(1+2*sqrt(3+4*sqrt(5)))


Funkcje zwracające wartośćStandardowe funkcje biblioteczne nie zawierają wszystkich funkcji potrzebnych

programiście. Funkcje definiowane muszą zawierać nagłówek funkcji:

typ identyfikator( lista parametrów formalnych )

oraz ciało funkcji: {

ciąg instrukcji;

return wyrażenie;

}

Lista parametrów formalnych jest

opcjonalna. Muszą jednak pozostać

nawiasy.

W C++ deklaracja funkcji może

być umieszczona przed funkcją

main() a jej definicja może być

umieszczona po funkcji.

int cube(int x)

{

return x*x*x;

}

int max(int x, int y)

{

if (x<y) return y;

else return x;

}


Oddzielna kompilacja

Bardzo często funkcje są kompilowane oddzielnie i umieszczane w oddzielnych

plikach. Sprzyja to „ukrywaniu informacji” użytecznemu w dużych projektach.test_max.cpp int max(int,int); W Borland C++ aby dwa oddzielne pliki

zlinkować

main() należy użyć projektu.

{ int m,n;

do {

cin>>m>>n;

cout<<max(m,n)<< endl; max.cpp while (m != 0); // zwraca większą z dwóch liczb

} int max( int x, int y)

{

if (x<y) return y;

else return x;

}


Funkcje typu void

Funkcje nie zwracające żadnej wartości, będące odpowiednikiem procedur

nazywane są często funkcjami typu void. Nagłówek takiej funkcji jest postaci:

void identyfikator (lista parametrów)

void drukuj_dzien( int nr_d)

{

switch (nr_d){

case 0: cout<<"Niedziela"<<endl;break;

case 1: cout<<"Poniedziałek"<<endl;break;

case 2: cout<<"Wtorek"<<endl;break;

case 3: cout<<"Środa"<<endl;break;

case 4: cout<<"Czwartek"<<endl;break;

case 5: cout<<"Piątek"<<endl;break;

case 6: cout<<"Sobota"<<endl;

}

}

void main ()

{

int n;

cout<<"Podaj numer dnia tygodnia ";

cin>>n;

drukuj_dzien(n);

return;

}

Wywołanie funkcji typu void jest

samodzielną instrukcją.


Parametry przekazywane przez wartość

Parametry przekazywane przez wartość nie ulegają zmianie, gdyż funkcja działa na kopii parametru aktualnego umieszczonej na stosie.

#include <math.h>

int cube(int n)

{

return n*n*n;

}

void main() sześcian = 64 x = 4

{ wyrażenie = 33

int x=4;

cout<<"sześcian = "<<cube(x)<<" x = "<<x<<endl;

cout<<" wyrażenie = "<<cube(2*sqrt(x))-cube(3))<<endl;

}

Parametry aktualne w wywołaniu

funkcji mogą być stałą, zmienną

bądź dowolnym wyrażeniem.


Przekazywanie adresów zmiennych

Aby funkcja mogła dokonać zmiany parametru musi mieć dostęp do samej zmiennej (np. poprzez jej adres).void swap(float *x, float *y)

{

float temp = *x;

*x = *y;

*y = temp; * wskaźnik - zmienna zawierająca

} a = 500 b = 400 adres

void main( ) a = 400 b = 500 & operator adresu - pobiera adres

{ zmiennej float a = 500, b = 400;

cout<<"a = "<<a<<" b = "<<b<<endl;

swap(&a, &b);

cout<<"a = "<<a<<" b = "<<b<<endl;

}


Referencja

Referencja jest aliasem (drugą nazwą) zmiennej. Deklaracja referencji wymaga podania zmiennej, dla której tworzona jest referencja

typ& alias = identyfikator

void main()

{

int a = 500;

int& b = a;

cout<<" zmienna = "<<a<<" alias = "<<b<<endl;

b+=500;

cout<<" zmienna = "<<a<<" alias = "<<b<<endl;

}

Referencja NIE JEST zmienną : nie można zmieniać jej wartości,

nie nożna pobrać jej adresu,

nie można przypisać jej wskaźnika

zmienna = 500 alias = 500

zmienna = 1000 alias = 1000


Parametry przekazywane przez referencję

Parametry przekazywane przez referencję ulegają zmianie gdyż do funkcji przekazywany jest adres zmiennej

void swap(float& x, float& y)

{

float temp = x;

x = y;

y = temp;

} a = 500 b = 400 void main() a = 400 b = 500 {

float a = 500, b = 400;

cout<<"a = "<<a<<" b = "<<b<<endl;

swap(a, b);

cout<<"a = "<<a<<" b = "<<b<<endl;

}

Parametr aktualny odpowiadający

parametrowi formalnemu

przekazywanemu przez referencję

musi być zmienną.


Porównanie parametrów

Podsumowanie różnic pomiędzy przekazywaniem parametrów przez wartość i przez referencję:

Przekazywanie przez wartość Przekazywanie przez referencję

int x; int& x;

Parametr formalny jest zmienną lokalną; Parametr formalny jest lokalną referencją;

Jest kopią parametru aktualnego; Jest synonimem parametru aktualnego;

Nie można zmienić parametru Można zmienić parametr aktualny;

aktualnego;

Parametr aktualny może być stałą, Parametr aktualny musi być zmienną.

zmienną bądź wyrażeniem.

Jest to odpowiednik przekazywania Jest to odpowiednik przekazywania przez

przez wartość w Pascalu. zmienną w Pascalu.


Parametry przekazywane przez stałą referencję

Duże obiekty są przekazywane przez referencję aby nie tworzyć ich kopii. Jeśli nie chcemy, by uległy zmianie można je przekazywać przez stałą referencję.

void f(int x, int& y, const int& z)

{

x+=z;

y+=z;

cout<<" x = "<<x<<" y = "<<y<<" z = "<<z<<endl;

}

void main ()

{

int a = 20, b = 30, c = 40;

cout<<" a = "<<a<<" b = "<<b<<" c = "<<c<<endl;

f(a,b,c);

cout<<" a = "<<a<<" b = "<<b<<" c = "<<c<<endl;

}

a = 20 b = 30 c = 40

x = 60 y = 70 z = 40

a = 20 b = 70 c = 40


Wywołanie funkcji związane jest z dodatkowym czasem i pamięcią. W niektórych przypadkach korzystniejsze jest zdefiniowanie funkcji jako inline.

inline int cube( int n)

{

return n*n*n;

}

main ( ) main ( )

{ {

cout<<cube(4)<<endl; cout<<(4*4*4)<<endl;

int x, y; int x, y;

cin>>x; cin>>x;

y = cube(2*x - 3); y = (2*x - 3)*(2*x - 3)*(2*x - 3);

}

Funkcje typu inline


Zmienna lokalna - zmienna deklarowana wewnątrz bloku; widoczna jest od miejsca deklaracji do końca najbardziej wewnętrznego bloku;

Zmienna globalna - zmienna dostępna w całym programie; deklarowana na zewnątrz wszystkich funkcji;

Operator zakresu - :: pozwala na dostęp do zmiennej globalnej z bloku, w którym jest zadeklarowana zmienna lokalna o takiej samej nazwie.

void f( );

int x = 9;

void main( )

{

int x = 22;

cout<<" x w main = "<<x<<endl;

cout<<" x globalne = ”<<::x<<endl;

f( );

}

Zakres widoczności zmiennych

void f( )

{

int x = 44;

cout<<" x w funkcji f = "<<x<<endl;

}

x w main = 22

x globalne = 9

x w funkcji f = 44


C++ pozwala na użycie tej samej nazwy dla różnych funkcji. Aby funkcje były rozróżniane lista parametrów musi zawierać różną liczbę parametrów albo

musi wystąpić różnica typu przynajmniej jednego parametru

int max (int, int);

int max (int, int, int);

float max(float, float);

void main ( )

{

cout<<max(99,77)<<" "<<max(55,66,33)<<" "<<max(3.4, 7.2)<<endl;

}

int max (int x, int y) int max( int x, int y, int z) float max(float x, float y)

{ { {

return (x>y ? x : y); int m = (x>y ? x : y); return (x>y ? x : y);

} return (m>z ? m : z); }

}

Przeciążenie (overloading)


Parametry domyślne

Dzięki parametrom domyślnym liczba parametrów w wywołaniu funkcji może się zmieniać.

double p( double, double, double=0, double=0, double=0);

main( )

{

double x = 2.0003;

cout<<"p(x,7) = "<<p(x,7)<<endl;

cout<<"p(x,7,6) = "<<p(x,7,6)<<endl;

cout<<"p(x,7,6,5) = "<<p(x,7,6,5)<<endl;

cout<<"p(x,7,6,5,4) = "<<p(x,7,6,5,4)<<endl;

}

double p( double x, double a0, double a1, double a2, double a3)

{

return a0+(a1+(a2+a3*x)*x)*x;

}

p(x,7) = 7

p(x,7,6) = 19.0018

p(x,7,6,5) = 39.0078

p(x,7,5,4) = 71.0222 Parametry z wartościami

domyślnymi muszą wystąpić

na końcu listy parametrów.

Jeśli w wywołaniu pomija się

któryś z parametrów to trzeba

pominąć również wszystkie

następne.


Czas życia obiektu trwa od momentu jego deklaracji do momentu kiedy przestaje istnieć - obiekt może być niewidoczny ale istnieć.

Obiekty automatyczne - obiekty, które wraz z zakończeniem bloku, w którym

zostały powołane do życia przestają istnieć.

Obiekty automatyczne w chwili deklaracji nie są zerowane.

Obiekty lokalne statyczne - obiekty deklarowane lokalnie,

static typ identyfikator;

zakres widoczności tych obiektów odnosi się do bloku ale ich czas życia jest taki jak

obiektów void f( ) globalnych.

{

static int licznik;

licznik++

}

Czas życia zmiennych


Tablice

Tablica - strukturalny typ danych będący ciągiem obiektów tego samego typu. Składniki tablicy zwane elementami są dostępne poprzez indeksy.

identyfikator : array [zakres] of typ

typ identyfikator[stała]

a: array [1..3] of integer; int a [3];

a[1], a[2], a[3] a[0], a[1], a[2]

- indeksy tablicy mogą być - stała określa liczbę elementów

z dowolnego zakresu. Numeracja elementów rozpoczynasię zawsze od zera.

Element o indeksie równym stałej nie istnieje.


Inicjalizacja tablic

Zmienna tablicowa tak jak każda inna zmienna może zostać zainicjalizowana w momencie deklaracji.

int a[3] = {1,2,3}; - inicjalizacja w deklaracji to jedyne miejsce, gdzie kompilator sprawdza zakres tablicy:

int a[3]={1,2,3,4} ŹLE

int a[3] = {1,2} - jeżeli liczba elementów jest większa niż liczba wartości,

to zadane wartości zostaną przyporządkowane pierwszym elementom a pozostałe będą

inicjalizowane zerem;

int a[ ] = {1,2,3,4} -jeśli nie podajemy rozmiaru tablicy, to kompilator liczy wartości i rezerwuje pamięć na tablicę o takim

rozmiarze;


Przekazywanie tablic do funkcjiconst int size=100;

void getArray(double [ ], int&);

void printArray(const double[ ], const int);

int main()

{ double a[size];

int n;

getArray(a,n);

cout<<"Tablica ma "<<n<<" elementów"<<endl;

printArray(a,n);

}

void getArray(double a[ ], int& n)

{ cout<<"Podaj liczbe elementów ";

cin>>n;

for( int i=0; i<n,i<size; i++) void printArray(const double a[ ], const int n)

{ cout<<" element "<<i<<" = "; {

cin>>a[i]; for (int i=0; i<n; i++)

} cout<<i<<" : "<<a[i]<<endl;

} }

Deklaracja tablicy na liście

parametrów formalnych funkcji

nie wymaga podawania jej zakresu.

Nazwa tablicy jest jej adresem

bazowym.


Typ wyliczeniowy jest typem całkowitym i jest jednym z najprostszych typów definiowanych przez użytkownika:

type identyfikator = ( lista wartości) enum identyfikator{ lista wartości }

Lista wartości jest listą identyfikatorów definiujących stałe całkowite rozpoczynając od zera.

main ()

{

enum Day = {sun, mon, tue, wed, thu, fri, sat}

float temp[sat+1] = {23.0, 22.4, 21.0, 18.5, 19.0, 20.2, 19.0}

for (Day day=sun; day<=sat; day++)

cout<<" Temp max w dniu "<<day<<" wynosiła "

<<temp[day]<<endl;

}

Typ wyliczeniowy

Temp max w dniu 0 wynosiła 23.0








Definiowanie typów

Typ wyliczeniowy w C++ ma kilka cech, których nie miał odpowiadający mu typ

z Pascala: Nie zawsze jest to typ porządkowy.enum Base {bin = 2, oct = 8, dec = 10, hex = 16} -można nadawać wartości

poszczególnym identyfikatorom;

enum Answer {no = 0, false = 0, yes = 1, ok = 1} - może wystąpić kilka identyfikatorów z taką samą wartością;

C++ umożliwia nadawanie nowych nazw istniejącym typom:

typedef typ alias;

typedef long Integer; Integer n;

typedef double Real; Real x;

typedef float tablica[ ]; tablica a;


Tablice wielowymiarowe

Elementy tablicy mogą być dowolnego typu nie wyłączając typu tablicowego. Otrzymujemy wówczas tablicę tablic zwaną tablicą wielowymiarową.

void print(const int a[][5]); - tablica wielowymiarowa przekazywana do

main() funkcji musi zawierać zakresy wszystkich

{ pozostałych wymiarów oprócz pierwszego;

int a[2][5]={ 1, 2, 3, 4, 5, 6, 7, 8, 9,10} - wartości tablicom wielowymiarowym są

print(a); przypisywane wierszami, co można zaznaczyć

} przy pomocy nawiasów klamrowych;void print(const int a[][5])

{

for (int i=0;i<2;i++){

for(int j=0; j<5; j++)

cout<<" "<<a[i][j]; - każdy indeks musi być umieszczony w

cout<<endl; oddzielnym nawiasie kwadratowym; }

}


WskaźnikiWskaźniki to zmienne, których wartościami są adresy innych zmiennych.

identyfikator : ^typ typ* identyfikator

Deklaracja zmiennej wskaźnikowej musi zawierać informację o typie zmiennych, na które wskaźnik może pokazywać.

main()

{

int n=33;

int* p=&n; - inicjalizacja zmiennej wskaźnikowej

int& r = *p; - deklaracja i inicjalizacja referencji

cout<<" n = "<<n<<" *p = "<<*p<<" r = "<<r<<endl; int* p = &n;

} p ==&n

n==*p

n ==*&n p ==&*p

n = 33 *p = 33 r = 33


Obiekty i l-wartości

Obiekt jest obszarem w pamięci;

l-wartość jest wyrażeniem odnoszącym się do obiektu lub funkcji.

int n; //nazwy zmiennych są l-wartościami;

const int max = 655;

int a[8];

int* p = &n;

l-wartość może być zmienna (jeśli może pojawić się po lewej stronie instrukcji przypisania)

bądź niezmienna (w przeciwnym wypadku)

* jest operatorem służącym do odnoszenia się wskaźnikiem;

& jest operatorem służącym do pobrania adresu.

* operator dereferencji wraz ze zmienną wskaźnikową jest l-wartością

*p = 77;


Zwracanie referencji przez funkcję

Typ zwracany przez funkcję może być referencją pod warunkiem, że wartość zwracana jest l-wartością, która nie jest lokalna dla funkcji.

int& max(int& m, int& n)

{

return (m>n ? m:n)

}

main()

{

int m = 44, n = 22;

cout<<m<<", "<<n<<", "<<max(m,n)<<endl; 44, 22, 44 max(m,n)=55;

cout<<m<<", "<<n<<", "<<max(m,n)<<endl; 55, 22, 55}


Wskaźniki mogą być wykorzystywane do działań na tablicach.

Wskaźniki mogą być inkrementowane

main( ) i dekrementowane. Oznacza to

{ przesunięcie wskaźnika o wielkość

const int size = 3; odpowiadającą obiektowi, na który

int a[size]={11,22,33}; wskazuje. cout<<"a = "<<a<<" wielkość elementu = "

<<sizeof(int)<<endl;

int* end = a+size; a = 0xffee wielkość elementów = 2

int sum=0; 0xffee *p = 11 sum = 11

for (int* p=a; p<end; p++){ 0xfff0 *p = 22 sum = 33

sum+=*p; 0xfff2 *p = 33 sum = 66 cout<<p<<" * p = "<<*p<<" sum = "<<sum<<endl;

} int* p = a == int* p = &a[0]

} &a[2] == p+2 == *(a+2)

Tablice i wskaźniki


Arytmetyka wskaźników

Jedyną stałą wskaźnikową jest adres 0x0 inaczej NULL co oznacza, że wskaźnik nie pokazuje na nic konkretnego.

int* p = 0; // inicjalizacja wskaźnika z wartością NULL

int* p = NULL; //wymaga pliku stddef.h

Nazwa tablicy jest stałym wskaźnikiem co oznacza, że jej adres nie może ulec zmianie.

int* p, *q, n; Operatory relacji:... p<=q; p<q; p>=q, p>q; p==q; p!=q

p - q;

p + n; Operator logicznego przeczenia

p - n; !p

wynikiem jest 1 jeśli wskaźnik p jest NULL, w

przeciwnym przypadku wynik jest równy 0.


Operator newWskaźnik można zainicjalizować poprzez podanie adresu zmiennej bądź użycie

operatora new, który rezerwuje miejsce w pamięci, na które wskaźnik pokazuje.

float* p; // p jest wskaźnikiem do float

*p = 3.14; // ERROR: nie została przydzielona pamięć, na którą ma wskazywać p

float x=3.14; // zainicjalizowanie zmiennej x; alokacja pamięci pod nazwą x

float*p = &x; // wskaźnik zawiera adres zmiennej x

*p = 3.14; // O.K.: *p wskazuje na określone miejsce w pamięci

float* q;

q = new float; //przydzielenie pamięci dla float; alokacja pamięci bez nazwy

*q = 3.14; //O.K.: pamięć została przydzielona

float* p = new float; float* q = new float(3.14);

Operator new zwraca adres określonej liczby bajtów wolnej pamięci.


Operator deleteOperator delete odwraca działanie operatora new zwracając określoną liczbę bajtów

pamięci jako wolną do zagospodarowania.

float* q = new float;

delete q; // zwolnienie pamięci przydzielonej dla wskaźnika q

*q = 3.14; //ERROR: q nie pokazuje na żaden obiekt.

Za pomocą operatora delete kasuje się tylko obiekty stworzone operatorem new poza wskaźnikami do stałych.

float x = 3.14;

float* p = &x;

delete p; //RYZYKOWNE: p nie było tworzone przez new;

const int* p = new int;

delete p; //ERROR: nie można zlikwidować wskaźnika do stałej


Tablice dynamiczne

Obiekty dynamiczne - obiekty tworzone w trakcie wykonywania programu przez

użycie operatorów new i delete.void get(double*& a, int& n)

{ // funkcja tworzy tablicę dynamiczną

cout<<"Podaj liczbę elementów: "; new typ [wyrażenie]

cin>>n; delete [ ] wskaźnika = new double [n];

for (i=0; i<n; i++) {

cout<<i+1<<": ";

cin>>a[i]; main()

} {

} double* a; // a jest nieokreślonym wskaźnikiem do double

void print(double* , int); int n;

get(a,n);

print(a,n); //a jest tablicą n liczb typu double

delete [ ]a; //a jest nieokreślonym wskaźnikiem do double

}


Użycie const ze wskaźnikami

Wskaźnik do stałej to coś innego niż stały wskaźnik.

int* p; // wskaźnik do int

++(*p);

++p;

int* const cp; // stały wskaźnik do int

++(*cp);

++cp;

const int* pc; // wskaźnik do stałej int

++(*pc);

++pc;

const int* const cpc; //stały wskaźnik do stałej int

++(*cpc);

++cpc;


Tablice wskaźników i wskaźniki do wskaźników

Elementami tablic mogą być wskaźniki

int* a[4];

// pośrednie sortowanie bąbelkowe a[2] = new int(4);// tablicy wskaźników

void sort(float* p[ ], int n) Wskaźnik może pokazywać na inny wskaźnik{

float* temp; char c = ’t’;

for(i=1; i<n; i++) char* pc = &c;

for(j=0; j<n-i; j++); char** ppc = &pc;

if (*p[j]>*p[j+1]){ char*** pppc = &ppc;

temp = p[j]; ***pppc = ’w’; // zmienia wartość c p[j] = p [j+1];

p [j+1] = temp;

}

}


Wskaźniki do funkcjiNazwa funkcji podobnie jak nazwa tablicy jest stałym wskaźnikiem.

int f ( int ); // deklaracja funkcji

int (*pf) ( int ); // deklaracja wskaźnika do funkcji

pf = &f; // inicjalizacja wskaźnika adresem funkcji

int sum(int (*)(int), int);

int square(int);

int cube (int);

main()

{

cout<< sum (square,4)<<endl; int sum( int (*pf)(int k), int n)

cout<< sum(cube,4)<<endl; {

} int suma = 0;

int square(int k) for (int i=1; i<=n; i++)

{ return k*k; } suma+=(*pf)(i);

int cube (int k) return suma

{ return k*k*k; } }

30

90


Łańcuchy

String jest kolekcją znaków zakończonych znakiem ’\0’ (NULL) traktowanych

jako pojedynczy obiekt.

W C++ string jest tablicą znaków o pewnych wyjątkowych cechach:

- Dodatkowy element jest dodawany na końcu tablicy i jego wartość wynosi NULL;

Liczba elementów w tablicy jest o jeden większa niż długość łańcucha

- Łańcuch może być inicjalizowany stałą łańcuchową

char str[ ]= "Hello";

- Łańcuch może być wysłany do strumienia wyjściowego jako pojedynczy element

cout<<str;

- Łańcuch może być pobrany ze strumienia wejściowego jako pojedynczy element

cin>>s; // będą wczytywane znaki aż do napotkania spacji lub innego znaku końca

- <string.h> zawiera funkcje działające na łańcuchach


Inicjalizacja łańcuchów

Jeśli wypełniamy tablicę znaków element po elemencie należy pamiętać o umieszczeniu znaku NULL na końcu. Kompilator C++ automatycznie dołącza znak NULL na końcu stałej tekstowej.

main()

{

char alfabet[27]; //26 liter + NULL

char litera;

int indeks;

for(litera='A', indeks=0; litera<='Z';litera++)

alfabet[indeks]=litera;

alfabet[indeks]=NULL;

cout<<"Litery alfabetu: "<<alfabet;

}

char alfabet[ ]="ABCDEFGHIJKLMNOPQRSTUWVXYZ";

char alfabet[ ]={'A','B','C','D','E',....,'Z','\0'}

NULL to znak o kodzie ASCII 0for (indeks=0; alfabet[indeks]; indeks++)

cout<<alfabet[indeks];

Niedopuszczalna jest instrukcja przypisania

stałej tekstowej do zmiennej tablicowej: char alfabet[27];

alfabet ="ABCDEFGHIJKLMNOPQRSTUWVXYZ";


Łańcuch jako wskaźnik i tablice łańcuchów

Nazwa tablicy jest jej adresem - string można traktować jako wskaźnik do

pierwszego elementu łańcucha. char* p;Jeśli p jest wskaźnikiem do dowolnego typu to

cout<<p; powoduje wypisanie adresu zmiennej;

w przypadku gdy p jest wskaźnikiem do char

cout<<p; powoduje wypisanie wszystkich znaków aż do napotkania ’\0’

main()

{

char* name[] = {" George Washington",

" John Adams",

"Thomas Jefferson" }

for(int i=0; i<3; i++)

cout<<"\t"<<i<<". [ "<<name[i]<<" ]"<<endl;

}

0. [ George Washington ]

1. [ John Adams ]

2. [ Thomas Jefferson ]


Funkcje biblioteczne <string.h>

char *strcpy(char *str1, const char *str2) Kopiuje s2 do s1;

Zwraca s1

char *strncpy(char *str1, const char *str2, size_t n) Kopiuje co najwyżej n znaków z s2 do s1;

Zwraca s1

char *strcat(char *str1, const char *str2) Dołącza s2 do s1 (NULL z s1 zastępuje s2[1]);

Zwraca s1

char *strncat(char *str1, const char *str2, size_t n) Dołącza co najwyżej n znaków z s2 do s1;

Zwraca s1

int strcmp(char *str1, const char *str2) Porównuje s1 z s2 ( zgodnie z tabelą ASCII);

Zwraca wartość ujemną, dodatnią lub 0

int strncmp(char *str1, const char *str2, size_t n) Porównuje do n znaków łańcucha s1 z s2;

Zwraca wartość ujemną, dodatnią lub 0

char *strtok(char *str1, const char *str2) Rozkłada łańcuch s1 na „elementy” oddzielone separatorami umieszczonymi w s2; Zwraca wskaźnik do wydzielonego elementu. Kolejne wywołania wymagają jako pierwszego argumentu NULL.

Modyfikuje s1!!!

size_t strlen(const char* s) Zwraca długość łańcucha s (bez znaku NULL)


Użycie funkcji bibliotecznych#include <iostream.h>

#include <string.h>

main( )

{

char string[ ]= "To jest zdanie czterowyrazowe";

char* tokenPtr;

cout<<"Zdanie do rozbioru: \n"<<string;

cout<<"\nWyrazami są: \n";

tokenPtr=strtok(string," ");

while (tokenPtr!=NULL){

cout<<tokenPtr<<'\n';

tokenPtr = strtok(string, " ");

}

}

#include <iostream.h>#include <string.h>main( ){

char x[ ]="Happy Birthday to You";char y[25]; char z[15];cout<<"Łańcuch w tablicy x: "<<x;cout<<"\nŁańcuch w tablicy y: "<<strcpy(x,y);strncpy(z,x,14); //nie kopiuje NULLz[14]='\0';cout<<"\nŁańcuch w tablicy z: "<<z;

}Łańcuch w tablicy x: Happy Birthday to You

Łańcuch w tablicy y: Happy Birthday to You

Łańcuch w tablicy z: Happy BirthdayZdanie do rozbioru:

To jest zdanie czterowyrazowe

Wyrazami są

To

jest

zdanie

czterowyrazowe

...

char myStr[100];

...

myStr= "Abrakadabra"; //NIE

strcpy(myStr, "Abrakadabra"); //TAK

Documents

Programowanie C++