main() { float promien=p,wysokosc=h,objetosc; float objetosc_walca(float promien, float wysokosc);

Transkrypt

1 /* funkcje*/ #include<stdio.h> #define PI #define P 3.3 #define H 44.4 float promien=p,wysokosc=h,objetosc; float objetosc_walca(float promien, float wysokosc); objetosc = objetosc_walca(promien,wysokosc); printf( \nobjetosc walca = %f, objetosc); /* funkcja obliczajaca objetosc walca */ float objetosc_walca(float promien, float wysokosc) return (PI*promien*promien*wysokosc); Efekt: Objetosc walca =

2 definicja funkcji: typ funkcji nazwa funkcji (lista parametrów formalnych) definicje i deklaracje lokalne instrukcje void funkcja_a(void) int i; printf( \n ); for (i=1; i<20; i++) printf(.- ); void funkcja_b(float a) if (a>0) printf( \n a jest dodatnie ); else printf( \n a nie jest dodatnie ); int funkcja_c(void) int i=55; return (i- 5 ); int funkcja_d(int a, int b, float c) #define CG if (c>cg) return (b + 2); else return (a b);

3 Wywołanie funkcji: #include<stdio.h> /*prototypy*/ void funkcja_a(void); void funkcja_b (float(a); int funkcja_c(void); int funkcja_d(int a, int b, float c); /*inne deklaracje*/ float x=4.44, y=13.13; int k=2, m=3; /*przyklady wywolan funkcji*/ funkcja_a(); funkcja_b(y); m+=funkcja_c() + k; printf( \n m = %d, m); k=funkcja_d(k,m,x); printf( \n k = %d, k); k=funkcja_d(5,6,17.33); printf( \n k = %d, k); funkcja_a(); /*definicje funkcji*/ a jest dodatnie m = 7 k = -5 k =

4 /*Funkcje*/ #include<stdio.h> #include<ctype.h> int wyszuk(char znak,char t[]); void podkr (char znak, int n); char s[]= abcdefghijklmnopqrst...abcdefghij... ; char v[]= abcdefgh...fghijk ; int i; podkr( +,55); printf(s); i=wyszuk( n,s); printf( \ni=%i\n,i); printf(s); podkr( -,53); prinf(v); i=wyszuk( h,v); printf( \ni=%i\n,i); printf(v); podkr(.,50); i=wyszuk( #,v); printf( \ni=%i\n,i); printf(v); podkr( +,55); /*funkcja wyszukiwania znaku w tablicy, gdy litera to zamiana na duże*/ int wyszuk(char znak,char t[]) int i=0; while (t[i]!= \0 ) if(t[i]==znak) t[i]=toupper(znak);

5 else podkr(?,3); return (-1); return (i); i++; /*funkcja linia podkreślająca*/ void podkr (char znak, int n) int i; printf( \n ); for(i=1;i<=n;i++) putchar(znak); printf( \n ); abcdefghijklmnopqrst...abcdefghij... i=13 abcdefghijklmnopqrst...abcdefghij abcdefgh...fghijk i= abcdefgH...fghijk...??? i= abcdefgH...fghijk

6 /*rekurencja*/ /*obliczanie silni*/ #include<stdio.h> int n; long int silnia(int n); for(n=1; n<=12;n++) printf( \n n=%2d n!=%9ld, n, silnia(n)); /*funkcja rekurencyjna obliczania silni*/ long int silnia(int n) if(n<=1) return (1); else return (n*silnia(n-1)); n= 1 n!= 1 n= 2 n!= 2 n= 3 n!= 6 n= 4 n!= 24 n= 5 n!= 120 n= 6 n!= 720 n= 7 n!= 5040 n= 8 n!= n= 9 n!= n=10 n!= n=11 n!= n=12 n!=

7 /*funkcja iteracyjna obliczania silni*/ long int silnia(int n) int i; long int wynik=1; if(n>1) for(i=2;i<=n;++i) wynik*=i; return (wynik);

8 putchar(c); c stała, zmienna znakowa /*putchar*/ #include<stdio.h> #define SPACJA 32 char napis[] = ABCDEFGHIJKLMNOPQRS... ; int znak = 73; /*wyprowadzenie pojedynczych znakow przy pomocy funkcji putchar*/ putchar( \n ); putchar(znak); putchar(spacja); putchar(55); putchar(spacja); putchar( Z ); putchar(spacja); putchar( \066 ); putchar(spacja); putchar( \x3a ); putchar( \n ); putchar(napis[0]); putchar(spacja); putchar(napis[4]); putchar(spacja); putchar(znak + \066 52); putchar( \n ); Wynik I 7 Z 6 : A E K

9 puts(string); string stała, zmienna łańcuchowa /*puts*/ #include<stdio.h> #define N_L putchar( \n ); char napis[] = ABCDEFGHIJKLMNOPQRS... ; /*wyprowadzenie pojedynczej linii tekstu przy pomocy funkcji puts*/ N_L; puts (napis); N_L; puts( To jest praktyczna funkcja ): puts( \066\067\x2b\x2a itd. ); Wynik ABCDEFGHIJKLMNOPQRS... To jest praktyczna funkcja 67+* itd.

10 printf(łańcuch formatu, lista argumentów); /*printf*/ #include(stdio.h> int k=21101; printf( \nk(_10) = %i k(_8) = %o k(_16) = %X,k, k, k); k(_10) = k(_8) = k(_16) = 526D Formaty realizowane przez funkcję printf Typ danych Argument Format wyjściowy Liczba %d int liczba całkowita %i int liczba całkowita %u unsigned int liczba całkowita bez znaku %o int liczba całkowita w postaci ósemkowej %x unsigned int liczba całkowita w postaci szesnastkowej %X unsigned int liczba całkowita w postaci szesnastkowej %f float/double liczba zmiennoprzecinkowa [-]nn.mmmm %e float/double liczba zmiennoprzecinkowa [-]n.mme[+-]xx %E float/double liczba zmiennoprzecinkowa [-]n.mme[+-]xx %g float/double jak %e lub %f bez 0 nieznaczących %G float/double jak %E lub %f bez 0 nieznaczących Znak lub łańcuch %c char pojedynczy znak %s char* łańcuch znaków Wskaźnik %n int* limitowana liczba znaków %p pointer liczba szesnastkowa

11 Pełny zapis instrukcji format %[pole znaku][szerokość][.dokładność][modyfikator] typ danych Pole znaku +,, #, spacja, 0 Szerokość całkowita pola przeznaczonego na postać zewnętrzną liczby Dokładność liczba miejsc po kropce dziesiętnej lub długość łańcucha Modyfikator F, N, h, l, L /*Wybrane formaty*/ #include <stdio.h> double a= , b=153.; int k=22799; int m=-500; int *p; p=&k; printf( \nformat %%# +8d %# +8d,k); printf( \nformat %%# +8i %# +8i,m); printf( \nformat %%# +8o %# +8o,k); printf( \nformat %%# +8X %# +8X,k); printf( \nformat %%#020.8f %#020.8f,a); printf( \nformat %%+20.8e %+20.8e,b); printf( \nformat %%#+20.8G %#+20.8G,a); printf( \nformat %%24p %24p,p); m=printf( \n\n \n ); printf( \nm=%i,m);

12 Wynik: Format %# +8d Format %# +8i 500 Format %# +8o Format %# +8X 0X590F Format %#020.8f Format %+20.8e e+02 Format %+20.8G Format %24p 100D:590F m=13

13 Dynamiczny format #include <stdio.h> double a=153.22; char napis[]= Wszystko dobre co się dobrze konczy ; int i,j; printf( \n%.9s,napis); printf( \n%.*s,9,napis); i=9; printf( \n%.*s,i,napis); i=21; printf( \n%.*s,i,napis); printf( \na=%#09.3f,a); printf( \na=%#0*.3f,9,a); printf( \na=%#0*.*f,9,3,a); i=9; j=3; printf( \na=%#0*.*f,i,j,a); i=20; j=8; printf( \na=%#0*.*f,i,j,a); Wynik: Wszystko Wszystko Wszystko Wszystko dobre co się a= a= a= a=

14 c=getchar(); #include <stdio.h> /*Wprowadzenie i wyprowadzenie 1 znaku*/ char znak; znak=getchar(); putchar(znak); gets(string); #include <stdio.h> /*Wprowadzenie i wyprowadzenie 1 linii*/ char linia[80]; gets(linia); puts(linia); scanf(łańcuch formatu, lista argumentów); #include <stdio.h> #define PI float promien, wysokosc; printf( \npodaj dane wejsciowe: ); printf( \npromien = ); scanf( %f,&promien); printf( Wysokosc = ); scanf( %f,&wysokosc); printf( \nobjetosc walca=%f,pi*promien*promien*wysokosc);

15 Wynik: Dane wejsciowe Promien =3.3 Wysokosc =44.4 Objetosc walca = Instrukcja formatu %[*][Szerokość][Modyfikator1][Modyfikator2]Typ danych * zignorowanie pola wejściowego Szerokość maksymalna liczba wczytanych znaków Modyfikator1 F,N Modyfikator2 h, l, L Formaty realizowane przez funkcję scanf Typ danych Argument Format wyjściowy Liczba %d int* liczba całkowita %i int* liczba całkowita %D long* liczba całkowita %l long* liczba całkowita %u unsigned * liczba całkowita bez znaku %U unsigned long * liczba całkowita bez znaku %o int * liczba ósemkowa %O long * liczba ósemkowa %x int * liczba szesnastkowa %X long * liczba szesnastkowa %f float * liczba zmiennoprzecinkowa %e float * liczba zmiennoprzecinkowa %E float * liczba zmiennoprzecinkowa Znak lub łańcuch %c char* pojedynczy znak %s char tab[n] łańcuch znaków Wskaźnik %n brak liczba znaków zapamiętana w (int*) %p far * / near * wskaźnik do dowolnego objektu

16 Wczytanie i wyprowadzenie znaku, łańcucha #include <stdio.h> char znak, linia[80]; scanf( %c,&znak); printf( %c\n,znak); scanf( %s,linia); printf( %s,linia); Filtr #include <stdio.h> char linia[80]; scanf( %[a-zabc],linia); printf( %s,linia); Wynik aabbzzabcdzz aabbzzabc Używane filtry %[A-Z] duże litery dozwolone %[^A-Z] duże litery wykluczone %[AaBb+-.:K] wybrane znaki dozwolone %[^XYZxyz] wybrane znaki wykluczone

17 Funkcje biblioteczne math.h Nagłówek funkcji Przeznaczenie int abs (int i) Wartość bezwzględna z int double fabs (double x) Wartość bezwzględna z float long labs (long x) Wartość bezwzględna z long double cos (double x) Wyznaczanie cosinusa double sin (double x) Wyznaczanie sinusa double log (double x) Wyznaczanie logarytmu naturalnego double log10 (double x) Wyznaczanie logarytmu dziesiętnego double pow (double x, double y) Wyznaczanie potęgi x y double sqrt (double x) Wyznaczanie pierwiastka kwadratowego stdlib.h Nagłówek funkcji int atoi (char *s) double atof (char *s) char* itoa (int n, char* s, int p) char* gcvt (double x, int ndec, char* s) Przeznaczenie Przekształcenie tekstu w liczbę int Przekształcenie tekstu w liczbę double Przekształcenie liczby n w tekst Przekształcenie liczby rzeczywistej w tekst string.h Nagłówek funkcji Przeznaczenie char* strcpy (char* s1, char* s2) Kopiuje łańcuch s2 do s1 char* strcat (char* s1, char* s2) Dołącza łańcuch s2 do końca s1 int strcmp (char* s1, char* s2) Porównuje dwa łańcuchy. 0 identyczne unsigned int strlen (char* s) Zwraca długość łańcucha (bez znaku NULL) char* strupr (char* s) Zamienia wszystkie litery na duże char* strlwr (char* s) Zamienia wszystkie litery na małe

18 conio.h Nagłówek funkcji Przeznaczenie int getch (void) Zwraca wartość znaku z konsoli (nie wyświetla) int getche (void) Zwraca wartość znaku z konsoli (wyświetla znak) int kbhit (void) Zwraca 0 bufor klawiatury pusty void clrscr (void) Czyści ekran monitora int wherex (void) Zwraca pozycję x kursora int wherey (void) Zwraca pozycję y kursora void gotoxy (int x, int y) Przenosi kursor do punktu o współrzędnych (x, y) void highvideo (void) Znaki rozjaśnione void lowvideo (void) Znaki przygaszone void normalvideo (void) Znaki normalne void textcolor (int i) Ustala kolor znaków void textbackground (int i) Ustala kolor tła void textattr (int i) Ustala atrybut znaku ctype.h Nagłówek funkcji Przeznaczenie int isalpha (int c) Czy znak c jest literą int isdigit (int c) Czy znak c jest cyfrą int isspace (int c) Czy znak c jest odstępem int islower (int c) Czy znak c jest małą literą funkcje zwracają 0 jeśli nie lub 1 jeśli tak Deklaracje stałych np. z modułu math #define M_E #define M_PI 3, #define M_PI_ #define M_PI_ #define M_1_PI

19 Makrodefinicja jest to funkcja włączana do programu w sposób tekstowy. definicja: #define NAZWA (lista parametrów) ciąg instrukcji przykład: #define MIN (a,b) ((a)<(b)?(a):(b)) wywołanie: z=min(x+2,y-3); zamiana: z=((x+2)<(y-3)?(x+2):(y-3)); Nawiasy (a), (b) w tym przypadku są zbędne. Stosowanie ich jest jednak dobrym nawykiem, pozwalającym uniknąć błędów. definicja: #define PIERWIASTEK(a,b) sqrt((a)*(a)+(b)*(b)) wywołanie: x=pierwiastek(a+1,b+2); zamiana: x=sqrt((a+1)*(a+1)+(b+2)*(b+2)); brak nawiasów: #define PIERWIASTEK(a,b) sqrt(a*a+b*b) zamiana: x=sqrt(a+1*a+1+b+2*b+2);

20 #include<stdio.h> #define KWADR(X) X*X #define PR(X) printf( \nwynik wynosi %d, X) int main(void) int x = 4; int z; z = KWADR(x); PR(z); z = KWADR(2); PR(z); PR(KWADR(x +2)); PR(100/KWADR(2)); printf( \nx wynosi %d, x); PR(KWADR(++x)); printf( \npo zwiekszeniu X wynosi %d, x); return 0; Wynik wynosi 16 Wynik wynosi 4 Wynik wynosi 14 Wynik wynosi 100 x wynosi 4 Wynik wynosi 30 Po zwiekszeniu x wynosi 6

21 #define PKW(X) printf( Kwadratem liczby X jest %d\n,((x)*(x)) PKW(8); Kwadratem liczby X jest 64 PKW(2+3); Kwadratem liczby X jest 25 Jeśli chcemy, aby argument makra został zastąpiony argumentem faktycznym to poprzedzamy go znakiem # #define PKW(X) printf ( Kwadratem liczby #X jest %d\n, ((X)*(X)) int y=5; PKW(y); Kwadratem liczby y jest 25 PKW(2+4); Kwadratem liczby 2+4 jest 36 Symbol #x został zastąpiony raz łańcuchem y drugi raz łańcuchem 2+4 i połączony z pozostałymi łańcuchami w instrukcji printf

22 /* makrodefinicja */ #include <stdio.h> #define NL printf( \n ) #define LINIA_PODKR(n, z) NL; \ for (i=1; i<=(n); i++) \ putchar(z); \ NL; int i; Wynik: LINIA_PODKR (16, * ) LINIA_PODKR (38, # ) /*makrowywolanie*/ /*makrowywolanie*/ **************** ######################################

23 Makrodefinicje ustanowione za pomocą dyrektywy #define mogą być anulowane za pomocą dyrektywy #undef NAZWA. Nie jest to niezbędne. Włączanie zawartości plików: 1. #include<nazwa_pliku> 2. #include nazwa_pliku 1. przeglądanie katalogu zbiorów nagłówkowych 2. przeglądanie katalogu bieżącego, a potem przeglądanie katalogu zbiorów nagłówkowych