Stosowany powszechnie system dziesiętny zapisu operuje dziesięcioma różnymi znakami dla przedstawienia cyfr

Np. 2504=2*10³+5*10²+0*10¹+4*10⁰

W liczbach ułamkowych podstawa występuje w potęgach ujemnych, a zatem ogólny zapis liczby dziesiętnej ma postać

Tak więc ogólny zapis liczb tworzonych na takiej zasadzie jak dziesiętna ma postać

Przy P=2 dowolne liczby mogą być zapisywane za pomocą tylko dwóch znaków (zwykle 0 i 1),

np.

10110₂=1*2⁴+0*2³+1*2²+1*2¹+0*2⁰

Istnieje wiele sposobów konwersji liczb z systemu dziesiętnego do dwójkowego i odwrotnie, ale najprostsza jest metoda polegająca na sumowaniu albo wydzielaniu wag. Należy tu jedynie pamiętać, że pozycje liczby na lewo od przecinka mają wagi, kolejno:1,2,4,8,16,32,....,.a na prawo od przecinka 1/2,1/4,1/8, itd. Zamiana liczby dziesiętnej na dwójkową polega na dodawaniu tych wag, dla których cyfra ma wartość 1, np.

10110,1 = 22 ^1/2

1-- 1/2

1 -- 2

1 -- 4

• -- 16

Liczby dwójkowe są zwykle długie, co utrudnia zapis, zwiększa możliwość pomyłek i wydłuża czas przy opisywaniu sygnałów. Aby uniknąć tych wad, wprowadza się niekiedy (wyłącznie w charakterze pomocniczym, przy sporządzaniu dokumentacji) grupowanie trzech lub czterech cyfr dwójkowych i oznaczanie ich jednym symbolem.

Łatwo zauważyć, że sprowadza się to do wyrażania liczb w systemie ósemkowym lub szesnastkowym, np.:

87₁₀=1010111₂=127₈=57₁₆

57₁₆=57_H

W zapisie ósemkowym stosuje się oczywiście znaki systemu dziesiętnego, ale dla zapisu szesnastkowego znaków tych jest zbyt mało. Do oznaczenia cyfr większych od 9 (10,11,..,15) są zazwyczaj używane litery:

A -10,

B -11,

C -12,

D -13,

E -14,

F -15.

Reguły dodawania i odejmowania liczb binarnych

operacja dodawania operacja odejmowania

dodajna 0 0 1 1 odjemna 0 0 1 1

dodajnik 0 1 0 1 odjemnik 0 1 0 1

suma 0 1 1 0 różnica 0 1 1 0

przeniesienie 0 0 0 1 pożyczka 0 1 0 0

W przypadku liczb wielocyfrowych przeniesienie jest dodawane do cyfr bardziej znaczących, a pożyczka jest odejmowana od cyfr bardziej znaczących.

np.: 17 00010001

+ 05 00000101

• 00010110

1

np.: 17 00010001

- 05 00000101

• 00001100

11

Bit-Najmniejsza jednostka informacyjna, jaka może być przetworzona przez komputer.

Bit przekazuje jedną z dwóch wiadomości: „prąd płynie” lub „prąd nie płynie”.

Bajt-Jednostka danych składająca się z ośmiu bitów.

Rozmiary pamięci RAM, dysków twardych czy plików podawane są w jego wielokrotności.

Słowo-?

ASCII-tablica znaków, która opisuje przyporządkowanie poszczególnych znaków odpowiadającym im wartościom liczbowym, dzięki ASCII komputer wie, że np. liczbie 65

odpowiada litera A.

Istnieją dwa rodzaje kodów ASCII:7-bitowy, który opisuje tylko 128 znaków oraz 8-bitowy, zawierający 256 znaków (zwany także rozszerzonym ASCII lub ANSI).

ASCII ze względu na ograniczenie 256 znaków jest powoli wypierany przez system kodowania znaków o nazwie Unicode.

ASCII (ang. American Standard Code for information Interchange- standardowy amerykański kod wymiany informacji.)

Operatory bitowe stosowane w języku C

Operator	Działanie
&	Koniunkcja, AND
|	Alternatywa,OR
^	Różnica symetryczna, XOR
~	Uzupełnienie do 1, NOT
>>	Przesunięcie w prawo
<<	Przesunięcie w lewo

P	Q	P AND Q
0	0	0
0	1	0
1	0	0
1	1	1

P	Q	P OR Q
0	0	0
0	1	1
1	0	1
1	1	1

P	NOT P
0	1
1	0

P	Q	P XOR Q
0	0	0
0	1	1
1	0	1
1	1	0

Działanie	System binarny	System dziesiętny
x=7	00000111	7
x=x<<1	00001110	14
x=x<<3	01110000	112
x=x<<2	11000000	192
x=x>>1	01100000	96
x=x>>2	00011000	24

Każde przesunięcie w lewo powoduje pomnożenie liczby przez 2. Po wykonaniu instrukcji x=x<<2 nastąpiła częściowa utrata informacji z powodu przesunięcia bitu poza 8-bitowe słowo. Każde przesunięcie w prawo powoduje podzielenie liczby przez 2.

Język C

Książki:

• Brian Kerninghan i Dennis Ritchie: The C programming language. Prentice-Hall, Inc. Englewood Cliffs, New Jersey 1978. (Polskie wydanie Język C, WNT 1987, tłum. Danuta i Marek Kruszewscy)

• Jerzy Grębosz, Symfonia C++, Oficyna Kallimach, Kraków 1993r.

Przykład tekstu źródłowego C i jego kod wynikowy.

32 słowa kluczowe zdefiniowane w standardowym języku C (ANSI standard C)
auto	double	int	struct
break	else	long	switch
case	ensum	register	typedef
char	extern	return	union
const	float	short	unsigned
continue	for	signed	void
default	goto	sizeof	volatile
do	if	static	while

Dodatkowe słowa kluczowe dozwolone w programach C (dodane przez firmę Borland)
asm	_cs	_ds.	_es
_ss	cdecl	far	huge
interrupt	near	pascal	_export

Wszystkie słowa kluczowe języka C pisze się małymi literami!.

Ogólna struktura obszaru pamięci zajmowanego przez program C.

Poprawnie	Niepoprawnie
count	1count
test56	test!56

Identyfikatory (ang. identifiers)

W C istnieje pięć podstawowych typów danych:

Typy danych

int (całkowity)

float(zmiennoprzecinkowy)

double (zmiennoprzecinkowy podwójnej długości)

char (znakowy) do przechowywania znaków ASCII

void (pusty)

Modyfikatory typów

signed

unsigned

long

short

Wszystkie możliwe połączenia typów podstawowych z modyfikatorami w systemach 16 -bitowych
Typ	Liczba Bitów	Zakres
char	8	-128÷127
unsigned char	8	0÷255
signed char	8	-128÷127
int	16	-32 768÷32 767
unsigned int	16	0÷65 535
signed int	16	-32 768÷ 32 767
short int	16	-32 768÷ 32 767
unsigned short int	16	0÷65 535
signed short int	16	-32 768÷ 32 767
long int	32	- 2 147 483 648÷2 147 483 647
unsigned long int	32	0÷4 294 967 295
signed long int	32	- 2 147 483 648÷2 147 483 647
float	32	3,4*10^-38÷3,4*10^+38
double	64	1,7*10^-308÷1,7*10^+308
long double	80	3,4*^10-4932÷1,1*10^+493^2

typ lista_zmiennych;

int i,j,l;

short int pi;

unsigned int liczba;

static int k;

Wszystkie możliwe połączenia typów podstawowych z modyfikatorami w systemach 32 -bitowych
Typ	Liczba Bitów	Zakres
char	8	-128÷127
unsigned char	8	0÷255
signed char	8	-128÷127
int	32	- 2 147 483 648÷2 147 483 647
unsigned int	32	0÷4 294 967 295
signed int	32	- 2 147 483 648÷2 147 483 647
short int	16	-32 768÷ 32 767
unsigned short int	16	0÷65 535
signed short int	16	-32 768÷ 32 767
long int	32	- 2 147 483 648÷2 147 483 647
unsigned long int	32	0÷4 294 967 295
signed long int	32	- 2 147 483 648÷2 147 483 647
float	32	3,4*10^-38÷3,4*10^+38
double	64	1,7*10^-308÷1,7*10^+308
long double	80	3,4*^10-4932÷1,1*10^+4932

Modyfikatory dostępu

const

volatile

Na przykład instrukcja:

const int licznik=779;

const volatile unsigned char *port=0x45;

Specyfikatory klas pamięci

extern

register

static

auto

specyfikator_pamięci typ nazwa_zmiennej;

Stosowanie zmiennych globalnych w oddzielnie kompilowanych plikach.

Instrukcja przypisania

Nazwa_zmiennej=wyrażenie;

Na przykład podana niżej instrukcja przypisuje wartość zmiennym x,y,z:

x=y=z=0;

int x;

char ch;

float f;

void funkcja(void)

{

ch=x; /*1*/

x=f; /*2*/

f=ch; /*3*/

f=x; /*4*/

}

Typ nazwa_zmiennej=stała;

char ch='a';

int k =0;

float zmienna=123.45;

Operatory bitowe

Operator	Działanie
&	Koniunkcja, AND
|	Alternatywa,OR
^	Różnica symetryczna, XOR
~	Uzupełnienie do 1, NOT
>>	Przesunięcie w prawo
<<	Przesunięcie w lewo

Pamiętaj!

Operacje bitowe AND, OR i XOR są wykonywane oddzielnie na każdym z bitów zmiennej.

y=10;

x = (y=y-6 , 36/y);

/* y=4 x=9*/

Chcemy wymusić resztę z wyniku dla zmiennej x

int i=10,j=3;

float x;

x= (float) i/j;

Np.

x=y/3-34*cos&127;

x = (y/3) - ((34*cos) & 127);

Skróty języka C

Język C umożliwia stosowanie specjalnych skrótów, które upraszczają postać niektórych operacji przypisania.

x=x+10; można zapisać x+=10;

x=x*10; można zapisać x*=10;

x=x-10; można zapisać x-=10;

x=x%10; można zapisać x%=10;

x=x<<2; można zapisać x<<=2;

x=x>>2; można zapisać x>>=2;

x=x&2; można zapisać x&=2;

x=x|2; można zapisać x|=2;

char tablica_znaków[30][80];

Na przykład, aby wywołać funkcję gets() z trzecim łańcuchem tablicy tablica_znaków należy napisać

gets(tablica_znaków[2]);

typ nazwa_tablicy[wymiarN]...[wymiar2][wymiar1];

Podane informacje odnoszą się także do tablic wielowymiarowych. Na przykład zakładając, że a jest tablicą o wymiarach 10 x 10, następujące dwie instrukcje są równoważne

a równoważne &a[0][0];

Dostęp do elementu 0-4 a można uzyskać albo przez jej indeksowanie, a[0][4],

albo za pomocą wskaźnika *((int *)a+4).

Podobnie, element 1-2 jest reprezentowany zarówno przez a[1][2], jak i przez *((int*)a+12).

pracownik.wynagrodzenie = 1000;

pracownik.lista.imie=”Roman”;

Prototyp funkcji printf() wygląda następująco:

int printf(const char *fmt string, ...);

^Specyfikatory formatu funkcji printf()
^Kod	^Format
%c	Pojedynczy znak
%s	Łańcuch znaków
%d	Liczba całkowita ze znakiem w systemie dziesiętnym
%i	Liczba całkowita ze znakiem w systemie dziesiętnym
%u	Liczba całkowita bez znaku w systemie dziesiętnym
%e	Liczba w zapisie wykładniczym z małą literą e
%E	Liczba w zapisie wykładniczym z dużą literą e
%f	Liczba zmiennoprzecinkowa w systemie dziesiętnym
%g	Krótszy z formatów %e i %f
%G	Krótszy z formatów %E i %f
%o	Liczba bez znaku w systemie ósemkowym
%x	Liczba bez znaku w systemie szesnastkowym (małe litery)
%X	Liczba bez znaku w systemie szesnastkowym (duże litery)
%p	Wskaźnik
%n	Liczba wyświetlonych do tej pory znaków; związana z tym specyfikatorem zmienna powinna być wskaźnikiem do zmiennej całkowitej,
%%	Znak %

Specyfikator formatu funkcji scanf()
Kod	Format
%c	Pojedynczy znak
%s	Łańcuch znaków
%d	Liczba całkowita w systemie dziesiętnym
%i	Liczba całkowita w systemie dziesiętnym
%u	Liczba całkowita bez znaku w systemie dziesiętnym
%e	Liczba zmiennoprzecinkowa w systemie dziesiętnym
%f	Liczba zmiennoprzecinkowa w systemie dziesiętnym
%g	Liczba zmiennoprzecinkowa w systemie dziesiętnym
%o	Liczba bez znaku w systemie ósemkowym
%x	Liczba bez znaku w systemie szesnastkowym (małe litery)
%p	Wskaźnik
%n	Wartość całkowita określająca liczbę wczytanych do tej pory znaków %[] Wczytanie znaków należących do określonego zbioru skanowania

^Dopuszczalne wartości parametru mode funkcji fopen()
^Tryb	^Działanie
"r"	Otwarcie pliku do odczytu (domyślnie plik jest otwierany w trybie tekstowym).
"w"	Otwarcie lub utworzenie pliku do zapisu; w przypadku otwarcia pliku jego poprzednia zawartość jest usuwana (domyślnie plik jest otwierany w trybie tekstowym).
"a"	Otwarcie lub utworzenie pliku do zapisu; w przypadku otwarcia pliku nowe dane są dopisywane do jego poprzedniej zawartości (domyślnie plik jest otwierany w trybie tekstowym).
"r+"	Otwarcie pliku do odczytu i zapisu z pozostawieniem jego poprzedniej zawartości (domyślnie plik jest otwierany w trybie tekstowym).
"w+"	Otwarcie lub utworzenie pliku do odczytu i zapisu; w przypadku otwarcia pliku jego poprzednia zawartość jest usuwana (domyślnie plik jest otwierany w trybie tekstowym ).
"a+"	Otwarcie lub utworzenie pliku do odczytu i zapisu; w przypadku otwarcia pliku nowe dane są dopisywane do jego poprzedniej zawartości (domyślnie plik jest otwierany w trybie tekstowym).
"rb"	Otwarcie pliku do odczytu w trybie binarnym.
"wb"	Otwarcie lub utworzenie pliku do zapisu w trybie binarnym; w przypadku otwarcia pliku jego poprzednia zawartość jest usuwana.
"ab"	Otwarcie lub utworzenie pliku do zapisu w trybie binarnym; w przypadku otwarcia pliku nowe dane są dopisywane do jego poprzedniej zawartości.
"r+b"	Otwarcie pliku do odczytu i zapisu w trybie binarnym; poprzednia zawartość pliku jest pozostawiana.
"w+b"	Otwarcie lub utworzenie pliku do odczytu i zapisu w trybie binarnym; w przypadku otwarcia pliku jego poprzednia zawartość jest usuwana.
"a+b"	Otwarcie lub utworzenie pliku do odczytu i zapisu w trybie binarnym; w przypadku otwarcia pliku nowe dane są dopisywane do jego poprzedniej zawartości.
"rt"	Otwarcie pliku do odczytu w trybie tekstowym.
"wt"	Otwarcie lub utworzenie pliku do zapisu w trybie tekstowym; w przypadku otwarcia pliku jego poprzednia zawartość jest usuwana.
"at"	Otwarcie lub utworzenie pliku do zapisu w trybie binarnym; w przypadku otwarcia pliku nowe dane są dopisywane do jego poprzedniej zawartości.
"r+t"	Otwarcie pliku do odczytu i zapisu w trybie tekstowym; poprzednia zawartość pliku jest pozostawiana.
"w+t"	Otwarcie lub utworzenie pliku do odczytu i zapisu w trybie tekstowym; w przypadku otwarcia pliku jego poprzednia zawartość jest usuwana.
"a+t"	Otwarcie lub utworzenie pliku do odczytu i zapisu w trybie tekstowym; w przypadku otwarcia pliku nowe dane są dopisywane do jego poprzedniej zawartości.

Strumień Urządzenie

stdin klawiatura

stdout ekran

stderr ekran

stdaux . pierwszy port szeregowy

stdprn drukarka

/* Program zmieniający wielkość liter */

# include <conio.h># include <stdio.h># include <ctype.h>int main(void) {char ch;do{ch=getche();if(islower(ch)) putchar (toupper(ch));else putchar(tolower(ch));} while(ch!='.'); /* wprowadzenie kropki kończy działanie programu */

return 0;

}

/* Ten program działa jak "oszalały" program obsługi poleceń DOS-a: wyświetla tekst zachęty, a następnie wczytuje znaki z klawiatury !*/

# include <stdio.h>

# include <conio.h>

int main(void)

{

char ch;

do {

printf("C>");

for(;;){

ch=getch(); /* wczytanie znaku bez "echa" */

if(ch=='\r' || ch==1) {

printf("\n");

break;

}

putchar(ch+1);;

}

}while(ch!=1); /* koniec dziaaania po wprowadzeniu Ctrl+A*/

return 0;

}

Podany niżej program wczytuje łańcuch do tablicy str i wyświetla jego długość:

#include <stdio.h>#include <string.h>int main(void){char str[80];gets(str);printf("Długość† łancucha wynosi %d",strlen(str));

return 0;

}

Funkcja	Działanie
getchar()	Wczytuje znak z klawiatury, czekając na naciśnięcie klawisza Enter
getche()	Wczytuje znak i wyświetla go na ekranie, nie czeka na naciśnięcie klawisza Enter, nie zdefiniowana w standardzie ANSI C, ale występuje jako dodatek w większości implementacji
getch()	Wczytuje znak, nie wyświetlając go na ekranie, nie czeka na naciśnięcie klawisza Enter, nie zdefiniowana w standardzie ANSI C, ale występuje jako dodatek w większości implementacji
putchar()	Wyświetla znak na ekranie
gets()	Wczytuje z klawiatury łańcuch zakończony naciśnięciem klawisza enter
puts()	Wyświetla na ekranie pojedyńczy łańcuch, umożliwia stosowanie kodów z ukośnikiem wstecznym.

Prototyp funkcji fopen() wygląda następująco:

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

Zwykle stosuje się sekwencję instrukcji podobną do następującej:

if ( ( fp = fopen ( "test", "w" ) ) ==NULL) { puts("Błąd otwarcia pliku"); exit(1);}

Prototyp funkcji fclose() wygląda następująco:

int fclose(FILE *fp);

Prototyp funkcji putc() wygląda następująco:

int putc(int ch, FIIE *fp);

Prototyp funkcji getc() wygląda następująco:

int getc(FILE *fp);

Nazwa	Działanie
fopen()	Otwiera plik
fclose()	Zamyka plik
putc()	Zapisuje pojedynczy znak do pliku
fputc()	Działa tak samo jak putc()
getc()	Odczytuje pojedynczy znak z pliku
fgetc()	Działa tak samo jak getc()
fseek()	Przechodzi od określonego bajtu pliku
fprintf()	Wykonuje w stosunku do pliku takie same działania, jak printf() wykonuje w stosunku do monitora
fscanf()	Wykonuje w stosunku do pliku takie same działania, jak scanf() wykonuje w stosunku do klawiatury
feof()	wraca wartość true po osiągnięciu końca pliku
ferror()	Zwraca wartość true po wystąpieniu błędu
rewind()	Ustawia wskaźnik położenia pliku na jego początku
remove()	usuwa plik
fflush()	Wymywa bufor pliku

Pogram ten wyświetla zawartość pliku tekstowego którego nazwa jest podana jako parametr funkcji main(). Program obsługuje standardowy plik obsługi błędu

# include <stdio.h>main(argc,argv)/* argc -argument counter*//* argv - argument values zawiera on treść linii komendy wywołania podzielona na słowa*/

int argc;

char *argv[];

{

FILE *fp,*fopen();

printf("liczba słów w linii komendy%d\n",argc);

if(argc==1)

filecopy(stdin);

else

while(--argc>0)

if((fp=fopen(*++argv,"r"))==NULL)

{

printf("sklejam-printf:nie moge otworzyc%s\n",*argv);

fprintf(stderr,"sklejam-fprintf:nie moge otworzyc%s\n",*argv);

exit(1);

}

else

{

filecopy(fp);

fclose(fp);

}

exit(0);

}

filecopy(fp)

FILE *fp;

{

int c;

while((c=getc(fp))!=EOF)

putchar(c);

}

Operatory relacyjne

Operator Działanie

> większy,

>= większy lub równy,

< mniejszy,

<= mniejszy lub równy,

== równy,

!= różny,

Operatory logiczne

Operator Działanie

&& koniunkcja, AND

|| alternatywa, OR

! negacja, NOT

Operator Działanie

• odejmowanie, również minus jednoargumentowy,

+ dodawanie,

* mnożenie,

/ dzielenie,

% dzielenie modulo,

-- dekrementacja (zmniejszenie o 1),

++ inkrementacja (zwiększanie o 1).

Np. Np.

x=7; x=7;

x && 8 wynosi (true) x & 8 jest false

Np.

X=34;

Y=X>9 ? 234 : 3566;

Zmiennej Y zostanie przypisana wartość 234.



X=34; /* równoważny zapis */

if(x>9) Y=234;

else Y=3566;

for(k=0;k<100;++k) {

licznik=1;

for(;;) {

printf(„%d ”,licznik );

licznik++;

if(licznik==10) break;

}

}

#include <stdio.h>

int main(void)

{

int k;

for(k=0;k<100;k++) {

printf(”%d” ,k);

if(k==10) break;

}

return 0;

}

/* Powyższy program wyświetla liczby od 0 do 10, po czym kończy swoje działanie, ponieważ instrukcja break powoduje natychmiastowe wyjście z pętli */

x=1;

etykieta:

x++;

if (x<100) goto etykieta;

do {

scanf(”%d”,&x);

if(x<0) continue;

printf(”%d ”,x);

}while(x!=100);

/* program wyświetla tylko liczby dodatnie */

# include <stdio.h>

int main(void)

{

int x[10]; /* ta instruk. rezerwuje 10 elementów całkowitych */

int g;

for(g=0; g<10; ++g) x[g]=g;

for(g=0; g<10; ++g) printf(”%d ”, x[g] );

return 0;

}

int main(void)

{

int j[10];

funkcja(j);

}

void funkcja(int *s) /*wskaźnik */

{

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

}

lub

void funkcja( int s[10]) /*tablica o określonym rozmiarze */

{

......

}

lub

void funkcja( int s[ ] ) /*tablica o nieokreślonym rozmiarze */

{

......

}

funkcje testujące rodzaj znaku:

• isdigit - cyfra,

• isxdigit - cyfra heksadecymalna,

• islower- mała litera,

• isupper - duża litera,

• isalpha - litera,

• isalnum - litera lub cyfra,

• isspace - odstęp (spacja, tabulator, nowa linia itp.),

• iscntrl - znak sterujący (ASCII 0-31 lub 127),

• ispunct - znak interpunkcyjny lub spacja,

• isprint - znak „drukowany” (nie sterujący),

• isgraph - „drukowalny” znak graficzny (j.w., lecz bez spacji),

• isascii - znak kodu ASCII.

Druga grupa funkcji realizuje konwersję znaku:

• tolower - z dużej na małą literę,

• toupper - z małej na dużą literę.

Dalsze funkcje obsługują jeden lub dwa łańcuchy znaków:

• strcat - połączenie dwóch łańcuchów w jeden,

• strncat - połączenie dwóch łańcuchów w jeden, o podanej maksymalnej długości,

• strcmp - porównanie dwóch łańcuchów znaków,

• strncmp - porównanie dwóch łańcuchów znaków na podanej liczbie początkowych pozycji,

• strcpy - skopiowanie łańcucha znaków,

• strncpy - skopiowanie łańcucha znaków, do podanej maksymalnej długości,

• strlen - długość łańcucha znaków,

• strchr - pozycja pierwszego wystąpienia podanego znaku w łańcuchu,

• strrchr - pozycja ostatniego wystąpienia podanego znaku w łańcuchu.

Kolejne grupy, to funkcje przeprowadzające konwersję znaków na liczby:

• atod - rzeczywistą,

• atol - cłkowitą typu long,

• atoi - całkowitą.

int *p ,i[10];

p=i;

p[5]=100; /* przypisanie wartości za pomocą indeksu */

*(p+5)=100; /* przypisanie wartości za pomocą arytmetyki wskaźnikowej */

Obie instrukcje przypisania umieszczają liczbę 100 w szóstym elemencie tablicy i.

Pierwsza instrukcja indeksuje p, natomiast druga stosuje arytmetykę wskaźnikową.

*((typ *) a+(j*długość_wiersza)+k))

gdzie typ jest typem bazowym tablicy a.

main()

{

int i, a[10][10];

for(i=0;i<100;*((int*) a+i)=i++);

} /* program ten wypełnia tablicę kolejno wartościami od 0 do 99*/

main()

{

int i,j,l,a[10][10];

l=0;

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

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

{

a[i][j]=l++;

}

}

/*program realizujący wypełnianie tablicy wartościami od 0 do 99 przy wykorzystaniu indeksów tablic */

/*wersja tablicowa */

strcpy(char s[],char t[]) /*kopiuj t do s*/

{

int i=0;

while((s[i]=t[i])!='\0')

i++;

}

/* wersja wskażnikowa 1*/

strcpy(char *s, char *t) /*kopiuj t do s*/

{

while((*s=*t)!='\0')

{

s++;

t++;

}

}

/* wersja wskaźnikowa 2*/

strcpy(char *s, char *t) /*kopiuj t do s*/

{

while(*s++=*t++)

;

}

specyfikator_typu nazwa_tablicy[wymN]...[wym1]={lista_wartości};

int i[10] = {1,2,3,4,5,6,7,8,9,10 };

Po wykonaniu tej instrukcji element i[0] będzie mieć wartość 1, a element i[9] wartość 10.

char tab[7] =”Witamy”;

char tab[7] = {`W','i','t','a','m','y','\0'};

int dom[10][2] = {

1,1,

2,4,

3,9,

4,16,

5,25,

6,36,

7,49,

8,64,

9,81,

10,100

};

Po wykonaniu tej instrukcji dom[0][0]=1,dom[0][1]=1,

dom[1][0]=2,dom[1][1]=4

int dom[10][2] = {

{1,1},

{2,4},

{3,9},

{4,16},

{5,25},

{6,36},

{7,49},

{8,64},

{9,81},

{10,100}

};

Po wykonaniu tej instrukcji dom[0][0]=1,dom[0][1]=1,

dom[1][0]=2,dom[1][1]=4

jeżeli w instrukcji utworzonej z zastosowaniem grupowania częściowego jedna z grup nie jest pełna, to pozostałe elementy danego wymiaru są zerowane.

char t1[14]=”Błąd odczytu\n”;

char t2[13]=”Błąd zapisu\n”;

char t3[21] =”Błąd otwarcia pliku\n”;

lub

char t1[]=”Błąd odczytu\n”;

char t2[]=”Błąd zapisu\n”;

char t3[] =”Błąd otwarcia pliku\n”;

char *p;

p = malloc(1000); /* uzyskanie 1000 bajtów */

Po wykonaniu tych instrukcji p wskazuje na pierwszych 1000 bajtów wolnej pamięci.

#include <stdio.h>

int main(void)

{

int linia, q;

int *p;

linia=100;

p=&linia;

q=*p;

printf("%d",q);

return 0;

}

#include <stdio.h>

int main(void)

{ double x,y;

int *p;

x=100.123;

p=&x;

y=*p;

printf("%f",y);

/*zostanie wyświetlona liczba całkowita */

return 0;

}

#include <stdio.h>

int main(void)

{

int x;

int *p1, *p2;

p1=&x;

p2=p1;

printf(”%p %p”' p1,p2);

return 0;

}

#include <stdio.h>

#include <stdlib.h>

#define ROZMIARSTOSU 50

void push(int i);

int pop(void);

int *p1, *tos,stos[ROZMIARSTOSU];

int main(void)

{

int value;

p1=stos;

tos=p1;

do{

printf("wprowadz liczbe (-1 - koniec, 0 - pobranie):");

scanf("%d",&value);

if(value!=0) push(value);

else printf("pobrales %d\n", pop());

} while(value!=-1);

return 0;

}

void push(int i)

{

p1++;

if(p1==(tos+ROZMIARSTOSU)){

printf("Przepelnienie");

exit(1);

}

*p1 =i;

}

int pop(void)

{

if(p1==tos){

printf("poczatek stosu");

exit(1);

}

p1--;

return *(p1+1);

}

#include <stdio.h>

void komunikat(int numer)

{

static char *err[] = {

"Błąd otwarcia pliku\n",

"Błąd odczytu\n",

"Błąd zapisu\n",

"błąd urzadzenia\n",

};

printf("%s", err[numer]);

}

main()

{

komunikat(1);

komunikat(2);

komunikat(3);

}

#include <stdio.h>

int main(void)

{

int x, *p, **q;

x=10;

p=&x;

q=&p;

printf("%d",**q);

return 0;

}

#include <stdio.h>

#include <string.h>

/* wyswietla łańcuch w zwykłej postaci i od tyłu*/

char *p="Witajcie na wykładzie";

int main(void)

{

register int t;

printf(p);

for(t=strlen(p)-1; t>-1; t--) printf("%c", p[t]);

return 0;

}

struct adresy{

char imie[20];

char nazwisko[40];

char ulica[30];

char miasto[25];

char wojewodztwo[10];

};

struct adresy{

char imie[20];

char nazwisko[40];

char ulica[30];

char miasto[25];

char wojewodztwo[10];

} adresy_baza, dane;

#include <stdio.h>

#include <string.h>

#include "stdlib.h"

#include "conio.h"

void hello(void), cos(void), dane(void), wiosna(void);

int wybor(void);

void (*opcje[]) (void)={

hello,

cos,

dane,

wiosna

};

int main(void)

{

int i;

i=wybor();

(*opcje[i])();

return 0;

}

int wybor(void)

{

char ch;

do {

printf("1 - Wprowadzenie\n");

printf("2 - Omówienie\n");

printf("3 - Wprowadzanie\n");

printf("4 - Koniec\n");

printf("5 - Wprowadź numer polecenia: ");

ch=getchar();

printf("\n");

}while(!strchr("1234", ch));

return ch-49;

/*przekształcenie kodu ascii cyfry do jej wartości dziesietnej */

}

void hello(void)

{ printf("Funkcja Hello!");

}

void cos(void)

{ printf("Funkcja cos!");

}

void dane(void)

{ printf("Funkcja dane!");

}

void wiosna(void)

{ printf("Funkcja wiosna!");

}

struct nazwa_struktury{

typ nazwa_pola;

typ nazwa_pola;

typ nazwa_pola;

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

} zmienne_strukturowe;

#include <stdio.h>

int main(void)

{

struct {

int a;

int b;

}x,y;

x.a=10;

x.b=20;

y=x;

printf(„Zawartość struktury y: %d %d.”, y.a, y.b);

return 0;

}

struct adresy{

char imie[20];

char nazwisko[40];

char ulica[30];

char miasto[25];

char wojewodztwo[10];

} adresy_baza, dane;

struct adresy tablica_adresow[100];

struct dane{

char q;

int y;

float h;

char s[10];

} tx;

Przykłady przekazywania funkcjom poszczególnych pól tej struktury:

funkcja1 (tx. q); /* przekazywanie znaku q */

funkcja2 (tx. y); /* przekazywanie liczby całkowitej y */

funkcja3 (tx. h); /* przekazywanie liczby zmiennoprzecinkowej h */

funkcja4 (tx. s[5]); /* przekazywanie znaku s[5] */

struct impreza {

int liczba_gości;

char nazwisko[40];

} bal;

struct impreza p; / deklaracja wskaźnika do struktury */

instrukcja

p=&bal;

umieszcza w zmiennej p adres struktury bal.

struct adresy{

char imie[20];

char nazwisko[40];

char ulica[30];

char miasto[25];

char wojewodztwo[10];

};

struct adresy *baza_adresów;

struct dane{

char q;

int y;

float h;

char s[10];

} tx;

Przykłady przekazywania funkcjom poszczególnych pól tej struktury:

funkcja1 (&tx. q); /* przekazywanie adresu znaku q */

funkcja2 (&tx. y); /* przekazywanie adresu liczby całkowitej y */

funkcja3 (&tx. h); /* przekazywanie adresu liczby zmiennoprzecinkowej h */

funkcja4 (&tx. s); /* przekazywanie adresu łańcucha znaków s */

funkcja4 (&tx. s[5]); /* przekazywanie adresu znaku s[5] */

struct x{

int a[10][10];

float b;

} y;

Aby uzyskać dostęp do elementu 3-7 tablicy a należącej należącej do struktury y, należy napisać:

y.a[3][7];

struct baza {

struct adresy lista;

float wynagrodzenie;

} pracownik;

struct nazwa_struktury {

typ nazwa1:długość;

typ nazwa2:długość;

........

typ nazwaN:długość;

}

union typ_unii{

unt i;

char ch;

};

struct urządzenie{

unsigned aktywne:1;

unsigned gotowe:1;

unsigned błąd:1;

unsigned :3;

unsigned szybkość:2;

} urządzenie1;

Specyfikatory formatu funkcji scanf();

---