/* funkcje*/ #include<stdio.h> #define PI 3.1415926 #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 =1519.010254
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 15.51 if (c>cg) return (b + 2); else return (a b);
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 = 8.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-
/*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[]= 1234567890...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);
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... ----------------------------------------------------- 1234567890...abcdefgh...fghijk i=20 1234567890...abcdefgH...fghijk...??? i=-1 1234567890...abcdefgH...fghijk +++++++++++++++++++++++++++++++++++++++++++++++++++++++
/*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!= 40320 n= 9 n!= 362880 n=10 n!= 3628800 n=11 n!=39916800 n=12 n!=479001600
/*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);
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
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.
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) = 21101 k(_8) = 51155 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
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=153.67789, 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\n123456789 \n ); printf( \nm=%i,m);
Wynik: Format %# +8d +22799 Format %# +8i 500 Format %# +8o 054417 Format %# +8X 0X590F Format %#020.8f 00000000153.67789000 Format %+20.8e +1.5300000e+02 Format %+20.8G +153.67789 Format %24p 100D:590F 123456789 m=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=00153.220 a=00153.220 a=00153.220 a=00000000153.22000000
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 3.1415926 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);
Wynik: Dane wejsciowe Promien =3.3 Wysokosc =44.4 Objetosc walca =1519.010296 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
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
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
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 2.71828182845904523536 #define M_PI 3,14159265358979323846 #define M_PI_2 1.57079632679489661923 #define M_PI_4 0.785398163397448309116 #define M_1_PI 0.318309886183790671538
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);
#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
#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
/* 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*/ **************** ######################################
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