Pobieranie prezentacji. Proszę czekać

Pobieranie prezentacji. Proszę czekać

Funkcje Modularyzacja : program główny, funkcje Funkcje : – obliczające wartość – nie obliczające wartości Niedozwolone : – zagnieżdżanie – wywoływanie.

Podobne prezentacje


Prezentacja na temat: "Funkcje Modularyzacja : program główny, funkcje Funkcje : – obliczające wartość – nie obliczające wartości Niedozwolone : – zagnieżdżanie – wywoływanie."— Zapis prezentacji:

1 Funkcje Modularyzacja : program główny, funkcje Funkcje : – obliczające wartość – nie obliczające wartości Niedozwolone : – zagnieżdżanie – wywoływanie niezadeklarowanych ( deklaracje i definicje )

2 Deklaracja funkcji typ identyfikator_funkcji (lista_argumentów_formalnych ); typ wartości funkcji : liczbowy, wskaźnikowy, referencyjny, strukturowy sygnatura funkcji : liczba i typy argumentów formalnych argument_formalny : typ identyfikator int f1( int x, int y );

3 float wartosc( float cena, int liczba ); char* odpowiedz ( char *pytanie ); double alfa( double x1, x2 ); // błąd max( int k, int l ); // typ domyślny int // przestarzałe void druk( char *napis ); // bez wyniku

4 Definicja funkcji typ identyfikator_funkcji (lista_argumentów_formalnych ) { blok } blok : ciąg deklaracji, definicji i instrukcji wykonywany : – do końca bloku – do instrukcji return argument_formalny : typ identyfikator

5 float sqr( float x ) { return x * x ; } void max( int *m, int a, int b ) { *m = a > b ? a : b ; } // return; void DrukujWynik ( float x ) { printf ( "\nWynik : %10.2f", x); }

6 int split( char *S, char *D1, char *D2 ) { int licz_S = 0 ;// zmienna lokalna while ( *S ) { if ( licz_S & 0x01 ) *D2++ = *S++; else *D1++ = *S++; licz_S++; } *D1 = *D2 = 0; return licz_S; }

7 Wywołanie funkcji identyfikator_funkcji ( lista_argumentów_aktualnych ) argument_aktualny : wyrażenie a = 1 + sqr( 1.25 ); // w wyrażeniu max( &lepsza, cena_1, cena_2 ); // instrukcja sqr(3 + b * d ); DrukujWynik ((sqrt(delta) - 4 * a * c ) / ( 2 * a ) ) ; printf( "\n%d\t%d\n", a + 2, a - 1 );

8 Powiązanie argumentów aktualnych i formalnych int Funa ( int a, int b, int c ) { if ( a > 3 * b – 1) return c + 2; else return c * c + 1; } int k, r; // int x = Funa (12, k + 4, r - 3); // a = 12, b = k + 4, c = r - 3

9 Przekazywanie argumentów do funkcji zgodny typ argumentu formalnego i aktualnego : – typy identyczne – możliwa konwersja

10 long suma( long x ) { return x ; } suma(3); // poprawnie int -> long suma( L); // poprawnie bez konwersji suma(17.8); // ryzykownie double -> long suma('A'); // poprawnie char -> long suma("ALA"); // błąd, konwersja niemożliwa

11 int oblicz( float *wf ); int *wi; oblicz( wi ); // błąd, nieodpowiedni wskaźnik oblicz (( float*) wi); // poprawnie, ryzykownie

12 Sposoby przekazywania argumentów przekazywanie wartości przekazywanie wskaźnika przekazywanie referencji

13 void D2V ( int n ) // przekazywanie wartości { n = n + 2; // krok 2 } int a = 5; D2V ( a ); // krok 1

14 void D2P( int *n )// przekazywanie wskaźnika { *n = *n + 2; // krok 2 } int a = 5; D2P( &a ); // krok 1

15 void D2R(int& n) // przekazywanie referencji { n = n + 2; // krok 2 } int a = 5; D2R( a ); // krok 1

16 long b = 5; D2R( b ); // krok 1 program główny funkcja D2R b tt n 55& 57 & krok 1 krok 2

17 struct Konto { long numer; long suma; } void Wplata ( Konto kk, long kwota) { kk.suma += kwota; } Konto AB = { 84404, 0 }; Wplata ( AB, 3285 ); // AB.suma == ?

18 Konto Wplata ( Konto kk, long kwota) { kk.suma += kwota; return kk; } AB = Wplata ( AB, 3285 ); // AB.suma == 3285 Argument stały float PoleKola(const float *lpi, float *pr) { *lpi = 2.5;// błąd... } Podatek, ONP, SumIloFun

19 Tablice jako argumenty funkcji Tablice jednowymiarowe int FT(int *);// deklaracje int FT(int[ ]); int FT(int[10]); int FT(int *T) {... }// definicje int FT(int T[ ]) {... } int FT(int T[10]) {... } // T [ 3 ] // T + 3 * sizeof ( int )

20 void ZAP1( int T[100] ) { for ( int i = 0; i < 100; ++i ) T[ i ] = i; } // int ALFA[15]; ZAP1 ( ALFA ) ;// zapis + niszczenie int BETA[100]; ZAP1 ( &BETA [0] );// zapis całej tablicy int GAMMA[150]; ZAP1 ( GAMMA );// zapis 2/3 tablicy

21 void ZAP2(int T[ ], int rozmiar) { for ( int i = 0; i < rozmiar; ++i ) T[i] = i; }

22 Tablice wielowymiarowe wszystkie wymiary tablicy, poza najstarszym ( pierwszym od lewej ) void ZAP3( float TT[ ][10], int wierszy ) { for (int i = 0; i < wierszy; ++i) for (int j = 0; j < 10; ++j) TT[i][j] = i + j; } // TT [ 3 ] [ 5 ] // TT + 3 * 10 * sizeof ( float ) + 5 * sizeof ( float ) TabDem,EwTelFun

23 Wartości domyślne argumentów funkcji float SUM3(float x, float y = 2.5, float z = 3.5) { return x + y + z; } float a, b, c; SUM3( a, b, c ); // a + b + c SUM3( a, b ); // a + b SUM3( a ); // a SUM3( ); // błąd SUM3( a,,c ); // błąd

24 long Dotacja( const char *Osoba, long Kwota = 100 ); long Dotacja (const char *Osoba = "Jan Kowalski", long Kwota ) { } void F1 (int = 8, int, int = 5, long = 3); void F1 (int x, int y = 4, int z, long g ) { }

25 Funkcje rekurencyjne n * ( n - 2 ) * ( n - 4 ) *... // > 0 int IR ( int n ) { return n <= 0 ? 1 : n * IR( n – 2 ); } int IP ( int n ) { int s = 1; while ( n > 0 ) { s *= n; n -= 2; } return s; }

26 Podprogramy wstawiane inline double WB(double x, double y, double z) { return x > y ? z : x; } Hash

27 Wskaźniki funkcji int ( *pf )( int, int ); // typ wyniku i sygnatura int Ki( int x, int y ) { return (x + y) * (x + 2 * y); } long Kl( int x, int y ) { return (long)(x + 3 * y) * (x - y); } pf = Ki; // poprawnie pf = & Ki; // poprawnie pf = Kl; // błąd, nieodpowiedni wskaźnik

28 void bubbleSort ( float T[ ], int n ) {... } void mergeSort ( float T[ ], int n ) {... } void heapSort ( float T[ ], int n ) {... } void ( *wS )( float[ ], int ) = bubbleSort; void ( *nS )( float[ ], int ) ; nS = wS; float TAB[ 150 ]; wS ( TAB, 150 ); ( *nS )( TAB, 150 ); /* równoważne wywołania funkcji bubbleSort */

29 Tablice wskaźników funkcji int fA(double x) {... } int fB(double y) {... } int fC(double z) {... } int ( *fX [3] )( double ) = { fA, fB }; fX[2] = fC; fX[1]( );// wywołanie

30 int ( *Test [10] )( char* ) = { }; int Wyniki [10]; char* Napisy[10]; for (int i = 0; i < 10; ++i ) Wyniki[i] = Test[i] ( Napisy[i] ); // typedef int ( *PF )( float, float ); int Fun( float a, float b ) {... } PF f1, f2 = Fun; PF Tfun[15];

31 Wskaźnik funkcji jako argument funkcji void Sort( float[ ], int, void (*) ( float[ ], int ) = mergeSort ); void Sort(float TAB[ ], int rozmiar, void (*fS) (float[ ], int) ) { fS( TAB, rozmiar ); } float T1[100], T2[200]; void ( *wF )( float[ ], int ) = heapSort; Sort( T1, 100, bubbleSort ); Sort( T2, 200, wF );// heapSort Sort( T2, 200 );// mergeSort

32 Wskaźnik funkcji jako wynik funkcji typedef char* ( *NP )( char*, char* ); struct FUNKCJE { int cecha; NP funkcja; } TABLICA[15];

33 NP Szukaj( FUNKCJE TAB[ ], int rozmiar, int wzorzec ) { for (int i = 1; i < rozmiar; ++i) if (TAB[i].cecha == wzorzec) return TAB[i].funkcja; return TAB[0].funkcja; } // printf ( "%s\n", Szukaj ( TABLICA, 15, 1527 )( "Alf","Ogi") ); Kalku, MatFun, Oferta

34 Przeciążanie identyfikatorów funkcji int SA( int TI[ ], int n ) { int s = 0; for (int i = 0; i < n; ++i) s += TI[i]; return s / n; } double SA( double TD[ ], int n ) { double s = 0; for (int i = 0; i < n; ++i) s += TD[i]; return s / n; }

35 int TAB_I [ 10 ]; double TAB_D [ 10 ]; SA ( TAB_I, 10); SA ( TAB_D, 10); // wyboru dokonuje kompilator Różne sygnatury : przeciążenie identyfikatora Równe sygnatury : równe typy wyniku : przesłanianie różne typy wyniku : błąd

36 /* plik funkcji bibliotecznych */ int strlen( char *s ); /* plik programu użytkowego */ int strlen( char *z ) { int len = 0; while (*z++) if (*z != ' ') ++len; return len; } /* definicja zawarta w pliku programu użytkowego przesłania deklarację z pliku bibliotecznego */ void czytaj(char *) {... } int czytaj(char *) {... } // błąd

37 Wybór wersji funkcji o przeciążonym identyfikatorze zgodność : typ taki sam lub konwersja niezgodność : konwersja niemożliwa niejednoznaczność : zgodność w kilku funkcjach

38 void druk( char c ) {... } // wersja C void druk( int i ) {... } // wersja I void druk( float f ) {... } // wersja F void druk( char *s ) {... } // wersja S int a; druk( a ); // zgodność: wersja I druk( 'a' ); // zgodność: wersja C druk( "a" ); // zgodność: wersja S long l; druk( l ); // błąd: niejednoznaczność // możliwe wersje C, I, F float f, *pf = &f; druk( f ); // zgodność: wersja F druk( pf ); // błąd: niezgodność

39 Zasada minimalizacji liczby konwersji void ff( int k, float z ) {... } // wersja 1 void ff( char c, float z ) {... } // wersja 2 // ff( 'a', 15 ) //?

40 Wartości domyślne argumentów void fun( int n ) {... } // wersja 1 void fun( long l, int n = 0 ) { } // wersja 2 fun( 2L ); // wersja 2: fun (2L, 0); fun( 5, 38 ); // wersja 2: fun (5, 38); fun( 137 ); // wersja 1: fun (137); fun( 3.14 ); // błąd: niejednoznaczność Tekst

41 Wzorce funkcji int min(int a, int b) // wersja I {return a < b ? a : b; } long min(long a, long b) // wersja L { return a < b ? a : b; } float min(float a, float b) // wersja F { return a < b ? a : b; } // zastępuje wzorzec template T min( T a, T b ) {return a < b ? a : b; } // min( 1, 2 ); // poprawnie: wersja I min( 3, 1.5 ); // błąd: niejednoznaczność Templa

42 Łączenie wielu plików programu dyrektywa #include pliki nagłówkowe deklaracja extern External


Pobierz ppt "Funkcje Modularyzacja : program główny, funkcje Funkcje : – obliczające wartość – nie obliczające wartości Niedozwolone : – zagnieżdżanie – wywoływanie."

Podobne prezentacje


Reklamy Google