Programowanie strukturalne w C

Programowanie strukturalne – j

zyk C

Struktura programu

Przykład programu:

# include <stdio.h>

main()

{

printf(”Program w j

zyku C \n”);

return 0;

}

Komentarze

W j

zykach programowania wyst

puj

specjalne znaczniki

powoduj

ce i

umieszczony tekst nie jest cz

ęś

programu, a

jedynie dodatkow

informacj

o tre

ci i zadaniach programu.

/* - znak otwarcia komentarza

*/ - znak zamkni

cia komentarza

/* komentarz */

/*

komentarz

*/

// komentarz

Dyrektywa #include

# include - dyrektywa preprocesora - polecenia dla
preprocesora aby w tym miejscu doł

czy

do programu zawarto

ść

wskazanego pliku

preprocesor – specjalny program wykonuj

cy czynno

przygotowawcze do kompilacji (przed kompilacj

)

Pliki nagłówkowe

Po dyrektywie #include wyst

puj

pliki nagłówkowe, s

to pliki

dodawane do programów za pomoc

tej dyrektywy, nazwa ich

wywodzi si

d ,

e s

zawsze doł

czane na pocz

tku programu

(w jego nagłówku)

stdio.h - plik nagłówkowy standardowego wej

cia – wyj

cia

stdlib.h – standardowa biblioteka funkcji

string.h – operacje na ła

cuchach tekstowych

math.h – funkcje matematyczne

conio.h – funkcje obsługi konsoli

<stdio.h> i ”stdio.h”

< ... > - plik nagłówkowy b

dzie poszukiwany w katalogu innym

bie

żą

cy; wskazanym w opcjach kompilatora – jest to

najcz

ęś

ciej katalog /..../INCLUDE

” ... ” - plik nagłówkowy b

dzie poszukiwany w katalogu

bie

żą

cym

Funkcja main()

Funkcja specjalna w j

zyku C, w ka

dym programie musi ona

wyst

i jest tylko jedna.

na j

wstawi

w dowolne miejsce w programie , jednak

program zacznie zawsze wykonywa

od funkcji main() i

zako

czy swoje działanie w tej funkcji. Je

eli wszystkie

instrukcje zawarte w funkcji main() zostały wykonane i
zako

czone program ko

czy swoje działanie.

W zamieszczonym powy

ej przykładzie funkcja main() zawiera

funkcje biblioteczn

printf() , której argumentami jest tekst

wyprowadzany na urz

dzenie wej

ciowe , oraz specjalny znak

steruj

cy :

\n - znak steruj

cy przej

cia do nast

pnego wiersza.

zasad

tego j

zyka programowania jest to,

e ka

da funkcja w

tym main() zwraca wynik; domy

lnie wynikiem jest liczba typu

całkowitego (integer)

wykorzystywana jest do tego celu instrukcja :

return 0;

Zwrócenie przez funkcj

warto

ci 0 - oznacza i

zako

czyła si

ona poprawnie, ka

da inna warto

ść

całkowita wi

ksza od zera

oznacza zako

czenie działania funkcji z bł

dem.

funkcja biblioteczna (stdlib.h) exit() - mo

e by

równie

yta do zako

czenia działania programu.

Funkcja exit() nie zwraca

adnego wyniku, ale argument

przekazany do funkcji wskazuje czy program zako

czył si

normalnie czy z bł

dem.

exit(0) – zako

czenie poprawne

exit(n) – zako

czenie z bł

dem n<>0

#include <stdio.h>

#include <stdlib.h>

void main()

{

printf(”Program w j

zyku C\n”);

exit(0);

}

typ danych: void

void - pusty, nijaki

słowo to pojawiaj

ce si

przed nazw

funkcji oznacza,

e nie

dzie ona zwraca

adnej warto

main() à zwraca domy

lnie warto

ść

typu integer

void main() à funkcja main() nie zwraca

adnej warto

linia instrukcji w j

zyku C zako

czona jest

rednikiem

zyk ten rozró

nia małe i du

e litery

Podstawowe elementy programu

Stałe i zmienne

stała – nigdy nie zmienia swojej warto

zmienna – mo

e by

ywana do reprezentowania ró

nych warto

Stałe i zmienne mog

wystepowa

razem w wyra

eniach.

i = 1;
- jest stał

;

i = 10;
- jest stał

;

i - mo

e przyjmowa

ró

ne warto

ci (1,10, lub inne) zatem jest

zmienn

Wyra

enie

Wyra

enie to kombinacja stałych, zmiennych i operatorów

( 3 + 6 ) * 20

4/2

20 * ( 2 + 1 )

Operatory arytmetyczne

+ - dodawanie
- odejmowanie

* - mno

enie

/ - dzielenie

% - reszta z dzielenia (dzielenie modulo)

8 % 5 à 3

* / % - operatory o wy

szym priorytecie

+ - - operatory o ni

szym priorytecie

Priorytet okre

la kolejno

ść

wykonywanych działa

, chyba,

wystepuj

nawiasy, wtedy w pierwszej kolejno

ci wykonywane s

wyra

enia w nawiasach.

Instrukcje

W j

zyku C instrukcja to polecenie zako

czone

rednikiem.

i = 5;

j = (12+4 ) * 2;

k = i + j;

return 0;

exit(0);

printf(”To jest program w C”);

Bloki instrukcji

Grupa instrukcji tworzy blok instrukcji, który jest traktowany
przez kompilator jako pojedyncza instrukcja.

{

i = 5;

j = 8;

k = i + j;

}

Blok instrukcji to sposób poł

czenia kilku instrukcji

prostych, tak aby zawsze były wykonywane razem – tak jak jedna
instrrukcja.

Struktura funkcji

Funkcje w j

zyku c mog

albo funkcjami bibliotecznymi,

albo stworzonymi przez programist

, albo przez innych

programistów.

Funkcja składa si

typu funkcji
nazwy funkcji
argumentów funkcji
nawiasu otwieraj

cego

ciała funkcji
nawiasu zamykaj

cego

int nazwa_funkcji(int x, int y)

{

int rezult;

rezult = x + y;

return rezult;

}

typ funkcji :

to rodzaj warto

ci wyniku, który funkcja zamierza zwróci

jej wykonaniu.

nazwa funkcji :

nazwa funkcji musi by

zwi

zana z zadaniem wykonywanym przez

funkcje
nazwa funkcji nie mo

e rozpoczyna

do cyfry

nazwa funkcji nie mo

e rozpoczyna

od znaku *

nazwa funkcji nie mo

e rozpoczyna

od znaku operatora

arytmetycznego
nazwa funkcji nie mo

e rozpoczyna

od znaku .

nazwa funkcji nie mo

e zawiera

(wewn

trz) znaku -

nazwa funkcji nie mo

e zawiera

(wewn

trz) znaku ‘

argumenty przekazywane do funkcji
dla prawidłowego wykonania pewne funkcje potrzebuj

przekazania im pewnych informacji , przekazywanych w postaci
tzw. argumentów
argumenty umieszczane s

w nawiasach okr

głych tu

po nazwie

funkcji
je

eli do prawidłowego działania funkcji niezb

dne jest

podanie wi

cej ni

jednego argumentu, wtedy tworzymy tzw.

list

argumentów, w które argumenty oddzielone s

od siebie

przecinkami
je

eli funkcja nie wymaga

adnych argumentów to lista

argumentów jest pusta

pocz

tek i koniec funkcji :

{ } znaki słu

żą

ce do zaznaczenia pocz

tku i ko

ca funkcji;

pomi

dzy nimi zawarte jest ciało funkcji;

ciało funkcji :

zawiera :
deklaracje zmiennych
instrukcje j

zyka C

wykonanie funkcji à wykonanie instrukcji stanowi

cych jej

ciało

wywołanie funkcji polega na podaniu jej nazwy i okre

leniu

argumentów wywołania;

// p_0

# include <stdio.h>int dodaj(int x, int y)

{

int wynik;

wynik=x+y;

return wynik;

}

int main()

{

int suma;

suma=dodaj(2,3);

printf("Wynik dodawania 2 + 3 = %d\n",suma);

return 0;

}

// p_01

# include <stdio.h># include <conio.h>

int dodaj(int x, int y)

{

int wynik;

wynik=x+y;

return wynik;

}

int main()

{

int suma;

suma=dodaj(2,3);

clrscr();

printf("Wynik dodawania 2 + 3 = %d\n",suma);

return 0;

}

// p_02

# include <stdio.h>

# include <conio.h>

int dodaj(int ax,int ay);

int main()

{

int suma;

suma=dodaj(2,3);

clrscr();

printf("Wynik dodawania 2 + 3 = %d\n",suma);

return 0;

}

int dodaj(int x, int y)

{

int wynik;

wynik=x+y;

return wynik;

}

Słowa kluczowe j

zyka C

auto break case char const continue

default do double else enum extern

float for goto if int long

register return short signed sizeof static

struct switch typedef union unsigned void

volatile while

słowa kluczowe j

zyka C pisane s

małymi literami

Typy danych

Typ danych - char

obiekty typu charakter to znaki : a, b, z, A,B,7,,0,2,W,w
ka

dy z tych znaków przechowywany jest w pami

ci w postaci

numerycznego kodu liczbowego
tablica kodów ASCII 27 =128
rozszerzona tablica kodów ASCII 28 =256
obiekt typu char zajmuje 1 bajt (8 bitów)

zmienne znakowe - mog

reprezentowa

ró

ne znaki

deklaracja zmiennej znakowe jest sposobem przyporz

dkowania

tej zmiennej okre

lonego miejsca w pami

ci o rozmiarze

odpowiadaj

cym typowi tej zmiennej

char lista nazw zmiennych /oddzielone przecinkami/;

char c1,c2,c_znak;

Stałe znakowe

znak uj

ty w apostrofy (‘) jest nazywany stał

znakow

‘a’ , ‘A’ , ‘b’
stałe znakowe (pojedyncze znaki ASCII) s

ujmowane w apostrofy

(‘) ;
ła

cuchy znakowe (teksty) s

ujmowane w znaki (”);

poszczególnym znakom przyporz

dkowane s

ich kody ASCII;

‘A’ à 65

‘a’ à 97

‘B’ à 66

‘b’ à 98

dlatego dla zmiennej x

char x;

x=’A’; i x=65 to równowa

ne zapisy

znak specjalny : \

tworzy wraz z innymi znakami znaki steruj

ce:

np.:

\n - przej

cie do nast

pnej linii

\b - cofni

cie kursora o jeden znak w lewo

\f - przej

cie do nast

pnej strony

\r - powrót na pocz

tek bie

żą

cego wiersza

\t - tabulacja

drukowanie znaków :

do wyprowadzania znaków na ekran mo

na stosowa

funkcj

printf();

W funkcji tej do wyprowadzenia pojedynczego znaku słu

y format

: %c

# include <stdio.h># include <conio.h>void main(void){char
c1,c2; c1='a'; clrscr(); printf("Oto c1 %c \n",c1); c2='A';
c1='B'; printf("Oto c1 %c \n",c1);

printf("Oto c2 %c \n",c2);

getch();

}

# include <stdio.h># include <conio.h>int main(){char c1,c2;
c1=97; c2=65; clrscr(); printf("Oto c1 %c \n",c1); printf("Oto
c2 %c \n",c2);}

Specyfikator formatu %c, u

yty w funkcji printf(), okre

sposób wy

wietlenia zmiennej - w tym przypadku jest to sposób

wietlenia w postaci znaku;

Typ danych int /integer/
typ danych int wykorzystywany jest dla danych numerycznych –
całkowitych;
liczby całkowite nie zawieraj

ani cz

ęś

ci ułamkowej, ani

przecinka dziesi

tnego;

wynik dzielenie liczb całkowitych ulega obci

ciu o cz

ęść

ułamkow

;

w najprostszym przypadku obiekty typu int zajmuj

2 bajty / w

innych systemach mo

e to by

4 bajty/

zakres warto

ci 16 bitowych liczb całkowitych (2bajty)

32 767 (215 – 1) do -32 768 dla liczb ze znakiem

lub
do 216 dla liczb bez znaku

deklarowanie zmiennych dla obiektów typu int

int lista zmiennych;

int x, zm_1,i;

drukowanie numerycznych kodów znaków

%d - jest specyfikatorem formatu, który zawarto

ść

komórek

pami

ci interpretuje jako warto

ść

typu integer

// p_1

# include <stdio.h># include <conio.h>void main(void){char
c1,c2; c1='a'; clrscr(); printf("Oto c1 %c %d \n",c1,c1);
c2='A'; c1='B'; printf("Oto c1 %c %d \n",c1,c1);

printf("Oto c2 %c %d \n",c2,c2);

getch();

}

//p_2

# include <stdio.h># include <conio.h>int main(){char c1,c2;
c1=97; c2=65; clrscr(); printf("Oto c1 %c %d \n",c1,c1);
printf("Oto c2 %c %d \n",c2,c2);

}

zmienne znakowe mog

wyprowadzane na ekran albo w postaci

znaków, albo w postaci ich kodów numerycznych ; zale

y to od

specyfikatora formatu.

typ danych - float

zmienne przecinkowe (z pływaj

cym przecinkiem) – float

- stałe 6,56f lub 6,56F oznaczaj

stałe typu float

6,56 domy

lnie jest traktowane jako typ double

typ float zajmuje 4 bajty pami

co najmniej 6 miejsc znacz

cych po przecinku

deklaracja:

float lista zmiennych;

float y, zm_1, x;

%f jest zmiennoprzecinkowym specyfikatorem formatu

//p_3

# include <stdio.h># include <conio.h>int main(){int i1,i2,d;
i1=3; i2=2; d=i1/i2; clrscr(); printf("Oto wynik 3/2 = %d
\n",d); getch();}

//p_4

# include <stdio.h># include <conio.h>void main(void){int
int_1,int_2,int_3,int_4;

float flt_1,flt_2,flt_3,flt_4;

clrscr();

int_1=32/10;

flt_1=32/10;

int_2=32.0/10;

flt_2=32.0/10;

int_3=32/10.0;

flt_3=32/10.0;

int_4=32.0/10.0;

flt_4=32.0/10.0;

printf("Dzielenie całkowite 32/10 %d\n",int_1);

printf("Dzielenie zmiennoprzecinkowe 32/10 %f\n",flt_1);

printf("Dzielenie całkowite 32.0/10 %d\n",int_2);

printf("Dzielenie zmiennoprzecinowe 32.0/10 %f\n",flt_2);

printf("Dzielenie całkowite 32/10.0 %d\n",int_3);

printf("Dzielenie zmiennoprzecinkowe 32/10.0 %f\n",flt_3);

printf("Dzielenie całkowite 32.0/10.0 %d\n",int_4);

printf("Dzielenie zmiennoprzecinkowe 32.0/10.0 %f\n",flt_4);

getch();

}

typ danych - double
w przeciwie

stwie do typu float, typ zmiennopozycyjny double

zajmuje dwa razy wi

cej miejsca w pami

ci (8 bajtów)

co najmniej 10 miejsc znacz

cych po przecinku

zapis wykładniczy liczb

w formacie wykładniczym liczba przedstawiona jest w postaci
mantysy i wykładnika; cecha i mantysa rozdzielone s

litera E

(e)

mantysa E (e) wykładnik

= 5e3

-300 = -3e2

przy wyprowadzaniu liczb w takim formacie na ekran, funkcja
printf() u

ywa specyfikatora:

%e lub %E

Identyfikatory

s

to nazwy zmiennych i funkcji j

zyka C

Znaki, które mo

na stosowa

przy nadawaniu nazw zmiennych:

litery du

e A,...,Z i małe a,...,z;

cyfry 0,...,9 /cyfra nie mo

e by

pierwszym znakiem nazwy/;

znak podkre

lenia (_);

Znaki zabronione przy nadawaniu nazw zmiennych:
nazwa zmiennej nie mo

e zawiera

znaku jakiejkolwiek operacji

arytmetycznej;
nazwa zmiennej nie mo

e zawiera

kropki (.);

nazwa zmiennej nie mo

e zawiera

apostrofu (‘);

nazwa zmiennej nie mo

e zawiera

adnego spo

ród pozostałych

symboli specjalnych : *,@,#,?, itp.
nie mo

na stosowa

słów kluczowych j

zyka C, nazw funkcji

bibliotecznych jako nazw zmiennych w programach pisanych w

j

zyku C;

Obsługa standardowego wej

cia/wyj

cia

Miejscem przechowywania informacji s

pliki. Poniewa

informacje s

reprezentowane jako ci

gi bitów pogrupowane po 8

w bajty, j

zyk C traktuje plik jako ci

g bajtów.

g bajtów mo

e by

nazwany plikiem b

strumieniem. W

zyku C wszystkie strumienie danych i wszystkie pliki

traktowane s

tak samo.

W j

zyku C mamy do czynienia z 3 strumieniami plikowymi:

stdin - standardowe wej

cie do odczytu

stdout - standardowe wyj

cie do zapisu

stderr - standardowe wyj

cie diagnostyczne dla komunikatów o

bł

dach

zazwyczaj stdin à klawiatura

stdout , stderr à ekran monitora

Wprowadzanie danych

Funkcja getc() - wczytuje pojedynczy znak ze strumienia
(pliku) wej

ciowego , zwracaj

c kod wczytanego znaku w postaci

liczby całkowitej (int).

int getc(FILE *stream);

int getc(stdin);

//P_5

# include <stdio.h># include <conio.h>void main(void){ int c;
clrscr(); printf("Naci

nij klawisz : \n"); c=getc(stdin);

printf("Nacisn

łe

klawisz < %c > ,którego kod ASCII wynosi %d

\n",c,c); getch();}

Funkcja getchar() - jest równowa

na funkcji getc(stdin);

int getchar(void);

//p_6

# include <stdio.h># include <conio.h>void main(void){ int c;
clrscr(); printf("Naci

nij klawisz : \n"); c=getchar();

printf("Nacisn

łe

klawisz < %c > ,którego kod ASCII wynosi %d

\n",c,c);

getch();

}

Wyprowadzanie danych

Funkcja putc() - wysyła znak do wskazanego jej jako argument
strumienia /pliku.

int putc(int c, FILE *stream);

int c - pierwszy argument funkcji to nazwa zmiennej
numerycznej przechowuj

cej kod znaku do przesłania;

drugi argumnet to wska

nik do pliku wyj

ciowego

eli operacja si

powiodła funkcja zwraca numer kodu

przesłanego znaku; w przeciwnym przypadku (bł

d) funkcja

zwraca EOF (-1)

//P_7

# include <stdio.h># include <conio.h>void main(void)

{

int c;

clrscr();

c=70;

printf("Znak o kodzie ASCII 70 to \n");

putc(c,stdout);

getch();

}

Funkcja putchar() - funkcja ta w przeciwie

stwie do putc()

potrzebuje tylko jednego argumentu tj. znaku przeznaczonego do
wyprowadzenia;

drugiego argumentu nie trzeba wprowadza

poniewa

jest on

domy

lny tj. stdout

// p_8

# include <stdio.h># include <conio.h>void main(void){ int c;
clrscr(); c=70; printf("Znak o kodzie ASCII 70 to \n");
putchar(c); getch();}

//p_9

# include <stdio.h>

# include <conio.h>

void main(void)

{

clrscr();

putchar(65);

putchar(10);

putchar(66);

putchar(10);

putchar(67);

putchar(10);

getch();

}

Funkcja printf()

int printf(const char *format_string, ...);

const – stała

char - typ znakowy

* - wska

nik (wskazanie)

format_string - ła

cuch formatuj

... - nastepne elementy
pierwszy element format_string to ła

cuch znaków zawieraj

równie

specyfikatory formatu (%c, %d, %f, itp.)

ęść

druga to ewentualna lista wyra

, które powinny by

sformatowane w cz

ęś

ci pierwszej zgodnie ze specyfikatorami

formatu;

ilo

ść

tych wyra

musi by

równa ilo

ci specyfikatorów

formatu w cz

ęś

ci pierwszej

funkcja printf() zwraca (int) ilo

ść

poprawnie sformatowanych

wyra

, w przeciwnym przypadku zwraca warto

ść

ujemn

Specyfikatory formatu, które mo

na stosowa

w wywołaniu

funkcji printf()
%c - znak (typ char)
%d - liczba (typ int)
%i - liczba (typ int) to samo co %d
%f - liczba zmiennoprzecinkowa (typ float)
%e - format wykładniczy z u

yciem małej litery e

%E - format wykładniczy z u

yciem du

ej litery E

%g - zastosuj %f lub %e – wybierz format, w którym wynik
b

dzie krótszy

%G - zastosuj % f lub %E – wybierz format, w którym wynik
b

dzie krótszy

%o - liczba ósemkowa bez znaku
%s - ła

cuch znaków (string)

%u - liczba całkowita (typu unsigned) jak int, ale bez znaku
%x - liczba szesnastkowa bez znaku (z zastosowanie przyrostka
x, małe litery)
%X - liczba szesnastkowa bez znaku (z zastosowaniem przyrostka
X, du

e litery)

%p - argument odpowiadaj

cy wska

nikowi (pointer)

%n - rejestruj ilo

ść

znaków wyprowadzon

do tego momentu

%% - wyprowad

znak ‘%’

Zamiana liczb dziesi

tnych na szesnastkowe - wykorzystanie

formatu %x i %X

//p_10

# include <stdio.h># include <conio.h>void
main(void){clrscr(); printf("Liczba 16 X Liczba 16 x Liczba
10\n");

printf("%X %x %d\n",0,0,0);

printf("%X %x %d\n",1,1,1);

printf("%X %x %d\n",2,2,2);

printf("%X %x %d\n",3,3,3);

printf("%X %x %d\n",4,4,4);

printf("%X %x %d\n",5,5,5);

printf("%X %x %d\n",6,6,6);

printf("%X %x %d\n",7,7,7);

printf("%X %x %d\n",8,8,8);

printf("%X %x %d\n",9,9,9);

printf("%X %x %d\n",10,10,10);

printf("%X %x %d\n",11,11,11);

printf("%X %x %d\n",12,12,12);

printf("%X %x %d\n",13,13,13);

printf("%X %x %d\n",14,14,14);

printf("%X %x %d\n",15,15,15);

printf("%X %x %d\n",16,16,16);

printf("%X %x %d\n",17,17,17);

printf("%X %x %d\n",18,18,18);

printf("%X %x %d\n",19,19,19);

printf("%X %x %d\n",20,20,20);

getch();

}

Minimalna szeroko

ść

pola

zyk C umo

liwia na wstawienie do specyfikatora formatu

pomi

dzy znak % a liter

specyfikatora liczby nazywanej

specyfikatorem minimalnej szeroko

ci pola

np. %10f - wyprowadzenie w formacie zmiennoprzecinkowym z
u

yciem minimum 10 znaków (cyfr)

//p_11

# include <stdio.h># include <conio.h>void main(void){int
n1,n2;clrscr(); n1=12; n2=12345; printf("%d\n",n1);
printf("%d\n",n2); printf("%5d\n",n1); printf("%05d\n",n1);
printf("%2d\n",n2); getch();}

%5d - ustalenie na 5 minimalnej szeroko

ci pola wyj

ciowego

%05d - jak wy

ej z tym

e puste miejsca zostana wypełnione

zerami

%2d - gdy specyfikator formatu jest za mały w stosunku do
długo

ci liczby to liczba jest wyprowadzana w cało

Wyrównanie pola wyj

ciowego

Znaki wyj

ciowe s

wyrównywane do prawej strony.

Aby to zmieni

, i doprowadzi

do wyrównywania do lewej nale

poprzedzi

specyfikator minimalnej szeroko

ci pola znakiem

minus (-);

//p_12

# include <stdio.h># include <conio.h>

void main(void)

{

int n1,n2;

clrscr();

n1=12;

n2=12345;

printf("%-d\n",n1);

printf("%-d\n",n2);

printf("%-5d\n",n1);

printf("%-05d\n",n1);

printf("%-2d\n",n2);

getch();

}

//p_13

# include <stdio.h># include <conio.h>void main(void)

{

int n1,n2,n3,n4,n5;

clrscr();

n1=1;

n2=12;

n3=123;

n4=1234;

n5=12345;

printf("%10d %-10d\n",n1,n1);

printf("%10d %-10d\n",n2,n2);

printf("%10d %-10d\n",n3,n3);

printf("%10d %-10d\n",n4,n4);

printf("%10d %-10d\n",n5,n5);

getch();

}

Specyfikator precyzji

Po specyfikatorze minimalnej szeroko

ci pola mo

na doda

kropk

(.) i liczb

całkowit

. Poł

czenie .liczba tworzy

specyfikator precyzji.

Pozwala on okre

ilo

ść

cyfr dziesi

tnych po przecinku dla liczb

zmiennoprzecinkowych;
albo maksymalna szeroko

ść

pola wyj

ciowego /przypadek ten

odnosi si

do liczb całkowitych i do ła

cuchów tekstowych/

np.:

%10.3f
minimalna szeroko

ść

pola wyj

ciowego 10 znaków

ilo

ść

cyfr dziesi

tnych po przecinku : 3 /domy

lna ilo

ść

cyfr

po przecinku to 6/

%3.8d
minimalna szeroko

ść

pola wyj

ciowego – 3

maksymalna szeroko

ść

pola wyj

ciowego - 8

//p_14

# include <stdio.h># include <conio.h>void main(void){int
n1;double d1;clrscr(); n1=123; d1=123.456789; printf("Format
całkowity domy

lny %d\n",n1);

printf("j.w. ze spec. pracyzji %2.8d\n",n1);

printf("Format zmiennoprzecinkowy domy

lny %f\n",d1);

printf("j.w. ze spec. praecyzji %10.2f\n",d1);

getch();

}

//p_15

# include <stdio.h># include <conio.h>void main(void){int n1;

float d1;

clrscr();

n1=123;

d1=123.456789;

printf("Format całkowity domy

lny %d\n",n1);

printf("j.w. ze spec. pracyzji %2.8d\n",n1);

printf("Format zmiennoprzecinkowy domy

lny %f\n",d1);

printf("j.w. ze spec. precyzji %10.2f\n",d1);

getch();

}

Operatory

Operator przypisania

= operator przypisania

operand_lewostronny = operand_prawostronny

warto

ść

operandu prawostronnego zostaje przypisana operandowi

lewostronnemu; przypisanie polega na umieszczeniu w obszarze
pami

ci zarezerwowanym dla operandu lewostronnego warto

operandu prawostronnego;

x = 10;

y = a + 5;

Operatory arytmetyczne i operator przypisania

z = x + y;

x = x + y; ß à x += y

Poł

czenie operatorów arytmetycznych z operatorem przypisania

tworzy w j

zyku C

arytmetyczne operatory przypisania

+= operator przypisania z dodawaniem

-= operator przypisania z odejmowaniem

*= operator przypisania z mni

eniem

/= operator przypisania z dzieleniem

%= operator przypisania reszty z dzielenia

x += y ß à x = x + y

x -= y ß à x = x - y

x *= y ß à x = x * y

x /= y ß à x = x / y

x %= y ß à x = x % y

z = z * x + y i z *= x + y nie s

równowa

ne ze wzgl

du na

kolejno

ść

operacji

równowa

ne s

z *= x + y i z = z * ( x + y )

//p_16

# include <stdio.h># include <conio.h>void main(void){int
x,y,z;clrscr(); x=1; y=3; z=10; printf("x= %d y= %d z=

%d\n",x,y,z); x=x+y; printf("\nx=x+y przypisuje zmiennej x
warto

ść

%d\n",x);

x=1;

x+=y;

printf("\nx+=y przypisuje zmiennej x warto

ść

%d\n",x);

x=1;

x=x-y;

printf("\nx=x-y przypisuje zmiennej x warto

ść

%d\n",x);

x=1;

x-=y;

printf("\nx-=y przypisuje zmiennej x warto

ść

%d\n",x);

x=1;

z=z*x+y;

printf("\nz=z*x+y przypisuje zmiennej z warto

ść

%d\n",z);

z=10;

z=z*(x+y);

printf("\nz=z*(x+y) przypisuje zmiennej z warto

ść

%d\n",z);

z=10;

z*=x+y;

printf("\nz*=x+y przypisuje zmiennej z warto

ść

%d\n",z);

getch();

}

Jednoargumentowy operator zmiany znaku

Operandem tego operatora mo

e by

warto

ść

numeryczna całkowita

lub zmiennoprzecinkowa – stała b

zmienna.

Nie mo

na myli

jednoargumentowego operatora (-) z

dwuargumentowym operatorem (-) odejmowania.

W wyra

eniu:

x - -y à pierwszy jest operatorem dwuargumentowym odejmowania,
za

drugi minus operatorem jednoargumentowym zmiany znaku.

tj. x – (-y) à x + y

Zwi

kszanie i zmniejszanie o 1. à Inkrementacja i

dekrementacja.

++ x ß à x = x+1 lub x += 1

-- x ß à x = x-1 lub x -= 1

Operatory inkrementacji i dekrementacji wystepuj

w j

zyku C w

dwóch wersjach ka

dy :

++ x - operator pre-inkrementacji

x ++ - operator post-inkrementacji

-- x - operator pre-dekrementacji

x -- - operator post-dekrementacji

W przepadku pre- najpierw nast

puje dodanie lub odjecie

jedynki a pó

niej wykorzystanie zmiennej z now

warto

programie;

W przypadku post- najpierw nast

puje wykorzystanie warto

zmiennej w programie a dopiero pó

niej jej zwi

kszenie lub

zmniejszenie o 1;

y = x ++;

1/ najpierw wykonane zostanie przypisanie y = x;

2/ potem x = x + 1;

praktycznie realizuje si

to w nast

puj

cy sposób:

1/ program wykonuje kopie tymczasow

zmiennej x;

2/ inkrementuje zmienn

x , a nie tymczasow

kopi

;

3/ wykorzystuje tymczasowa kopie x do przypisania y = x;

//p_17

# include <stdio.h># include <conio.h>void main(void){int
x,y,z,w,wynik;clrscr(); x=y=z=w=1; printf("x = %d y = %d z =
%d w = %d\n",x,y,z,w); wynik=++x; printf("\n++x wynosi
%d\n",wynik); wynik=y++;

printf("\ny++ wynosi %d\n",wynik);

wynik=--z;

printf("\n--z wynosi %d\n",wynik);

wynik=w--;

printf("\nw-- wynosi %d\n",wynik);

getch();

}

Operatory relacji

Mi

dzy wyra

eniami w j

zyku C mog

wyst

powa

nast

puj

relacje:

== równe

!= ró

ne od

> wi

ksze od

< mniejsze od

>= wi

ksze lub równe

<= mniejsze lub równe

Wszystkie operatory relacji maj

szy priorytet ni

operatory arytmetyczne, co oznacza

e najpierw zostan

wykonane operacje arytmetyczne a nast

pnie zostan

dokonane

porównania warto

ci.

cie operacji w nawiasy powoduje ich wykonanie w pierwszej

kolejno

ci.

W grupie operatorów logicznych, operatory > , < , >= , <= maja
wy

szy priorytet ni

== oraz != .

eli relacja jest prawdziwa to zwrócona zostanie warto

ść

w przeciwnym przypadku warto

ść

//p_18

# include <stdio.h># include <conio.h>void main(void){int
x,y;double z;clrscr(); x=7; y=25; z=24.46;

printf("x = %d y = %d z = %.2f\n",x,y,z);

printf("operacja %d >= %d daje wynik %d\n",x,y,x>=y);

printf("operacja %d == %d daje wynik %d\n",x,y,x==y);

printf("operacja %d < %.2f daje wynik %d\n",x,z,x<z);

printf("operacja %d > %.2f daje wynik %d\n",y,z,y>z);

printf("operacja %d != %d - 18 daje wynik %d\n",x,y,x!=y-18);

printf("operacja %d + %d != %.2f daje wynik
%d\n",x,y,z,x+y!=z);

getch();

}

1 / 2 + 1 / 2 == 1 à logiczny wynik 0 1 / 2 à 0

1.0 / 3.0 + 1.0 / 3.0 + 1.0 / 3.0 == 1 à logiczne 0 1.0 / 3.0
à 0.3333333

Operator rzutowania

W j

zyku C mo

na zamieni

jeden typ danych na inny poprzez

poprzedzenie operandu operatorem rzutowania.

(typ_danych)x

typ danych na który ma zosta

zamieniona warto

ść

(float)5 à 5.0

x=1;

(float)(x+2) à 3.0

//p_19

# include <stdio.h># include <conio.h>void main(void){int
x,y;clrscr(); x=8; y=5;printf("x = %d y = %d \n",x,y);
printf("operacja %d / %d daje wynik %d\n",x,y,x/y);
printf("operacja float(%d) / %d daje wynik
%f\n",x,y,float(x)/y);

getch();

}

Operacje p

tli

tla for ( ... )

for ( wyra

enie1; wyra

enie2; wyra

enie3 )

{

instrukcja1;

instrukcja2;

instrukcja3;

...........

...........

}

wyra

enie1 - wyra

enie inicjuj

ce p

tli /wykonuje si

tylko

raz/

wyra

enie2 - wyra

enie warunkowe 1 à wykonuje si

tla

à nie wykonuje si

wyra

enie3 - wykonuje si

po ka

dym przebiegu instrukcji

tli, przed

sprawdzeniem warto

ci wyra

enia2;

//p_20

# include <stdio.h>

# include <conio.h>

void main(void)

{

int i;

clrscr();

printf("Kod 16 D.L. Kod 16 m.l. Kod 10 \n");

for (i=0;i<16;i++)

printf(" %X %x %d \n",i,i,i);

getch();

}

for (i=0; i<8; i++)

{

ciało p

tli

}

for (i=0; i<8; i++ )

suma+=i;

for (i=0; i<8; i++ ); à p

tla pusta

rozbudowana p

tla for

for ( i=0, j=10; i<10, j>0; i++, j-- )

{

}

//p_21

# include <stdio.h>

# include <conio.h>

void main(void)

{

int i,j;

clrscr();

for (i=0,j=8;i<8;i++,j--)

printf("%d + %d = %d\n",i,j,i+j);

getch();

}

//p_22

# include <stdio.h>

# include <conio.h>

void main(void)

{

int i,j;

clrscr();

for (i=0,j=8;i<8,j>5;i++,j--)

printf("%d + %d = %d\n",i,j,i+j);

getch();

}

//p_23

# include <stdio.h>

# include <conio.h>

void main(void)

{

int i,j;

clrscr();

for (i=0,j=1;i<8;i++,j++)

printf("%d - %d = %d\n",j,i,j-i);

getch();

}

P

tle niesko

czone

for (;;)

{

ciało p

tli

}

for(;;);

for(;1;);

for (;1;)

{

ciało p

tli

}

//p_24

# include <stdio.h>

# include <conio.h>

void main(void)

{

int c;

clrscr();

printf("Wpisz znak - jesli wpiszesz znak <x> to koniec
programu\n");

for (c=' ';c!='x';)

{

c=getc(stdin);

putchar(c);

}

printf("\nKoniec programu\n");

getch();

}

P

tla while

while(wyra

enie)

{

instrukcja1;

instrukcja2;

)

Je

eli wyra

enie zwraca warto

ść

niezerow

wykonywane s

instrukcje wewn

trz p

tli. Po wykonaniu instrukcji p

tli

wyra

enie sprawdzane jest ponownie i je

eli zwróci warto

ść

niezerowa instrukcje wewn

trz p

tli wykonywane s

ponownie, a

do chwili gdy po kolejnym sprawdzeniu wyra

enie przyjmie

warto

ść

//p_25

# include <stdio.h># include <conio.h>

void main(void)

{

int c;

clrscr();

printf("Wpisz znak - jesli wpiszesz znak <x> to koniec
programu\n");

while (c!='x')

{

c=getc(stdin);

putchar(c);

}

printf("\nKoniec programu\n");

getch();

}

Niesko

czona p

tla while

while(1)

{

instrukcja1;

instrukcja2;

}

//p_26

# include <stdio.h># include <conio.h>void main(void){int
c;clrscr(); printf("Wpisz znak\n"); while (1) { c=getc(stdin);
putchar(c); break; } printf("\nKoniec programu\n"); getch();}

Petla do - while

W p

tlach for i while wyra

enia warunkowe znajduj

nagłówku p

tli. W p

tli do-while odwrotnie – wyra

enie

znajduje si

na ko

cu p

tli. Dzieki temu instrukcje znajduj

wewn

trz p

tli b

wykonywane przynajmniej jeden raz

zanim dojdzie do sprawdzenia warunku.

do

{

instrukcja1;

instrukcja2;

} while (wyra

enie);

Instrukcja do-while zako

czona jest srednikiem.

//p_26_1

#include <stdio.h>main(){ int i; i = 65; do { printf("The
numeric value of %c is %d.\n", i, i);

i++;

} while (i<72);

return 0;

}

P

tle zagnie

one

Wstawianie jednej p

tli wewn

trz innej p

tli nazywa si

zagnie

eniem p

tli.

//p_27

# include <stdio.h># include <conio.h>void main(void){int i,j;
clrscr(); for(i=1;i<=3;i++)

{

printf("Poczatek iteracji %d p

tli zewnetrznej \n",i);

for(j=1;j<=4;j++)

printf("Iteracja %d petli wewnetrznej \n",j);

printf("Koniec iteracji %d petli zewnetrznej \n",i);

}

getch();

}

Zanim rozpocznie si

kolejna iteracja p

tli zawn

trznej, musi

zosta

zako

czone wykonywanie p

tli wewn

trznej. Gdy

rozpocznie si

kolejne wykonanie p

tli zewn

trznej, p

tla

wewn

trzna jest ponownie wykonywana zadan

ilo

ść

razy.

//p_28

# include <stdio.h># include <conio.h>void main(void)

{

int i,j;

clrscr();

for(i=1;i<=3;i++)

{

printf("Poczatek iteracji %d p

tli zewnetrznej \n",i);

for(j=1;j<=4;j++)

printf("Iteracja %d petli wewnetrznej \n",j);

printf("Koniec iteracji %d petli zewnetrznej \n",i);

}

getch();

}

Operatory - cd

Operator sizeof

sizeof(wyra

enie)

wyra

enie oznacza typ danych lub zmienn

, warto

ść

jest zwraca

w bajtach;

//p_29

# include <stdio.h># include <conio.h>void main(void){char c='
';int i=0;float f=0.0f;double d=0.0;clrscr();

printf("Dane typu char zajmuj

: %d - bajt\n",sizeof(char));

printf("Zmienna typu char zajmuje %d - bajt\n",sizeof c);

printf("Dane typu int zajmuj

: %d - bajty\n",sizeof(int));

printf("Zmienna typu int zajmuje %d - bajty\n",sizeof i);

printf("Dane typu float zajmuj

: %d - bajty\n",sizeof(float));

printf("Zmienna typu float zajmuje %d - bajty\n",sizeof f);

printf("Dane typu double zajmuj

: %d -

bajt˘w\n",sizeof(double));

printf("Zmienna typu double zajmuje %d - bajt˘w\n",sizeof d);

getch();

}

podaj

c operatorowi sam typ danych np. sizeof(int) lub

identyfikator zmiennej np. sizeof int_1; poniewa

identyfikator zmiennej nie jest słowem kluczowym j

zyka C

zatem mo

emy pomin

ąć

nawiasy.

Operatory logiczne

&& - iloczyn logiczny (AND)

| | - suma logiczna (OR)

! - negacja logiczna (NOT)

s

to operatory dwu (&& , || ) lub jednoargumentowe, których

argumentami s

wyra

enia b

warto

ci logiczne;

Operator iloczynu logiczne (AND)

wyr1 && wyr2

wyr1 wyr2 wyr1 && wyr2

1 1 1

1 0 0

0 1 0

0 0 0

//p_30

# include <stdio.h>

# include <conio.h>

void main(void)

{

int num=0;

clrscr();

printf("Operator && zwraca: %d\n", (num%2==0)&&(num%3==0));

num =2;

printf("Operator && zwraca: %d\n", (num%2==0)&&(num%3==0));

num=3;

printf("Operator && zwraca: %d\n", (num%2==0)&&(num%3==0));

num=6;

printf("Operator && zwraca: %d\n", (num%2==0)&&(num%3==0));

getch();

}

Operator sumy logicznej (OR)

wyr1 | | wyr2

wyr1 wyr2 wyr1 | | wyr2

1 1 1

1 0 1

0 1 1

0 0 0

//p_31

# include <stdio.h>

# include <conio.h>

void main(void)

{

int num;

clrscr();

printf("Wpisz jednocyfrow

liczbe podzieln

\n przez 2 i przez

3\n");

for (num=1; (num%2!=0)||(num%3!=0);)

num=getchar()-48;

printf("Szukana liczba to : %d\n",num);

getch();

}

Operator logicznej negacji

! wyr

wyr ! wyr

1 0

0 1

//p_32

# include <stdio.h>

# include <conio.h>

void main(void)

{

int num;

clrscr();

num=7;

printf("Dana jest zmienna num o warto˜ci 7 \n");

printf("!(num<7) zwraca : %d\n",!(num<7));

printf("!(num>7) zwraca : %d\n",!(num>7));

printf("!(num==7) zwraca : %d\n",!(num==7));

getch();

}

//p_33

# include <stdio.h>

# include <conio.h>

void main(void)

{

int num;

clrscr();

printf("Wpisz jednocyfrow

liczb

podzieln

\n przez 2 i przez

3\n");

for (num=1; !((num%2==0)&&(num%3==0));)

num=getchar()-48;

printf("Szukana liczba to : %d\n",num);

getch();

}

Logiczne operatory bitowe

& - bitowy iloczyn logiczny AND (I)

| - bitowa suma logiczna OR (LUB)

^ - bitowa alternatywa wył

czna XOR (ALBO)

~ - bitowe uzupełnienie do 2 (komplementarne)

>> - przesuni

cie bitów w prawo

<< - przesuni

cie bitów w lewo

HEX Binarnie Dziesi

tnie

0 0000 0

1 0001 1

2 0010 2

3 0011 3

4 0100 4

5 0101 5

6 0110 6

7 0111 7

8 1000 8

9 1001 9

A 1010 10

B 1011 11

C 1100 12

D 1101 13

E 1110 14

F 1111 15

x & y

Operator & porównuje ka

dy bit operandu x z odpowiednim bitem

operandu y. Je

eli oba bity s

równe 1 operator ustawia 1 na

tej samej pozycji bitu wyniku. Je

eli cho

by jeden z

porównywanych bitów jest równy 0 to bit wyniku jest 0.
& 11 à 01

x | y

Operator bitowy sumy logicznej (alternatywy zwykłej) ustawia
bit wyniku na 1 je

eli cho

by jeden z bitów operandu (lub oba)

jest równy 1.
| 11 à 11

x ^ y

Operator alternatywy wył

cznej ustawia bit wyniku na 1 ,

elili dokładnie jeden z bitów obu operandów jest równy 1.

^ 11 à 10

~ x

Operator negacji (inwersji bitowej) – dokonuj

cy operacji na

pojedynczym operandzie - odwraca warto

ść

dego bitu

operandu.

~ 01 à 10

//p_34

# include <stdio.h># include <conio.h>void main(void){int
x,y,z;x=4321;y=5678;clrscr(); printf("Dana jezt zmienna x = %u
, czyli 0x%04X\n",x,x); printf("oraz zmienna y = %u , czyli
0x%04X\n",y,y);

z=x&y;

printf("x&y zwraca %6u , czyli 0x%04X\n",z,z);

z=x|y;

printf("x|y zwraca %6u , czyli 0x%04X\n",z,z);

z=x^y;

printf("x^y zwraca %6u , czyli 0x%04X\n",z,z);

printf("~x zwraca %6u , czyli x%04X\n",~x,~x);

getch();

}

Operatory przesuni

cia bitowego

>> przesuwa bity operandu w prawo

<< przesuwa bity operandu w lewo

x >> y

x << y

x – operand, którego bity b

przesuwane

y – ilo

ść

miejsc o które nale

y przesun

ąć

bity operandu

8 >> 2 à 1000>>2 à 0010 à 2

5 << 1 à 0101<<1 à 1010 à 10

//p_35

# include <stdio.h># include <conio.h>void main(void){int
x,y,z;x=255;y=5;clrscr(); printf("Dana jest zmienna x = %4d ,
czyli 0x%04X\n",x,x); printf("oraz zmienna y = %4d , czyli
0x%04X\n",y,y); z=x>>y; printf("x>>y zwraca %6d , czyli
0x%04X\n",z,z);

z=x<<y;

printf("x<<y zwraca %6d , czyli 0x%04X\n",z,z);

getch();

}

y > 0

x >> y ß à x / 2y

x << y ß à x * 2y

Operator warunkowy – jedynym operatorem trójargumentowym.

?: - operator warunkowy

x ? y : z

operandy x , y , z

x - wyra

enie logiczne – wyra

enie warunkowe

y - wyra

enie wynikowe , które jest wykonywane gdy x zwraca

warto

ść

niezerow

(np. 1)

z - wyra

enie wynikowe, które jest wykonywane gdy x zwraca

warto

ść

//p_36

# include <stdio.h># include <conio.h>void main(void){int
x;x=sizeof(int);clrscr(); printf("%s\n", (x==2) ? "Typ danych
int ma 2 bajty.":"Typ int nie ma 2 bajtów");
printf("Maksymalna wartosc liczby typu int to : %d\n", (x!=2)
? ~(1<<x*8-1): ~(1<<15));

getch();

}

Typy danych - modyfikatory

Bit znaku

Jeden bit liczby mo

e by

wykorzystany po to aby wskazywał czy

liczba jest dodatnia czy ujemna. Jest to tzw, bit znaku.

Modyfikator signed

Dla liczb całkowitych pierwszy od lewej bit jest u

ywany jako

bit znaku. Je

eli liczby całkowite typu int maj

16 bitów, i

pierwszy bit od prawej jest okre

lany bitem na pozycji 0 to

bit znaku znajduje si

na pozycji 15. Je

eli jego warto

ść

wynosi 0 to liczba jest dodatnia, za

gdy 1 to liczba jest

ujemna.

Sposób implementacji liczb ujemnych zmiennopozycyjnych typu
float i double na razie pominiemy.

modyfikator signed jest u

ywany dla wskazania, i

jeden bit

danych jest bitem znaku;

deklaracja int à jest domyslnie traktowana jako signed int

deklaracja char à zakres warto

ci 0 – 255 (28 – 1)

deklaracja signed char à zakres warto

od -128 (-27 )

do +127 (27 – 1)

Aby zamieni

liczb

dwójkow

na równ

jej co do warto

bezwzgl

dnej lecz ujemn

, nale

liczba 12 345 à 0011 0000 0011 1001

1/ znajdujemy kod odwrotny liczby:

1100 1111 1100 0110

2/ dodajemy 1

1100 1111 1100 0111

jest to kod dwójkowy liczby - 12 345

Modyfikator unsigned

modyfikator unsigned stosowany jest dla okre

lenia , i

pierwszy bit liczby nie jest jej bitem znaku;

mo

e on by

stosowany jako :

unsigned int

unsigned char

unsigned int x; à x: 0 , 65 535 (216 – 1)

Standard ANSI C pozwala na stosowanie przyrostków U i u przy
stałych bez znaku:

unsigned int x,y;

x = 1234U;

y = 0xABCFu;

//p_37

# include <stdio.h># include <conio.h>// funkcja druk_bin
drukuje binarny podany dzisi

tnie argument x typu intvoid

druk_bin(int x){ int n; for (n=15;n>=0;n--) ((x>>n&1) ?
putchar('1') : putchar('0'));

}

void main(void)

{

signed char ch;

int x;

unsigned int y;

ch=0xFF;

x=0xFFFF;

y=0xFFFF;

clrscr();

printf("\nDziesi

tnie ze znakiem 0xFF to : %d",ch);

printf("\nDziesi

tnie ze znakiem 0xFFFF to : %d a binarnie

:",x);

druk_bin(0xFFFF);

printf("\nDziesietnie bez znaku 0xFFFF to : %u",y);

printf("\nDziesi

tnie: 12345 to Hex: 0x%X i binarnie:

",12345);

druk_bin(12345);

printf("\nDziesi

tnie: -12345 to Hex: 0x%X i binarnie: ",-

12345);

druk_bin(-12345);

getch();

}

Modyfikatory rozmiaru danych

Dla zmniejszenia lub zwi

kszenia pami

ci zajmowanej przez dane

słu

żą

modyfikatory short i long.

Modyfikator short

Modyyfikator short umo

liwia np. w systemie 32 bitowym

skrócenie danych in z 32 bitów do 16 bitów

short x; oznacza short signed int x;

unsigned short x; oznacza short unsigned int x;

Modyfikator long

Modyfikator long poszerza zakres warto

ci iprzez to dane

zajmuja wi

cej miejsca w pami

ci.

eli zmienna typu int zajmuje domy

lnie 16 bitów to

modyfikator long int powi

ksza wielko

ść

tej zmiennej do 32

bitów;

long int x; à -2147483648 (-231 ) do 2147483647 (231 – 1)

Standard ANSI C pozwala na dodawanie do stałych typu long
przyrostków L i l .

long int x,y;

x=123456789L;

y=0xABCD1234l;

//p_38

# include <stdio.h># include <conio.h>void
main(void){clrscr(); printf(" Rozmiar int: %d \n
",sizeof(int)); printf("Rozmiar short int: %d \n
",sizeof(short int)); printf("Rozmiar long int: %d \n
",sizeof(long int));

printf("Rozmiar float: %d \n ",sizeof(float));

printf("Rozmiar double: %d \n ",sizeof(double));

printf("Rozmiar long double: %d \n ",sizeof(long double));

getch();

}

short int - 2 bajty - 16 bitów - liczby całkowite krótkie

long int - 4 bajty - 32 bity - liczby całkowite długie

float - 4 bajty - 32 bity - liczby zmiennoprzecinkowe krótkie

double - 8 bajtów – 64 bity - liczby zmiennoprzecinkowe o
podwójnej

precyzji

long double - 10 bajtów - 80 bitów - liczby zmiennoprzecinkowe
długie

Specyfikatory formatu h l L

%hd %hi

dziesietnie, liczba całkowita krótka - short int

%hu

dziesi

tnie, liczba całkowita krótka bez znaku - short

unsigned int

%ld %Ld

dziesi

tnie, całkowita długa - long int

%lu %Lu

dziesi

tnie, całkowita długa bez znaku - long unsigned int

//P_39

# include <stdio.h># include <conio.h>void main(void)

{

short int x;

unsigned int y;

long int s;

unsigned long int t;

x=0xFFFF;

y=0xFFFFU;

s=0xFFFFFFFFl;

t=0xFFFFFFFFL;

clrscr();

printf("Short int 0xFFFF to: %hd\n",x);

printf("Unsigned int 0xFFFF to: %u\n",y);

printf("Long int 0xFFFFFFFF to: %ld\n",s);

printf("Unsigned long int 0xFFFFFFFF to %lu\n",t);

getch();

}

Funkcje matematyczna

Grupy funkcji matematycznych

Trygonometryczne i hiperboliczne : sin() , cos() , cosh()
,......

Wykładnicze i logarytmiczne : exp() , pow() , log10() , .....

Pozostałe : ceil() , fabs() , floor() , ....

Wykorzystanie funkcji sin(), cos(), tan();

argumentem funkcji jest k

t x w radianach

radiany = stopnie * (3.141593 / 180.0 )

#include <math.h>

double sin(double x);

double cos(double x);

double tan(double x);

//p_40

# include <stdio.h># include <conio.h># include <math.h>void
main(void){double x;x=45.0;x*=3.141593/180.0;clrscr();
printf("Sinus 45 : %f\n",sin(x)); printf("Cosinus 45 :
%f\n",cos(x));

printf("Tangens 45 : %f\n",tan(x));

getch();

}

Wywołanie funkcji : pow() i sqrt();

#include <math.h>

double pow(double a, double b);

double sqrt(double x);

//p_41

# include <stdio.h># include <conio.h># include <math.h>void
main(void){double x,y,z;x=64.0;y=3.0;z=0.5;clrscr();
printf("64 x 64 x 64 : %7.0f\n",pow(x,y));

printf("Pierw. kw. z 64 : %2.0f\n",sqrt(x));

printf("64 do pot

gi 1/2 : %2.0f\n",pow(x,z));

getch();

}

Sterowanie programem

Instrukcja warunkowa if

if (wyra

enie)

{

blok instrukcji

}

//p_42

# include <stdio.h>

# include <conio.h>

void main(void)

{

int i;

clrscr();

printf("Liczby caˆkowite podzielne przez 2 i przez 3\n");

printf("\tw zakresie od 0 do 100 \n");

for (i=0;i<=100;i++)

if((i%2==0)&&(i%3==0))

printf(" %d\n",i);

getch();

}

Instrukcja warunkowa if-else

if (wyra

enie)

{

blok instrukcji

}

else

{

blok instrukcji

}

//p_43

# include <stdio.h>

# include <conio.h>

void main(void)

{

int i;

clrscr();

printf("Liczby parzyste Liczby nieparzyste\n");

for (i=0;i<10;i++)

if(i%2==0)

printf("%d",i);

else

printf("%30d\n",i);

getch();

}

Zagnie

one instrukcje warunkowe if

//p_44

# include <stdio.h>

# include <conio.h>

void main(void)

{

int i;

clrscr();

for (i=-5;i<=5;i++)

if(i>0)

if(i%2==0)

printf("%d to liczba parzysta \n",i);

else

printf("%d to liczba nieparzysta \n",i);

else

if (i==0)

printf("To jest zero\n");

else

printf("Liczba ujemna %d\n",i);

getch();

}

Instrukcja switch

switch (wyra

enie)

{

case wyra

enie1:

instrukcja1;

case wyra

enie2:

instrukcja2;

...........

default:

instrukcja-domyslna;

}

Najpierw sprawdzana jest warto

ść

wyra

enia (wyra

enie

sterujace)

Je

eli warto

ść

wyra

enia jest równa wyra

enie1 to wykonywana

jest instrukcja1, je

eli jest równa wyra

enie2 to wykonywana

jest isntrukcja2, itd.

wyra

enie1, wyra

enie2 i pozostałe wyra

enia s

wyra

eniami

stałowarto

ciowymi;

eli warto

ść

zwrócona przez wyra

enie steruj

ce nie jest

równa warto

ci któregokolwiek z wyra

stałowarto

ciowych,

zostanie wykonana instrukcja domyslna.

//p_45

# include <stdio.h>

# include <conio.h>

void main(void)

{

int day;

clrscr();

printf("Wpisz numer dnia z zakresu od 1 do 3\n");

day=getchar();

switch(day)

{

case '1':

printf("Dzie

1\n");

case '2':

printf("Dzie

2\n");

case '3':

printf("Dzie

3\n");

default:

;

}

getch();

}

Instrukcja break

//p_45p

# include <stdio.h>

# include <conio.h>

void main(void)

{

int day;

clrscr();

printf("Wpisz numer dnia z zakresu od 1 do 3\n");

day=getchar();

switch(day)

{

case '1':

printf("Dzie

1\n");

break;

case '2':

printf("Dzien 2\n");

break;

case '3':

printf("Dzie

3\n");

break;

default:

;

}

getch();

}

//p_46

# include <stdio.h>

# include <conio.h>

void main(void)

{

int day;

clrscr();

printf("Wpisz numer dnia tygodnia od 1 do 7\n");

day=getchar();

switch(day)

{

case '1':

printf("Dzie

1 - Niedziela\n");

break;

case '2':

printf("Dzie

2 - Poniedziaˆek\n");

break;

case '3':

printf("Dzie

3 - Wtorek\n");

break;

case '4':

printf("Dzie

4 -

roda\n");

break;

case '5':

printf("Dzie

5 - Czwartek\n");

break;

case '6':

printf("Dzie

6 - Pi

tek\n");

break;

case '7':

printf("Dzie

7 - Sobota\n");

break;

default:

printf("Liczba spoza zakresu 1 - 7");

break;

}

getch();

}

Przerwanie p

tli niesko

czonej

for(;;)

{

instr1;

instr2;

......

}

while(1)

{

instr1;

instr2;

......

}

//p_47

# include <stdio.h>

# include <conio.h>

void main(void)

{

int c;

clrscr();

printf("Wpisz znak:\n");

printf("x + <Enter> = Koniec programu\n");

while (1)

{

c=getc(stdin);

if(c=='x')

break;

}

printf("Program zostaˆ przerwany - Koniec \n");

getch();

}

Instrukcja continue

Czasem zamist przerywa

, trzeba tylko pomin

ąć

pewn

grup

instrukcji, ale p

tla powinna wykonywa

dalej.

Instrukcja continue powoduje natychmiastowy skok na pocz

tek

tli i poj

cie próby ponownego wykonania p

tli od pocz

tku.

//p_48

# include <stdio.h>

# include <conio.h>

void main(void)

{

int i,sum;

clrscr();

sum=0;

for(i=1;i<8;i++)

{

if((i==3) || (i==5))

continue;

sum+=i;

}

printf("Suma liczb 1 2 3 4 6 i 7 wynosi: %d\n",sum);

getch();

}

Instrukcja goto

etykieta:

instrukcja1;

instrukcja2;

.........

goto etykieta;

etykieta pokazuje w które miejsce w programie ma nastapi

skok

po wykonaniu instrukcji goto;

etykieta wyst

puje w dwóch miejscach:

1/ ze znakiem : w miejscu do którego nastepuje skok (etykietaJ

2/ po instrukcji goto (goto etykieta:)

Wska

niki

adres w pami

ci = zmienna = stała

warto

ść

lewostronna warto

ść

prawostronna

zmiennej zmiennej

deklaracja nadaje zmiennej warto

ść

lewostronn

–

przyporz

dkowuj

c jej adres w pami

ci;

int x;

podstawienie nadaje zmiennej warto

ść

prawostronn

– umiesza w

zarezerwowanym dla zmiennej obszarze pami

ci dane;

x=10;

Operator adresowy &

Operator adresowy zwraca warto

ść

lewostronn

zmiennej

long int x,y;

y=&x;

przypisuje zmiennej y adres zmiennej x;

// p_49

# include <stdio.h># include <conio.h>void main(void){char
c;int x;float y;clrscr(); printf("c: adres=0x%p,
zawarto

ść

=%c\n",&c,c); printf("x: adres=0x%p,

zawarto

c=%d\n",&x,x); printf("y: adres=0x%p,

zawarto

c=%5.2f\n",&y,y);

c='A';

x=7;

y=123.45;

printf("c: adres=0x%p, zawarto

ść

=%c\n",&c,c);

printf("x: adres=0x%p, zawarto

c=%d\n",&x,x);

printf("y: adres=0x%p, zawarto

ść

=%5.2f\n",&y,y);

getch();

}

specyfikator formatu %p /’pointer’/ u

ywany jest dla

wyprowadzania adresów zmiennych;

Deklaracja wska

ników

Wska

nik to zmienna, w której przechowywany jest adres innej

zmiennej.

warto

ść

lewostronna warto

ść

prawostronna

wska

nika to jego = wska

nik = to adres innej zmiennej

adres

słu

y do odwołania si

do samego wska

nika

deklaracja wska

nika

typ danych * nazwa_wska

nika

typ danych , których adres operator jednoargumentowy

przechowywał b

dzie wska

nik

// p_50

# include <stdio.h># include <conio.h>void main(void){char
c,*ptr1;int x,*ptr2;float y,*ptr3;clrscr(); c='A'; x=7;
y=123.45; printf("c: adres=0x%p, zawarto

ść

=%c\n",&c,c);

printf("x: adres=0x%p, zawarto

ść

=%d\n",&x,x);

printf("y: adres=0x%p, zawarto

ść

=%5.2f\n",&y,y);

ptr1=&c;

printf("ptr_c adres=0x%p, zawiera=0x%p\n",&ptr1,ptr1);

printf("*ptr_c => %c\n",*ptr1);

ptr2=&x;

printf("ptr_x adres=0x%p, zawiera=0x%p\n",&ptr2,ptr2);

printf("*ptr_x => %d\n",*ptr2);

ptr3=&y;

printf("ptr_y adres=0x%p, zawiera=0x%p\n",&ptr3,ptr3);

printf("*ptr_y => %5.2f\n",*ptr3);

getch();

}

Operator dereferencji * /operator jednoargumentowy – unarny/

Poł

czenie oparatora dereferencji * oraz nazwy wska

nika

powoduje odwołanie do prawostronnej warto

ci zmiennej

wskazywanej.

char c; - deklaracja zmiennej

char *ptrc; - deklaracja wska

nika

ptrc=&c; - zainicjowanie wska

nika

odwołanie do zmiennej c:

przez nazw

c - bezpo

rednie

przez *ptrc - posrednie ; przez wska

nik

printf(”%c”,c) to samo co printf(”%c”,*ptrc)

int x=1234, *ptrx;

ptrx=&x;

printf(”%d”,(*ptrx+1)); à 1235

Wska

nik pusty - to wska

nik o prawostronnej warto

ci = 0;

char *ptrc;

int *ptrx;

ptrc=ptrx=0;

puste wska

niki

Modyfikowanie zawarto

ci zmiennej przez wska

niki:

// p_51

# include <stdio.h># include <conio.h>void main(void){char
c,*ptr_c;clrscr(); c='A'; printf("c: adres=0x%p,
zawarto

ść

=%c\n",&c,c);

ptr_c=&c;

printf("ptr_c adres=0x%p, zawiera=0x%p\n",&ptr_c,ptr_c);

printf("*ptr_c => %c\n",*ptr_c);

*ptr_c='B';

printf("ptr_c adres=0x%p, zawiera=0x%p\n",&ptr_c,ptr_c);

printf("*ptr_c => %d\n",*ptr_c);

printf("c: adres=0x%p, zawiera=%c\n",&c,c);

getch();

}

Wskazanie tego samego adresu.

Ten sam adres w pami

ci mo

e by

wskazywany przez wi

cej ni

jeden wska

nik.

char p1,p2;

char zmienna;

p1=&zmienna;

p2=&zmienna;

//p_52

# include <stdio.h># include <conio.h>void main(void){int
x;int *ptr_1,*ptr_2,*ptr_3;clrscr(); x=1234;

printf("x: adres=0x%p, zawarto˜†=%d\n",&x,x);

ptr_1=&x;

printf("ptr_1 adres=0x%p, zawiera=0x%p\n",&ptr_1,ptr_1);

printf("*ptr_1 => %d\n",*ptr_1);

ptr_2=&x;

printf("ptr_2 adres=0x%p, zawiera=0x%p\n",&ptr_2,ptr_2);

printf("*ptr_2 => %d\n",*ptr_2);

ptr_3=ptr_1;

printf("ptr_3 adres=0x%p, zawiera=0x%p\n",&ptr_3,ptr_3);

printf("ptr_3 => %d\n",*ptr_3);

getch();

}

Tablice

Zestaw danych tego samego typu, posiadaj

cych podobne

przeznaczenie nazywany jest tablic

da zmienna wchodz

ca w skł

d tablicy nazywa si

jej

elementem. Do wszystkich elementów tablicy mo

na odwoływac si

poprzez t

sama nazw

tablicy, zajmuj

one poło

one koło

siebie miejsca w pami

ci.

Deklaracja tablicy :

typ_danych nazwa_tablicy[rozmiar_tablicy];

wspólny typ identyfikator ilo

ść

elementów tablicy

np. tablica danych numerycznych 10-elementowa

int tab[10];

Indeksowanie elementów tablicy :

int tab[9];

element – 1 tab[0]

element - 2 tab[1]

..........

element - 9 tab[8]

wyra

enia umieszczone w nawiasach umo

liwiaj

odwołanie do

elementów tablicy - s

nazywane referencjami do elementów

tablicy;

Inicjowanie tablic

1/ przez referencje do elementów i operator podstawienia :

tab[6]=12;

2/ jednoczesnie :

int tab[5] = {2,4,3,66,1};

//p_53

# include <stdio.h># include <conio.h>void main(void){int
i;int Tab[10];clrscr(); for(i=0;i<10;i++)

{

Tab[i]=i+1;

printf("Element tablicy Tab[%d] ma warto

ść

: %d. \n",i,Tab[i]);

}

getch();

}

Rozmiar tablicy

Obszar pami

ci zajmowany przez tablic

– adres jej pierwszego

i ostatniego elementu.

// p_54

# include <stdio.h># include <conio.h>void main(void){int
total;int list[10];clrscr(); total=sizeof(int)*10;
printf("Element typu int zajmuje %d - bajty \n",sizeof(int));

printf("Cała tablica zajmuje %d bajt˘w \n",total);

printf("Adres pierwszego elementu tablicy: 0x%x\n",&list[0]);

printf("Adres ostatniego elementu tablicy : 0x%x\n",&list[9]);

getch();

}

- operator adresowy & zwraca adres elementu tablicy

typ_danych nazwa_tablicy[rozmiar_tablicy];

Ilo

ść

bajtów zajmowanych przez tablic

to :

sizeof(typ_danych) * rozmiar_tablicy

lub

sizeof(nazwa_tablicy)

Wska

nikowanie tablic

//p_55

# include <stdio.h># include <conio.h>void main(void){int
*ptr_int;int list_int[10];int i;clrscr(); for(i=0;i<10;i++)
list_int[i]=i+1; ptr_int=list_int; printf("Adres startowy
tablicy 0x%p\n",ptr_int);

printf("Warto

ść

pierwszego elementu tablicy %d\n",*ptr_int);

ptr_int=&list_int[0];

printf("Adres pierwszego elementu : 0x%p\n",ptr_int);

printf("Warto

ść

pierwszego elementu : %d\n",*ptr_int);

getch();

}
podstawienie pod wska

nik adres pierwszego elementu tablicy

p_tab=&tab[0];
podstawienie pod wska

nik nazwy tablicy;

p_tab=tab;
wykorzystanie nazwy tablicy jako adresu jej pierwszego
elementu

// p_55p

# include <stdio.h># include <conio.h>void main(void)

{

int *ptr_int;

int list_int[10];

int i;

clrscr();

for(i=0;i<10;i++)

list_int[i]=i+1;

ptr_int=list_int;

printf("Adres startowy tablicy 0x%p\n",ptr_int);

printf("Warto

ść

pierwszego elementu tablicy %d\n",*ptr_int);

ptr_int=&list_int[0];

printf("Adres pierwszego elementu : 0x%p\n",ptr_int);

printf("Adres drugiego elementu : 0x%p\n",ptr_int+1);

printf("Warto

ść

pierwszego elementu : %d\n",*ptr_int);

printf("Warto

ść

drugiego elementu : %d\n",*(ptr_int+1));

getch();

}

Tablice znakowe

Tablice znakowe posiadaj

elementy, z których ka

dy zajmuje 1

bajt; zatem rozmiar tablicy jest jednocze

nie obszarem w

bajtach zajmowanym przez tablic

;

W j

zyku C ła

cuchy znaków (teksty) s

okre

lane jako

jednowymiarowe tablice znakowe, w których ostatni element to
tzw. znak zerowy, oznaczany symbolicznie ‘\0’ o kodzie ASCII =
0.

//p_56

# include <stdio.h>

# include <conio.h>

void main(void)

{

char tab_ch[7]={'W','i','t','a','j','!','\0'};

int i;

clrscr();

for(i=0;i<7;i++)

printf("Tab_ch[%d] zawiera %c\n",i,tab_ch[i]);

// Metoda I

printf("Wszystkie elementy razem - metoda I: \n");

for(i=0;i<7;i++)

printf("%c",tab_ch[i]);

// Metoda II

printf("\nWszystkie elementy razem - metoda II: \n");

printf("%s\n",tab_ch);

getch();

}

Znak zerowy ‘\0’

Jest to pojedynczy znak specjalny okre

laj

cy koniec ła

cucha

znakowego. Funkcja printf() przetwarzaj

c ła

cuch znaków w

formacie %s przetwarza znak po znaku, a

do napotkania znaku

zerowego. Zank zerowy uto

samiany z fałszem mo

e by

równie

stosowany to testowania warto

ci logicznej w p

tlach

steruj

cych.

//p_57

# include <stdio.h>

# include <conio.h>

void main(void)

{

char tab_ch[18]={'C',' ',

't','o',' ',

'j','

','z','y','k',' ',

'p','r','o','g','r','.','\0'};

int i;

clrscr();

for(i=0;tab_ch[i]!='\0';i++)

printf("%c",tab_ch[i]);

getch();

}

Tablice wielowymiarowe

typ_danych
nazwa_tablicy[rozmiar_tab1][rozmiar_tab2]....[rozm_tabN];

N - jest całkowite i dodatnie

tablica dwuwymiarowa 2 x 3 :

int tab [2][3];

inicjowanie :

tab[0][0] = 1;

tab[0][1] = 2;

tab[0][2] = 3;

tab[1][0]= 4;

tab[1][1] = 5;

tab[1][2] = 6;

lub

int tab[2][3] = {1,2,3,4,5,6};

lub

int tab[2][3] = { {1,2,3},{4,5,6}};

/p_58

# include <stdio.h>

# include <conio.h>

void main(void)

{

int tab[3][5]={1,2,3,4,5,

10,20,30,40,50,

100,200,300,400,500};

int i,j;

clrscr();

for(i=0;i<3;i++)

{

printf("\n");

for(j=0;j<5;j++)

printf("%6d",tab[i][j]);

}

getch();

}

//p_59

# include <stdio.h>

# include <conio.h>

void main(void)

{

int tab[3][5]={1,2,3,4,5,10,20,30,40,50,100,200,300,400,500};

int i,j;

clrscr();

for(i=0;i<3;i++)

{

printf("\n");

for(j=0;j<5;j++)

printf("%6d",tab[i][j]);

}

getch();

}

//p_60

# include <stdio.h>

# include <conio.h>

void main(void)

{

int
tab[3][5]={{1,2,3,4,5},{10,20,30,40,50},{100,200,300,400,500}}
;

int i,j;

clrscr();

for(i=0;i<3;i++)

{

printf("\n");

for(j=0;j<5;j++)

printf("%6d",tab[i][j]);

}

getch();

}

//p_61

# include <stdio.h>

# include <conio.h>

void main(void)

{

int
tab[][5]={{1,2,3,4,5},{10,20,30,40,50},{100,200,300,400,500}};

int i,j;

clrscr();

for(i=0;i<3;i++)

{

printf("\n");

for(j=0;j<5;j++)

printf("%6d",tab[i][j]);

}

getch();

}

Tablice bezwymiarowe

Mo

emy deklarowac tablic

bez wpisywania jej rozmiaru w

nawiasach kwadratowych. Kompilator mo

e sam obliczy

rozmiar

tablicy je

eli zadeklarowana zostanie jako bezwymiarowa,

int tab[] = {12,45,56,78,34,2,34,5,6,78,98};

w przypadku tablic wielowymiarowych bez wymiaru mo

pozostawi

tylko jeden wymiar (pierwszy z lewej);

int tab_2[ ][4] = {

‘a’,’A’,

‘b’,’B’,

‘c’,’C’,

‘d’,’D’};

//p_62

# include <stdio.h>

# include <conio.h>

void main(void)

{

char tab_ch[]={'C',' ',

't','o',' ',

'j','

','z','y','k','\0'};

int
tab[][5]={{1,2,3,4,5},{10,20,30,40,50},{100,200,300,400,500}};

clrscr();

printf("Rozmiar tablicy tab_ch[] wynosi %d
bajt˘w.\n",sizeof(tab_ch));

printf("Rozmiar tablicy tab[][5] wynosi %d
bajt˘w.\n",sizeof(tab));

getch();

}

Ła

cuchy znakowe

Ła

cuch znakowy czyli string to tablica znakowa, której

ostatnim elementem jest znak ‘\0’.

Szereg znaków uj

ty w cudzysłów (” ”) jest nazywany stał

ła

cuchow

lub stał

tekstow

, kompilator mo

e automatycznie

doda

znacznik ko

ca [\0].

char tab1[5] = {‘J’,’a’,’n’,’e’,’k’};

char tab2[6] = {‘J’,’a’,’n’,’e’,’k’,’\0’};

tab1 - jest traktowana jako tablica znakowa

tab2 - jest teraz tak

e traktowana jako ła

cuch znakowy

poniewa

posiada znacznik ko

ca ła

cucha;

char tab3[6] = ”Janek”;

kompilator automatycznie doda znak ‘\0’;

inicjowanie tablicy przy pomocy stałej ła

cuchowej oraz

inicjacja tab2 s

równowa

ne;

Stałe ła

cuchowe i stałe znakowe

Stała ła

cuchowa to szereg znaków uj

tych w znak (” ”);

Stał

znakowa to pojedynczy znak umieszczony w (‘ ’);

char znak = ‘x’;

char string = ”x”;

zadeklarowanie zmiennej znakowej znak powoduje zarezerwowanie
w pami

ci 1 bajtu;

zadeklarowanie zmiennej ła

cuchowej string powoduje

zarezerwowanie 2 bajtów : dla znaku ‘x’ i dla znacznika ko

ła

cucha;

Ła

cuch znakowy jest traktowany jako wska

nik do zmiennej typu

char (wskazuj

cy pierwszy znak ła

cucha).

Dlatego identyfikator ła

cucha znakowego mo

na przypisa

wska

nikowi wprost bez stosowania operatora adresowego;

char *ptr_str;

ptr_str = ”Ła

cuch znakowy”;

stałej znakowej nie mo

na w ten sposób przypisa

char *ptr_str;

ptr_str = ‘x’; /operator przypisania próbuje przypisa

prawostronna

warto

ść

(‘x’), natomiast wska

nik oczekuje warto

lewostronnej (adresu)/

Natomiast prawidłowe jest :

char *ptr_str;

*ptr_str = ‘x’;

wykorzystanie wska

nika do przypisania mu ła

cucha znaków

// p_63

# include <stdio.h># include <conio.h>void main(void){char
str1[]={'S','t','a','ł','a',' ',
'ł','a','

','c','u','c','h','o','w','a','\0'};char

str2[]="Druga stała ła

cuchowa";char *ptr_str;

int i;

clrscr();

// wydruk str1

for(i=0;str1[i];i++) // str1[i]=='\0' - synonim fałszu

printf("%c",str1[i]);

printf("\n");

// wydruk str2

for(i=0;str2[i];i++)

printf("%c",str2[i]);

printf("\n");

// przypisanie ła

cucha do wska

nika

ptr_str="Przypisanie ła

cucha do wska

nika";

for(i=0;*ptr_str;i++) à i jest zb

dne

printf("%c",*ptr_str++);

getch();

}

Długo

ść

ła

cucha znaków

Ile znaków zawiera ła

cuch ?

Funkcja strlen()

#include <string.h>

size_t strlen(const char *s)

ilo

c bajtów wska

nik do ła

cucha znaków

zajmowanych przez /identyfikator ła

cucha/

ła

cuch

//p_64

# include <stdio.h># include <conio.h># include <string.h>void
main(void){char str1[]={'S','t','a','ł','a',' ',

'ł','a','

','c','u','c','h','o','w','a','\0'};

char str2[]="Druga stała ła

cuchowa";

char *ptr_str="Przypisanie ła

cucha do wska

nika";

clrscr();

printf("Długo

ść

str1 wynosi: %d bajt˘w\n",strlen(str1));

printf("Długo

ść

str2 wynosi: %d bajt˘w\n",strlen(str2));

printf("Długo

ść

ła

cucha przypisanego wska

nikowi: %d

bajt˘w\n",strlen(ptr_str));

getch();

}

Kopiowanie ła

cuchów – strcpy()

#include <string.h>

char *strcpy(char *dest, const char *src);

src à dest

kopiowanie ła

cuchów bez u

ycia wska

ników

// p_65

# include <stdio.h># include <conio.h># include <string.h>void
main(void)

{

char str1[]="Kopiowanie ła

cuchów";

char str2[25];

char str3[25];

int i;

clrscr();

// kopiowanie przy pomocy strcpy()

strcpy(str2,str1);

// kopiowanie bez uzycia strcpy()

for(i=0;str1[i];i++)

str3[i]=str1[i];

str3[i]='\0';

printf("Zawarto

ść

str2 : %s\n",str2);

printf("Zawarto

ść

str3 : %s\n",str3);

getch();

}

kopiowanie ła

cuchów z wykorzystaniem wska

ników

// p_65p

# include <stdio.h># include <conio.h># include <string.h>void
main(void){char str1[]="Kopiowanie ła

cuchów";

char str2[25];

char str3[25];

int i;

clrscr();

// kopiowanie przy pomocy strcpy()

strcpy(str2,str1);

// kopiowanie bez uzycia strcpy()

for(i=0;*(str1+i);i++)

*(str3+i)=*(str1+i);

*(str3+i)='\0';

printf("Zawarto

ść

str2 : %s\n",str2);

printf("Zawarto

ść

str3 : %s\n",str3);

getch();

}

Odczyt i zapis ła

cuchów znakowych

gets() - odczyt ła

cuchów tekstowych ze standardowego

strumienia wej

ciowego stdin

#include <stdio.h>

char *gets(char *s);

s – identyfikator tablicy znakowej, w której przechowywane s

znaki wczytane ze standardowego wej

cia;

gets() ko

czy swoje działanie po wczytaniu ze standardowego

wej

cia znaku przej

cia do nast

pnej linii (naci

cie

Entera), albo po wczytaniu EOF – (koniec pliku) . Funkcja
dodaje do tablicy znakowej znacznik ‘\0’ i zwraca wska

nik do

tablicy s, do której zapisała znaki, lub wska

nik pusty je

operacja nie powiodła si

puts() - zapis ł

ąń

cuchów tekstowych do standardowego

strumienia wyj

ciowego stdout

#include <stdio.h>

char puts(const char *s)

s – tablica (lub wska

nik) odwołuj

ca si

do ła

cucha

znakowego, który ma zosta

wysłany do standardowego strumienia

(urz

dzenia) wyj

ciowego.

Funkcja puts() likwiduje znacznik ko

ca ła

cucha tekstowego,

dodaj

c w jego miejsce znak przej

cia do nowego wiersza.

we wprowadzonym tek

cie zamiana małych liter na du

e – bez

wska

ników

//p_66

# include <stdio.h># include <conio.h># include <string.h>void
main(void){char str[80];int i;clrscr(); printf("Wprowad

ła

cuch do max. 80 znaków\n");

gets(str);

i=0;

while(str[i])

{

if((str[i]>=97)&&(str[i]<=122))

str[i]-=32;

i++;

}

printf("Wprowadzony tekst po zamianie małych liter na du

\n");

puts(str);

getch();

}

we wprowadzonym tek

cie zamiana małych liter na du

e – ze

wska

nikami

//p_66p

# include <stdio.h>

# include <conio.h>

# include <string.h>

void main(void)

{

char str[80];

int i;

clrscr();

printf("Wprowad

ła

cuch do max. 80 znak˘w\n");

gets(str);

i=0;

while(*(str+i))

{

if((*(str+i)>=97)&&(*(str+i)<=122))

*(str+i)-=32;

i++;

}

printf("Wprowadzony tekst po zamianie małych liter na du

\n");

puts(str);

getch();

}

Specyfikator %s w funkcji printf() à wydrukowanie na ekranie
ła

cucha znakowego.

Funkcja scanf()

Podobnie jak printf() funkcja scanf() słu

y do wczytywania

danych ró

nego typu.

# include <stdio.h>

int scanf(const char *format,[adres,......]);

w ła

cuchu formatuj

cym mog

znale

źć

wszystkie

specyfikatory formatu, w tym %s. Je

eli działanie funkcji

scanf() jest poprawne funkcja zwraca liczb

wczytanych

elementów (nie bajtów), ze strumienia stdin.

W przypadku bł

du zwraca EOF.

ycie specyfikatora formatu %s nakazuje funkcji scanf()

wczyta

dane ze standardowego wej

cia traktuj

c je jako

ła

cuch znaków. Wczytywanie danych przez funkcje scanf()

zostaje zako

czone je

eli w strumieniu znaków wej

ciowych

pojawi si

jeden z nastepuj

cych znaków : spacja, znak nowego

wiersza, tabulator, tabulacja pionowa, FF – znak ko

ca strony.

Znaki wczytywane przez funkcj

przechowywane w tablicy

znakowej, która musi zosta

wskazana funkcji jako jej

argument. Tablica powinna by

wystarczaj

co du

a aby pomie

wszystkie wczytane znaki.

Po zako

czeniu wczytania ła

cucha znaków jako ostatni element

tablicy znakowej zostaje automatyczne dodany znacznik ‘\0’.

//p_67

# include <stdio.h># include <conio.h># include <string.h>void
main(void)

{

char str[80];

int i;

clrscr();

printf("Wprowad

ła

cuch do max. 80 znak˘w\n");

gets(str);

i=0;

while(str[i])

{

if((str[i]>=97)&&(str[i]<=122))

str[i]-=32;

i++;

}

printf("Wprowadzony tekst po zamianie małych liter na du

\n");

puts(str);

printf("\n%s",str);

getch();

}

//p_68

# include <stdio.h># include <conio.h># include <string.h>

void main(void){char str[80];int i;clrscr(); printf("Wprowad

ła

cuch do max. 80 znak˘w\n");// gets(str);

scanf("%s",&str);

i=0;

while(str[i])

{

if((str[i]>=97)&&(str[i]<=122))

str[i]-=32;

i++;

}

printf("Wprowadzony tekst po zamianie małych liter na du

\n");

puts(str);

printf("\n%s",str);

getch();

}

//p_69

# include <stdio.h># include <conio.h>

# include <string.h>

void main(void)

{

char str[80];

int x,y;

float z;

clrscr();

printf("Po wpisaniu danych dowolnego typu naci

nij

<Enter>\n");

printf("Wpisz dwie liczby całkowite:\n");

scanf("%d %d",&x,&y);

printf("Wpisz liczb

zmiennoprzecinkow

: \n");

scanf("%f",&z);

printf("Wpisz ła

cuch znaków: \n");

scanf("%s",str);

printf("Wpisałe

nast

puj

ce dane: \n");

printf("%d %d\n%f\n%s\n",x,y,z,str);

getch();

}

Po napotkaniu spacji wczytywanie znaków funkcja scanf()
zostaje przerwane.

Funkcja scanf nie wczytuje znaków z wej

cia dopóki nie

zostanie naci

niety klawisz ENTER ( do tego czasu znaki

znajduj

w buforze wej

ciowym ).

Widoczno

ść

zmiennych

W zło

onym programie mog

zmienne, z których korzystaj

ró

ne funkcje, a z drugiej strony u

ycie niektórych zmiennych

e ogranicza

tylko do pojedynczych funkcji. Oznacza to

e widoczno

ść

i dost

pno

ść

tych zmiennych mo

e by

ograniczona, a warto

ci przypisane tym zmiennym mog

ukryte z punktu widzenia innych funkcji.

W j

zyku C mo

na deklaruj

c zmienn

okre

zakres jej

dost

pno

ci i widoczno

ci. Zmienne dost

pne tylko lokalnie s

dost

pne tylko wewn

trz tego bloku programu , w którym zostały

zadeklarowane.

Zmienne lokalne /blokowe/

Zmienna zadeklarowana wewnatrz bloku programu ma zasi

blokowy. Jest ona dostepna od miejsca zadeklarowania do ko

bloku w którym zastała zadeklarowana. Takie zmienne nazywaj

lokalnymi lub blokowymi.

//p_70

# include <stdio.h># include <conio.h># include <string.h>

void main(void)

{

int i=32;

clrscr();

printf("W bloku zewnetrznym i=%d\n",i);

{

int i,j;

printf("W bloku wewn

trznym \n");

for (i=0,j=10;i<=10;i++,j--)

printf("i=%2d, j=%2d\n",i,j);

}

printf("Znowu w bloku zewn

trznym: i=%d\n",i);

getch();

}

P

tla for modyfikuje i wyprowadza warto

ci zmiennych lokalnych

bloku wewn

trznego, jednak

e po zako

czeniu i wyj

ciu z tego

bloku lokalna zmienna i (wewn

trzna) przestaje by

dost

pna.

Ponownie widoczna jest zewn

trzna zmienna i, która nie uległa

zmianie. Dzi

ki umiej

tno

ci ograniczania zakresu dost

pno

zmiennych , nie nast

piło ani nadpisanie warto

ci ani

konflikt.

Zmienne widoczne w obr

bie funkcji

Zmienne wewn

trzne funkcji to takie zmienne, które s

dost

pne

i aktywne tylko pomi

dzy pocz

tkiem a ko

cem danej funkcji.

W j

zyku C tylko goto label ma taki zasi

g. Je

eli etykieta

przyporz

dkowana instrukcji goto jako docelowy adres skoku

dzie nazywa

start, to w obrebie funkcji main() jest

widoczna i dostepna z dowolnego punktu, czyli jej adres
widoczno

ci to cała funkcja

int main()

{

int i;

....

start:

.....

goto start;

.....

return 0;

}

Etykieta start jest widoczna od poczatku do konca funkcji
main(), dlatego w obr

bie funkcji main() nie mo

e wystapi

druga etykieta o nazwie start: (natomiast zmienne i mog

wyst

powa

lokalnie wewn

trz zagnie

onych bloków).

Zmienne widoczne w całym programie

Je

eli zmienna została zadeklarowana przed funkcj

main() to

jej zasi

giem widoczno

ci jest cały program. Zmienne takie

nazywaj

zmiennymi globalnymi.

int a = 0;

float b = 2.0;

int main()

{

int i;

return 0;

}

//p_71

# include <stdio.h># include <conio.h># include <string.h>//
deklaracje zmiennych globalnychint x=1234;double
y=1.234567;void fun_1(){ printf("Wewn

trz funkcji \n x=%d,

y=%f\n",x,y);

}

void main(void)

{

int x=4321;

clrscr();

fun_1();

printf("Blok główny funkcji main() \n x=%d, y=%f\n",x,y);

{

double y=7.654321;

fun_1();

printf("Blok zagnie

dzony funkcji main() \n x=%d,

y=%f\n",x,y);

}

getch();

}

Z wn

trza funkcji widoczne s

zmienne globalne.

Deklaracja lokalnej zmiennej x przysłania zmienn

globalna w

obr

bie bloku funkcji.

Specyfikatory i modyfikatory klasy pami

W j

zyku C s

cztery specyfikatory i dwa modyfikatory, które

mog

ywane do okre

lania czasu

ycia zmiennej.

Specyfikator auto

Specyfikator auto okre

la,

e lokalizacja zmiennej w pami

jest tymczasowa tzn. kiedy zmienna przestanie by

widoczna i

dost

pna w programie, zmienna mo

e zosta

przemieszczona w

inne miejsce w programie albo skasowana.

Tylko zmienne o lokalnym zakresie dost

pno

ci mog

deklarowane jako zmienne auto. Auto jest rzadko u

ywanym

słowem kluczowym, poniewa

zmienne o blokowym zakresie

dostepno

ci, s

w sposób domy

lny traktowane jako tymczasowe

(auto).

Specyfikator static

Specyfikator static (zmienna statyczna) mo

e by

stosowany

wobec zmiennych dost

pnych w zakresie bloku lub w zakresie

programu. Je

eli zmienna wewn

trz funkcji zostanie

zadeklarowana jako statyczna istnieje ona w sposób ci

gły w

czasie. Miejsce w pami

ci przeznaczona dla przechowywania tej

zmiennej nie podlega likwidacji, gdy zmienna ta wyjdzie poza
zakres swojej widoczno

ci (warto

ść

zmiennej jest przechowywana

dalej pod tym samym adresem, mimo

e jest niewidoczna). Po

powrocie przez program do zakresu widoczno

ci zmiennej nadal

znajduje si

tam jej ostatnio zapisana warto

ść

//p_72

# include <stdio.h># include <conio.h>int sumuj(int x,int
y){static int licznik=1;printf("Wywołanie funkcji, stan
licznika : %d, \n",licznik++);

return(x+y);

}

int main(void)

{

int i,j;

clrscr();

for(i=0,j=5;i<5;i++,j--)

printf("dodawanie liczb: %d oraz %d suma: %d.
\n",i,j,sumuj(i,j));

getch();

}

//p_73

# include <stdio.h># include <conio.h>int sumuj(int x,int
y){int licznik=1;

printf("Wywołanie funkcji, stan licznika : %d, \n",licznik++);

return(x+y);

}

int main(void)

{

int i,j;

clrscr();

for(i=0,j=5;i<5;i++,j--)

printf("dodawanie liczb: %d oraz %d suma: %d.
\n",i,j,sumuj(i,j));

getch();

}

//p_74

# include <stdio.h>

# include <conio.h>

int sumuj(int x,int y)

{

static int licznik=1;

printf("Wywołanie funkcji, stan licznika : %d, \n",++licznik);

return(x+y);

}

int main(void)

{

int i,j;

clrscr();

for(i=0,j=5;i<5;i++,j--)

printf("dodawanie liczb: %d oraz %d suma: %d.
\n",i,j,sumuj(i,j));

getch();

}

Zakresy dost

pno

ci :

zasi

g blokowy

zasi

g w obr

bie funkcji

zasi

g w obr

bie programu

zasi

g w obrebie pliku

W j

zyku C zmienna globalna zadeklarowana jako static jest

nazywana zmienn

o zasi

gu obejmuj

cym cały plik. Jest ona

dost

pna od punktu zadeklarowania a

do ko

ca pliku. Słowo

plik oznacza

ródłowy plik programu, czyli plik tekstowy

zawieraj

cy tekst programu. ( Wi

kszo

ść

ych programów

składa si

z wielu plików

ródłowych)

int x = 0;

static int y = 0;

static float z = 0.0;

int main()

{

int i;

...

...

return 0;

}

Zasi

g programu --------------------à

Zasi

g pliku --------------à

Zasi

g funkcji --------à

Zasi

g blokowy -----à

Specyfikator register

100

dy komputer ma pewn

ilo

ść

rejestrów do przechowywania

danych i wykonywania operacji arytmetycznych i logicznych.
Poniewa

rejestry s

umieszczone w pami

ci procesora zatem

dost

p do nich jest du

o szybszy ni

do pami

ci RAM gdzie

znajduj

zmienne programu. Aby przy

pieszy

dost

p do

pewnych zmiennych mo

emy je umie

bezpo

rednio w pami

procesora, czyli w rejestrze.

Kompilator mo

e zignorowa

tak

sugesti

, je

eli nie ma

dostepnego rejestru, b

inne ograniczenia uniemo

liwiaj

takie postepowanie.

Pobranie adresu zmiennej zadeklarowanej jako rejestrowa jest
nielegalne.

int main()

{

register int i;

for (i=0;i<max;i++)

{

......

}

return 0;

}

Specyfikator extern

Zmienna globalna widoczna jest we wszystkich plikach

ródłowych tworz

cych program. Jak zmienna zadeklarowana jako

globalna w jednym pliku dyskowym (A) mo

e by

widoczna i

dost

pna w innym pliku dyskowym (B). Sk

d kompilator ma

wiedzie

e w pliku B chodzi o t

sam

zmienn

, która została

zadeklarowana jako globalna w pliku A.

Aby w pliku B odwoła

do zmiennych globalnych

zadeklarowanych w A, nale

y w pliku B zadeklarowa

te zmienne

jako zmienne zewn

trzne, u

ywaj

c specyfikatora extern.

plik A

101

int a,b;

int main()

{

return 0;

}

plik B

int c;

extern int a;

int main()

{

extern int b;

int i;

return 0;

}

Zasady deklarowania i odwoływania si

do zmiennych

zewn

trznych :

Deklaruj

c zmienna globaln

pomin

ąć

słowo extern

zainicjowa

zmienn

przy deklaracji

Kiedy w innym pliku odwołujemy si

do tej zmiennej:

słowa extern

nie inicjowa

zmiennej w deklaracji

Modyfikatory sposobów odwoływania si

do zmiennych.

Modyfikator const

Je

eli zmienna zostanie zadeklarowana z u

yciem modyfikatora

const, po jednorazowym zainicjowaniu jej warto

ść

nie mo

zosta

zmieniona.

102

const double pi = 3.141593;

const char str[ ] = ”Tablica znakowa”;

str[0] = ‘x’; à bł

Modyfikator volatile - dane ulotne

Zmienn

której warto

ść

e by

zmieniana w trakcie programu

bez stosowania operacji przypisania nale

y zadeklarowa

jako

ulotn

– volatile.

na np. zadeklarowa

zmienn

globalna do zapami

tania znaku

wprowadzanego przez uzytkownika z klawiatury. W procesie
optymalizacji kodu kompilator mo

e t

zmienna potraktowa

tak

jak inne zmienne , których warto

ci ustalane s

operacjami

podstawienia. Zadeklarowanie jej jako ulotn

zabezpieczy j

przed tym procesem i jej zmiana warto

ci b

dzie mo

liwa

jedenie poprzez wprowadzenie nowego znaku z klawiatury.

void read_keyboard()

{

volatile char keyboard_ch;

.......

}

Funkcje

Deklaracja a definicja funkcji

Deklaracja zmiennej lub funkcji okre

la interpretacj

atrybuty zestawu identyfikatorów;

Definicja wymaga od kompilatora zarezerwowania pami

ci dla

zmiennej lub funkcji okre

lonej danym identyfikatorem;

Deklaracja zmiennej jest jej definicj

Deklaracja funkcji nie stanowi jej definicji. Deklaracja
funkcji odwołuje si

do jej definicji (znajduj

cej si

w innym

103

miejscu), okre

la natomiast jakiego typu warto

ść

zostanie

zwrócona przez funkcj

Definicja funkcji okre

la co ta funkcja robi, podaj

jednocze

nie liczb

i typy argumentów przekazywanych do

funkcji.

Zadeklarowanie funkcji nie jest równoznaczne z jej definicj

eli definicja funkcji jest umieszczona przed miejscem

pierwszego wywołania funkcji, to nie musimy funkcji wcze

niej

deklarowa

. W przeciwnym razie musimy przed pierwszym

wywołaniem funkcji umie

jej deklaracj

Typ warto

ci zwracanej przez funkcj

Funkcja mo

e by

zadeklarowana i zwraca

dane dowolnego typu

(za wyj

tkiem tablicy i funkcji). Instrukcja return z

definicji funkcji zwraca jedn

warto

ść

, którejm typ powinien

zgodny z typem zadeklarowanym przed nazw

funkcji.

Domy

lnym typem jest typ int.

specyfikator_typu_danych nazwa_funkcji();

Prototyp funkcji

Deklaracja funkcji zawiera tak

e liczb

i typy argumentów

przekazywanych do funkcji.

Liczba i typ argumentów funkcji nazywa si

prototypem funkcji.

Ogólna forma deklaracji:

spec_typu_danych nazwa_funkcji ( spec_typ_danych argument1,

spec_typ_danych argument2,

spec_typ_danych argument3,

..................................................);

nazwy : argument1, argument2 itd. s

opcjonalne

104

Wywołanie funkcji

Po wywołaniu funkcji wykonanie programu przenosi si

do kodu

funkcji, a

do zako

czenia jego wykonania. Po powrocie z

funkcji i ewentualnym zwrocie warto

ci , wykonanie programu

jest podejmowane pocz

wszy od nastepnej intrukcji nastepuj

cej

po wywołaniu funkcji.

Wywołanie funkcji to wyra

enie, które mo

e by

ywane jako

samodzielna instrukcja, lub jako element wewn

trz innych

wyra

//p_75

# include <stdio.h># include <conio.h>int funkcja1(int x,int
y);double funkcja2(double x,double y){printf("Jeste

my w

funkcji2\n");return (x-y);}void main(void){int x1=80;int
y1=10;double x2=100.123456;

double y2=10.123456;

clrscr();

printf("Wywołanie funkcja1(%d,%d).\n",x1,y1);

printf("Funkcja1 zwraca : %d. \n",funkcja1(x1,y1));

printf("Wywołanie funkcja2(%f,%f).\n",x2,y2);

printf("Funkcja2 zwraca : %f.\n",funkcja2(x2,y2));

getch();

}

int funkcja1(int x,int y)

{

printf("Jeste

my w funkcji1.\n");

return(x+y);

}

105

Prototypy funkcji :

1/ Funkcja przy wywołaniu nie pobiera

adnych argumentów –

bezargumantowa;

2/ Funkcja pobiera stał

okre

lon

liczb

argumentów;

3/ Funkcja pobiera zmienn

liczb

argumentów;

Funkcje bezargumentowe

int c;

c = getchar();

deklaracja: int getchar(void);

Dla wszystkich funkcji bezargumentowych w ich deklaracji
(prototypie) stosowany jest typ danych void.

//p_76

#include <stdio.h>#include <conio.h>#include <time.h>void
data_czas(void);main(){ printf("Przed wywołaniem \n");
data_czas(); printf("Po wywołaniu \n"); return 0;}void
data_czas(void){time_t t; printf("Wewn

trz funkcji data_czas()

\n");

time(&t);

printf("Aktualna data i czas : %s",asctime(localtime(&t)));

getch();

}

Funkcja data_czas() wykorzystuje zmienna t typu time_t i
posługuje si

funkcjami bibliotecznymi zadeklarowanymi w pliku

nagłówkowym time.h tj. time(), localtime(), asctime();

Funkcje czasowe daj

nam 3 rodzaje czasów :

106

1/ czas kalendarzowy – czas bie

żą

cy w oparciu o kalendarz

gregoria

ski

2/ czas lokalny – czas kalendarzowy w okre

lonej strefie

czasowej

3/ czas zimowy/letni – czas strefowy z uwzgl

dnieniem

przesuni

cia zimowego/letniego.

Funkcja time() zwraca czas kalendarzowy

#include <time.h>

time_t time(time_t *timer);

time_t - tzw. typ arytmetyczny, stosowany da zapisu czasu

timer - zmienna typu wska

nik wskazuj

ca miejsce w pami

ci, w

którym powinny zosta

zapisane dane dotycz

ce daty i czasu

zwracane przez funkcje;

Je

eli dane dotycz

ce czasu kalendarzowego s

niemo

liwe do

odczytania na danym komputerze to funkcja zwraca –1.

Funkcja localtime() zwraca czas lokalny po przekształceniu
czasu kalendarzowego

#include <time.h>

struct tm *localtime(const time_t *timer);

tm - struktura danych, zawieraj

ca składniki czasu

kalendarzowego

timer - wska

nik do adresu pami

ci, gdzie przechowywany jest

czas kalendarzowy zwrócony wcze

niej przez funkcje time();

aby przekształci

dane dotycz

ce daty i czasu w strukturze tm

w ła

cuch znaków nale

y wywoła

funkcje asctime();

#include <time.h>

char *acstime(const strunct tm *timeptr)

timeprt - wska

nik odwołuj

cy si

do struktury tm zwróconej

przez funkcje localtime();

107

Funkcje o stałej liczbie argumentów

int function_1(int x, int y);

Deklaruj

c funkcj

o stałej liczbie argumentów, nale

y poda

typy wszystkich argumentów (zalecane jest równie

podanie ich

nazw);

Funkcje o zmiennej liczbie argumentów

np. printf()

int printf(const char *format , argument1,argument2,.....);

wielokropek jest oznaczeniem dla kompilatora C ,

e ilo

ść

argumentów funkcji mo

e by

zmienna;

typ_danych nazwa_funkcji(typ_danych arg1,...);

wielokropek oznacza tu pozastałe argumenty, które nie zostały
wymienione na li

cie argumentów;

printf(const char * format,...);

W pliku stdarg.h zadeklarowane zostały trzy podprogramy, które
pozwalaj

na tworzenie i obsług

funkcji o zmiennej liczbie

argumentów :

va_start()

va_arg()

va_end()

Aby zainicjowa

tablic

, która jest niezb

dna do działania

makrorozkazów va_arg() oraz va_end() nale

y zawsze najpierw

wywoła

makro va_start().

Plik nagłówkowy stdarg.h zawiera tak

e typ danych va_list,

który okre

la typ tablicy odpowiedni do przechowywania danych

potrzebnych do działania makropolece

va_start() , va_arg() ,

va_end() .

#include <stdarg.h>

108

void va_start(va_list tab, lastfix);

tab - inicjowana tym poleceniem tablica

lastfix - okre

la ostatni argument funkcji przed wielokropkiem

w

deklaracji

Poprzez u

ycie makropolecenia va_arg() mo

na obsługiwa

wyra

enia okre

lajace typ i warto

ść

nastepnego argumentu

funkcji. Makro va_arg() mo

e by

yte do pobrania kolejnego

argumentu przekazywanego do funkcji,

#include <stdarg.h>

typ_danych va_arg()(va_list tab, typ_danych);

tab - tablica zainicjowana w momencie działania makra
va_start()

typ_danych - typ danych argumentu przesłanego do funkcji

Aby zapewni

normalny i poprawny zwrot warto

ci przez funkcj

o zmiennej liczbie argumentów, nale

y zastosowa

makro

va_end(), po tym jak wszystkie argumenty zostan

przetworzone.

#include (stdarg.h>

void va_end(va_list tab);

//p_76_0

/* Funkcja ze zmienn

liczb

argumentów */#include

<stdio.h>#include <stdarg.h>double AddDouble(int x, ...);main
(){ double d1 = 1.5; double d2 = 2.5; double d3 = 3.5; double
d4 = 4.5;

printf("Wprowadzony argument: %2.1f\n", d1);

printf("Wynik zwrócony przez AddDouble() jest: %2.1f\n\n",

AddDouble(1, d1));

printf("Wprowadzone argumenty: %2.1f and %2.1f\n", d1, d2);

printf("Wynik zwrócony przez AddDouble() jest: %2.1f\n\n",

AddDouble(2, d1, d2));

109

printf("Wprowadzone argumenty: %2.1f, %2.1f and %2.1f\n", d1,
d2, d3);

printf("Wynik zwrócony przez AddDouble() jest: %2.1f\n\n",

AddDouble(3, d1, d2, d3));

printf("Wprowadzone argumenty: %2.1f, %2.1f, %2.1f, and
%2.1f\n", d1, d2, d3, d4);

printf("Wynik zwrócony przez AddDouble() jest: %2.1f\n",

AddDouble(4, d1, d2, d3, d4));

return 0;

}

double AddDouble(int x, ...)

{

va_list arglist;

int i;

double result = 0.0;

printf("Liczba argumentów jest: %d\n", x);

va_start (arglist, x);

for (i=0; i<x; i++)

result += va_arg(arglist, double);

va_end (arglist);

return result;

}

Zastosowania wska

ników

110

Arytmetyka wska

ników

Skalarny wymiar wska

nika

spec_typu_danych *nazwa_wsk;

nazwa_wsk + n

oznacza w bajtach

nazwa_wsk + n * sizeof(spec_typu_danych);

//p_76_1

/* arytmetyka wska

ników */

#include <stdio.h>

#include <conio.h>

main()

{

char *ptr_ch;

int *ptr_int;

double *ptr_db;

clrscr();

/* char wsk. ptr_ch */

printf("Warto

ść

ptr_ch: 0x%p\n", ptr_ch);

printf(" ptr_ch + 1: 0x%p\n", ptr_ch + 1);

printf(" ptr_ch + 2: 0x%p\n", ptr_ch + 2);

printf(" ptr_ch - 1: 0x%p\n", ptr_ch - 1);

printf(" ptr_ch - 2: 0x%p\n", ptr_ch - 2);

/* int wsk. ptr_int */

printf("Warto

ść

ptr_int: 0x%p\n", ptr_int);

111

printf(" ptr_int + 1: 0x%p\n", ptr_int + 1);

printf(" ptr_int + 2: 0x%p\n", ptr_int + 2);

printf(" ptr_int - 1: 0x%p\n", ptr_int - 1);

printf(" ptr_int - 2: 0x%p\n", ptr_int - 2);

/* double wsk ptr_db */

printf("Warto

ść

ptr_db: 0x%p\n", ptr_db);

printf(" ptr_db + 1: 0x%p\n", ptr_db + 1);

printf(" ptr_db + 2: 0x%p\n", ptr_db + 2);

printf(" ptr_db - 1: 0x%p\n", ptr_db - 1);

printf(" ptr_db - 2: 0x%p\n", ptr_db - 2);

getch();

return 0;

}

Odejmowanie wska

ników

typy odejmowanych wska

ników musz

takie same;

// p_76_2

/* odejmowanie wska

ników */

#include <stdio.h>

#include <conio.h>

main()

{

int *ptr_int1, *ptr_int2;

clrscr();

printf(" ptr_int1: 0x%p\n", ptr_int1);

112

ptr_int2 = ptr_int1 + 5;

printf(" ptr_int2 = ptr_int1 + 5: 0x%p\n", ptr_int2);

printf(" ptr_int2 - ptr_int1: %d\n", ptr_int2 - ptr_int1);

ptr_int2 = ptr_int1 - 5;

printf(" ptr_int2 = ptr_int1 - 5: 0x%p\n", ptr_int2);

printf(" ptr_int2 - ptr_int1: %d\n", ptr_int2 - ptr_int1);

getch();

return 0;

}

Dost

p do tablic i elementów tablic za pomoc

wska

ników:

nazwa tablicy jest wska

nikiem do jej 1 elementu;

dodanie liczby całkowitej do nazwy tablicy jest dost

pem do

jej elementu o indeksie równym liczbie całkowitej

// p_76_3

/* dostep do tablic i elementów tablic za pomoc

wska

ników */

#include <stdio.h>

#include <conio.h>

main()

{

char str[] = "It's a string!";

char *ptr_str;

int list[] = {1, 2, 3, 4, 5};

int *ptr_int;

113

/* dost

p do tablicy znaków */

clrscr();

ptr_str = str;

printf("Przed zmian

str : %s\n", str);

printf("Przed zmian

str[5] : %c\n", str[5]);

*(ptr_str + 5) = 'A';

printf("Po zmianie, str[5] : %c\n", str[5]);

printf("Po zmianie, str : %s\n", str);

/* dostep do tablicy liczb */

ptr_int = list;

printf("Przed zmian

, list[2] : %d\n", list[2]);

*(ptr_int + 2) = -3;

printf("Po zmianie, list[2] : %d\n", list[2]);

getch();

return 0;

}

Przekazywanie tablicy jako argumentu do funkcji

jest metoda na proste przekazanie wi

kszej ilo

ci argumentów

do funkcji

//p_76_4

/* przekazywanie tablicy jako argumentu do funkcji */#include
<stdio.h>#include <conio.h>int AddThree(int list[]);main(){
int sum, list[3]; clrscr(); printf("Wprowad« 3 liczby :\n");

114

scanf("%d%d%d", &list[0], &list[1], &list[2]);

sum = AddThree(list);

printf("Ich suma wynosi : %d\n", sum);

getch();

return 0;

}

int AddThree(int list[])

{

int i;

int result = 0;

for (i=0; i<3; i++)

result += list[i];

return result;

}

Przekazywanie wska

ników jako argumentów do funkcji

Nazwa tablicy po której nie nast

puje indeks jest wska

nikiem

do pierwszego elementu. Zatem adres do pierwszego elementu
tablicy b

cy wska

nikiem mo

e by

przekazany do funkcji tak

jak tablica.

//p_76_5

/* przekazywanie wska

ników jako argumentów do funkcji

*/#include <stdio.h>#include <conio.h>void ChPrint(char
*ch);int DataAdd(int *list, int max);

main()

{

char str[] = "It's a string!";

115

char *ptr_str;

int list[5] = {1, 2, 3, 4, 5};

int *ptr_int;

/* przypisanie adresu do wska

nika */

clrscr();

ptr_str = str;

ChPrint(ptr_str);

ChPrint(str);

/* przypisanie adresu do wska

nika */

ptr_int = list;

printf("The sum returned by DataAdd(): %d\n",

DataAdd(ptr_int, 5));

printf("The sum returned by DataAdd(): %d\n",

DataAdd(list, 5));

getch();

return 0;

}

void ChPrint(char *ch)

{

printf("%s\n", ch);

}

int DataAdd(int *list, int max)

{

int i;

int sum = 0;

116

for (i=0; i<max; i++)

sum += list[i];

return sum;

}
tablice znakowe i liczbowe przekazywane s

do funkcji

wska

nikiem

poprzez:

ptr = n_tablicy

lub

n_tablicy

Przekazywanie tablic wielowymiarowych do funkcji

Mo

na przekaza

nazw

tablicy lub wska

nik zawieraj

cy adres

startowy tablicy wielowymiarowej.

//p_76_6

/* przekazywanie tablic wielowymiarowych jako argumentów do
funkcji */#include <stdio.h>#include <conio.h>/* deklaracje
funkcji */

int DataAdd1(int list[][5], int max1, int max2);

int DataAdd2(int *list, int max1, int max2);

/* funkcja main() */

main()

{

int list[2][5] = {1, 2, 3, 4, 5,

5, 4, 3, 2, 1};

int *ptr_int;

117

clrscr();

printf("Suma otrzymana przez DataAdd1(): %d\n",

DataAdd1(list, 2, 5));

ptr_int = &list[0][0];

printf("Suma otrzymana przez DataAdd2(): %d\n",

DataAdd2(ptr_int, 2, 5));

getch();

return 0;

}

/* definicja funkcji Data Add1 */

int DataAdd1(int list[][5], int max1, int max2)

{

int i, j;

int sum = 0;

for (i=0; i<max1; i++)

for (j=0; j<max2; j++)

sum += list[i][j];

return sum;

}

/* definicja funkcji DataAdd2 */

int DataAdd2(int *list, int max1, int max2)

{

int i, j;

int sum = 0;

for (i=0; i<max1; i++)

118

for (j=0; j<max2; j++)

sum += *(list + i*max2 + j);

return sum;

}
do funkcji przekazywana jest tablica

Add1 à przez warto

ść

/nazw

Add2 à przez wska

nik

W przykładach p_76_4 do p_76_6 deklaracje wymiaru tablic w
programie głównym i w funkcjach.

Tablice wska

ników

deklaracja tablicy wska

ników

int *ptr_int[5];

//p_76_7

/* Tablice wska

ników */#include <stdio.h>#include <conio.h>/*

deklaracje funkcji */

void StrPrint1(char **str1, int size);

void StrPrint2(char *str2);

/* funkcja main() */

main()

{

char *str[4] = {"To jest zdanie 1;",

"To jest zdanie 2;",

"To jest zdanie 3;",

"To jest zdanie 4.\n"

119

};

int i, size;

clrscr();

size = 4;

StrPrint1(str, size);

for (i=0; i<4; i++)

StrPrint2(str[i]);

getch();

return 0;

}

/* definicja funkcji */

void StrPrint1(char **str1, int size)

{

int i;

for (i=0; i<size; i++)

printf("%s\n", str1[i]);

}

/* definicja funkcji */

void StrPrint2(char *str2)

{

printf("%s\n", str2);

}

deklarujemy i inicjujemy tablice składaj

z wielu ci

gów

znaków
mo

emy ja potraktowac jako tablic

dwuwymiarow

120

1 wymiar – ilo

ść

stringów

2 wymiar – ilo

ść

znaków w stringu

emy ja równie

potraktowac jako tablice wska

ników do

poszczególnych stringów
tablica jest wyprowadzana na ekran przez dwie funkcje

StrPrint1 (wska

nik do tablicy wska

ników, wymiar)

nazwa tablicy

str – w programie głównym jest nazw

tablicy b

tablic

wska

ników do stringów;

jest zatem jako nazwa tablicy wska

nikiem do jej pierwszego

elementu zatem jest wska

nikiem do wska

nika

wywołanie StrPrint1(str,size)

Funkcja StrPrint1(char **str1, int size)

StrPrint2 - argumentem funkcji jest pojedynczy ła

cuch

/string/;

Zatem argumentem wywołania jest wska

nik do stringa i w

tablicy [i]

Wywołanie StrPrint2(str[i])

Deklaracja StrPrint(char *str2)

Wska

nik do funkcji

Poniewa

funkcja ma warto

ść

lewostronn

w postaci adresu

startowego w pami

ci, podobnie zatem jak w przypadku tablic

na zadeklarowa

i zainicjowa

wska

nik przy pomocy

lewostronnej warto

ci (adresu) funkcji.

//p_76_8

/* wska

nik do funkcji */

121

#include <stdio.h>

#include <conio.h>

/* deklaracja funkcji */

int StrPrint(char *str);

/* main() function */

main()

{

char str[22] = "Wskazanie funkcji.";

int (*ptr)(char *str);

clrscr();

ptr = StrPrint;

if (!(*ptr)(str))

printf("OK!\n");

getch();

return 0;

}

/* definicja funkcji */

int StrPrint(char *str)

{

printf("%s\n", str);

return 0;

}

funkcja zwraca typ int pobiera wska

nik do znaku:

122

deklaracja funkcji

int StrPrint(char *str)

deklaracja wska

nika do funkcji

int (*ptr)(char *str)

deklaracja wska

nika - wska

nik uj

ty w nawiasy okr

głe

wskazuje funk.

typ (*nazwa_wska

nika)(typ argumentu funkcji)

zgodny z typem funkcji wska

nik funkcji

ptr = StrPrint à przypisanie lewostronnej warto

ci funkcji

wska

nikowi

(*ptr)(str) à wywołanie funkcji wskazywanej przez wska

nik

ptr z argumentem str à jest to przekazanie

do funkcji tablicy str

Funkcja drukuje ła

cuch znaków, a po zako

czeniu zwraca 0

(return 0;) if(!0) à wydruk OK

123

124

Dynamiczne przyporz

dkowanie pami

eli chcemy w trakcie realizacji programu zarz

dza

pami

dostepn

do jego realizacji to mamy do dyspozycji nastepuj

funkcje z biblioteki stdlib.h :

1/ malloc()

2/ calloc()

3/ realloc()

4/ free()

Funkcja malloc()

Słu

y do przyporz

dkowania okreslonego obszaru pami

#include <stdlib.h>

void *malloc(size_t size);

size – wielko

ść

obszaru pami

ci w bajtach przeznaczony do

przyporz

dkowania

funkcja zwraca wska

nik typu void (nieokre

lony), wskazuj

pocz

tkowy adres zarezerwowanego obszaru pami

ci à typ tego

wska

nika jest automatycznie poddawany konwersji i zmieniany

na typ wska

nika, który znajduje si

po lewej stronie

operatora przypisania.

Funkcja zwraca wska

nik pusty, gdy operacja zarezerwowania

żą

danego obszaru pami

ci sko

czy si

niepowodzeniem. Dlatego

zawsze przed u

yciem takiego wska

nika nale

y sprzwdzi

czy

nie jest pusty.

//p_76_9

125

/ U

ycie funkcji malloc() */#include <stdio.h> #include

<stdlib.h>#include <string.h>/* function declaration */void
StrCopy(char *str1, char *str2);/* main() function */main(){

char str[] = "U

ycie malloc() do rezerwacji pami

ci.";

char *ptr_str;

int termination;

/* call malloc() */

ptr_str = malloc( strlen(str) + 1);

if (ptr_str != NULL){

StrCopy(str, ptr_str);

printf("Ła

cuch okre

lony wska

nikiem ptr_str:\n%s\n",

ptr_str);

termination = 0;

}

else{

printf("malloc() function failed.\n");

termination = 1;

}

return termination;

}

/* function definition */

void StrCopy(char *str1, char *str2)

{

int i;

for (i=0; str1[i]; i++)

str2[i] = str1[i];

126

str2[i] = '\0';

}

Zadaniem funkcji malloc() jest zarezerwowanie pami

ci dla

ła

cucha znaków. Wska

nik zwracany przez funkcj

malloc() jest

wykorzystywany w operacji kopiowania ła

cuchów.

eli po wykorzystaniu przyporz

dkowanej dynamicznie pami

ta nie zostanie zwolniona, a w dalszej cz

ęś

ci programu

nast

kolejne operacje przyporz

dkowania pami

ci to pami

e po prostu zabrakn

ąć

Dynamicznie przyporz

dkowan

pami

ęć

zwalnia funkcja free().

Funkcja free()

poniewa

pami

ęć

dost

pna w ka

dym komputerze jest ograniczona,

nale

y przyporz

dkowa

tylko tyle pami

ci ile jest jest jej

rzeczywi

cie potrzebne, a po wykorzystaniu j

zwolni

//p_76_10

/ Use the free() function */#include <stdio.h> #include
<stdlib.h>/* function declarations */ void DataMultiply(int
max, int *ptr);void TablePrint(int max, int *ptr);/* main()
function */main(){ int *ptr_int, max;

int termination;

char key = 'c';

max = 0;

termination = 0;

while (key != 'x'){

printf("Enter a single digit number:\n");

scanf("%d", &max);

/* call malloc() */

ptr_int = malloc(max * max * sizeof(int));

if (ptr_int != NULL){

127

DataMultiply(max, ptr_int);

TablePrint(max, ptr_int);

free(ptr_int);

}

else{

printf("malloc() function failed.\n");

termination = 1;

break;

}

printf("\nPress x-key to quit; other key to continue.\n");

scanf("%s", &key);

}

printf("\nBye!\n");

return termination;

}

/* function definition */

void DataMultiply(int max, int *ptr)

{

int i, j;

for (i=0; i<max; i++)

for (j=0; j<max; j++)

*(ptr + i * max + j) = (i+1) * (j+1);

}

/* function definition */

void TablePrint(int max, int *ptr)

128

{

int i, j;

printf("The multiplication table of %d is:\n",

max);

printf(" ");

for (i=0; i<max; i++)

printf("%4d", i+1);

printf("\n ");

for (i=0; i<max; i++)

printf("----", i+1);

for (i=0; i<max; i++){

printf("\n%d|", i+1);

for (j=0; j<max; j++)

printf("%3d ", *(ptr + i * max + j));

}

}

Działanie programu ma na celu zbudowanie dwuwymiarowej
numerycznej tablicy n x n z elementami zaczerpni

tymi z

tabliczki mno

enia. P

tle w programie b

powtarzane, a

naci

cia znaku ‘x’, lub niepowodzenia w przyporz

dkowaniu

pami

ci przez funkcj

malloc().

Aby zademonstrowa

działanie funkcji free(), program dokonuje

tymczasowego obszaru pami

ci, do przechowywania elementów

tabliczki mno

enia. Zaraz po wydrukowaniu na ekran pami

ęć

zostaje zwolniona poprzez działanie funkcji free().

Funkcja calloc()

Funkcja ta podobnie jak malloc() mo

na stosowa

dynamicznego przyporz

dkowania pami

ci. Funkcja calloc()

129

pobiera dwa argumenty i po zarezerwowaniu pami

ci powoduje

dodatkowo wyzerowanie bajtów wchodz

cych w skład tego obszaru.

#include <stdlib.h>

void *calloc(size_t nitem, size_t size);

nitem – oznacza ilo

ść

elementów, które chcemy przechowa

pami

size – rozmiar pojedynczego elementu w bajtach

calloc() zwraca równie

wska

nik typu void

//p_76_11

/* 17L03.c: Use the calloc() function */

#include <stdio.h>

#include <stdlib.h>

/* main() function */

main()

{

float *ptr1, *ptr2;

int i, n;

int termination = 1;

n = 5;

ptr1 = malloc(n * sizeof(float));

ptr2 = calloc(n, sizeof(float));

if (ptr1 == NULL)

printf("malloc() failed.\n");

else if (ptr2 == NULL)

printf("calloc() failed.\n");

else{

for (i=0; i<n; i++)

130

printf("ptr1[%d]=%5.2f, ptr2[%d]=%5.2f\n",

i, *(ptr1 + i), i, *(ptr2 + i));

free(ptr1);

free(ptr2);

termination = 0;

}

return termination;

}

Aby sprawdzi

czy pami

ęć

zarezerwowana przez funkcj

calloc()

zostaje wyzerowana , pocz

tkowa zawarto

ść

pami

ci zostaje

wydrukowana i porównana z zawarto

cia pami

ci rezerwowanej

funkcj

malloc().

Funkcja realloc()

Funkcja ta pozwala na zmiane rozmiaru bloku w dynamicznie
przyporz

dkowanym obszarze pami

ci, który został uprzednio

zarezerwowany przez funkcje malloc(), calloc() i realloc().

#include <stdlib.h>

void *realloc(void *block, size_t size)
blok - wska

nik do obszaru pami

ci uprzednio przyporz

kowanego

dynamicznie;
size – rozmiar bloku pami

ci, który powinien zosta

przeorganizowany

Funkcja zwraca wska

nik typu void, albo wska

nik zerowy.

Funkcja realloc() wywołana z pierwszym argumentem zerowym jest
równowa

na funkcji malloc().

ptr_flt = realloc(NULL, 10*sizeof(float));

ptr_flt = malloc(10*sizeof(float)); à s

równowa

ęż

eli funkcja realloc() b

dzie miała 2 argument równy zero to

jest równowa

na fnkcji free();

131

free(prt);

realloc(prt,0); à sa równowa

//p_76_12

/* 17L04.c: Use the realloc() function */#include <stdio.h>
#include <stdlib.h>#include <string.h>/* function declaration
*/void StrCopy(char *str1, char *str2);

/* main() function */

main()

{

char *str[4] = {"There's music in the sighing of a reed;",

"There's music in the gushing of a rill;",

"There's music in all things if men had ears;",

"There earth is but an echo of the spheres.\n"

};

char *ptr;

int i;

int termination = 0;

ptr = malloc(strlen((str[0]) + 1) * sizeof(char));

if (ptr == NULL){

printf("malloc() failed.\n");

termination = 1;

}

else{

StrCopy(str[0], ptr);

printf("%s\n", ptr);

132

for (i=1; i<4; i++){

ptr = realloc(ptr, (strlen(str[i]) + 1) * sizeof(char));

if (ptr == NULL){

printf("realloc() failed.\n");

termination = 1;

break;

}

else{

StrCopy(str[i], ptr);

printf("%s\n", ptr);

}

}

}

free(ptr);

return termination;

}

/* funciton definition */

void StrCopy(char *str1, char *str2)

{

int i;

for (i=0; str1[i]; i++)

str2[i] = str1[i];

str2[i] = '\0';

}

Funkcja ma za zadanie przyporz

dkowa

dynamicznie blok pami

do przechowywania ła

cucha znakowego. W przykł

dzie wyst

puj

133

4 ła

cuchy znakowe o ró

nej długo

ci. Aby przystosowa

wielko

ść

poprzednio przyporz

dkowanego obszaru pami

ci do

nastepnego ła

cucha znaków stosowana jest funkcja realloc().

Wykorzystano tablic

wska

ników str do 4 ła

cuchów tekstowych.

Obszar pami

ci zostaje przyporz

dkowany, a jego rozmiar

dostosowany do aktualnych potrzeb w oparciu o długo

ść

dego

ąń

cucha znaków. Obie stosowane funkcje malloc() i realloc()

dokonuj

przydziału obszaru pami

ci i regulacji jego rozmiaru

w sposób dynamiczny – tzn w ruchu programu.

Wyliczeniowy typ danych

Wyliczeniowy typ danych umo

liwia skojarzenie nazw

symbolicznych ze stałymi numerycznymi typu integer.

Deklaracja:

enum nazwa {lista wyliczeniowa} lista zmiennych;

enum – słowo kluczowe;

nazwa – nazwa typu wyliczeniowego;

lista zmiennych – nazwy zmiennych danego typu wyliczeniowego;

134

lista wyliczeniowa – identyfikatory – zdefiniowane stałe
tekstowe, u

ywane do reprezentacji numerycznych stałych

całkowitych;

wariant 1:

enum auto {sedan, pick_up, sport} krajowe, zagraniczne;

wariant 2:

enum auto {sedan, pick_up, sport};

auto krajowe, zagraniczne;

Przypisanie warto

ci liczbowych do typu wyliczeniowego.

Standardowo gdy programista nie zadeklaruje inaczej:

Stała symboliczna wymieniona na pocz

tku listy wyliczeniowej

ma przypisan

warto

ść

0, nast

pne kolejno i 1 wi

ksz

Sposób przyporz

dkowania stałych int w programie:

enum auto {sedan=60, pick_up=30, sport=10};

//p_77

#include <stdio.h>#include <conio.h>void main(void){enum jezyk
{human=100,animal=50,computer};enum dni
{pon,wto,sro,czw,pio,sob,nie};clrscr();printf("human %d,
animal %d, computer %d\n",human,animal,computer);

printf("pon %d\n",pon);

printf("wto %d\n",wto);

135

printf("sro %d\n",sro);

printf("czw %d\n",czw);

printf("pio %d\n",pio);

printf("sob %d\n",sob);

printf("nie %d\n",nie);

getch();

}

powy

szy przykład ilustruje automatyczne i r

czne

przyporz

dkowanie stałym symbolicznym warto

ci numerycznych

typu int;

/p_78

#include <stdio.h>#include <conio.h>void main(void){enum
money_units{grosik=1,piatka=5,dycha=10,polowka=50,zlocisz=100}
; int money_units[5]={zlocisz,polowka,dycha,piatka,grosik};

char *unit_name[5]={"złocisz(-ów)","połów(-ka/ek)","dycha(-
ch)","pi

tka(-ek)","grosik(-ow)"};

int cent,tmp,i;

clrscr();

printf("Wpisz sum

w groszach:\n");

scanf("%d",&cent);

printf("Odpowiada to zestawowi monet:\n");

tmp=0;

for(i=0;i<5;i++)

136

{

tmp=cent/money_units[i];

cent-=tmp*money_units[i];

if(tmp)

printf("%d %s ",tmp,unit_name[i]);

}

printf("\n");

getch();

}

Zadaniem programu jest wykorzystanie typu wyliczeniowego do
reprezentacji sumy wprowadzonej przez u

ytkownika za pomoc

zestawu monet.
typ wyliczeniowy money_units wykorzystywany jest do
przyporz

dkowanie stałym symbolicznym warto

ci monet złocisz –

100 (gr) , dycha – 10 (gr) itd;
deklarowana tablica numeryczna typu int inicjowana jest
stałymi symbolicznymi typu wyliczeniowego – co odpowiada :

int money_units[5]={100,50,10,5,1} à po zadeklarowaniu typu
wyliczeniowego mo

na stosowa

stałe symboliczne z listy

wyliczeniowej zamiast odpowiadaj

cych im warto

numerycznych;
delaracja tablicy zło

onej ze wska

ników do ła

cuchów

tekstowych umo

liwi wyprowadzanie opisów;

Definiowanie typów u

ytkownika.

137

typedef int liczba_2bajty;

liczba_2bajty i,j,k,l; ß à int i,j,k,l;

Definicja typu typedef tworzy synonim deklaracji typu i musi
wyst

w programie zanim ten synonim zostanie u

yty.

umo

liwia uproszczenie nazwy skomplikowanego typu danych do

pojedynczego słowa;
po dokonaniu jednokrotnej korekty definicji synonimu, mo

ywac tego nowego synonimu wielokrotnie w przyszłosci;

138

Przekazywanie do funkcji main() argumentów z wiersza polece

Argumenty z wiersza polece

przekazujemy podczas uruchamiania

wersji exe programu napisanego w j

zyku C.

Maj

c program o nazwie prog.c à prog.exe

C:> prog argument1, argument2, argument3

Argumenty 1-3 sa argumentami z wiersza polece

Funkcja main() posiada dwa wbudowane argumenty , które mog

wykorzystane do pobierania parametrów z wiersza polece

systemu operacyjnego /trzeci odnosi si

do otoczenia

systemowego/.

Pierwszy nazywa si

argc – słu

y on do przechowywania

całkowitej liczby parametrów przekazywanych do funkcji main()
z wiersza polece

Drugi argv – jest wska

nikiem do tablicy wska

ników – ła

cuchy

znaków. Ka

dy element tej tablicy wskazuje jeden argument z

wiersza polece

, traktowany jako ła

cuch znaków;

typ_wy main(int argc, char *argv[])

{

}

Przy wywołaniu prog.exe argc=4 gdy

nazwa programu jest

uznawana jako pierwszy argument z wiersza polece

;

argv[0]=”c:\programy\prog.exe”

argv[1]=”argument1”

argv[2]=”argument2”

139

argv[3]=”argument3”

//p_79

#include <stdio.h>#include <conio.h>void main(int argc,char
*argv[]){ int i; clrscr(); printf("%d\n",argc);
printf("%d\n",argc); for(i=0;i<argc;i++)
printf("%s\n",argv[i]); getch();

}

140

Struktura – ł

czenie ró

nych typów danych

Struktura jest poł

czeniem w cało

ść

danych ró

nych typów, tak

aby mogły stanowi

jeden moduł.

Róznica mi

dzy strukturami a tablicami:

w obr

bie struktury mog

znajdowa

ró

ne typy;

dy element w strukturze ma swoj

własna nazw

;

Elementy danych wchodz

ce w skł

d struktury – pola struktury;

Deklarowanie struktur

struct nazwa_struct{

typ zmienna1;

typ zmienna2;

typ zmienna3;

};

struct auto{

int rok;

char model[8];

int moc_silnika;

float masa;

141

};

Definiowanie struktur

struct auto sedan,pick_up,sport;

struct auto{

int rok;

char model[8];

int moc_silnika;

float masa;

} seadan, pick_up, sport;

Odwoływanie si

do elementów struktur – operator .

zmienna_struktury.nazwa_pola

ptr=sport.model;

//p_80

#include <stdio.h>#include <conio.h>void main(void){struct
komputer { float koszt; int rok; int cpu_cz; char cpu_typ[16];
} model; clrscr(); printf("Podaj typ CPU: \n");
gets(model.cpu_typ); printf("Podaj cz

st. CPU w MHz: \n");

scanf("%d",&model.cpu_cz);

142

printf("Podaj rok produkcji: \n");

scanf("%d",&model.rok);

printf("Podaj cene jego zakupu: \n");

scanf("%f",&model.koszt);

printf("Oto wprowadzone dane: \n");

printf("Rok produkcji : %d \n",model.rok);

printf("Cena zakupu : %6.2f \n",model.koszt);

printf("Typ CPU : %s \n",model.cpu_typ);

printf("Szybko

ść

CPU w MHZ : %d \n",model.cpu_cz);

getch();

}

powy

szy program demonstruje dowołania do poszczególnych pól

struktury

Inicjowanie struktur

Poni

szy program przedstawia sposób inicjowania struktury, a

nast

pnie aktualizacj

zawarto

ci pól danych przez

ytkownika.

//p_81

#include <stdio.h>#include <conio.h>void main(void){struct
pracownik

{

int nr;

char nazwisko[32];

};

143

struct pracownik info = { 0001,"J.Nowak"};

clrscr();

printf("Wydruk pól struktury\n");

printf("Nazwisko pracownika: %s\n",info.nazwisko);

printf("Numer ID #: %04d\n",info.nr);

printf("Podaj swoje nazwisko: ? \n");

gets(info.nazwisko);

printf("Podaj swój numer: ? \n");

scanf("%d",&info.nr);

printf("Wprowadziłe

dane: \n");

printf("Nazwisko pracownika: %s\n",info.nazwisko);

printf("Numer ID #: %04d\n",info.nr);

getch();

}

definicja, deklaracja i zainicjowanie struktury w pojedy

czej

instrukcji

struct pracownik

{

int nr;

char nazwisko[30];

} info = {0001,”J.Nowak”};

144

Struktury a funkcje

J

zyk C pozwala przekaza

cał

struktur

jako argument do

funkcji, jak równie

funkcja mo

e zwrócic struktur

jako

warto

ść

Demonstruje to poni

szy przykład.

//p_82

#include <stdio.h>#include <conio.h>struct komputer { float
koszt; int rok; int cpu_cz; char cpu_typ[16]; }; typedef
struct komputer SC; SC PobierzDane(SC s);

void main(void)

{

SC model;

clrscr();

model=PobierzDane(model);

printf("Dane, które wprowadziłe

: \n");

printf("Rok: %d \n",model.rok);

printf("Cena: %6.2f \n",model.koszt);

printf("CPU typ: %s \n",model.cpu_typ);

printf("Predko

ść

: %d MHz \n",model.cpu_cz);

getch();

}

SC PobierzDane(SC s)

{

printf("Podaj typ CPU: \n");

gets(s.cpu_typ);

printf("Podaj cz

st. CPU w MHz: \n");

145

scanf("%d",&s.cpu_cz);

printf("Podaj rok produkcji: \n");

scanf("%d",&s.rok);

printf("Podaj cene jego zakupu: \n");

scanf("%f",&s.koszt);

return s;

}

Wska

niki do struktur

Podobnie jak przekazuje si

funkcjom wska

niki do tablic, tak

na przekaza

im równie

w postaci argumentu wska

nik

wskazuj

cy struktur

W przeciwie

stwie do przekazywania całej struktury w formie

argumentu do funkcji , co powodowało na u

ytek funkcji

tworzenie kopii całej struktury, przekazanie do funkcji
wska

nika powoduje jedynie przekazanie jej adresu w pami

ci,

pod którym zlokalizowana jest struktura. Funkcja mo

posługiwac si

tym adresem , odwołuj

c si

bezpo

rednio do pól

struktury, a nie do kopii struktury.

Prezentuje to poni

szy program.

//p_83

#include <stdio.h>#include <conio.h>struct komputer { float
koszt; int rok; int cpu_cz;

char cpu_typ[16];

};

typedef struct komputer SC;

void PobierzDane(SC *ptr_s);

void main(void)

{

146

SC model;

clrscr();

PobierzDane(&model);

printf("Dane, które wprowadziłe

: \n");

printf("Rok: %d \n",model.rok);

printf("Cena: %6.2f \n",model.koszt);

printf("CPU typ: %s \n",model.cpu_typ);

printf("Predko

ść

: %d MHz \n",model.cpu_cz);

getch();

}

void PobierzDane(SC *ptr_s)

{

float pomoc;

printf("Podaj typ CPU: \n");

gets((*ptr_s).cpu_typ);

printf("Podaj cz

st. CPU w MHz: \n");

scanf("%d",&(*ptr_s).cpu_cz);

printf("Podaj rok produkcji: \n");

scanf("%d",&(*ptr_s).rok);

printf("Podaj cene jego zakupu: \n");

scanf("%f",&pomoc);

(*ptr_s).koszt=pomoc;

147

// scanf("%f",&(*ptr_s).koszt);

}

(*ptr_s).pole à odwołanie si

do pola struktury

co mo

na zast

pic przez

ptr_s à pole

natomiast wyra

enie: &(*ptr_s).pole przez: &(ptr_s à pole)

ilustruje to poni

szy przykład:

//p_84

#include <stdio.h>#include <conio.h>struct komputer {

float koszt;

int rok;

int cpu_cz;

char cpu_typ[16];

};

typedef struct komputer SC;

void PobierzDane(SC *ptr_s);

void main(void)

{

SC model;

clrscr();

PobierzDane(&model);

printf("Dane, kt˘re wprowadzi

�

: \n");

148

printf("Rok: %d \n",model.rok);

printf("Cena: %6.2f \n",model.koszt);

printf("CPU typ: %s \n",model.cpu_typ);

printf("Predko

ść

: %d MHz \n",model.cpu_cz);

getch();

}

void PobierzDane(SC *ptr_s)

{

float pomoc;

printf("Podaj typ CPU: \n");

gets(ptr_s->cpu_typ);

printf("Podaj cz

st. CPU w MHz: \n");

scanf("%d",&(ptr_s->cpu_cz));

printf("Podaj rok produkcji: \n");

scanf("%d",&(ptr_s->rok));

printf("Podaj cene jego zakupu: \n");

scanf("%f",&pomoc);

ptr_s->koszt=pomoc;

// scanf("%f",&(*ptr_s.koszt));

}

149

Tablice struktur

W j

zyku C mo

na zadeklarowa

tablic

, której elementami b

struktury.

Nale

y nazw

tablicy (identyfikator) poprzedzi

nazw

typu

struktur.

struct x tablica[8];

jest deklaracj

8-elementowej jednowymiarowej tablicy, której

elementami s

struktury typu x.

//p_85

#include <stdio.h>#include <conio.h>struct wiersz { int
start_year; int end_year; char autor[16]; char str1[64]; char
str2[64]; char str3[64]; }; typedef struct wiersz WS;

void WyswietlDane(WS *ptr_s);

void main(void)

{

WS poemat[2]=

{

{1641,

1716,

"Autor1",

"Wiersz01",

"Wiersz02",

150

"Wiersz03"

},

{1729,

1781,

"Autor2",

"Wiersz11",

"Wiersz12",

"Wiersz13"

}

};

int i;

clrscr();

for(i=0;i<2;i++)

WyswietlDane(&poemat[i]);

getch();

}

void WyswietlDane(WS *ptr_s)

{

printf("%s\n",ptr_s->str1);

printf("%s\n",ptr_s->str2);

printf("%s\n",ptr_s->str3);

printf("---%s\n",ptr_s->autor);

printf(" (%d-%d)\n\n",ptr_s->start_year,ptr_s->end_year);

}

151

Struktury zagnie

dzone

Struktury nazywane sa strukturami zagnie

dzonymi je

li co

najmniej jedno z pól struktury jest struktur

struct x

{

int a;

float b;

};

struct y

{

int i;

char ch[10];

x strukt_wew

};

struktura y stanowi strukture zło

ona z zagnie

dzona wewn

trz

struktur

//p_86

#include <stdio.h>#include <conio.h>struct dzial { int kod;
char nazwa[32]; char stanowisko[16]; }; typedef struct dzial
DZ;

struct pracownik

{

DZ d;

int id;

char nazwisko[32];

};

152

typedef struct pracownik PRAC;

void InfoWyswietl(PRAC *ptr);

void InfoWprowadz(PRAC *ptr);

void main(void)

{

PRAC info =

{

{ 01,

"Marketing",

"Manager"

},

0001,

"J.Nowak"

};

clrscr();

printf("Przykład: \n");

InfoWyswietl(&info);

InfoWprowadz(&info);

printf("\nOto dane, które wprowadziłe

: \n");

InfoWyswietl(&info);

getch();

}

void InfoWyswietl(PRAC *ptr)

{

printf("Nazwisko: %s \n",ptr->nazwisko);

printf("Numer : %04d \n",ptr->id);

153

printf("Nazwa działu : %s \n ",ptr->d.nazwa);

printf("Numer działu : %02d \n",ptr->d.kod);

printf("Stanowisko: %s \n",ptr->d.stanowisko);

}

void InfoWprowadz(PRAC *ptr)

{

printf("\n Wpisz swoje dane: \n");

printf("Nazwisko: \n");

gets((*ptr).nazwisko);

printf("Funkcja: \n");

gets((*ptr).d.stanowisko);

printf("Nazwa działu: \n");

gets((*ptr).d.nazwa);

printf("Numer działu: \n");

scanf("%d",&(ptr->d.kod));

printf("Twój numer ID : \n");

scanf("%d",&(ptr->id));

}

dost

p do danych ptr à nazwa_zm_str_wew.nazwa_pola

Forward reference – wyprzedzaj

ce odwoływanie si

do struktur

eli jednym z elementów struktury jest wska

nik do struktur

innego typu, który to typ struktur nie został jeszcze
zadeklarowany, to struktura taka nazywa si

struktura ze

wskazaniem wyprzedzaj

cym – forward referencing structure.

154

struct x

{

int i;

char ch[10];

struct y *ptr;

};

oczywi

cie przy zało

eniu

e typ struktury y nie został

jeszcze zadeklarowany;

je

eli wska

nik b

cy elementem struktury wskazuje na ni

sam

, to struktura taka nazywa si

auto referencyjn

struct x

{

int i;

char ch[10];

struct x *ptr;

};

//p_87

#include <stdio.h>#include <conio.h>struct dane

{

char name[16];

struct date *p;

struct date *d;

};

struct date

{

155

int rok;

char szkola[32];

char stopien[8];

};

typedef struct dane DAN;

typedef struct date DAT;

void InfoWyswietl(DAN *ptr);

void main(void)

{

DAT pier =

{

1985,

"Politechnika",

"in

};

DAT drug =

{

1988,

"AGH",

"mgr in

};

DAT *pp,*pd;

pp=&pier;

pd=&drug;

DAN prac =

156

{

"Marek",

pp,

pd

//&pier,

//&drug

};

clrscr();

printf("To sa dane Marka: \n");

InfoWyswietl(&prac);

getch();

}

void InfoWyswietl(DAN *ptr)

{

printf("Imie: %s \n",ptr->name);

printf("Nazwa szkoły: %s \n",ptr->p->szkola);

printf("Data uzyskania tytułu %d \n",ptr->p->rok);

printf("Stopie

: %s \n",ptr->p->stopien);

printf("Nazwa szkoły: %s \n",ptr->d->szkola);

printf("Data uzyskania tytułu %d \n",ptr->d->rok);

printf("Stopie

: %s \n",ptr->d->stopien);

}

nowy sposób odwołania do pola : ptr à d à stopien

157

Unie

158

Unia jest to blok pami

ci u

ywany do przechowywania róznych

elementów danych.

W j

zyku C unia jest podobna do struktury , z tym wyj

tkiem

dane zawarte w unii nakładaj

wzajemnie na siebie –

poniewa

dziel

dzy siebie ten sam obszar pami

ci.

Deklarowanie unii

union auto {

int rok;

char model[8];

int moc_silnika;

float waga;

};

union – słowo kluczowe /okresla kategorie typu danych/

auto - nazwa typu danych

{

} - struktura wewn

trzna unii zawieraj

ca jej pola nazywane

równie

jej elementami; poniewa

elementy unii mog

nawzajem nakładac zatem nazwa element jest zasadniejsza od
nazwy pole;

Definiowanie zmiennych unii

union auto sedan, pick_up, sport;

union auto {

int rok;

char model[8];

int moc_silnika;

159

float waga;

} sedan, pick_up, sport;

je

eli poł

czymy deklaracj

typu unii i definicj

zmiennych

danego typu w pojedyncz

instrukcj

emy w tej instrukcji

pomin

ąć

identyfikator typu unii: (słowo auto)

union {

int rok;

char model[8];

int moc_silnika;

float waga;

} sedan, pick_up, sport;

podobnie jak w przypadku elementów struktury, tak i w
przypadku do elementów składowych unii mo

e by

stosowany

operator .

sedan.year=1997;

po zadeklarowaniu wska

nika do zmiennych unii

union auto *ptr;

ptr à year = 1997;

//p_88

#include <stdio.h>#include <string.h>

#include <conio.h>

void main(void)

{

union menu

{

char nazwa[20];

double cena;

160

} danie;

clrscr();

printf("Zawarto

ść

unii\n");

strcpy(danie.nazwa,"kotlet schabowy");

printf("Nazwa dania: %s\n",danie.nazwa);

danie.cena=12.95;

printf("Cena dania: %5.2f\n",danie.cena);

printf("Ko

cowa zawarto

ść

unii %s",danie.nazwa);

getch();

}

przykład powy

szy pokazuje sposób dost

pu do elementów unii;

ostatnia instrukcja printf jest dowodem nakładania w pami

elementów unii na siebie;

potwierdzaj

to dwa poni

sze przykłady:

//p_89

#include <stdio.h>#include <string.h>#include <conio.h>void
main(void){ union menu { char nazwa[20]; double cena; } danie;
clrscr(); printf("Zawarto

ść

unii\n"); danie.cena=12.95;

printf("Cena dania: %5.2f\n",danie.cena);

strcpy(danie.nazwa,"kotlet schabowy");

printf("Nazwa dania: %s\n",danie.nazwa);

printf("Ko

cowa zawarto

c unii %s\n",danie.nazwa);

printf("Cena dania: %5.2f\n",danie.cena);

getch();

}

//p_90

161

#include <stdio.h>#include <string.h>#include <conio.h>void
main(void){ union menu { char nazwa[20]; double cena; } danie;
clrscr(); printf("Zawarto

c unii\n"); danie.cena=12.95;

printf("Cena dania: %5.2f\n",danie.cena);
strcpy(danie.nazwa,"kotlet schabowy");

printf("Nazwa dania: %s\n",danie.nazwa);

printf("Koäcowa zawarto

ść

unii %5.2f ",danie.cena);

getch();

}

Inicjowanie unii

Elementy danych unii nakładaj

nawzajem na siebie w

obr

bie tego samego obszaru pami

ci. Obszar ten jest

wykorzystywany do zapisu ró

nych danych w ró

nym czasie.

Rozmiar unii odpowiada rozmiarowi najwi

kszego spo

ród jej

elementów. Daltego nie ma sensu inicjowanie wszystkich
elementów unii jednoczesnie, poniewa

warto

ść

ostatnio

inicjowanego elementu nadpisze si

na warto

ść

poprzednich.

Element unii inicjuje si

tylko wtedy gdy jeste

my gotowi do

jego wykorzystania. Bie

żą

ca warto

ść

zawarta w unii jest zawsze

warto

cia ostatniego elementu przypisanego unii.

union u {

char ch;

int x;

} n_unia;

n_unia.ch=’H’;

n_unia.x=365;

najpierw pami

c przeznaczona na elementy unii zawierała ‘H’

potem warto

c 365.

union u {

char ch;

162

int x;

} n_unia = {‘H’);

co si

stanie gdy zainicjujemy wszystkie elementy unii

jednoczesnie ?

//p_91

#include <stdio.h>#include <string.h>#include <conio.h>void
main(void){ union sprawa { int rok; int dzial; int id; } info;
info.rok=1999; info.dzial=234; info.id=1234; clrscr();
printf("Rok: %d\n",info.rok);

printf("Numer dziaˆu: %d\n",info.dzial);

printf("Numer identyfikacyjny: %d\n",info.id);

getch();

}

wynik jest oczywisty à 1234

Rozmiar unii

163

Wielko

ść

unii jest równa obszarowi zajmowanemu przez

najwi

kszy jej element.

W przeciwie

stwie do unii, w strukturze wszystkie elementy

(pola) struktury mog

zainicjowane jednocze

nie i nie

nakładaja si

nawzajem. Dzieje si

tak dlatego,

e ka

element struktury ma własny obszar pami

ci. Rozmiar struktury

to suma rozmiarów wszystkich jej elementów (pól), a nie jak w
przypadku unii rozmiar jej najwi

kszego elementu.

Pokazuje to przykład:

//p_92

#include <stdio.h>#include <string.h>#include <conio.h>

void main(void)

{

union u

{

double x;

int y;

} a_union;

struct s

{

double x;

int y;

} a_struct;

clrscr();

printf("Rozmiar double: %d-bajtowe \n",sizeof(double));

printf("Rozmiar int : %d-bajtowe \n",sizeof(int));

printf("Rozmiar unii a_union: %d-bajtowe \n",sizeof(a_union));

164

printf("Rozmiar struktury a_struct: %d-bajtowe
\n",sizeof(a_struct));

getch();

}

Zastosowania unii

Odwoływanie si

do tego samego obszaru pami

ci na dwa ró

sposoby

Np.:

//p_93

165

#include <stdio.h>#include <string.h>#include <conio.h>union u
{ char ch[2]; int num; };int InicjalizacjaUnii(union u
val);void main(void){ union u val;

int x;

x=InicjalizacjaUnii(val);

clrscr();

printf("Dwie stałe znakowe zawarte w unii: \n");

printf("%c \n",x & 0x00FF); /*młodszy bajt*/

printf("%c \n",x>>8); /*starszy bajt*/

getch();

}

int InicjalizacjaUnii(union u val)

{

val.ch[0]='H';

val.ch[1]='i';

return val.num; /*posługujemy sie elementem numerycznym unii
*/

/*do przesłania danych do f. main()*/

}

Uelastycznienie struktur

Zagnie

dzenie unii wewn

trz struktury powoduje,

e w polach

struktur mog

przechowywane dane ró

nych typów.

166

Przykład:

//p_94

#include <stdio.h>#include <conio.h>#include <string.h>struct
ankieta { char name[20]; char c_d_p; int wiek; int
hour_per_week; union { char cable[16]; char sat[16];

} dostawca;

};

void DataEnter(struct ankieta *s);

void DataDisplay(struct ankieta *s);

void main(void)

{

struct ankieta tv;

clrscr();

DataEnter(&tv);

DataDisplay(&tv);

getch();

}

void DataEnter(struct ankieta *ptr)

{

char jest_tak[4];

printf("Czy korzystasz w domu z telewizji kablowej T/N \n");

gets(jest_tak);

if ((jest_tak[0]=='T')||(jest_tak[0]=='t'))

{

printf("Wpisz nazw

firmy dostawcy TV kablowej: \n");

gets(ptr->dostawca.cable);

167

ptr->c_d_p='c';

}

else

{

printf("Czy korzystasz z TV sat T/N \n");

gets(jest_tak);

if((jest_tak[0]=='T')||(jest_tak[0]=='t'))

{

printf("Wpisz nazwe firmy diostwcy TV sat \n");

gets(ptr->dostawca.sat);

ptr->c_d_p='d';

}

else

ptr->c_d_p='p';

}

printf("Wpisz swoje nazwisko: \n");

gets(ptr->name);

printf("i sw˘j wiek: \n");

scanf("%d",&ptr->wiek);

printf("Ile godzin tygodniowo ogl

dasz TV : \n");

scanf("%d",&ptr->hour_per_week);

}

void DataDisplay(struct ankieta *ptr)

{

printf("\nOto dane, kt˘re wprowadziłe

: \n");

168

printf("Nazwisko: %s\n",ptr->name);

printf("Wiek: %d \n",ptr->wiek);

printf("Godzin tygodniowo: %d\n",ptr->hour_per_week);

if(ptr->c_d_p=='c')

printf("Twoja firma TV kablowej :%s\n",ptr->dostawca.cable);

else

if(ptr->c_d_p=='d')

printf("Twoja firma TV Sat: %s \n",ptr->dostawca.sat);

else

printf("Niekorzystasz ani z kabla ani z TV sat\n");

printf("Dzi

kujemy -- Koniec aniekty! \n");

}

Definiowanie pól bitowych przy pomocy słowa kluczowego struct

Typ char to najmniejszy typ danych w j

zyku C. Dane te zajmuja

8 bitów.

Jednak posługuj

c si

słowem kluczowym struct mo

zadeklarowa

obiekt jeszcze mniejszy - pole bitowe /bit

field/.

Pole bitowe umo

liwia łatwy dost

p do pojedynczych bitów.

Pojedynczy bit mo

e przyjmowa

jedna z warto

ci 0 lub 1.

Format deklaracji:

struct nazwa {

data_typ_1 nazwa1: dlugosc1;

169

data_typ_2 nazwa2: dlugosc2;

.....................................................

data_typ_N nazwanN: dlugoscN;

} lista_zmiennych;

struct - słowo kluczowe

nazwa - nazwa typu zmiennych

data_typ_i - typ danych kolejnego pola bitowego (musi by

jednym z typów : int, unsigned, signed)

nazwai - nazwy poszczególnych pól bitowych

długosci – długo

ci poszczególnych pól bitowych, które nie

mog

przekraczac długo

ci typu danych int

lista_zmiennych - wyliczenie zmiennych danego typu

struct bf {

int jumper1: 1;

int jumper2: 2;

int jumper3: 3;

} jumpers;

jumper1 jumper2 jumper3 trzy pola bitowe o długo

ciach

odpowiednio: 1, 2, 3 bity

zmienna o nazwie jumpers jest struktur

zawieraj

ca trzy pola

bitowe.

jumper1 jumepr2 jumper3

//p_95

#include <stdio.h>#include <conio.h>#include <string.h>struct
bit_field

170

{

int cable: 1;

int sat: 1;

};

struct ankieta

{

char name[20];

struct bit_field c_d;

int wiek;

int hour_per_week;

union

{

char cable[16];

char sat[16];

} dostawca;

};

void DataEnter(struct ankieta *s);

void DataDisplay(struct ankieta *s);

void main(void)

{

struct ankieta tv;

clrscr();

DataEnter(&tv);

DataDisplay(&tv);

getch();

171

}

void DataEnter(struct ankieta *ptr)

{

char jest_tak[4];

printf("Czy korzystasz w domu z telewizji kablowej T/N \n");

gets(jest_tak);

if ((jest_tak[0]=='T')||(jest_tak[0]=='t'))

{

printf("Wpisz nazw

firmy dostawcy TV kablowej: \n");

gets(ptr->dostawca.cable);

ptr->c_d.cable=1;

ptr->c_d.sat=0;

}

else

{

printf("Czy korzystasz z TV sat T/N \n");

gets(jest_tak);

if((jest_tak[0]=='T')||(jest_tak[0]=='t'))

{

printf("Wpisz nazwe firmy diostwcy TV sat \n");

gets(ptr->dostawca.sat);

ptr->c_d.cable=0;

ptr->c_d.sat=1;

}

else

{

172

ptr->c_d.cable=0;

ptr->c_d.sat=0;

}

}

printf("Wpisz swoje nazwisko: \n");

gets(ptr->name);

printf("i swój wiek: \n");

scanf("%d",&ptr->wiek);

printf("Ile godzin tygodniowo ogl

dasz TV : \n");

scanf("%d",&ptr->hour_per_week);

}

void DataDisplay(struct ankieta *ptr)

{

printf("\nOto dane, które wprowadziłe

: \n");

printf("Nazwisko: %s\n",ptr->name);

printf("Wiek: %d \n",ptr->wiek);

printf("Godzin tygodniowo: %d\n",ptr->hour_per_week);

if(ptr->c_d.cable && !ptr->c_d.sat)

printf("Twoja firma TV kablowej :%s\n",ptr->dostawca.cable);

else

if(!ptr->c_d.cable && ptr->c_d.sat)

printf("Twoja firma TV Sat: %s \n",ptr->dostawca.sat);

else

printf("Nie korzystasz ani z kabla ani z TV sat\n");

173

cie pliku odnosi si

do urz

dzenia peryferyjnego

(terminal, drukarka, plik na ta

mie, plik na dysku) z którym

ma nast

wymiana informacji.

Przed rozpocz

ciem procesu wymiany informacji plik nale

otworzy

, za

po zako

czeniu tego procesu nale

y go zamkn

ąć

Strumie

Przepływ danych z programu do pliku lub odwrotnie nazywamy
strumieniem danych.

Strumie

stanowi seri

bajtów.

174

Strumie

nie jest zwi

zany z

adnym urz

dzeniem.

Aby przeprowadzi

operacj

wej

cia/wyj

cia nale

y skojarzy

plik ze strumieniem.

Istniej

dwa formaty strumieni :

1/ Strumie

tekstowy - zawiera sekwencje znaków; stosowany do

przesyłania danych tekstowych;

2/ Strumie

binarny - stanowi seri

bajtów (np. plik exe);

Stosowany do danych nietektowych;

Buforowanie wej

cia/wyj

cia

Buforem nazywamy obszar pami

ci słu

żą

cy do tymczasowego

przechowywania danych przed przesłaniem ich do miejsca
przeznaczenia.

Strumienie wej

cia/wyj

cia s

buforowane w sposób domy

lny.

Buforowane wej

cie/wyj

cie na zywane jest obsług

We/Wy

wysokiego poziomu, za

nie buforowane wej

cie/wyj

cie obsług

We/Wy niskiego poziomu.

Podstawy operacji We/Wy

Wska

niki typu FILE

Struktura FILE słu

y do zarz

dzania plikami, zdefiniowana w

pliku nagłówkowym stdio.h.

Wska

nik typu FILE jest wska

nikiem plikowym i jest

wykorzystywany przez strumie

do sterowania operacjami We/Wy .

FILE *fptr;

W obr

bie struktury FILE znajduje si

wska

nik pozycji w

pliku, który wskazuje bie

żą

pozycje podczas operacji

zapisu/odczytu danych.

Otwieranie pliku

175

Funkcja fopen() pozwala na otwarcie pliku i skojarzenie go ze
strumieniem danych. Wymaga ona podania dwóch argumentów: trybu
otwarcia i nazwy przedmiotowego pliku.

#include <stdio.h>

FILE *fopen(const char *filename, const char *mode);

filename - nazwa pliku do otwarcia /wska

nik do stałego

ła

cucha znaków/

mode - tryb otwarcia pliku /wska

nik do stałego ła

cucha

znaków/

Funkcja zwraca wska

nik typu FILE.

eli wystapi bł

d otwarcia , funkcja zwraca wska

nik pusty.

Tryby otwarcia pliku – mode

r - otwiera istniej

cy plik tekstowy tylko do odczytu

w - tworzy nowy plik tekstowy do zapisu

a - otwiera istniej

cy plik tekstowy w trybie dopisywania do

ca pliku

r+ - otwiera istniej

cy plik tekstowy do odczytu i/lub zapisu

w+ - tworzy plik tekstowy do zapisu i/lub odczytu

a+ - otwiera lub tworzy plik tekstowy do dopisywania na ko

rb - otwiera istniej

cy plik binarny do odczytu

wb - tworzy nowy plik binarny do zapisu

ab - otwiera istneij

cy plik binarny w trybie dopisywania do

ca pliku

r+b - otwiera istniej

cy plik binarny dla odczytu i/lub zapisu

w+b - tworzy plik binarny do zapisu i/lub zapisu

a+b - otwiera lub tworzy plik binarny do dopisywania na ko

próba otwarcia pliku test.txt

FILE *fprt;

176

if ((fptr = fopen(”test.txt”,”r”))==NULL)

{

printf(”Nie mog

otworzy

pliku test.txt \n”);

exit(1);

}

.........

Zamykanie pliku

Po wykonaniu operacji na otwartym pliku dyskowym (r,w,a),
nale

y odł

czy

plik od strumienia danych – zamkn

ąć

go à

fclose().

#include <stdio.h>

int fclose(FILE *pointer);

pointer - wska

nik skojarzony ze strumieniem do otwartego

pliku.

Je

eli operacja zamkni

cia powiedzie si

funkcja zwraca 0, w

przeciwnym razie zwraca kod EOF, lub kod bł

du je

eli

dyskietka z plikiem została wyj

ta z nap

du b

brak jest

miejsca na dysku

Otwarcie i zamkni

cie pliku dyskowego.

//p_96

/* Otwarcie i zamkni

cie pliku */#include <stdio.h> enum

{SUCCESS, FAIL};main(void){ FILE *fptr; char filename[]=
"haiku.txt"; int reval = SUCCESS; clrscr();

if ((fptr = fopen(filename, "r")) == NULL){

printf("Nie mog

otworzy

%s.\n", filename);

reval = FAIL;

} else {

printf("Warto

ść

fptr: 0x%p\n", fptr);

177

fclose(fptr);

getch();

}

return reval;

}

-------------------------

#include <stdio.h>enum {SUCCESS, FAIL};int CharRead(FILE
*fin);main(void){ FILE *fptr; char filename[]= "haiku.txt";
int reval = SUCCESS; clrscr(); if ((fptr = fopen(filename,
"r")) == NULL){ printf("Nie mog

otworzy

%s.\n", filename);

reval = FAIL;

} else {

printf("\nIlo

ść

znaków -> %d.\n",

CharRead(fptr));

fclose(fptr);

}

getch();

return reval;

}

int CharRead(FILE *fin)

{

int c, num;

num = 0;

while ((c=fgetc(fin)) != EOF)

{

putchar(c);

178

++num;

}

return num;

}

Odczyt i zapis plików dyskowych

Sposoby przeprowadzania operacji wej

cia/wyj

cia :

1/ czyta

i pisa

znak po znaku

2/ czyta

i pisa

wiersz po wierszu

3/ czyta

i pisa

blok po bloku

Odczyt i zapis po znaku

Funkcje fgetc() i fputc() mo

na zastosowac do odczytu i zapisu

znak po znaku.

#include <stdio.h>

int fgetc(FILE *stream);

stream - wska

nik do pliku, który jest skojarzony ze

strumieniem danych

Funkcja fgetc() wczytuje kolejny znak ze strumienia stream.

179

Po przekształceniu wczytanego znaku na kod numeryczny int
funkcja zwraca t

warto

ść

#include <stdio.h>

int fputc(int c, FILE *stream);

int c - numeryczny kod znaku c;

Odczyt i zapis metod

znak po znaku

//p_97

/* Czytanie i pisanie znak po znaku */

#include <stdio.h>

enum {SUCCESS, FAIL};

void CharReadWrite(FILE *fin, FILE *fout);

main(void)

{

FILE *fptr1, *fptr2;

char filename1[]= "outhaiku.txt";

char filename2[]= "haiku.txt";

int reval = SUCCESS;

clrscr();

if ((fptr1 = fopen(filename1, "w")) == NULL){

printf("Bł

d otwarcia %s.\n", filename1);

reval = FAIL;

} else if ((fptr2 = fopen(filename2, "r")) == NULL){

printf("Bł

d otwarcia %s.\n", filename2);

reval = FAIL;

180

} else {

CharReadWrite(fptr2, fptr1);

fclose(fptr1);

fclose(fptr2);

}

getch();

return reval;

}

/* definicja funkcji */

void CharReadWrite(FILE *fin, FILE *fout)

{

int c;

while ((c=fgetc(fin)) != EOF){

putchar(c);

fputc(c, fout);

}

}

-----------------------

#include <stdio.h>

#include <string.h>

enum {SUCCESS, FAIL, MAX_LEN = 80};

void LineWrite(FILE *fout, char *str);

181

main(void)

{

FILE *fptr;

char str[MAX_LEN+1];

char filename[32];

int reval = SUCCESS;

clrscr();

printf("Podaj nazw

pliku:\n");

gets(filename);

printf("Wprowad

ła

cuch znak˘w :\n");

gets(str);

if ((fptr = fopen(filename, "w")) == NULL){

printf("Bł

d otwarcia %s dla zapisu.\n", filename);

reval = FAIL;

} else {

LineWrite(fptr, str);

fclose(fptr);

}

getch();

return reval;

}

/* definicja funkcji */

void LineWrite(FILE *fout, char *str)

{

fputs(str, fout);

182

printf("OK!\n");

}

Odczyt i zapis wiersz po wierszu

Mo

na przeprowadzi

zarówno zapis jak i odczyt wiersz po

wierszu.

Słu

żą

do tego celu funkcje fgets() i fputs().

#include <stdio.h>

char *fgets((char *s, int n, FILE *stream);

s - wska

nik do tablicy znakowej u

ywanej do zapami

tania

znaków wczytanych z otwartego pliku wskazanego przez wska

nik

stream.

stream - wska

nik do pliku

n – maksymalna ilo

ść

elementów tablicy znakowej /l. znaków w

wierszu/

Je

eli operacja wczytania wiersza zako

czy si

powodzeniem ,

funkcja zwraca wska

nik char *s. Je

eli funkcja napotka znak

cz apliku EOF funkcja zwraca pusty wska

nik i pozostawia

tablic

znakowa w stanie nienaruszonym. Je

eli wyst

pi bł

funkcja zwraca pusty wska

nik, ale zawarto

ść

tablicy jest tym

razem nieokre

lona.

Funkcja fgets() mo

e wczyta

n-1 znaków i mo

e doł

czy

znak

ca ła

cucha tekstowego ‘\0’ po wczytaniu ostatniego znaku,

dopóki nie napotka znaku przej

cia do nowego wiersza lub znaku

ca pliku /EOF/.

Po napotkaniu znaku przej

cia do nowego wiersza funkcja wł

czy

go do wyj

ciowej tablicy znakowej.

#include <stdio.h>

int fputs(const char *s, FILE *stream);

s - wskazuje tablic

znakow

, wktórej znajduje si

tekst

przeznaczony do zapisu w pliku dyskowym skojarzonym ze
wska

nikiem plikowym stream.

183

Odczyt i zapis metoda wiersz po wierszu

//p_98

/* Czytanie i zapis wierszami */

#include <stdio.h>

enum {SUCCESS, FAIL, MAX_LEN = 81};

void LineReadWrite(FILE *fin, FILE *fout);

main(void)

{

FILE *fptr1, *fptr2;

char filename1[]= "outhaiku.txt";

char filename2[]= "haiku.txt";

int reval = SUCCESS;

clrscr();

if ((fptr1 = fopen(filename1, "w")) == NULL){

printf("Bł

d otwarcia %s dla zapisu.\n", filename1);

reval = FAIL;

} else if ((fptr2 = fopen(filename2, "r")) == NULL){

printf("Bł

d otwarcia %s dla odczytu.\n", filename2);

reval = FAIL;

} else {

LineReadWrite(fptr2, fptr1);

fclose(fptr1);

fclose(fptr2);

}

getch();

184

return reval;

}

/* definicja funkcji */

void LineReadWrite(FILE *fin, FILE *fout)

{

char buff[MAX_LEN];

while (!feof(fin)){

fgets(buff, MAX_LEN, fin);

printf("%s", buff);

fputs(buff, fout);

}

}

--------------------

#include <stdio.h>

enum {SUCCESS, FAIL};

void CharWrite(FILE *fout, char *str);

main(void)

{

FILE *fptr;

char filename[]= "test_21.txt";

char str[]= "Plik dyskowy I/O ";

int reval = SUCCESS;

clrscr();

185

if ((fptr = fopen(filename, "w")) == NULL){

printf("Bł

d otwarcia %s.\n", filename);

reval = FAIL;

} else {

CharWrite(fptr, str);

fclose(fptr);

}

getch();

return reval;

}

/* definicja funkcji */

void CharWrite(FILE *fout, char *str)

{

int i, c;

i = 0;

while ((c=str[i]) != '\0'){

putchar(c);

fputc(c, fout);

i++;

}

}

Odczyt i zapis blok po bloku

Do zapisu lub odczytu bloku danych do/z pliku wykorzystywane
s

funkcje fread() , fwrite().

186

#include <stdio.h>

size_t fread(void *ptr, size_t size, size_t n, FILE *stream);

ptr - oznacza wska

nik do tablicy, w której sa przechowywane

dane wczytane

size - rozmiar ka

dego elementu tablicy

n - liczba elementów do odczytu

stream - wska

nik skojarzony z plikiem otwartym do odczytu

size_t - typ numeryczny całkowity zdefiniowany w pliku
nagłówkowym stdio.h

Funkcja fread() zwraca liczb

elementów, które wczytała.

Ilo

ść

elementów wczytanych przez funkcje powinna by

równa jej

trzeciemu argumentowi /chyba

e zdarzy si

bł

d lub funkcja

napotka na znak EOFà w takim przypadku zwróci rzeczywist

ilo

ść

wczytanych elementów/.

#include <stdio.h>

size_t fwrite(const void *ptr, size_t size, size_t n, FILE
*stream);

ptr – wska

nik do tablicy, wktórej s

przechowywane dane,

które nale

y zapisa

do otwartego pliku wskazanego przez

wska

nik stream.

Parametr size okre

la wielko

ść

elementów tablicy.

n - okre

la ilo

ść

elementów tablicy, które nale

y zapisa

pliku.

Funkcja zwraca liczb

rzeczywi

cie zapisanych do pliku

elementów.

Je

eli nie wystapiły

adne bł

dy, liczba zwrócona przez

funkcj

fwrite() powinna by

równa jej trzeciemu elementowi.

eli wyst

pił bł

d to warto

ść

zwrócona mo

e by

mniejsza.

Bardzo istotne jest sprawdzenie czy tablica jest wystarczaj

a , by pomie

dane dla funkcji fread() i fwrite(). Dla

sprawdzenia kiedy nastapi znak ko

ca pliku słuzy funkcja

feof().

187

eli w programie stwierdzimy napotkanie znaku ko

ca pliku

(EOF) w obr

bie pliku binarnego poprzez sprawdzenie warto

zwróconej przez funkcje fread(), mo

emy zako

czy

prac

nieprawidłowym miejscu (nie osi

wszy rzeczywistego ko

pliku). Zastosowanie funkcji feof() pozwoli unikn

ąć

bł

dów

wykrywaj

c rzeczywisty koniec pliku.

#include <stdio.h>

int feof(FILE *stream)

stream - wska

nik plikowy skojarzony z otwartym plikiem.

Funkcja ta zwraca 0 je

eli koniec pliku nie został osi

gni

, w przeciwnym razie zwraca niezerow

warto

ść

całkowit

Zapis i odczyt bloku znaków

//p_99

/* Odczyt i zapis blokami */

#include <stdio.h>

enum {SUCCESS, FAIL, MAX_LEN = 80};

void BlockReadWrite(FILE *fin, FILE *fout);

int ErrorMsg(char *str);

main(void)

{

FILE *fptr1, *fptr2;

char filename1[]= "outhaiku.txt";

188

char filename2[]= "haiku.txt";

int reval = SUCCESS;

clrscr();

if ((fptr1 = fopen(filename1, "w")) == NULL){

reval = ErrorMsg(filename1);

} else if ((fptr2 = fopen(filename2, "r")) == NULL){

reval = ErrorMsg(filename2);

} else {

BlockReadWrite(fptr2, fptr1);

fclose(fptr1);

fclose(fptr2);

}

getch();

return reval;

}

/* definicja funckji */

void BlockReadWrite(FILE *fin, FILE *fout)

{

int num;

char buff[MAX_LEN + 1];

while (!feof(fin)){

num = fread(buff, sizeof(char), MAX_LEN, fin);

buff[num * sizeof(char)] = '\0';

printf("%s", buff);

fwrite(buff, sizeof(char), num, fout);

189

}

}

/* definicja funkcji */

int ErrorMsg(char *str)

{

printf("Bł

d otwarcia %s.\n", str);

return FAIL;

}

--------------------

#include <stdio.h>

#include <string.h>

enum {SUCCESS, FAIL};

void BlkWrite(FILE *fout, char *str);

main(void)

{

FILE *fptr;

char filename[]= "test_21.txt";

char str[]= "Plik dyskowy I/O ";

int reval = SUCCESS;

if ((fptr = fopen(filename, "w")) == NULL){

printf("Bł

d otwarcia %s.\n", filename);

reval = FAIL;

} else {

BlkWrite(fptr, str);

190

fclose(fptr);

}

return reval;

}

/* definicja funkcji */

void BlkWrite(FILE *fout, char *str)

{

int num;

num = strlen(str);

fwrite(str, sizeof(char), num, fout);

printf("%s\n", str);

}

Dostep sekwencyjny i bezpo

redni do pliku.

Zapis/Odczyt pliku od pocz

tku bajt po bajcie, z mo

liwo

cia

dopisania danych na ko

cu pliku nazywamy dospepem sekwencyjnym

do pliku,

Poszukiwanie informacji w pliku o taki dost

pie odbywa si

poprzez przegl

ganie informacji od pierwszego bajtu zawartego

w pliku.

W przypadku pliku o dost

pie swobodnym elementy danych mog

odczytywane w dowolnej kolejno

ci /bez konieczno

odczytywania wszystkich poprzednich danych/.

191

Jednym z elementów struktury FILE jest znacznik pozycji pliku,
który mo

na ustawi

na poprzedniej pozycji przed operacj

zapisu lub odczytu.

Funkcja fseek() - słu

y do przesuwania znacznika pozycji we

wła

ciwe miejsce w obr

bie pliku.

#include <stdio.h>

int fseek(FILE *stream, long offset, int relation);

stream - wska

nik plikowy skojarzony z otwartym plikiem

offset - oznacza przesuni

cie w bajtach od punktu okre

lonego

przez trzeci argument

relation - punkt odniesienia, od którego rozpoczyna si

odliczania

SEEK_SET - licz

c od pocz

tku pliku

SEEK_CUR - licz

c od bie

żą

cej pozycji znacznika w pliku

SEEK_END - licz

c od ko

ca pliku

eli operacja powiedzie si

funkcja fseek() zwraca 0, w

przeciwnym przypadku warto

ść

ró

od zera.

eli

relation = SEEK_SET offset > 0

relation = SEEK_END offset < 0

relation = SEEK_CUR

Aby odczyta

bie

żą

pozycj

znacznika w pliku - funkcja

ftell()

#include <stdio.h>

long ftell(FILE *stream);

stream - wska

nik plikowy skojarzony z otwartym plikiem

Funkcja zwraca bie

żą

warto

ść

/typu long/ pozycji znacznika

licz

c do bie

żą

cej pozycji od pocz

tku pliku w bajtach. Je

eli

wystapi bł

d zwraca

-1L.

192

Swobodny dost

p do pliku.

//p_100

/* Dost

p swobodny do pliku */

#include <stdio.h>

enum {SUCCESS, FAIL, MAX_LEN = 80};

void PtrSeek(FILE *fptr);

long PtrTell(FILE *fptr);

void DataRead(FILE *fptr);

int ErrorMsg(char *str);

main(void)

{

FILE *fptr;

char filename[]= "haiku.txt";

int reval = SUCCESS;

clrscr();

if ((fptr = fopen(filename, "r")) == NULL){

reval = ErrorMsg(filename);

} else {

PtrSeek(fptr);

fclose(fptr);

193

}

getch();

return reval;

}

void PtrSeek(FILE *fptr)

{

long offset1, offset2, offset3;

offset1 = PtrTell(fptr);

DataRead(fptr);

offset2 = PtrTell(fptr);

/* skok do 3 wiersza haiku */

fseek(fptr, 26L, SEEK_CUR);

offset3 = PtrTell(fptr);

DataRead(fptr);

printf("\nodczyt z haiku:\n");

/* ponowny odczyt 3 wiersza haiku */

fseek(fptr, offset3, SEEK_SET);

DataRead(fptr);

/* odczyt 2 wiersza haiku */

fseek(fptr, offset2, SEEK_SET);

DataRead(fptr);

/* odczyt 1 wiersza haiku */

fseek(fptr, offset1, SEEK_SET);

DataRead(fptr);

194

}

long PtrTell(FILE *fptr)

{

long reval;

reval = ftell(fptr);

printf(" fptr jest w %ld\n", reval);

return reval;

}

void DataRead(FILE *fptr)

{

char buff[MAX_LEN];

fgets(buff, MAX_LEN, fptr);

printf("---%s", buff);

}

int ErrorMsg(char *str)

{

printf("Bł

d otwarcia \n", str);

return FAIL;

}

----------------------

#include <stdio.h>

enum {SUCCESS, FAIL, MAX_LEN = 80};

void PtrSeek(FILE *fptr);

long PtrTell(FILE *fptr);

195

void DataRead(FILE *fptr);

int ErrorMsg(char *str);

main(void)

{

FILE *fptr;

char filename[]= "LaoTzu.txt";

int reval = SUCCESS;

clrscr();

if ((fptr = fopen(filename, "r")) == NULL){

reval = ErrorMsg(filename);

} else {

PtrSeek(fptr);

fclose(fptr);

}

getch();

return reval;

}

void PtrSeek(FILE *fptr)

{

long offset1, offset2, offset3;

offset1 = PtrTell(fptr);

DataRead(fptr);

offset2 = PtrTell(fptr);

DataRead(fptr);

196

offset3 = PtrTell(fptr);

DataRead(fptr);

printf("\nPonowny odczyt paragrafu:\n");

/* 3-ej sentencji */

fseek(fptr, offset3, SEEK_SET);

DataRead(fptr);

/* 2-ej sentencji */

fseek(fptr, offset2, SEEK_SET);

DataRead(fptr);

/* 1-szej sentencji */

fseek(fptr, offset1, SEEK_SET);

DataRead(fptr);

}

long PtrTell(FILE *fptr)

{

long reval;

reval = ftell(fptr);

printf(" fptr jest w %ld\n", reval);

return reval;

}

void DataRead(FILE *fptr)

{

char buff[MAX_LEN];

fgets(buff, MAX_LEN, fptr);

printf("%s", buff);

197

}

int ErrorMsg(char *str)

{

printf("Bł

d otwarcia %s.\n", str);

return FAIL;

}

Funkcja rewind() - cofni

cie znacznika pozycji na pocz

tek

pliku

#include <stdio.h>

void rewind(FILE *stream);

stream - wska

nik plikowy skojarzony z otwartym plikiem

Zatem równowa

ne s

rewind(ftpr); i fseek(ftpr, 0L, SEEK_SET);

Odczyt i zapis danych w trybie binarnym.

Otwarcie instniej

cego pliku binarnego w trybie tylko do

odczytu.

fprt = fopen(”test.bin”, ”rb”);

Odczyt i zapis danych binarnych

//p_101

/* Zapis i odczyt danych binarnych */

198

#include <stdio.h>

enum {SUCCESS, FAIL, MAX_NUM = 3};

void DataWrite(FILE *fout);

void DataRead(FILE *fin);

int ErrorMsg(char *str);

main(void)

{

FILE *fptr;

char filename[]= "double.bin";

int reval = SUCCESS;

clrscr();

if ((fptr = fopen(filename, "wb+")) == NULL)

{

reval = ErrorMsg(filename);

} else

{

DataWrite(fptr);

rewind(fptr);

DataRead(fptr);

fclose(fptr);

}

getch();

return reval;

}

void DataWrite(FILE *fout)

{

199

int i;

double buff[MAX_NUM] = {

123.45,

567.89,

100.11};

printf("Wielko

ść

buff: %d-bajty\n", sizeof(buff));

for (i=0; i<MAX_NUM; i++){

printf("%5.2f\n", buff[i]);

fwrite(&buff[i], sizeof(double), 1, fout);

}

}

void DataRead(FILE *fin)

{

int i;

double x;

printf("\nCzytanie z pliku binarnego :\n");

for (i=0; i<MAX_NUM; i++){

fread(&x, sizeof(double), (size_t)1, fin);

printf("%5.2f\n", x);

}

}

int ErrorMsg(char *str)

{

printf("Bł

d otwarcia %s.\n", str);

200

return FAIL;

}

---------------------

#include <stdio.h>

enum {SUCCESS, FAIL, MAX_LEN = 80};

void PtrSeek(FILE *fptr);

long PtrTell(FILE *fptr);

void DataRead(FILE *fptr);

int ErrorMsg(char *str);

main(void)

{

FILE *fptr;

char filename[]= "LaoTzu.txt";

int reval = SUCCESS;

clrscr();

if ((fptr = fopen(filename, "r")) == NULL){

reval = ErrorMsg(filename);

} else {

PtrSeek(fptr);

fclose(fptr);

}

getch();

return reval;

}

201

void PtrSeek(FILE *fptr)

{

long offset1, offset2, offset3;

offset1 = PtrTell(fptr);

DataRead(fptr);

offset2 = PtrTell(fptr);

DataRead(fptr);

offset3 = PtrTell(fptr);

DataRead(fptr);

printf("\nCzytanie paragrafu :\n");

/* 3 sentencja */

fseek(fptr, offset3, SEEK_SET);

DataRead(fptr);

/* 2 sentencja */

fseek(fptr, offset2, SEEK_SET);

DataRead(fptr);

/* 1 sentencja */

rewind(fptr); /* przewini

cie pozycjonera */

DataRead(fptr);

}

long PtrTell(FILE *fptr)

{

long reval;

reval = ftell(fptr);

202

printf(" fptr jest w %ld\n", reval);

return reval;

}

void DataRead(FILE *fptr)

{

char buff[MAX_LEN];

fgets(buff, MAX_LEN, fptr);

printf("%s", buff);

}

int ErrorMsg(char *str)

{

printf("Bł

d otwarcia %s.\n", str);

return FAIL;

}

Funkcje fscanf() i fprintf()

Funkcje printf() i scanf() słu

żą

do zapisu i odczytu

sformatowanych danych do/z strumieni do plików standardowego
urz

dzenia We/Wy (stdout,stdin).

Dla plików dyskowych s

dwa odpowiedniki tych funkcji :

fprintf() i fscanf(), które dodatkowo pozwalaj

wybrac

strumie

danych wej

cia wyj

cia stream.

#include <stdio.h>

int fscanf(FILE *stream, const char *format, ...);

stream - wska

nik plikowy skojarzony z otwartym plikiem, a

zastosowanie pozostałych elementów jest takie jak w finkcji
scanf()

203

Funkcja zwraca liczb

wczytanych argumentów lub EOF jako wynik

negatywny.

#include <stdio.h>

int fprintf(FILE *stream, const char *format, ... );

stream - wskaxnik plikowy skojarzony z otwartym plikiem,
zastosowanie pozostałych argumentów jest takie jak w funkcji
printf().

Funkcja zwraca liczb

sformatowanych wyra

lub warto

ść

ujemn

w przypadku negatywnym.

Zastosowanie funkcji fprintf() i fscanf().

//p_102

/* fscanf() i fprintf() */

#include <stdio.h>

enum {SUCCESS, FAIL,

MAX_NUM = 3,

STR_LEN = 23};

void DataWrite(FILE *fout);

void DataRead(FILE *fin);

int ErrorMsg(char *str);

main(void)

{

FILE *fptr;

char filename[]= "strnum.mix";

int reval = SUCCESS;

clrscr();

if ((fptr = fopen(filename, "w+")) == NULL){

reval = ErrorMsg(filename);

204

} else {

DataWrite(fptr);

rewind(fptr);

DataRead(fptr);

fclose(fptr);

}

getch();

return reval;

}

void DataWrite(FILE *fout)

{

int i;

char cities[MAX_NUM][STR_LEN] = {

"St.Louis->Houston:",

"Houston->Dallas:",

"Dallas->Philadelphia:"};

int miles[MAX_NUM] = {

845,

243,

1459};

printf("Zapis danych:\n");

for (i=0; i<MAX_NUM; i++){

printf("%-23s %d\n", cities[i], miles[i]);

fprintf(fout, "%s %d", cities[i], miles[i]);

}

205

}

void DataRead(FILE *fin)

{

int i;

int miles;

char cities[STR_LEN];

printf("\nCzytanie danych:\n");

for (i=0; i<MAX_NUM; i++){

fscanf(fin, "%s%d", cities, &miles);

printf("%-23s %d\n", cities, miles);

}

}

int ErrorMsg(char *str)

{

printf("Bł

d otwarcia %s.\n", str);

return FAIL;

}

------------------

#include <stdio.h>

enum {SUCCESS, FAIL};

void DataWrite(FILE *fout);

void DataRead(FILE *fin);

int ErrorMsg(char *str);

main(void)

206

{

FILE *fptr;

char filename[]= "data.bin";

int reval = SUCCESS;

clrscr();

if ((fptr = fopen(filename, "wb+")) == NULL){

reval = ErrorMsg(filename);

} else {

DataWrite(fptr);

rewind(fptr);

DataRead(fptr);

fclose(fptr);

}

getch();

return reval;

}

void DataWrite(FILE *fout)

{

double dnum;

int inum;

dnum = 123.45;

inum = 10000;

printf("%5.2f\n", dnum);

fwrite(&dnum, sizeof(double), 1, fout);

207

printf("%d\n", inum);

fwrite(&inum, sizeof(int), 1, fout);

}

void DataRead(FILE *fin)

{

double x;

int y;

printf("\nCzytanie z pliku binarnego:\n");

fread(&x, sizeof(double), (size_t)1, fin);

printf("%5.2f\n", x);

fread(&y, sizeof(int), (size_t)1, fin);

printf("%d\n", y);

}

int ErrorMsg(char *str)

{

printf("Bł

d otwarcia %s.\n", str);

return FAIL;

}

Funkcja freopen()

Standardowy przepływ strumieni danych mo

na zmieni

np. tak

aby strumienie stdin i stdout skojarzy

z plikami dyskowymi.

ywana do tego celu funkcja freopen().

#include <stdio.h>

208

FILE *freopen(const char *filename, const char *mode, FILE
*stream);

const char *filename - wska

nik do stałego ła

cucha znaków,

nazwy plików

Chodzi tu o ten plik, który nale

y skojarzy

ze standardowym

strumieniem (trzeci argument funkcji)

FILE *stream - wska

nik do standardowego strumienia, który

nale

y skojarzy

z plikiem.

mode - wska

nik typu *char wskazuj

cy ła

cuch znaków

okre

laj

cy tryb otwarcia danego pliku dyskowego; argument ten

e przybiera

tu te same warto

ci, co w przypadku funkcji

fopen();

Funkcja freopen() zwraca pusty wska

nik w przypadku

wyst

pienia bł

du, w przeciwnym przypadku zwraca standardowy

strumie

/wska

nik typu FILE */. Ten standardowy strumie

zostaje skojarzony z plikiem zadanym przez pierwszy argument
funkcji filename.

Skierowanie standardowego strumienia stdout do pliku dyskowego

//p_103

/* Zmiana kierunku przepˆywu standardowego srtumienia danych
*/

#include <stdio.h>

enum {SUCCESS, FAIL,

STR_NUM = 4};

void StrPrint(char **str);

int ErrorMsg(char *str);

main(void)

{

209

char *str[STR_NUM] = {

"Be bent, and you will remain straight.",

"Be vacant, and you will remain full.",

"Be worn, and you will remain new.",

"--- by Lao Tzu"};

char filename[]= "LaoTzu.txt";

int reval = SUCCESS;

clrscr();

StrPrint(str);

if (freopen(filename, "w", stdout) == NULL)

{

reval = ErrorMsg(filename);

} else

{

StrPrint(str);

fclose(stdout);

}

getch();

return reval;

}

void StrPrint(char **str)

{

int i;

for (i=0; i<STR_NUM; i++)

printf("%s\n", str[i]);

210

}

int ErrorMsg(char *str)

{

printf("Bł

d otwarcia %s.\n", str);

return FAIL;

}

------------------

#include <stdio.h>

enum {SUCCESS, FAIL,

MAX_NUM = 3,

STR_LEN = 23};

void DataRead(FILE *fin);

int ErrorMsg(char *str);

main(void)

{

FILE *fptr;

char filename[]= "strnum.mix";

int reval = SUCCESS;

clrscr();

if ((fptr = freopen(filename, "r", stdin)) == NULL){

reval = ErrorMsg(filename);

} else {

DataRead(fptr);

211

fclose(fptr);

}

getch();

return reval;

}

void DataRead(FILE *fin)

{

int i;

int miles;

char cities[STR_LEN];

printf("Czytanie danych :\n");

for (i=0; i<MAX_NUM; i++){

scanf("%s%d", cities, &miles);

printf("%-23s %d\n", cities, miles);

}

}

int ErrorMsg(char *str)

{

printf("Bł

d otwarcia %s.\n", str);

return FAIL;

}

212

Preprocesor

Preprocesor to specjalny program pozwalaj

cy na definiowanie i

kojarzenie nazw symboli ze stałymi. Preprocesor jest
uruchamiany przed kompilatorem. Przed uruchomieniem
kompilatora preprocesor przetwarza makropolecenia.
makrodefinicj

na umie

cic w dowolnym miejscu programu,

jednak makronazwa musi zosta

zdefiniowana przed jej pierwszym

yciem w programie.

Preprocesor pozwala równie

na doł

czanie do kodu

ródłowego

programu innych plików

ródłowych (stdlib.h,

strung.h,stdio.h).

Preprocesor ma własn

składni

Rozkazy jego rozpoczynaja si

od znaku # i ko

znakiem

przej

cia do nowego wiersza (nie

rednika jak w j

zyku C);

Preprocesor C pracuje w trybie wiersz-po-wierszu.

Najcz

ęś

ciej u

ywane dyrektywy preprocesora C :

#define - zdefiniuj

#undef - anuluj definicj

213

#if - je

eli

#elif - w przeciwnym razie, je

li...

#else - w przeciwnym razie

#ifdef - je

li zdefiniowane jest...

#ifndef - je

li nie jest zdefiniowane...

#endif - koniec bloku warunkowego

Makrorozkazy /te, które maja by

zast

pione stałymi/ s

zazwyczaj pisane du

ymi literami.

Dyrektywy #define #undef

#define macro_name macro_body

macro_name - identyfikator

macro_body - ła

cuch zło

ony z elementów danych zastepuj

identyfikator przy ka

dym jego wyst

pieniu w programie

np.

#define MY_NAME ‘Artur’

#define SUMA (12+3)

Dla anulowania dyrektywy #define słuzy dyrektywa #undef

#undef macro_name

np.

#undef MY_NAME ‘Artur’

Definiowanie makropolece

na podobie

stwo funkcji przy pomocy

dyrektywy #define

214

W makronazwie definiowanej przy pomocy dyrektywy #define ,
mo

na podobnie jak w przypadku funkcji definiowa

jeden lub

cej argumentów.

#define MULTIPLY (val1,val2) ((val1)*(val2))

rezult = MULTIPLY(2,3) + 10;

Zastosowanie dyrektywy #define

//p_104

Zagnie

anie makrodefinicji

Uprzednio zdefiniowane makro mo

e by

zastosowane w nast

pnej

definicji

#define JEDEN 1

#define DWA (JEDEN + JEDEN)

#define TRZY (JEDEN + DWA)

wynik = DWA + TRZY;

#define SUMA 12 + 8

wynik = SUMA * 10; à 92

#define SUMA (12 + 8)

wynik = SUMA * 10; à 200

Kompilacja warunkowa

215

Dyrektywy #infdef i #endif
wyznaczaj

pocz

tek i koniec fragmentu kodu

ródłowego

decyduj

czy w/w fragment kodu zostanie skompilowany

#ifdef macro_name

instr1;

instr2;

instr3;

...

#endif

nacro_name - dowolny ła

cuch zdefiniowany dyrektyw

define

Instrukcje zostan

skompilowane i wejd

w skład kodu, je

eli w

chwili przetwarzania identyfikator macro_name jest
zdefiniowany.

Dyrektywa #ifndef

Dyrektywa ta pozwala na warunkow

kompilacj

feagmentu kodu

ródłowego, je

eli okre

lona makronazwa nie jest zdefiniowana.

#ifndef

instr1;

instr2;

instr3;

...

#endif

Zastosowanie dyrektyw : #ifdef, #ifndef, #endif

//p_105

216

Dyrektywy #if, #elif, #else

Dyrektywa #if okre

la warunki ewentualnej kompilacji i

wł

czenia do kodu wykonywalnego pewnych instrukcji pod

warunkiem,

e wyra

enie warunkowe zwróci warto

ść

niezerow

(warunek spełniony). Wyra

enie warunkowe mo

e by

np.

wyra

eniem arytmetycznym.

#if wyra

enie

instr1;

instr2;

instr3;

...

#endif

Przy wyborze jednej z dwu mozliwo

ci :

#if

instr1;

instr2;

instr3;

...

#else

ins1;

ins2;

ins3;

...

#endif

#ifdef DEBUG

instrukcja1;

217

#else

instrukcja2;

#endif

#if 1

instr1; à zawsze b

dzie kompilowana

#endif

dyrektywa #elif oznacza to samo co else...if

Zastosowanie dyrektyw #if #elif #else

//p_106

Zagnie

anie bloków kompilacji warunkowej

/standard ANSI C max 8 poziomów/

#if makro1

#if makro2

#if makro3

instr1;

#else

instr2;

#endif

#else

instr3;

218

#endif

#else

instr4;

#endif

Zagnie

anie dyrektywy #if

//p_107