Język C (ANSI)

Komentarz:

W przykładach wyruznione są elementy na które zdaniem autorów należy zwrócić szczegółną uwage.

1. Zmienne

1. Typy podstawowe

Typy	Kwalifikatory
char - znak lub niewielka liczba całkowita int - liczba całkowita (domyślny) float - liczba zmiennoprzecinkowa double - długa liczba zmiennoprzecinkowa void - brak typu	short - krotka long - długa
		signed - ze znakiem (domyślny) unsigned - bez znaku

2. Typy stosowane

Pełna nazwa	Skrócona nazwa 1	Skrócona nazwa 2	Skrócona nazwa 3
signed long int	long	long int	signed long
unsigned long int	unsigned long
signed int	int	signed
unsigned int	unsigned
signed short int	short	short int	signed short
unsigned short int	unsigned short
signed char	char
unsigned char
float
double
long double
void

3. Deklaracja zmiennych

Zmienne	Tablice
int A; unsigned long B; signed short int C1; short C2; double D; int Wiek,Ilosc; double X,Y,Odleglosc;	int A[3]; unsigned long B[7]; signed short int C1[5]; short C2[30]; double D[19]; int Wiek[3],Ilosc[3]; double X[4],Y[4],Odleglosc[4*4];

4. Deklaracja + Inicjalizacja zmiennych

Zmienne	Znaki specjalne
long LS1=320000L,LS2=-420000L; unsigned long LU=320000LU; int IS1=32,IS2=-17; unsigned IU=17U; char C='A'; float F1=12.5F,F2=.125E2F; double D1=324.4,D2=.3244E3; long double LD=-65E300L;	'\n' /* LF (nowa linijka) */ '\r' /* CR (powrót karetki) */ '\t' /* tabulacja */ '\0' /* znak końca napisu */ '\XXX' /* znak o kodzie ASCII XXX 8-kowym */ '\'' /* znak ' */ '\"' /* znak " */ '\\' /* znak \ */
Inicjalizacja mieszana	Tablice
char C1='A',C3=66; int I1=90,I2='z'; long L1=32L,L1=2,L3='Q'; double D1=12.5,D2=7,D3=12LU;	int TA[4]={65,66,'C',68}; int TC[]={65,66,'C',68}; /* Rozmiar zostanie wyznaczony automatycznie */ int TB[6]={65,66,'C',68}; /* Pozostałe elementy będą mialy wartość 0 */
Tablice znaków = napisy	Znak końca napisu
char AlaMaKota[]="Ala ma kota"; char C[6]="Cześć"; /* 6=5 + znak końca */ char ala[]={'A','l','a',0};	char ala1[]={'A','l','a','\0'}; char ala2[]={'A','l','a',0}; /* 0 oraz '\0' - to samo */

2. Podstawowe operacje

1. Operacja przypisywania

int a,b; a=13; b=a;

int a,b,c,d; a=b=c=d=7;

int x1=1,x3,x5; x5=(x3=(x1+2))+2; /* x3=3; x5=5; */

2. Operacje arytmetyczne

int a=30,b=5,c; c=a+b; c=a-b; c=a*b; c=a/b; c=a%b; /* reszta z dzielenia */

int a=30; a+=20; /* a=a+20; */ a-=10; /* a=a-10; */ a*=3; /* a=a*3; */ a/=12; /* a=a/12; */ a%=3; /* a=a%3; */

3. Konwersja typów

/* Konwersja jawna jest niezbędna wtedy gdy istnieje prawdopodobieństwo utraty danych */
short S=5; int I=6; long L=7; L=I; /* konwersja nie jawna */ L=S; /* konwersja nie jawna */ S=(short)I; S=(short)L; I=(int)L;	int I=5; unsigned U=6; long L=7; L=I; /* konwersja nie jawna */ L=U; /* konwersja nie jawna */ I=(int)U; U=(unsigned)I;	double D=5.6; int I=7; long L=8; D=I; /* konwersja nie jawna */ D=L; /* konwersja nie jawna */ I=(int)D; L=(long)D;

4. Dzielenie całkowitoliczbowe oraz zmiennoprzecinkowe

/* Dzielenie na liczbach całkowitych - kiedy dzielnik oraz dzielna są całkowite */ /* Dzielenie na liczbach rzeczywistych - kiedy dzielnik lub dzielna są zmiennoprzecinkowe */
int ai=10,bi=4; double Wynik; Wynik=ai/bi; Wynik=ai/4; Wynik=10/bi; Wynik=10/4; /* Wynik=2.0 dla każdego z przypadków*/	double ad=10,bd=4; double Wynik; Wynik=ad/bd; Wynik=ad/4; Wynik=10/bd; /* Wynik=2.5 dla każdego z przypadków*/	int ai=10,bi=4; double ad=10,bd=4,Wyn; Wyn=ad/bi; Wyn=ai/bd; Wyn=10.0/bi; Wyn=ai/4.0; /* Wynik=2.5 dla każdego z przypadków*/	int ai=10,bi=4; double Wynik; Wynik=ai/((double)bi); Wynik=((double)ai)/bi; /* Wynik=2.5 dla każdego z przypadków*/

5. Operacje relacji i logiczne

int a=30,b=5,c; c=(a>b); c=(a<b); c=(a>=b); c=(a<=b); c=(a==b); c=(a!=b);

int c,a=5,b=0; c=((0<=a)&&(a<=9)); /* i (and) */ c=((1>b)||(b>9)); /* lub (or) */ c=(a||b); /* c=(a!=0||b!=0) */ c=(!a&&!b); /* c=(a==0||b==0) */ c=(a>0)+(!b);

Każda wartość arytmetyczna może być potraktowana jako wartość logiczna: 0 ► fałsz, różne od 0 ► prawda. Każda wartość logiczna może być potraktowana jako wartość arytmetyczna prawda ► 1, fałsz ► 0

6. Operacje bitowe

int a=3,b=6,c; c=a&b; /* i (and) */ c=a|b; /* lub (or) */ c=a^b; /* różnica symetryczna (xor) */ c=~b; /* negacja (not) */ c=b<<1; /* =12 */ c=b>>1; /* =3 */

int a=3,b=5; a&=b; /* a=a&b; */ a|=b; /* a=a|b; */ a^=b; /* a=a^b; */ b<<=a; /* b=b<<a; b=b*2*2*2; */ b>>=a; /* b=b>>a; b=b/2/2/2; */

7. Operacje inkrementacji, dekrementacji

int a=3; ++a; /* a=a+1 */ a++; /* a=a+1 */ --a; /* a=a-1 */ a--; /* a=a-1 */

int a,b=0,t[3]={1,2,3}; a=2*(++b); /* b=b+1; a=2*b; */ a=2*(b++); /* a=2*b; b=b+1; */ a=t[--b]; /* b=b-1; a=t[b]; */ a=t[b--]; /* a=t[b]; b=b-1; */

++x; --x; ► przedrostkowe (preferowane kiedy kolejność nie stanowi różnicy) x++; x--; ► przyrostkowe

8. Operator trójargumentowy warunkowy

int a=6,b=-6,c; c=a<b?a:b; /* jeżeli a<b to wynik a, jeżeli nie to b; równoważne c = minimum a,b */ c=a>b?a:b; /* jeżeli a>b to wynik a, jeżeli nie to b; równoważne c = maksimum a,b */ c=b<0?-b:b; /* c wartość bezwzględna b */ c=a?b/a:0; /* jeżeli a==0 to c=b/a, jeżeli a!=0 to c=0;

9. Operator sizeof()

char C; short S int I; long L; float F; double D; long double LD; int T[5]; int Dlugosc,Logic; Dlugosc=sizeof int; /* Dlugosc = liczba bajtów zajmowana przez dowolną zmienną typu int */ Dlugosc=sizeof(I); /* Dlugosc = liczba bajtów zajmowana przez zmienną I */ Logic=(sizeof(C)=sizeof(char)); /* Prawda */ Logic=(sizeof(I)=sizeof(int)); /* Prawda */ Logic=(sizeof(D)=sizeof(double)); /* Prawda */ Logic=(sizeof(T)==5*sizeof(int)); /* Prawda */ Logic=(sizeof(T)/sizeof(int)==5); /* Prawda */ Logic=(sizeof(T)/sizeof(T[0])==5); /* Prawda */ Logic=(sizeof(int)==sizeof(sizeof(T)/sizeof(T[0]))); /* Prawda */ Logic=(sizeof(int)==sizeof(sizeof(...))); /* Prawda, cokolwiek zamiast ... */

10. Relacje między typami zmiennych

Logic=(sizeof(char)==1); /* Prawda */ Logic=(sizeof(char)<sizeof(short)); /* Prawda */ Logic=(sizeof(short)<=sizeof(int)); /* Prawda */ Logic=(sizeof(int)<=sizeof(long)); /* Prawda */ Logic=(sizeof(short)<sizeof(long)); /* Prawda */ Logic=((sizeof(int)==sizeof(short))||(siseof(int)==sizeof(long))); /* Prawda */ Logic=(sizeof(float)<sizeof(double)); /* Prawda */ Logic=(sizeof(double)<=sizeof(long double)); /* Prawda */

11. Tabela priorytetów i wiązania

()	[]	->	.								od lewej do prawej
!	~	+	-	++	--	&	*	sizeof			od prawej do lewej
*	/	%									od lewej do prawej
+	-										od lewej do prawej
<<	>>										od lewej do prawej
<	<=	>	>=								od lewej do prawej
==	!=										od lewej do prawej
&											od lewej do prawej
^											od lewej do prawej
|											od lewej do prawej
&&											od lewej do prawej
||											od prawej do lewej
?:											od lewej do prawej
=	*=	/=	%=	+=	-=	&=	^=	|=	<<=	>>=	od prawej do lewej
,											od lewej do prawej

3. Struktura programu

1. Prosty przykład

#include <stdio.h> /* Podłączenie plików nagłówkowych */ #include <math.h> #define RozmiarBufora 100 /* Deklaracje preprocesora */ double ZminnaGlobalna; /* Deklaracje zmiennych globalnych */ int main() /* funkcja main */ { long ZminnaLokalna; /* Deklaracje zmiennych lokalnych */ printf("Mój Program\n"); /* Instrukcje funkcji main */ return(0); /* Wartość zwracana przez program do systemu */ }

4. Operacje wejścia wyjścia

1. Wymagane pliki nagłówkowe

#include <stdio.h>

2. Drukowanie na wyjście standardowe

printf("Cześć!\n"); /* wydrukuje tekst zawarty w cudzysłowach; \n następny wiersz */
int a=9; /* %d - dla zmiennych typu int */ printf("Zmienna a ma wartość %d (ma być 9)\n",a); /* w miejsce %d wpisana będzie wartość a */
long RozmiarPliku=123546L; printf("Rozmiar pliku wynosi %ld\n",RozmiarPliku); /* %ld - dla zmiennych typu long */
float Wzrost=1.74; printf("Średni wzrost jest %f\n",Wzrost); /* %f - dla zmiennych typu float */
double Odleglosc=123.456; printf("Odległość: %lf m.\n",Odleglosc); /* %lf - dla zmiennych typu double */
int a=10,b=30; /* %% - zostanie wydrukowane jako % */ printf("%d stanowi %.2lg%% wartosci %d\n",a,100.*a/b,b); /* 2 znaki po przecinku */
int a=3,b=5; /* wydruk w polu o określonej szerokości */ printf(" a\t b\n%4d\t%4d\n",a,b);	a b 3 5
char W='>',M='<'; int a=4,b=5; /* %c - dla zmiennych typu char */ printf("%d%c%d\n",a,a<b?M:W,b); /* UWAGA: jeżeli a==b również wypisze: a>b */
int a=3,b=5; char W[]="wieksze od",M[]="mniejsze od",R[]="równe"; printf("%d %s %d\n",a,a==b?R:(a<b?M:W),b); /* %s - dla napisów */
double T[4]={4,3,2,1}; int i=2; printf("T[4]={%lg,%lg,%lg,%lg};\n",T[0],T[1],T[2],T[3]); printf("T[%d]=%lg;\n",i,T[i]);

3. Wprowadzanie z wejścia standardowego

int a; scanf("%d",&a); /* %d dla int; jak na razie magiczny znaczek & */

long a; scanf("%ld",&a); /*%ld dla long; jak na razie magiczny znaczek & */

float a; scanf("%f",&a); /*%f dla float; jak na razie magiczny znaczek & */

double a; scanf("%lf",&a); /*%lf dla double; jak na razie magiczny znaczek & */

char a; scanf("%c",&a); /*%c dla char; jak na razie magiczny znaczek & */

char a[10]; scanf("%s",a); /*%s dla napisów; UWAGA!!! Bez magicznego znaczka & */ /* będzie poważny problem w przypadku gdy użytkownik wprowadzi więcej niż 9 znaków */ /* Nie należy stosować takiej konstrukcji */ fgets(a,10,stdin); /* zrobi prawie to samo co scanf, ale bezpiecznie */

int a; long b; double c; /* przy wprowadzaniu należy oddzielając wartości */ scanf("%d%ld%lf",&a,%b,&c); /* spacją lub klawiszem <Enter> */

double x,y; /* przy wprowadzaniu należy oddzielając wartości */ printf("wprowadź współrzędne x,y: "); /* przecinkiem np.: 2.5,17.3 */ scanf("%lf,%lf",&x,&y);

int Licznik,Mianownik; /* przy wprowadzaniu oddzielając wartości */ printf("wprowadź ułamek: "); /* znakiem / np.: 2/3 */ scanf("%d/%d",&Licznik,&Mianownik);

4. Tabelka formatów dla różnych typów

int ► %d unsigned ► %u long ► %ld unsigned long ► %lu float ► %f double ► %lf,%le,%lg; %le - w postaci naukowej, %lg - krótsza z naukowej i normalnej char ► %c napis ► %s

5. Instrukcje podstawowe

1. Instrukcja if else

int a=3,b=5; if(a<b) printf("%d<%d\n",a,b);	zostanie wydrukowane a<b
int a=3,b=5,c=0; if(a<b) { c=a; printf("Najmniejsza wartość to %d\n",c); }	konstrukcja if zawiera więcej niż jedną instrukcje, muszą być nawiasy klamrowe
int a,b; printf("Podaj wartości a,b: "); scanf("%d,%d",&a,&b); if(a<b) printf("%d<%d\n",a,b); else printf("%d>=%d\n,a,b);	else -> w przeciwnym wypadku
int a,b; printf("Podaj wartości a,b: "); scanf("%d,%d",&a,&b); if(a<b) printf("Najmniejsza wartość to a=%d\n",a); else { a=b; printf("Najmniejsza wartość to b=%d\n",b); }	else zawiera więcej niż jedną instrukcje, muszą być nawiasy klamrowe
int a; printf("Podaj wartośc a: "); scanf("%d",&a); printf("Wartość a(%d) jest ",a); if(a&1) { a=(a+1)>>1; printf("nieparzysta\n"); } else { a>>=1; printf("parzysta\n"); } printf("Zaokrąglona połowa wartości wynosi %d\n",a);	if oraz else zawierają więcej niż jedną instrukcje, muszą być nawiasy klamrowe
int a,b,c,t; printf("Podaj wartości a,b,c: "); scanf("%d,%d",&a,&b,&c); if(a>b) { t=a; a=b; b=t; } if(a>c) { t=a; a=c; c=t; } if(b>c) { t=b; b=c; c=t; } printf("Posortowane a,b,c: %d,%d,%d\n",a,b,c);	szereg warunków
int Liczba; printf("Podaj dodatnia liczbe całkowitą: "); scanf("%d",&Liczba); if(Liczba<0) printf("Liczba ujemna\n"); else if(Liczba==0) printf("Zero\n"); else if(Liczba<10) printf("Cyfra\n"); else printf(":-) Właśnie o to chodziło\n");	kaskada warunków

2. Instrukcja while (break,continue)

double c; printf("Podaj liczbe zmiennoprzecinkowa: "); scanf("%lf",&c); while(c>0) printf("Kolejny pierwiastek %lg\n",c=sqrt(c));

long a; int f=1; while(f) /* więcej niż jedną instrukcja, muszą być nawiasy klamrowe */ { printf("Podaj liczbe całkowitą (0-koniec): "); scanf("%ld",&a); if(a) { if(a<0) printf("Wartość %ld<0\n",a); else printf("Wartość %ld>0\n",a); } else { printf("Wprowadzono zero. (Koniec zabawy)\n"); f=0; } }

int a; while(1) /* dopóki prawda, pętla nieskończona */ { printf("Podaj wartość całkowitą dodatnią (0-koniec): "); scanf("%d",&a); if(a==0) break; /* przerywa działanie pętli natychmiast */ if(a<0) continue; /* przeskakuje do sprawdzenia warunku */ printf("Podałeś wartość %d\n",a); }

3. Instrukcja for (break,continue)

int i; for(i=0;i<10;++i) printf("%d",i); /* Wydruk: 0,1,2,3,4,5,6,7,8,9 */

int i; for(i=9;i>=0;--i) printf("%d",i); /* Wydruk: 9,8,7,6,5,4,3,2,1,0 */

int N; printf("Wprowadź liczbe całkowitą dodatnią: "); scanf("%d",&N); for(;N;N>>=1) printf("%c",'0'+(N&1)); /* brak instrukcji początkowej */

int a; for(;;) /* brak instrukcji początkowej, instrukcji krokowej oraz warunku pętla nieskończona */ { printf("Podaj wartość całkowitą dodatnią (0-koniec): "); scanf("%d",&a); if(a==0) break; /* przerywa działanie pętli natychmiast */ if(a<0) continue; /* przeskakuje do sprawdzenia warunku */ printf("Podałeś wartość %d\n",a); }

char Pomocnicza,Tekst[]="kobyła ma mały bok"; int p,k; for(p=0,k=sizeof(Tekst)-2;p<k;++p,--k) /* kilka instrukcji początkowych oraz krokowych */ { Pomocnicza=Tekst[p]; Tekst[p]=Tekst[k]; Tekst[k]=Pomocnicza; } printf("%s\n",Tekst);

6. Funkcje

1. Deklaracja(prototyp) / definicja

void PrintLogic(int Logic) /* Definicja powyżej miejsca wywołania, pełni rolę deklaracji */ { printf("%s\n",Logic?"Prawda":"Fałsz"); } int main() { PrintLogic(2<3); PrintLogic(2*2==5); /* Miejsce wywołania */ return(0); }

void PrintLogic(int); /* Deklaracja, UWAGA !!! średnik musi być koniecznie */ int main() { PrintLogic(sizeof(int)>=sizeof(short)); /* Miejsce wywołania */ PrintLogic(sizeof(short)==sizeof(long)); /* Miejsce wywołania */ return(0); } void PrintLogic(int Logic) /* Definicja */ { printf("%s\n",Logic?"Prawda":"Fałsz"); }

2. Wartości przekazywane, zwracane przez funkcje

double Min(double,double); /* Deklaracja */ int main() { double C; C=Min(3,1.7); printf("%lg\n",Min(C,2)); return(0); } double Min(double A,double B) { return(A<B?A:B); }

int CzyCyfra(char C) { return(('0'<=C)&&(C<='9')); } int main() { int x; x=CzyCyfra('A'); printf("%s\n",CzyCyfra('0')?"Prawda":"Fałsz"); return(0); }

double Pitagoras(long X,long Y); int main() { long Ax,Ay,Bx,By; printf("Podaj współrzędne punktu A: "); scanf("%lf,%lf",&Ax,&Ay); printf("Podaj współrzędne punktu B: "); scanf("%lf,%lf",&Bx,&By); printf("Odległość pomiędzy A i B wynosi %lg\n",Pitagoras(Bx-Ax,By-Ay)); return(0); } double Pitagoras(long X,long Y) { return(sqrt(X*X+Y*Y)); }

3. Parametry formalne są kopią

void ErrorSwap(double,double); /* Deklaracja */ int main() { double X1=1,X2=2; ErrorSwap(X1,X2); printf("X1=%lg; X2=%lg;\n",X1,X2); /* Nadal X1=1; X2=2; */ return(0); } void ErrorSwap(double A,double B) { double X; X=A; A=B; B=X; }

7. Wskaźniki

1. Operacje na wskaźnikach

char T[]="Ala ma kota"; char *W; /* Wskaźnik do char, nie zainicjalizowany ma wartość przypadkową */ W=T; printf("%s\n",W); /* Wydruk: Ala ma kota */ W=T+4; printf("%s\n",W); /* Wydruk: ma kota */ printf("%s\n",T+4); /* Tabela jest wskaźnikiem, Wydruk: ma kota */ printf("%c%c\n",W[0],W[1]); /* Wskaźnik jest tabelą, Wydruk: ma */

int Tab[]={55,44,33,22,11}; int *P,Pom,*K; /* Deklaracja kilku wskaźników, UWAGA zmienna Pom nie jest wskaźnikiem */ for(P=Tab,K=Tab+4;P<K;++P,--K) { (*P)=(*K); } /* znak * przed wskaźnikiem => zawartość */ /* K=Tab+4, oznacza ustaw K na 4-y element Tab, nie zaś numer komórki plus 4 */ /* ++P, oznacza przesun P do następnego elementu, nie zaś powiększ P o 1 */ /* --K, oznacza przesun K do poprzedniego elementu, nie zaś pomniejsz K o 1 */

double Td[]={1.1,2.2,3.3,4.4}; double *Wd; int i; Wd=Td-1; /* Poprzedni element Td, Wd można traktować jako tablice z indeksami od 1 */ for(i=1;i<=4;++i) printf("Wd[%d]=%lg;\n",i,Wd[i]);

2. Napis jest wskaźnikiem

char Ala1[]={'A','l','a',' ','m','a',' ','k','o','t','a',0}; char Ala2[]="Ala ma kota"; char *Ala3={'A','l','a',' ','m','a',' ','k','o','t','a',0}; char *Ala4="Ala ma kota"; printf("%c%c%c\n",Ala1[0],Ala1[1],Ala1[2]); printf("%c%c%c\n",Ala2[0],Ala2[1],Ala2[2]); printf("%c%c%c\n",Ala3[0],Ala3[1],Ala3[2]); /* Ala3 jest tablicą */ printf("%c%c%c\n",Ala4[0],Ala4[1],Ala4[2]); /* Ala4 jest tablicą */ /* --Ala1; */ /* Błąd!!! Ala1 jest też stałą wskaźnikową */ /* --Ala2; */ /* Błąd!!! Ala2 jest też stałą wskaźnikową */ --Ala3; /* Ala3 jest też zmienną wskaźnikową */ ++Ala4; /* Ala3 jest też zmienną wskaźnikową */

3. Przydatne funkcje biblioteczne

#include <string.h>

char Ala[]="Ala"; /*strlen(Ala)!=sizeof(Ala)*/ printf("Tablica Ala[%d] ma długość %d\n",sizeof(Ala),strlen(Ala));

char Pom[20],*Kot="kot"; /* Należy pilnować rozmiary */ strcpy(Pom,Kot); printf("%s\n",Pom);

char S1[]="Ala",S2[]="ma",S3[]="kota",S[]=" ",Pom[sizeof(S1)+sizeof(S2)+sizeof(S3)]; strcpy(Pom,S1); strcat(Pom,S); strcat(strcat(strcat(Pom,S2),S),S3); printf("%s\n",Pom);

char Ala[]="Ala ma kota",Pies[]="psa"; strcpy(strchr(Ala,'k'),Pies); printf("%s\n",Ala); /* na wydruku: Ala ma psa */

char PolskieZnaczki[]="ĄĆĘŁŃÓŚŻŹąćęłńóśżź"; char Znak; scanf("%c",&Znak); if(strchr(PolskieZnaczki,Znak)) printf("Wprowadzono Polski Znaczek\n");

char K[]="Ala ma kota",P[]="Ala ma psa"; int Porownanie; Porownanie=strcmp(K,P); /* ==0, <0, >0 => wynik = leksykograficzne odejmowanie */ if(!Porownanie) printf("Napisy K i P są identyczne\n"); else { if(Porownanie<0) printf("Napis K jest leksykograficznie mniejszy od P\n"); else printf("Napis K jest leksykograficznie większy od P\n"); }

char AlaMaKota[]="Ala ma kota",Ewa[]="Ewa"; memcpy(AlaMaKota,Ewa,strlen(Ewa)); printf("%s\n",AlaMaKota); /* na wydruku: Ewa ma kota */

int T1[5],T2[]={1,2,3,4}; memcpy(T1,T2,sizeof(T2)); /* 5-yj element T1 zostanie nie zmieniony */

char AlaMaKota[]="Ala ma kota",EwaMaPsa[]="Ewa ma psa"; if(memcmp(AlaMaKota,EwaMaPsa,3)) printf("Pierwsze 3 litery są rożne\n"); if(!memcmp(AlaMaKota+2,EwaMaPsa+2,5) printf("5 liter 2-go znaku (\"a ma \") za identyczne\n");

long Tablica[20]; memset(Tablica,0,10*sizeof(long)); /* wypełni zerami pierwsze 10 elementów */

/* Wiekszość funkcji napisowych posiada tez wersje z dodatkowym parametrem określającym maksymalną liczbe znaków biorącą udziął w operacji, np. strcpy() -> strncpy() */

4. Magiczny znaczek & przy użyciu scanf()

int x,*w; w=&x; /* &x => jest wskaźnikiem do obszaru w którym zaczyna się x */ scanf("%d",w);

int A=3,B=1,*w; w=&A; memcpy(w,&B,sizeof(int)); /* skopiuje zawartość B do A */

long L; double D; printf("Adres L=%p; Adres D=%p\n",&L,&D); /* wydruk adresów zmiennych */

5. Przekazywanie wskaźników do funkcji

void Swap(int *A,int *B) { int X; X=*A; *A=*B; *B=X; } int main() { int X=3,Y=5; Swap(&X,&Y); /* zamiana wartości X z Y */ printf("X=%d; Y=%d;\n",X,Y); return(0); }

void WydrukInt(char *Tekst,int X) printf("%s=%d;\n",Tekst,X); int main() { int X=1,Y=100; WydrukInt("X",X); WydrukInt("Y",Y); WydrukInt("X*Y",X*Y); WydrukInt("Suma kwadratów X,Y",X*X+Y*Y); return(0); }

void WprowadzWspolrzedne(char *Tekst,double *X,double *Y) { while(1) { printf("%s: ",Tekst); fflush(stdin); if((scanf("%lf,%lf",X,Y)==2)&&(getchar()=='\n')) return; /* X,Y bez znaczka & */ printf("Błąd wprowadzenia. Powtórz\n"); } } int main() { double Ax,Ay,Bx,By; WprowadzWspolrzedne("Podaj współrzędne punktu A",&Ax,&Ay); WprowadzWspolrzedne("Podaj współrzędne punktu B",&Bx,&By); printf("Odleglosc od A do B %lf\n",sqrt((Bx-Ax)*(Bx-Ax)+(By-Ay)*(By-Ay)); return(0); }

void WydrukujTabele(double *T,int Rozmiar) { int i; printf("{"); for(i=0;i<Rozmiar;++i) { if(i) printf(","); printf("%lg",T[i]); } printf("}\n"); } int main() { double Tab[]={1.1,2.2,3.3,4.4}; WydrukujTabele(Tab,sizeof(Tab)/sizeof(*Tab)); return(0); }

void Pisz1(char *Znaki,int Ile) { int i; for(i=0;i<Ile,++i) printf("%c",Znaki[i]); } void Pisz2(char *Znaki,int Ile) { int i; for(i=0;i<Ile,++i) printf("%c",*(Znaki+i)); } void Pisz3(char Znaki[],int Ile) { int i; for(i=0;i<Ile,++i) printf("%c",Znaki[i]); } void Pisz4(char Znaki[],int Ile) { int i; for(i=0;i<Ile,++i) printf("%c",*(Znaki+i)); } void Pisz5(char Znaki[],int Ile) /* Ciekawostka!!! Prawie nie stosowana!!! */ { int i; /* dowiedziałem się o takiej możliwości */ for(i=0;i<Ile,++i) printf("%c",i[Znaki]); /* dopiero po 20 latach praktyki */ }

8. Instrukcje dodatkowe

1. Instrukcja switch()

char op; double X,Y; printf("Podaj dzialanie do wykonania (np. 3*6): "); scanf("%lf%c%lf",&X,&op,&Y); printf("%lg%c%lg=",X,op,Y); switch(op) { default: printf("Nieznana operacja wykonam dodawanie\n"); printf("%lg+%lg=",X,Y); case '+': printf("%lg",X+Y); break; case '-': printf("%lg",X-Y); break; case '*': printf("%lg",X*Y); break; case '%': printf("Niedostępna operacja wykonam dzielenie\n"); printf("%lg/%lg=",X,Y); case '/': printf("%lg",X/Y); break; } printf("\n");

2. Instrukcja do { } while()

char T[]="1010",P[sizeof(T)]; int i; memcpy(P,T,sizeof(P)); do /* Rzadko stosowana, zawsze ma nawiasy klamrowe */ { for(i=sizeof(P)-2;i>=0;--i) { if(P[i]=='1') { P[i]='0'; break; } P[i]='1'; } printf("%s\n",P); }while(memcmp(P,T,sizeof(P)));

3. Instrukcja goto

/* Użycie tej instrukcji w C, to przestępstwo */ /* Nie należy stosować pod żadnym pozorem */ int main() { double d; Start: printf("Podaj wartość dodatnią: "); scanf("%lf",&d); if(d<0) goto Start; printf("Pierwiastek z %lg wynosi %lg\n",d,sqrt(d)); }

9. Struktury

1. Deklaracja struktur

struct Punkt { double X; double Y; }; /* średnik po zamkniętym nawiasie !!! */ int main() { struct Punkt A; double Odl; printf("Podaj współrzędne punktu A: "); scanf("%lf,%lf",&A.x,&A.y); Odl=sqrt(A.x*A.x+A.y*A.y); printf("Wprowadzono Punkt (%lg,%lg) odległość od (0,0) wynosi %lg\n",A.x,A.y,Odl); return(0); }

typedef struct { double X,Y; }Punkt; int main() { Punkt A; return(0); }

2. Wskaźniki do struktur

typedef struct { double x,y; }Punkt; typedef struct { Punkt A,B; }Prostokat; int main() { Prostokat P; Punkt *wP; wP=&P.A; printf("Podaj lewy-górny róg: "); scanf("%lf,%lf",&(wP->x),&(wP->y)); wP=&P.B; printf("Podaj prawy-dolny róg: "); scanf("%lf,%lf",&(wP->x),&(wP->y)); printf("(%lg,%lg)-(%lg,%lg)\n",P.A.x,P.A.y,P.B.x,P.B.y); return(0); }

3. Przekazywanie struktur do funkcji

typedef struct { double x,y; }Punkt; typedef struct { Punkt A,B; }Prostokat; void WprowadzPunkt(char *Tekst,Punkt *A) { printf("%s: ",Tekst); scanf("%lf,%lf",&(A->x),&(A->y)); } void WprowadzProstokat(char *Tekst,Prostokat *P) { printf("%s\n",Tekst); WprowadzPunkt("Lewy-Górny róg",&(P->A)); WprowadzPunkt("Prawy-Dolny róg",&(P->B)); } void DrukujPunkt(Punkt A) { printf("(%lg,%lg)",A.x,A.y); } void DrukujProstokat(Prostokat P) { DrukujPunkt(P.A); printf("-"); DrukujPunkt(P.B); } double Przekatna(double dx,double dy) { return(sqrt(dx*dx+dy*dy)); } int main() { Prostokat Pr; WprowadzProstokat("Wprowadz prostokąt",&Pr); printf("Przekątna prostokąta "); DrukujProstokat(Pr); printf(" wynosi %lg\n",Przekatna(Pr.B.x-Pr.A.x,Pr.B.y-Pr.A.y)); return(0); }

10. Dynamiczne przydzielanie pamięci

1. Tablice

int Wiersz[]={2,3,4},Kolumna[]={5,6,7}; int *Iloczyn,w,k,i; Iloczyn=(int*)malloc(sizeof(Wiersz)*sizeof(Kolumna)); if(Iloczyn) /* będzie == NULL w przypadku braku wolnej pamięci */ { for(i=w=0;w<sizeof(Wiersz)/sizeof(int);++w) { for(k=0;k<sizeof(Kolumna)/sizeof(int);++k) { Iloczyn[i++]=Wiersz[w]*Kolumna[k]; } } } for(w=0;w<sizeof(Wiersz)/sizeof(int);++w) { for(k=0;k<sizeof(Kolumna)/sizeof(int);++k) { if(k) printf("\t"); printf("%d",Iloczyn[w*sizeof(Kolumna)/sizeof(int)+k]); } printf("\n"); } free(Iloczyn);

char Bufor[16]; double *Tablica=NULL; int i,Rozmiar=0; while(1) { printf("Podaj element nr %d : ",Rozmiar+1); fflush(stdin); fgets(Bufor,16,stdin); if(strlen(Bufor)<2) break; if(!Rozmiar) Tablica=(double*)malloc(sizeof(double)); else Tablica=(double*)realloc(Tablica,(Rozmiar+1)*sizeof(double)); Tablica[Rozmiar++]=atof(Bufor); } printf("Wprowadzono %d elementów:\n",Rozmiar); for(i=0;i<Rozmiar;++i) printf("%d: %lg\n",i+1,Tablica[i]); free(Tablica);

long *Tabela; Tabela=(long*)calloc(30,sizeof(long)); /* calloc wypełnia przydzieloną pamięć zerami */ free(Tabela);

2. Napisy

char *Lista[4],Bufor[256]; int i; printf("Wprowadz 4 wierszy:\n"); for(i=0;i<4;++i) { fgets(Bufor,256,stdin); Lista[i]=strdup(Bufor); /* strlen, malloc, memcpy */ } for(i=4-1;i>=0;--i) { printf(Lista[i]); free(Lista[i]); }

3. Struktury

typedef struct { double x,y; }Punkt; Punkt *WprowadzPunkt(char *Tekst,int Nr) { Punkt *Punkt; printf(Tekst,Nr); printf(": "); Punkt=(Punkt*)malloc(sizeof(Punkt)); scanf("%lf,%lf",&(Punkt->x),&(Punkt->y)); return(Punkt); } void DrukujPunkt(Punkt A) { printf("(%lg,%lg)",A.x,A.y); } int main() { Punkt **Punkty=NULL; int i,N; printf("Podaj ilość punktów: "); scanf("%d",&N); for(i=0;i<N;++i) { if(!i) Punkty=(Punkt**)malloc(sizeof(Punkt*)); else Punkty=(Punkt**)realloc(Punkty,(i+1)*sizeof(Punkt*)); Punkty[i]=WprowadzPunkt("Podaj współrzędne %d-ego punktu",i+1); } for(i=N-1;i>=0;--i) { printf("Punkt[%d]=",i+1); DrukujPunkt(*(Punkty[i])); /* Punkty[i] -> wskaźnik; *(Punkty[i]) -> i-yj punkt */ printf("\n"); free(Punkty[i]); } if(N>0) free(Punkty); return(0); }

11. Praca z plikami

1. Tryb tekstowy

FILE *f; long Tbl1[]={111,222,333,444,555,666,777,888}; long Tbl2[sizeof(Tbl1)/sizeof(long)]; int i; /* Zapis */ f=fopen("Dane.txt","wt+"); for(i=0;i<sizeof(Tbl1)/sizeof(long);++i) fprintf(f,"%ld\n",Tbl1[i]); fclose(f); /* Odczyt */ f=fopen("Dane.txt","rt+"); for(i=0;i<sizeof(Tbl2)/sizeof(long);++i) fscanf(f,"%ld",Tbl2+i); fclose(f);

2. Tryb binarny

FILE *f; long Tbl1[]={111,222,333,444,555,666,777,888}; long Tbl2[8]; /* Zapis */ f=fopen("Dane.txt","wb+"); fwrite(Tbl1,sizeof(long),8,f); fclose(f); /* Odczyt */ f=fopen("Dane.txt","rb+"); fread(Tbl2,sizeof(long),8,f); fclose(f);

3. Napisy zapis / odczyt statyczny

FILE *f; char Napis1[]="Ala ma kota"; char Napis2[100]; /* Zapis */ f=fopen("Dane.txt","wb+"); fwrite(Napis1,1,100,f); fclose(f); /* Odczyt, jeżeli długość napisu przekroczy 99 znaków będzie poważny problem */ f=fopen("Dane.txt","rb+"); fread(Napis2,1,100,f); fclose(f);

4. Napisy zapis / odczyt dynamiczny

FILE *f; char Napis1[]="Ala ma kota"; char *Napis2; int Dlugosc; /* Zapis */ f=fopen("Dane.txt","wb+"); Dlugosc=strlen(Napis1); fwrite(&Dlugosc,sizeof(int),1,f); fwrite(Napis1,1,Dlugosc,f); fclose(f); /* Odczyt */ f=fopen("Dane.txt","rb+"); fread(&Dlugosc,sizeof(int),1,f); Napis2=(char*)malloc(Dlugosc+1); fread(Napis2,1,Dlugosc,f); Napis2[Dlugosc]=0; /* znak końca napisu */ fclose(f); free(Napis2);