Podstawy informatyki 2013/2014 Łukasz Sztangret Katedra Informatyki Stosowanej i Modelowania Prezentacja przygotowana w oparciu o materiały Danuty Szeligi i Pawła Jerzego Matuszyka

int, int*, int** int a=1; int *w=&a; int **ww=&w; cout<<&ww<<endl; cout<<ww<<endl; cout<<*ww<<endl; cout<<**ww<<endl; 0043F8CC 0043F8CF 0043F8D0 0043F8D3 0043F8D4 0043F8D7 a w ww F8CC 0043F8D0 0043F8D4 0043F8D0 0043F8CC 1

void f1(int), void f3(int*), void f5(int**) void f2(int&), void f4(int*&), void f6(int**&) void f1(int fa){} int main() { int a=1; int *w=&a; int **ww=&w; f1(a); return 0; } 0043F8CC 0043F8CF 0043F8D0 0043F8D3 0043F8D4 0043F8D7 0043F8D8 0043F8DB a w ww fa F8CC 0043F8D0 1 Nie możemy zmienić: a, w, ww Możemy zmienić:

void f1(int), void f3(int*), void f5(int**) void f2(int&), void f4(int*&), void f6(int**&) void f2(int &fa){} int main() { int a=1; int *w=&a; int **ww=&w; f2(a); return 0; } 0043F8CC 0043F8CF 0043F8D0 0043F8D3 0043F8D4 0043F8D7 a w ww F8CC 0043F8D0 fa Nie możemy zmienić: w, ww Możemy zmienić: a

void f1(int), void f3(int*), void f5(int**) void f2(int&), void f4(int*&), void f6(int**&) void f3(int *fw){} int main() { int a=1; int *w=&a; int **ww=&w; f3(w); return 0; } 0043F8CC 0043F8CF 0043F8D0 0043F8D3 0043F8D4 0043F8D7 0043F8D8 0043F8DB a w ww fw F8CC 0043F8D0 0043f8CC Nie możemy zmienić: w, ww Możemy zmienić: a

void f1(int), void f3(int*), void f5(int**) void f2(int&), void f4(int*&), void f6(int**&) void f4(int *&fw){} int main() { int a=1; int *w=&a; int **ww=&w; f4(w); return 0; } 0043F8CC 0043F8CF 0043F8D0 0043F8D3 0043F8D4 0043F8D7 a w ww F8CC 0043F8D0 fw Nie możemy zmienić: ww Możemy zmienić: a, w

void f(int), void f(int*), void f(int**) void f(int&), void f(int*&), void f(int**&) void f5(int **fww){} int main() { int a=1; int *w=&a; int **ww=&w; f5(ww); return 0; } 0043F8CC 0043F8CF 0043F8D0 0043F8D3 0043F8D4 0043F8D7 0043F8D8 0043F8DB a w ww fww F8CC 0043F8D0 Nie możemy zmienić: ww Możemy zmienić: a, w

void f(int), void f(int*), void f(int**) void f(int&), void f(int*&), void f(int**&) void f6(int **&fww){} int main() { int a=1; int *w=&a; int **ww=&w; f6(ww); return 0; } 0043F8CC 0043F8CF 0043F8D0 0043F8D3 0043F8D4 0043F8D7 a w ww F8CC 0043F8D0fww Nie możemy zmienić: Możemy zmienić: a, w, ww

Możliwe wywołania funkcji int a=1; int *w=&a; int **ww=&w; void f1(int); void f2(int&); void f3(int*); void f4(int*&); void f5(int**); void f6(int**&); f1(a);f1(*w);f1(**ww); int a;int *w;int **ww; f2(a);f2(*w);f2(**ww); f3(&a);f3(w);f3(*ww); --f4(w);f4(*ww); --f5(&w);f5(ww); -- f6(ww); 0043F8CC 0043F8CF 0043F8D0 0043F8D3 0043F8D4 0043F8D7 a w ww F8CC 0043F8D0

Wskaźnik do funkcji Funkcję można wywołać lub można pobrać jej adres (miejsce, gdzie jej kod zaczyna się w pamięci). W wyniku wywołania zaczyna się wykonywać kod tej funkcji: q = fun(x, 7); W wyniku pobrania adresu funkcji uzyskuje się wskaźnik do tej funkcji: pfun = &fun; Wskaźnika tego można użyć do wywołania funkcji: q = (*pfun)(x, 7)

Wskaźnik do funkcji Definicja: –funkcji fun typu T (T1, T2,...): T fun(T1, T2,...) {... } –wskaźnika pf (do tej funkcji) typu T (*)(T1, T2,...): T (*pf)(T1, T2,...); int (*pf)(double, char); Ustawienie (dwa alternatywne sposoby): pf = fun; pf = &fun; Użycie (wywołanie funkcji przez wskaźnik): int res; double x=0.5; char y=a; res = (*pf)(x, y); res = pf(x, y);

Wskaźnik do funkcji #include using namespace std; int podwoj(int a); int potroj(int a); int main() { int a, (*fun)(int a); a=10; fun=podwoj; cout << (*fun)(a) << endl; fun=potroj; cout << (*fun)(a) << endl; cout << a << endl; return 0; } int podwoj(int a) { return (a*2); } int potroj(int a) { return (a*3); }

Wskaźnik do funkcji #include using namespace std; int f(int a); void fun(int (*)(int),int); int main() { int (*w)(int)=&f; fun(w,5); return 0; } int f(int a) { return 2*a; } void fun(int (*wf)(int), int a) { cout<<wf(a)<<endl; } 10

Czytanie deklaracji 1.Zaczynamy od nazwy. 2.Następnie poruszamy się w prawo. 3.Gdy napotkamy na nawias zamykający poruszamy się w lewo. 4.Jeżeli odczytaliśmy już wszystko w obrębie danego nawiasu wychodzimy na zewnątrz i znowu poruszamy się w prawo.

Co to jest a??? int *(*(*a)(int))[10]; int *(*(*a)(int))[10 a jest ]; int *(*(*a)(int))[10]; wskaźnikiem int *(*(*a)(int))[10]; do funkcji wywoływanej z parametrem typu int int *(*(*a)(int))[10]; zwracającej wskaźnik int *(*(*a)(int))[10]; do 10-cio elementowej tablicy int *(*(*a)(int))[10]; wskaźników do obiektów typu int

Co to jest a??? int (*(*a())[10])(); int (*(*a())[10])(); a jest funkcją wywoływaną bez parametrów int (*(*a())[10])(); zwracającą wskaźnik int (*(*a())[10])(); do 10-cio elementowej tablicy int (*(*a())[10])(); wskaźników int (*(*a())[10])(); do funkcji wywoływanych bez parametrów int (*(*a())[10])(); zwracających obiekty typu int

Co to jest a??? float (*(*a)(int))(); float (*(*a)(int))(); a jest float (*(*a)(int))(); wskaźnikiem float (*(*a)(int))(); do funkcji wywoływanej z parametrem typu int float (*(*a)(int))(); zwracającej wskaźnik float (*(*a)(int))(); do funkcji wywoływanej bez parametrów float (*(*a)(int))(); zwracających obiekty typu float

Co to jest a??? int (*(*(*a)())[10])(); int (*(*(*a)())[10])(); a jest int (*(*(*a)())[10])(); wskaźnikiem int (*(*(*a)())[10])(); do funkcji wywoływanej bez parametrów int (*(*(*a)())[10])(); zwracającej wskaźnik int (*(*(*a)())[10])(); do 10-cio elementowej tablicy int (*(*(*a)())[10])(); wskaźników int (*(*(*a)())[10])(); do funkcji wywoływanych bez parametrów int (*(*(*a)())[10])(); zwracających obiekty typu int

Wskaźnik do funkcji jako argument innej funkcji #include using namespace std; double dod (double a, double b){return (a+b);} double ode (double a, double b){return (a-b);} double mno (double a, double b){return (a*b);} double dzi (double a, double b){return (a/b);} double wykonaj(double (*)(double, double),double,double); int main() { int wybor; double a,b; cout << "Wybierz dzialanie\n"; cout << "1.Dodawanie\n2.Odejmowanie\n"; cout << "3.Mnozenie\n4.Dzielenie\n"; cin >> wybor; cout << "Podaj dwie liczby\n"; cin >> a >> b; double (*wsk[4])(double, double)={dod, ode, mno, dzi}; cout<<wykonaj(*wsk[wybor-1],a,b)<<endl; return 0; } double wykonaj(double (*wsk)(double, double), double a, double b){return (*wsk)(a,b);}

Arytmetyka wskaźników Rezultat zastosowania do wskaźników operatorów arytmetycznych +, -, +=, -=, ++ i -- zależy od typu wskazywanego obiektu. Stosując operator arytmetyczny do wskaźnika p typu T* zakładamy, że p wskazuje na element w tablicy obiektów typu T. Wtedy: –p + 1 oznacza adres następnego elementu w tablicy, –p - 1 oznacza adres poprzedniego elementu w tablicy, –p + i oznacza adres i-tego następnego elementu, –p - i oznacza adres i-tego poprzedniego elementu

Arytmetyka wskaźników #include using namespace std; int main() { int tab[]={0,1,2,3,4}; int *wsk1,*wsk2; wsk1=&tab[1]; wsk2=&tab[4]; cout << wsk2-wsk1 << endl; return 0; } 3

Arytmetyka wskaźników int main() { int tab[5]={1,2,3,4,5}; int *wsk; wsk=tab; for (int i=0;i<5;i++) { cout<<*wsk<<"\t"<<wsk<<endl; wsk++; } return 0; }

Porównywanie wskaźników Dwa wskaźniki tego samego typu są równe (różne) jeżeli pokazują (nie pokazują) na ten sam obiekt: int *wsk1,*wsk2; if (wsk1==wsk2){}//ten sam obiekt if (wsk1!=wsk2){}//różne obiekty Porównywanie wskaźników operatorami, = ma sens tylko wtedy, gdy oba wskaźniki wskazują na elementy tej samej tablicy. Wtedy, jeżeli w1 < w2, to oznacza to, że obiekt wskazywany przez w1 znajduje się w pamięci wcześniej niż drugi (w1 jest bliżej początku tablicy niż w2).

Wskaźniki i const zwykły wskaźnik: int *wsk; stały wskaźnik int * const wsk; wskaźnik do obiektu stałego const int * wsk; stały wskaźnik do stałego obiektu const int * const wsk;

Stały wskaźnik #include using namespace std; int main() { int a=5,b=10; int * const w=&a; cout << *w << endl; (*w)++; cout << *w << endl; w=&b; return 0; } 5 6 BŁĄD

Wskaźnik do obiektu stałego int main() { const int a=5,b=10; const int *st_w; int *zm_w; st_w=&a; cout << *st_w << endl; st_w=&b; cout << *st_w << endl; (*st_w)++; zm_w=&a; return 0; } 5 10 BŁĄD

Stały wskaźnik do stałego obiektu int main() { const int a=5,b=10; const int * const st_w=&a; cout << *st_w << endl; (*st_w)++; st_w=&b; return 0; } 5 BŁĄD

Wskaźnik typu void int main() { int ti[]={1,2,3,4},*wi; double td[]={1.0,2.0,3.0,4.0},*wd; void *wv; wi=ti; wd=td; wv=wi; cout<<*wv<<endl; wv++; wv=wd; return 0; } BŁĄD

Operatory rzutowania int main() { double d=2.5; int i; i=d; cout << d << endl << i << endl; return 0; } conversion from 'double' to 'int', possible loss of data 2.5 2

Operatory rzutowania int main() { double d=2.5; int i; i=(int)d;// lub i=int(d) cout << d << endl << i << endl; return 0; } 2.5 2

Operatory rzutowania int main() { int i=65; char c; c=(char)i; cout << i << endl << c << endl; return 0; } 65 A

Nowe operatory rzutowania 1.Stare operatory rzutowania: –(nazwa_typu)wyrażenie –nazwa_typu (wyrażenie) 2.Nowe operatory rzutowania: –static_cast (wyrażenie) –const_cast (wyrażenie) –dynamic_cast (wyrażenie) –reinterpret_cast (wyrażenie)

static_cast Operator static_cast jest używany do wszystkich konwersji, które są dobrze zdefiniowane i mogą być wykonane przez kompilator (mogą powodować ostrzeżenia), np.: –konwersje roszerzające (np. int -> float, int -> long), –konwersje zawężające (utrata informacji, np. float -> int),

static_cast int main() { double d=3.14; int i; i=static_cast (d); cout << d << endl << i << endl; return 0; }

const_cast Używany do konwersji typu: –const -> non-const –volatile -> non-volatile Używany TYLKO do konwersji tego typu – jeżeli równocześnie konieczna jest inna konwersja, musi być ona wykonana za pomocą oddzielnego operatora. Nie może być użyty do bezpośredniej konwersji obiektu const na non-const.

const_cast int main() { const int a=2; const int *st_w=&a; int *zm_w; cout<<a<<endl; zm_w=const_cast (st_w); *zm_w=-2; cout<<*zm_w<<endl; cout<<a<<endl; return 0; } 2 -2 ???

dynamic_cast dynamic_cast robi rzutowanie tylko pod warunkiem, że w danej konkretnej chwili ma to sens.

dynamic_cast class pojazd { protected: int l_kol, max_sp; public: pojazd(int a,int b):l_kol(a),max_sp(b){} virtual void wypisz(); }; class samochod: public pojazd { double poj_s; public: samochod(int a,int b,double c):pojazd(a,b), poj_s(c){} void wypisz(); }; class rower: public pojazd { int li_prze; public: rower(int a, int b, int c):pojazd(a,b), li_prze(c){} void wypisz(); }; int main() { pojazd P(2,30),*WP; samochod S(4,180,1.9),*WS; rower R(2,30,21); char a; cout<<"S czy R\n"; cin>>a; if (a=='S') WP=&S; else WP=&R; WS=dynamic_cast (WP); cout<<&S<<endl; cout<<WS<<endl; return 0; } S czy R S 0040F950 S czy R R 0040F

reinterpret_cast Jest to najmniej bezpieczny mechanizm rzutowania, mogący powodować błędy. Traktuje obiekty jak pewien zestaw bitów, nie zwraca uwagi na znaczenie.

reinterpret_cast int main() { int ti[]={1,2,3,4},*wi,*wt; double td[]={1.0,2.0,3.0,4.0},*wd; wi=ti; wd=td; for (int i=0;i<4;i++) cout<<*(wi+i)<<"\t"<<*(wd+i)<<endl; wt=wi; wi=reinterpret_cast (wd); wd=reinterpret_cast (wt); cout<<endl; for (int i=0;i<4;i++) cout<<*(wi+i)<<"\t\t"<<*(wd+i)<<endl; return 0; }

reinterpret_cast int main() { int *wi; cin>>wi; return 0; } int main() { int *wi,a; a= ; wi=reinterpret_cast (a); cout<<wi<<endl; cout<<oct<<a<<endl; return 0; }

Dynamiczne tworzenie tablic 1D int *w=new int[n]; 2D int **w = new int*[n]; for(int i=0;i<n;i++) w[i] = new int[m]; 3D int ***w = new int**[n]; for(int i=0;i<n;i++) w[i] = new int*[m]; for(int i=0;i<n;i++) for(int j=0;j<m;j++) w[i][j] = new int[o];

Usuwanie tablic 1D delete [] w; 2D for(int i=0;i<n;i++) delete [] w[i]; delete [] w; 3D for(int i=0;i<n;i++) for(int j=0;j<m;j++) delete [] w[i][j]; for(int i=0;i<n;i++) delete [] w[i]; delete [] w;

Dynamiczne tworzenie tablicy 2D int n=3,m=2; int **tab; tab=new int *[n]; for (int i=0; i<n; i++) tab[i]=new int [m]; for (int i=0; i<n; i++) for (int j=0; j<m; j++) tab[i][j]=i*m+j+1; cout<<&tab<<endl; cout<<tab<<endl; cout<<*tab+1<<endl; cout<<*(tab+1)<<endl; cout<<tab[1]<<endl; cout<<&tab[1]<<endl; cout<<tab[1][0]<<endl; cout<<*(*(tab+1)+1)<<endl; cout<<&tab[1][0]<<endl; 0031FC3C 0031FC3F 0031FC FC FC FC47 tab m n 00658E E5B 00658E5C 00658E5F 00658E E F F13 int* int F F F F F F27 int F F F F37 int F F F FC3C 00658E F F E5C F20

Dynamiczne tworzenie tablicy 2D int n=3,m=2; int **tab; tab=new int *[n]; for (int i=0; i<n; i++) tab[i]=new int [m]; for (int i=0; i<n; i++) for (int j=0; j<m; j++) tab[i][j]=i*m+j+1; cout<<typeid(&tab).name()<<endl; cout<<typeid(tab).name()<<endl; cout<<typeid(*tab+1).name()<<endl; cout<<typeid(*(tab+1) ).name()<<endl; cout<<typeid(tab[1] ).name()<<endl; cout<<typeid(&tab[1] ).name()<<endl; cout<<typeid(tab[1][0] ).name()<<endl; cout<<typeid(*(*(tab+1)+1) ).name()<<endl; cout<<typeid(&tab[1][0] ).name()<<endl; int * * * int * * int * int * * int int *

Dynamiczne tworzenie tablic #include using namespace std; int main() { int n; cout << "Podaj rozmiar tablicy\n"; cin >> n; int *w=new int[n]; for (int i=0; i<n; i++){ cout << "Podaj wartosc\n"; cin >> w[i];} for (int i=0; i<n; i++) cout << *(w+i) << endl; delete [] w; return 0; }

Dynamiczne tworzenie tablic 2-D #include using namespace std; int main() { int n; cout << "Podaj rozmiar\n"; cin >> n; int **wsk=new int*[n]; for (int i=0; i<n; i++) wsk[i]=new int[n]; for (int i=0; i<n; i++) for (int j=0; j<n; j++) wsk[i][j]=i*n+j; for (int i=0; i<n; i++){ for (int j=0; j<n; j++) cout<<*(*(wsk+i)+j)<<"\t"; cout << endl;} for(int i=0;i<n;i++) delete [] wsk[i]; delete [] wsk; return 0; }

Wskaźnik do tablicy wielowymiarowej int main() { int tab[][3]={1,2,3,4,5,6,7,8,9}; int **w=new int*[3]; for (int i=0; i<3; i++) *(w+i)=&tab[i][0]; for (int i=0; i<3; i++){ for (int j=0; j<3; j++){ cout<<w[i][j]<<"\t";} cout << endl;} return 0; }

Funkcja zwracająca tablicę int *fun() { int tab[5]; for (int i=0; i<5; i++) tab[i]=i; return tab; } int main() { int *w; w=fun(); for (int i=0; i<5; i++) cout << w[i] << endl; return 0; }

Funkcja zwracająca tablicę int *fun() { int *wsk=new int[5]; for (int i=0; i<5; i++) wsk[i]=i; return wsk; } int main() { int *w; w=fun(); for (int i=0; i<5; i++) cout << w[i] << endl; return 0; }

Odbieranie tablic 2-D od funkcji #include using namespace std; int **tworz(int n); int main() { int **t, n; cout << "Podaj rozmiar macierzy\n"; cin >> n; t=tworz(n); for (int i=0; i<n; i++) { for (int j=0; j<n; j++) cout << *(*(t+i)+j) << "\t"; cout << endl; } return 0; } int **tworz(int n) { int **wsk=new int*[n]; for (int i=0; i<n; i++) wsk[i]=new int[n]; for (int i=0; i<n; i++) { for (int j=0; j<n; j++) wsk[i][j]=i*n+j; } return wsk; }

Argumenty z linii wywołania programu #include using namespace std; int main(int argc, char *argv[]) { cout<<"Dostalem parametrow: "<<argc<<endl<<endl; for (int i=0; i<argc; i++) cout<<i<<" parametr to\t"<<argv[i]<<endl; return 0; }

Argumenty z linii wywołania programu #include using namespace std; int main(int argc, char *argv[]) { if (!(argc-3)) { cout<<argv[1]<<"+"<<argv[2]<<"="; cout<<atof(argv[1])+atof(argv[2])<<endl; } return 0; }

Prezentacja udostępniona na licencji Creative Commons: Uznanie autorstwa, Na tych samych warunkach 3.0. Pewne prawa zastrzeżone na rzecz autorów. Zezwala się na dowolne wykorzystywanie treści pod warunkiem wskazania autorów jako właścicieli praw do prezentacji oraz zachowania niniejszej informacji licencyjnej tak długo, jak tylko na utwory zależne będzie udzielana taka sama licencja. Tekst licencji dostępny jest na stronie: