Programowanie Komputerów 

 
 
 
 
 
 
Skrypt wykładów  
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Opracowali:  Jarosław S. Walijewski 

Zenon A. Sosnowski 

ii

 

Literatura 
 

 

Skrypt wykładów: 

opal:// H:/C 
 

 

Brian W. Kernighan Dennis M. Ritchie 

 „ Język ANSI C ”

 

 WNT 
 

 

Claude Delannoy  

 

 „Ćwiczenia z języka C ”

 

WNT 
 

 

Marek Kotowski 

„Wysokie C ”

 

Wydawnictwo Lupus 
 

 

Jan Bielecki  

„Encyklopedia Języka C dla IBM PC”

 

WNT 
 

 

Marc J. Rochind 

„Programowanie w systemie UNIX dla zaawansowanych”

 

WNT 
 
 
 

 
 
 

iii

 

Program wykładów 

1. 

H

ISTORIA

............................................................................................ 1 

2. 

P

RZEGLĄD KONSTRUKCJI JĘZYKOWYCH

......................................... 3 

3. 

B

UDOWA PROGRAMU

....................................................................... 16 

4. 

P

ODSTAWOWE TYPY DANYCH

......................................................... 18 

5. 

O

PERATORY

..................................................................................... 23 

6. 

I

NSTRUKCJE

..................................................................................... 27 

7. 

F

UNKCJE

........................................................................................... 31 

8. 

T

ABLICE 

1-

WYMIAROWE

................................................................. 40 

9. 

T

ABLICE WIELOWYMIAROWE

......................................................... 48 

10.  A

RGUMENTY MAIN

........................................................................... 52 

11.  D

EFINIOWANIE TYPÓW

.................................................................... 53 

12.  S

TRUKTURY

...................................................................................... 55 

13.  U

NIE

.................................................................................................. 62 

14.  M

ODELE PAMIECI

............................................................................ 65 

15.  D

YNAMICZNY PRZYDZIAŁ PAMIĘCI

................................................ 68 

16.  S

TRUKTURY LISTOWE

...................................................................... 70 

17.  S

TOS

.................................................................................................. 81 

18.  D

RZEWA BINARNE

............................................................................ 87 

19.  P

REPROCESOR

.................................................................................. 92 

20.  F

UNKCJE ZE ZMIENNĄ ILOŚCIĄ ARGUMENTÓW

........................... 105 

21.  W

EJŚCIE

/

WYJŚCIE

......................................................................... 110 

22.  C

 W SYSTEMIE 

UNIX ..................................................................... 122 

23.  W

YSOKIE 

C .............................B

ŁĄD

!

 

N

IE ZDEFINIOWANO ZAKŁADKI

. 

 1 

1.

 

Historia 

 

1967    BCPL 
 
 

Martin Richards 

 

University, Cambridge, MA, USA 

 

Język beztypowy,  

 

słowo maszynowe, wskaźniki,  

 

arytmetyka wskaźników 

 

 

 

Bell Laboratories, New Jersey 

 
1969    B   

 Ken Thompson 

     pierwsza wersja systemu UNIX 
     j. wewnętrzny + B      1970 rok 
 
1972    C   

 Dennis Ritchie 

     pierwsza implementacja na PDP-11 
    Język systemowy systemu UNIX  (90% kodu) 
 
1978    The C Programming Language 
     klasyczna definicja Języka 
 
1983    American National Standard Institute 
        ANSI C 
 
koniec lat 80   
 

standard Języka, usuwa niejednoznaczność i 

 

 wprowadza rozszerzenie 

 

 

 

C++ 

 
 
 

 2 

1.1.

 

 

Dlaczego  C? 

 

język programowania, podstawowy język programowania.  
 
Język programowania strukturalnego, ogólnego przeznaczenia. Pozwala  
zbliżyć się do sprzętu i programowania operacji, które zwykle wyzmagają 
j.maszynowowego. 
 
C jest mały -  
 

mniej słów kluczowych niż w Pascalu przy większych 

możliwościach obliczeniowych. 

 
C silnie związany z UNIX 
 

nie potrzeba wbudowywać w programy kontroli we/wyj  

lub 

obslugi przerwań 

 

 w C używa się procedur bibliotecznych SO 

 
C - przenaszalny 
 

preprocesor (różne implementacje) 

 
C - zwięzły 
 

dużo operatorów 

(dostęp do słowa, arytmetka adresowa) 

 
C - modułowy 
 

jeden rodzaj procedur - funkcje zewnętrzne z parametrami 

przekazywanymi przez wartość 
 

1.1.1.

 

Wady 

 

skomplikowana składnia 

 

brak automatycznej kontroli indeksów tablic 

 

wielokrotne użycie operatorów +, = 

 

=     operator przypisania  

 

= =    operator równości 

 3 

2.

 

Przegląd konstrukcji językowych 

2.1.

 

 

Wyjście 

 
#include <stdio.h> 
main () 
{ 
  printf("Programowanie w C nie jest trudne!\n"); 
} 
 
 
printf ("Programowanie"); 
printf (" w C nie jest"); 
printf (" trudne\n"); 
 
 

Zmienne, wyrażenia, przypisanie wartości 

 
/*Temperatura Fahrenheita-Celsjusza*/ 
#include <stdio.h> 
main ( ) 
{ 
 int fahr; 
 float cel; 
 cel = (5.0/9.0)*(fahr-32); 
 printf( 
 "%d stopni Fahrenheita to %f stopni Celsjusza \n", 
         fahr,cel); 
} 
 
 

 4 

2.2.

 

 

Preprocesor  

 
#define PI  3.141592 
#define C   299792.458 
    

 

/* pr

ę

dko

ść

 

ś

wiatła w km/sec */ 

 
 
#include  <    .h>   - standardowa 
#include  " .h" - zdefiniowanie przez u

ż

ytkownika 

 

Plik  ocean.h 

   #include <stdio.h> 
   #define OBSZAR              2337 
   #define MIL_KW_NA_KM_KW     0.3861021585424458 
   #define STOP_KW_NA_MIL_KW    (5280 + 5280) 
   #define CALI_KW_NA_STOPE_KW  144 
 

Plik ocean.c 

   /*Mierzenie Pacyfiku*/ 
 #include "ocean.h" 
 main ( ) 
  { 
   const int ocean = OBSZAR; /* w km kwadratowych*/ 
   double mil_km,stop_kw,cal_kw; 
   mil_kw  = MIL_KW_NA_KM_KW * ocean; 
   stop_kw = STOP_KW_NA_MIL_KW*mil_kw; 
   cal_kw  = CAL_KW_NA_STOP_KW*stop_kw; 
   printf( 
   "Obszar Pacyfiku wynosi %d km kwadratowych \n", 
           obszar); 
   printf("W innych jednostkach \n"); 
   printf("%22.7e mil kwadratowych \n", mil_kw); 
 
   .   .   . 
 
  } 

 5 

2.3.

 

Funkcje wejścia i wyjścia

 

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

znak 

d          

liczba calkowita 

e          

liczba zmiennoprzecinkowa 

f          

liczba zmiennoprzecinkowa 

g          

liczba zmiennoprzecinkowa 

s          

napis 

 
   printf("abc"); 
   printf("%s","abc"); 
   printf("%c%c%c",'a','b','c'); 
   printf("%c%3c%5c",'A','B','C') 

   A  B    C 
 
Wprowadzanie danych    

scanf(constchar* format,...) 

 

 
    scanf("%d",&x); 
               & - operator adresowy 
                  adres x 
Kody konwersji: 
c 

d 

f 

s 

lf     - 

  double 

Lf    - 

  long double 

 
 #include <stdio.h> 
 main ( ) 
  { 
   char c1,c2,c3; 
   int i;   float x;    double y; 
   printf("\n%s\n%s%s", 
         "Wprowad

ź

 trzy znaki", 

         "liczb

ę

 całkowit

ą

, zmiennoprzecinkow

ą

", 

         " i liczb

ę

 podwójnej  precyzji"); 

scanf("%c%c%c%d%f%lf",&c1,&c2,&c3,&i,&x,&y); 
 printf("\n oto dane, które wprowadziłes \n");   
printf("%3c%3c%3c%5d%17e%17e\n\n",c1,c2,c3,i,x,y); 
  } 

 6 

2.4.

 

 

Sterowanie 

 

if (wyrażenie) 

instrukcja 

 
 
   a=1; 
   if (b==3) 
        a=5; 
   printf("%d",a); 
 
   if(a==3) 
     { 
      b=5; 
      c=7; 
     } 
 
 

   if (wyrażenie) 

           instrukcja1 

 

 

 

 

else 

           instrukcja2 

 
 
   if(l==0) 
     { 
      a=2; 
      b=3; 
     } 
  else 
     { 
      a=-2; 
      b=-3; 
     } 
 
 

 7 

2.5.

 

Instrukcja pętli  

 

while (wyrażenie) 

 

 

 instrukcja 

 
#include <stdio.h> 
main ( ) 
{ 
  int i=1, sum=0; 
   while  (i<=5) 
     { 
       sum+=i; 
       ++i; 
     } 
 printf("suma=%d", sum); 
} 
 

sum+=i;        sum = sum+i; 
 
 
     zmienna op= wyrażenie 
     zmienna = zmienna op wyrażenie 
gdzie 
 

op    +    -    *   / 

 
 
++i;          i=i+1;        - -i;     i=i-1; 
 
++zm   przed wyrażeniem 
zm++   po wyrażeniu 

 
h=5; 
x=h++;   5 
x=++h;   6 
 

 8 

2.5.1.

 

Pętla for 

for (wyrażenie1;wyrażenie2;wyrażenie3) 

    instrukcja 

   wyrażenie1; 
   while (wyrażenie2) 
   { 
   instrukcja; 
   wyrażenie3 
   } 

 
for (i=1;i<=5;++i) 
   sum+=i; 
 
 
/*obliczanie elementu minimalnego, maksymalnego 
 

i sredniej arytmentycznej */ 

#include <stdio.h> 
#include <stdlib.h> 
main ( ) 
  { 
   int i; 
   double x, min,max,sr,suma; 
    if(scanf("%lf",&x) != 1) 
     { printf("Brak danych \n"); exit (1);} 
    min=max=suma=sr=x; 
    printf("Nr   Min   Max   Suma   Sr  \n"); 
    printf("%d %f %f %f %f %f" , 
            1, x, min, max, suma, sr); 
   for (i=2;scanf("%lf",&x)==1;++i) 
     { 
       if(x<min)      min=x; 
       else if (x>max)  max=x; 
      suma+=x; 
      sr=suma/i; 
      printf("%d %f %f %f %f %f\n", 
               i, x, min, max, suma, sr) 
     } 
} 

 9 

2.6.

 

 

Funkcje 

 

   double potega (double x, double y) 
  
  prototyp funkcji 
   double potęga (double, double); 

 
 
  #include <stdio.h> 
  main ( ) 
    { 
     int i,h; 
     float min, max, x; 
     float minimum  
         (float, float), maximum (float, float); 
     void prt_inf (void); 
  
     prt_inf( ); 
     printf("Wprowad

ź

 n:"); 

     scanf("%d,&n); 
printf("\n Wprowad

ź

 %d liczb rzeczywistych :", n); 

     scanf("%f",&x); 
     min=max=x; 
     for(i=2; i<=n; ++i) 
       { 
        scanf("%f",&x); 
        min = minimum (min,x); 
        max = maximum (max,x); 
       } 
     printf( 
 "Warto

ść

 minimalna: %f\nWarto

ść

 maxymalna: %f\n",  

         min, max); 
     }   
void prt_inf (void) 
     { 
      printf("\n\n %s \n%s \n", 
       "Program wczytuje długo

ść

 ci

ą

gu" 

       ............................. 
      } 
  

 10 

float minimum (float x, float y) 
        { 
         if (x<y) 
               return x; 
            else 
               return y; 
        } 
       
float maximum (float x, float y) 
        { 
         if (x>y) 
               return x; 
            else 
               return y; 
        } 
 

2.6.1.

 

Przekazywanie parametrów "przez wartość" 

 
     #include <stdio.h> 
      main ( ) 
      { 
       int a=1; 
       void proba_zamiany(int); 
 
       printf("%d \n",a);         
 

 

 

 

 

 

/* drukuje si

ę

 1 */ 

       proba_zamiany (a); 
       printf("%d \n",a);  
 

 

 

 

/*jeszcze raz drukuj si

ę

 1 */  

 

 

} 

 
      void proba_zamiany (int a) 
      { 
       a=2; 
      } 

 11 

2.7.

 

Tablice 

int t[3]; 
 
 

t[0], t[1], t[2] 

 
Numeracja indeksów tablic zaczyna się od zera. 
Przykład.

 

/*********************************************** 
Program wczytuje 5 warotosci, porzadkuje je,      
 oblicza sume i wartosc srednia         

 

   

 **********************************************/ 
 #include   <stdio.h> 
 #define 

WYMIAR 5 

 main() 
   { 
     int i, j, tab[WYMIAR], sum = 0, rob; 
     printf("\n\nWprowadz %d wartosci: ", WYMIAR); 
     for (i = 0; i < WYMIAR; ++i) 
       { 
 

 

scanf("%d", &tab[i]); 

 

 

sum += tab[i]; 

       } 
     for (i = 0; i < WYMIAR - 1; ++i)  
 

 

 

/* Sortowanie babelkowe */ 

       for (j = WYMIAR - 1; j > i; --j) 
 

  if (tab[j-1] < tab[j]) 

        

 

 

 

/* Sprawdzenie porzadku */ 

 

    { 

 

     rob = tab[j-1]; 

 

     tab[j-1] = tab[j]; 

 

     tab[j] = rob; 

 

    } 

     printf("\nUporzadkowane wartosci:\n"); 
     for (i = 0; i < WYMIAR; ++i) 
       printf("     tab[%d] = %5d\n", i, tab[i]); 
     printf("\n\n%s%d\n%s%f\n", "Suma = ", sum, 
 

 

"Srednia arytmetyczna = ", 

 

 

(double) sum / WYMIAR); 

  } 

 12 

2.8.

 

Napisy 

 

Napis jest tablicą znaków. 

 
Funkcje standardowe (w <stdio.h>). 
 

Czytanie znaku z klawiatury - getchar(); 

 

Wyprowadzenie znaku na ekran - putchar(); 

 

Przykład. 

 
#include 

<stdio.h> 

#include 

<ctype.h> 

#define 

 

MAX_DL  100 

main() 
  { 
   char c, nazwa[MAX_DL]; 
   int i, sum = 0; 
   printf("\n\nNapisz swoje imie: "); 
   for (i = 0; (c = getchar()) != '\n'; ++i) 
     { 
      nazwa[i] = c; 
      if (isalpha(c)) 
 

sum += c; 

     } 
   nazwa[i] = '\0'; 
  printf("\n%s%s%s\n", "Witaj ", nazwa, " !"); 

  printf("Suma kodow liter Twojego imienia daje %d.\n"   
 

 

 

,sum); 

   printf("\n%s\n", "Zgadnii co to jest:"); 
   for (--i; i >= 0; --i) 
     putchar(nazwa[i]); 
  } 

Komentarz: 

(c = getchar()) != '\n' 
isalpha();   <ctype.h> 
nazwa[i] = '\0'; 
\0 - null  - koniec napisu 

0  1  2  3  4  5  6  7  8  9  ... 
B a r b a r a \0 

 13 

2.9.

 

Wskaźniki 

 

Wskaźnik jest  adresem objektu w pamęci. 

Przykład. 

/********************************************/ 
/* Nazwa tablicy jest wska

ź

nikiem.          */ 

/********************************************/ 
 
#include 

<stdio.h> 

#include 

<string.h> 

#define 

 

MAX_DL  100 

main() 
  { 
   char c = 'a', *w, s[MAX_DL]; 
   w = &c; 
   printf("%c%c%c ", *w, *w + 1, *w + 2); 
   strcpy(s,"ABC"); 
  printf("%s %c%c%s\n", s, *s + 6, *s + 7, s + 1); 
strcpy(s,"program pokazuje przeksztalcanienapisow"); 
   w = s + 8; 
   for ( ; *w != '\0'; ++w) 
     { 
      if (*w == 'p') 
 

    *w = 'P'; 

      if (*w == ' ') 
 

    *w = '\n'; 

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

Komentarze: 
 
Wynik działania programu: 
 
abc ABC GHBC 
program Pokazuje 
Przeksztalcanie 
naPisow 

 
   w = &c; 
 

 14 

 
   printf("%c%c%c ", *w, *w + 1, *w + 2); 
 
*w    wartosc  'a' 
*w+1           'b' 
*w+2           'c' 
 
strcpy(s,"ABC");  kopiowanie napisow <string.h> 
 
0   1  2  3  4  . . . 
A   B  C \0 
 
 
 printf("%s %c%c%s\n", s, *s + 6, *s + 7, s + 1); 
 

s       wskaźnik do s[0]  (adres bazowy tablicy)     ABC 

 

*s      wartośc     s[0]   czyli 'A'    
 

 

a wieęc   *s+6    daje 'G' 

                    *s+7         'H' 

 

s+1     arytmetyka na wskaźnikach 
    wartoscią jest wskaźnik do s[1]               BC 
 

       
 
   w = s + 8 

        równoważne    

w = &s[8];

 

 

w = s  poprawne bo  w zmienna wskaźnikowa 

     s = w  źle ,    bo s stała wskaźnikowa 
 
 

s[i]

  równoważne 

*(s + i)

 

w[i]             *(w + i) 

 

++w

    poprawne 

++s

    błędne 

 

 15 

2.10.

 

Pliki

 

#include 

<stdio.h> 

main() 
  { 
   FILE *wp; 
 
   wp = fopen("DANE.DAT","r"); 
   . . . 

 
 

Uwagi: 
1. FILE - typ standardowy zdefiniowany w <stdio.h> 
2. fopen(nazwa_pliku, tryb) - funkcja standardow <stdio.h> 
 

tryb: "r" - czytanie 

 

 

 "w" - pisanie   

 

 

 

 "a" - dołączanie 

 
 

Wartość funkcji NULL - pliku nie można otworzyć 

3. Odwołania do pliku realizuje się za pomocą zmiennej typu wskaźnik do 
FILE. 
4. Wszystkie pliki są automatyczne zamykane po zakończeniu programu. 
5. fclose() - zamknięcie pliku 
 
Przykład. 

#include  

<stdio.h> 

main() 
  { 
   int c, i, litery[26]; 
   FILE *wpd, *wpw; 
   wpd = fopen("DANE", "r"); 
   wpw = fopen("WYNIKI","w"); 
   for (i = 0; i < 26; ++i) 
     litery[i] = 0; 
   while ((c = getc(wpd)) != EOF) 
     if (c >= 'A' && c <= 'Z') 
       ++litery[c - 'A']; 
   for (i = 0; i < 26; ++i) 
     fprintf(wpw, "%c: %5d\n", 'A' + i, letter[i]); 
   putc('\n', wpw); 
  } 

 16 

3.

 

Budowa programu 

 

Program w języku C jest ciągiem znaków. 

 

Alfabet: 
 

małe litery   

a b c ... z 

 

duże litery   

A B C ... Z 

 

cyfry 

 

 

0 1 2 ... 9 

 

znaki specjalne  + - * / = ( ) [ ] { } < > ' " 

                         ! @ # $ % & _ | ^ ~ \ . , ; : ?   
     spacja (odstęp), koniec linii, znak tabulacji 
 
Proces kompilacji: 
Tekst programu w języku C  ----> grupowanie znaków w atomy 
 

 

 

 

 

  ----> tłumaczenie na kod wynikowy 

 
Atomy ANSI C: 
 

 

 

słowa kluczowe 

 

 

 

identyfikatory 

 

 

 

stałe 

 

 

 

napisy 

 

 

 

operatory 

 

 

 

separatory 

 
Reguły syntaktyczne (gramatyka języka) 
 
 

Metajęzyk  - BNF (Backus-Naur Form) 

 
Produkcja: 
 

cyfra ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 

 
 

Kategoria syntaktyczna cyfra jest równa z definicji 

0, lub 1, lub 2, ... , lub 9.  
 
Symbole używane w produkcjach: 
 

italics 

kategoria syntaktyczna 

 

::= 

 

"równe z definicji" 

 

| 

 

lub 

 

{ }

1

 

 

wybór 1 elementu z wymienionych 

 17 

 

{ }

0+

 

powtórzenie 0 lub więcej razy 

 

{ }

1+

 

powtórzenie 1 lub więcej razy 

 

{ }

op

 

opcjonalne 

 
Inne symbole są symbolami końcowymi języka. 
 
Przykłady: 
 

litera_lub_cyfra ::= litera | cyfra 

 

litera ::= mała_litera | duża_litera 

 

mała_litera ::= a | b | c | . . . | z 

 

duża_litera ::= A | B | C | . . . | Z  

 

 

 

ciąg_liter_lub_cyfr ::= { litera_lub_cyfra }

0+ 

 

    instrukcja_warunkowa ::= if (wyrażenie) instrukcja 
 

 

 

 

 

 

 

{ else instrukcja }

op

 

  
 
Słowa kluczowe: 
auto  

do   

goto   

signed 

 

unsigned 

break 

double 

if 

 

sizeof 

 

void 

case  

else  

int 

 

static  

volatile 

char  

enum 

 

long   

struc  

while 

const 

extern 

register 

switch 

continue 

float 

return 

typedef 

default 

for   

short union 

 18 

4.

 

Podstawowe typy danych 

 
Deklaracja 
 

deklaracja ::= typ identyfikator { , identyfikator }

0+

 

 

 

Podstawowe typy danych (pełny zapis): 

 
char 

 

signed char 

 

unsigned char 

signed short int   

signed int  

 

signed long int 

unsigned short int  unsigned int 

 

unsigned long int 

float 

 

double 

 

 

long double 

 

 

Podstawowe typy danych: 

 
char 

 

 

signed char 

 

unsigned char 

short 

 

 

int   

 

 

long 

unsigned short   

 

unsigned    

 

uunsigned long 

float 

 

 

double 

 

 

long double 

4.1.

 

TYPY całkowite 

 
 

 

 

 

 

( Reprezentacja w Borland C++ ) 

 
TYP char 
 
typ   

 

 

ilość bitów 

 

zakres 

--------------------------------------------------------------------------------------- 
unsigned char   

 

8 

 

 

0 do 255 

char, signed char 

 

8 

 

 

-128 do 127 

 

 

 
 
Przykład: 

 

char c = 'a'; 

 

printf("%c",c);  

/* drukuje sie a */ 

 

printf("%d",c); /* drukuje si

ę

 97 */ 

 
 
 

 19 

typ   

 

 

 

ilość bitów 

 

zakres 

---------------------------------------------------------------------------------- 
short, int 

 

 

 

16 

 

 

-32768 do 32767 

unsigned short, unsigned        16 

 

 

0 do 65535 

long 

 

 

 

32 

 

 

-2,147,483,648 do 

 

 

 

 

 

 

 

 

 2,147,483,647 

unsigned long 

 

 

 

32 

 

 

0 do 4,294,967,295 

 
 
Przykład: 

#define  

BIG 

2000000000 

main() 
{ 
 int a, b = BIG, c = BIG; 
 a = b + c;  

 

?* przekroczenie zakresu */ 

} 
 

Przykłady stałych: 
 

32000  

stała typu int 

 

320000 

stała typu long int 

 
 
 
Kwalifikator 

 

 

typ   

 

stała 

----------------------------------------------------------------------- 
u lub U 

 

 

unsigned   

 

37U 

l lub L 

 

 

long                   

37L 

ul lub UL 

 

 

unsigned long   

37UL 

 
 

 20 

4.2.

 

Typy zmiennoprzecinkowe 

 
typ   

ilość bitów 

 

zakres  

 

 

precyzja 

--------------------------------------------------------------------------------------- 
float 

32   

3.4*10^-38 do 3.4*10^38   

 

7 cyfr  

double 

64   

1.7*10^-308 do 1.7*10^308 

 

15 cyfr 

long double 

80   

3.4*10^-4932 do 1.1*10^4932   

19 cyfr 

 
 
Stała zmiennoprzecinkowa 
    - liczba zawierająca kropkę lub literę e lub E. 
 
Przykład: 
12.345 

3.   0.53   

2.34e-4 

2.5E3 

 
Uwaga: 
 

stała zmiennoprzecinkowa jest typu double 

 
Kwalifikator 

 

 

typ   

 

stała 

-------------------------------------------------------------------------- 
f lub F 

 

 

float  

 

 

3.7F 

l lub L 

 

 

long double 

 

3.7L 

Operator sizeof 
 
 

sizeof(obiekt) - ilość bajtów zajmowanych przez obiekt 

 
Przykład: 
 

sizeof(char) = 1 

 
 
FUNKCJE MATEMATYCZNE 

<math.h> 

 
sqrt() 

pow() 

exp() log() sin() cos() tan() 

 21 

Konwrsja typów 

 
Każde wyrażenie arytmetyczne nma wartość i typ 
 
Automatyczna konwersja typów wyrażenia 
 

x op y 

 
1. Typy char, short, signed char, unsigned char są zamieniane na typ 
int. 
 
2. Jezeli typy nadal nie są zgodne to typ niższy zamienia się na typ 
wyższy zgodnie z hierarchi_ typów: 
int < unsigned < long < unsigned long < float < double < long double 
 
Przykład: 
 

char c;  

double d; 

float f; 

int i;  

 

long l; 

short s;  unsigned u; 

 
c - s / i 

 

- int 

u * 2.0 - i   

- double 

c + 3 

 

- int 

c + 5.0 

 

- double 

u * 7 - 1 

 

- unsigned 

7 * s * l  

- long 

d + s 

 

- double 

 

4.2.1.

 

Rzutowanie 

 
Wymuszenie konwersji typów: 
 

(typ) wyrażenie 

 
Przykład: 
 

(double) i 

 

(long) ('A' + 1.0) 

 

x = (float) ((int) y + 1) 

 

(double) (x = 77) 

 

(float) i + 3 

 

 22 

4.3.

 

Stałe szesnastkowe i ósemkowe 

 
Cyfra szesnastkowa   

wartość dziesi_tna 

 

0 

 

 

 

 

0 

 

1 

 

 

 

 

1 

 

2 

 

 

 

 

2 

 

. . . 

 

9 

 

 

 

 

9 

 

A 

 

 

 

 

10 

 

B 

 

 

 

 

11 

 

C 

 

 

 

 

12 

 

D 

 

 

 

 

13 

 

E 

 

 

 

 

14 

 

F 

 

 

 

 

15 

 
 

h

n

h

n-1

 . . .h

1

h

0 

  
 

h

n

*16

n

 + h

n-1

*16

n-1

 + . . .+ h

1

*16 + h

0

 

 
0xA0F3C 

 

 

688260 

0x2A 

 

 

 

2*16 + 10 = 42 

0xB3 

 

 

 

B*16 + 3 = 11*16 + 3 = 179 

0x113 

 

 

1*16

2

 + 1*16 + 3 = 275 

 
 

 23 

5.

 

Operatory  

Priorytety operatorów: 
------------------------ 
1. ()  [] 

 

 

 

 

 

 

 

 

 

LP 

2. ++ ~ 

--  ! 

sizeof 

(typ)  

 

jedn.arg.(*, -) 

*(wsk) 

&(adres)   

 

 

 

PL 

3.  * 

/ 

% 

 

 

 

 

 

 

 

LP 

4.  +  

- 

 

 

 

 

 

 

 

 

LP 

5.  << 

>>   

 

 

 

 

 

 

 

LP 

6.  < 

<=  > 

>=   

 

 

 

 

 

LP 

7.  == 

!=   

 

 

 

 

 

 

 

LP 

8.   & 

 

 

 

 

 

 

 

 

 

LP 

9.  ^ 

 

 

 

 

 

 

 

 

 

LP 

10.  | 

 

 

 

 

 

 

 

 

 

LP 

11.  && 

 

 

 

 

 

 

 

 

 

LP 

12.  || 

 

 

 

 

 

 

 

 

 

LP 

13.  ?: 

 

 

 

 

 

 

 

 

 

PL 

14.  = 

+=  -= 

/=   itp. 

 

 

 

 

 

PL 

15   , (operator przecinkowy) 

 

 

 

 

 

 

LP 

 

5.1.

 

Operatory relacji, operatory logiczne 

 
1-arg (+ i -)  ++  --  !   

 

p -> l 

*   /  % 

 

 

 

 

 

l -> p 

+  -   

 

 

 

 

 

l -> p 

<  <=  >  >= 

 

 

 

 

l -> p 

==  != 

 

 

 

 

 

l -> p 

&&  (and) 

 

 

 

 

 

l -> p 

|| 

(or) 

 

 

 

 

 

l -> p 

=  +=  -=  *=  /=   

 

 

p -> l 

 
 
 
Przykład: 

char c = 'w'; 
int i = 1, j = 2, k = -7; 
double x = 7e+33, y = 0.0001; 
 

 24 

'a' + 1 < c

   

 

 

 

1 

-i - 5*j >= k+1

  

 

 

0 

((-i) - (5*j)) >= (k+1) 

3 < j < 5

 

 

 

 

 

1 

j = 4

 

 

 

 

 

1 

j = 7

 

 

 

 

 

1 

 
Przykład. 

char c = 'A'; 
int i = 7, j = 7; 
double x = 0.0, y = 2.5; 
 

!c

   

 

 

 

 

0 

!(i - j)

 

 

 

 

 

1 

!i - j 

 

 

 

 

-7 

!!(x+y) 

 

 

 

 

1 

5.2.

 

Operatory zwiekszanie i zmmiejszania 

++i;          i=i+1;         - -i;     i=i-1; 
 
++zm     

- -zm 

 

przed wyrażeniem 

     zm++        

    zm- -   

po wyrażeniu 

 
h=5; 
x=h++;   5 
x=++h;   6 

 

5.3.

 

Operatory Bitowe 

 
Logiczne: 
 

~ - negacja 

 

& - koniunkcja 

 

^ - różnica symetryczna 

 

| - alternatywa 

 
Przesunięcie: 
 

>> - w prawo 

 

<< - w lewo 

 

 25 

 
  
 
 
 
 
 

5.3.1.

 

Uzupełnienie jedynkowe 

 
long 

a = 70707; 

 
 

00000000 00000001 00010100 00110011 

 

~a 

 

11111111 11111110 11101011 11001100 

 

5.3.2.

 

Bitowe operatory logiczne 

 
 

a 

b 

a&b  a^b  a|b 

 

------------------------ 

 

0 

0 

0 

0 

0 

 

1  

0 

0 

1 

1 

 

0 

1 

0 

1 

1 

 

1 

1 

1 

0 

1 

 
long 

a = 33333, b = -77777; 

 
a 

00000000 00000000 10000010 00110101 

b 

11111111 11111110 11010000 00101111 

a&b 00000000 00000000 10000000 00100000 
a|b  11111111 11111110 11010010 00111111 
a^b  11111111 11111110 01010010 00011010 
 

5.3.3.

 

Operatory przesuwania 

 

wyr1 op wyr2 

 
char c = 'Z'; 
 
c 

 

01011010 

 26 

c << 1 

10110100 

cc>>1 

01011010 

 
x << y       mnożenie  x*2

y 

x >> y       dzielenie   x / 2

y 

 

 
 

 27 

6.

 

Instrukcje 

6.1.

 

Instrukcja złożona 

 
instrukcja_złożona ::= { { deklaracje }

0+

 

 

 

 

 

 

{instrukcje }

0+

 } 

 
{ 
 

int a; 

 
 

a = b; 

  

. . . 

} 
 

6.2.

 

Instrukcja pusta 

 

; 

6.3.

 

Instrukcja warunkowa 

 

if ( wyrażenie1 ) 

 

if ( wyrażenie2 )   

 

 

 

{ 

 

 

instrukcja1 

 

else  

 

 

 

instrukcja2   

 

 

 

} 

 
else wiąże się z najbliższym if   

 

 

 

6.4.

 

Instrukcje iteracyjne 

 

while ( wyrażenie ) instrukcja 

 

for (wyr1; wyr2; wyr3) 

 

instrukcja 

 

do instrukcja while ( wyrażenie ) 

 

do 
  { 

 28 

   sum +=i; 
   scanf("%d", &i); 
   }  while (i > 0); 

6.5.

 

Instrukcja Skoku 

goto etykieta 

etykieta ::= identyfikator: 
Przykład 

goto dalej: 
koniec : exit(1); 
dalej: 
while(1) 
{ 
if(i++>10) goto koniec; 
printf("%3d",i); 
} 

6.6.

 

Instrukcje strowania petlą 

break  

-    przerwanie działania pętli 

continue 

-   kontynuacja od początku pętli 

while(1) 
{ 
 

if(i++>10) break; 

 

printf("%3d",i); 

} 
void main() 
{ int x,y; 
for(;;)  { 
   printf("Podaj dwie liczby (0 0 by zakonczyc)"); 
   scanf("%d%d",&x,&y); 
   if(!x&&!y)break; 
   printf("%3d + %3d = %6d\n",x,y,x+y); 
   printf("%3d - %3d = %6d\n",x,y,x-y); 
   printf("%3d * %3d = %6d\n",x,y,x*y); 
   if(!y)continue; 
   printf("%3d / %3d = %6d\n",x,y,x/y); 
 } 
} 
void main() 
{ int x,y,c;   char s[500]="",*w; 
 w=s; 

 29 

for(x=0;x<10;x++) 
  for(y=0;y<50;y++) { 
  c=getchar();   if(c=='\n') break;  
  *w++=c; 
 } 
 w='\0';  printf(s); 
} 

6.7.

 

Instrukcja  wyboru 

instrukcja _switch   ::= switch(wyrażenie_skoku)  
 istrukcja_wyboru | instrukcja_domyślna |  blok_przełączeniowy
 

 

instrukcja_wyboru  ::= / case stała_składowa : /1+  instrukcje 
instrukcja_domyslna 

::= default: instrukcje 

blok_przełączeniowy::= { /grupa_wyboru /0+ 
 

       /grupa_domyślna /opt 

 

} 

grupa_wyboru  ::= / case stała_składowa : /1+   

/instrukcje/1+  

Grupa_domyślna  ::= default:  /instrukcje/1+ 
**************************************** 

switch(x) 
{ case 0:break; 
  case 2:printf("bardzo "); 
  case 1:printf("powazny "); 
  default:printf("blad\n"); 
} 
************************************** 
switch(c) 
{ 
        case '+':w=a+b;break; 
        case '-':w=a-b;break; 
        case '*':w=a*b;break; 
        case '/':if(b) {e=1;break;} 
                 w=a/b;break; 
       default:e=2; ; 
} 
 switch(e){ 
 case 0: printf("%d %c %d = %d\n",a,c,b,w);break; 
 case 2: printf(" Blad operatora");break; 
 case 1: printf( 

 30 

 

 

" Blad dzialenia przez zero");break; 

 default: printf(" Nieznany blad ");break; 
} 

6.8.

 

Operator przecinkowy 

 

wyrażenie_przecinkowe ::= wyrażenie , 

wyrażenie 

 
Uwagi: 
1. najniższy priorytet 
2. od lewej do prawej 
3. wartością jest ostatnie wyrażenie 
 

or (sum = 0, i = 1; i <= n; sum += i, ++i) 
 

 

; 

 
Przykłady: 

int i,j,k = 3; 
double x = 3.3; 
 
i = 1, j = 2, ++k+1 
 

(((i=1),(j=2)),((++k)+1) 

 

 

5 

 
k != 1, ++x*2.0+1 
 

((k != 1), (((++x)*2.0)+1)  

9.6 

 

 31 

7.

 

Funkcje 

 
Funkcja jako realizacja dekompozycyjnej metody rozwiązywania 
problemów zgodnie z Regułami programowania strukturalnego. 
 
Program w języku C składa się z jednego lub więcej plików.  
Każdy z nich może zawierać zero lub więcej funkcji.  
Jedną z tych funkcji jest funkcja main. 
Funkcje nie mogą być zagnieżdżane. 
Działanie programu zaczyna się od funkcji main. 
 
 

7.1.

 

Definicja funkcji 

 

 

typ nazwa_funkcji(listałparametrów) 

 

  { 

        deklaracje 
 

   instrukcje 

 

  } 

 

Przykłady: 

 

int potega(int n) 

 

  { 

        int i, p = 1; 
 
 

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

 

     p *= i; 

        return p; 
 

  } 

 

void nic(void) 

 

  { 

       } 
 
 

double podwojenie(double a) 

 

  { 

        return (2.0 * a); 
       } 
 

 32 

 

int dodaj(int a, int b) 

 

  { 

 

   int c; 

 
 

   . . . 

 

   return(a + b + c); 

 

  } 

 
Uwaga: 
 
 

Jeżeli  w  definicji  funkcji  nie  występuje  określenie  typu,  to 

funkcja jest typu 

int

. 

 
 

Zmienne zadeklarowane wewnątrz funkcji są lokalne (istnieją 

tylko  w  tej  funckcji).  Inne  zmienne  używane  w  funkcji  są 
zmiennymi globalnymi. 
 
 

#include 

<stdio.h> 

 
int a = 33;  

/* zmienna globalna */ 

 
 
main() 
  { 
   int b = 77;  

/* zmienna lokalna */ 

 
   printf("%d %d\n", a, b); 
  } 

 
 

 33 

7.2.

 

Instrukcja return 

 

 

instrukcja_return ::= return; | return 

wyrażenie ; 

 
 
Przykłady: 

 

return; 

 

return ++a; 

 

return (a + b); 

 
Uwaga: 

 

Wyrażenie po return może być ujęte w nawiasy. 

 

Wykonanie  instrukcji  return  powoduje  zakończenie  działania 
funkcji i przekazanie sterowania do instrukcji wywołującej daną 
funkcję.  

 

Jeżeli instrukcja return zawiera wyrażenie, to wartość tego  

 

wyrażenia 

jest 

przekazywana 

również 

do 

instrukcji 

wywołującej. 

 

Jeżeli zachodzi potrzeba, to typ wartości jest zamieniany na typ 
zgodny z typem funkcji. 

 

Brak  instrukcji  return  w  funkcji  powoduje  zakonczenie  jej 
działania po napotkaniu znaku końca funkcji tj. } . 

 
Przykład. 

 

double wartosc_bezwzgledna(double x) 

 

  { 

 

   if (x >= 0.0) 

 

 

return x; 

 

   else 

 

 

return -x; 

       } 

 34 

7.3.

 

Prototyp funkcji 

 

 

typ  

nazwa_funkcji (listałtypów_parametrów) 

 
Przyklady: 

 

double sqrt(double); 

 

void f(char c, int i); 

 

 

 

 

 

równoważne 

 

void f(char, int); 

7.4.

 

Wywołanie funkcji 

 
Wywołanie funkcji zawiera nazwę funkcji i listę parametrów aktualnych. 
 
Po wywołaniu funkcji następuje: 
1. Obliczne są wartości wyrażeń reprezentujących parametry aktualne. 
2. Typy obliczonych wartości wyrażeń są zamieniane na typy parametrów 
formalnych zgodnie z deklaracją funkcji. 
3. Wykonywana jest treść funkcji. 
4. Po napotkaniu instrukcji return lub znaku końca funkcji sterowanie 
powraca do miejsca wywołania funkcji. 
 
Uwaga. 

 

 

Parametry funkcji są przekazywane przez wartość. 

 
 

 35 

7.5.

 

Reguły zasłaniania 

 
 

Identyfikatory lokalne zasłaniają identyfikatory globalne. 

 
Przykłady. 

 

{ 

 

 int a = 1, b = 2, c = 3; 

 

  printf("%d %d %d\n", a, b, c); 

/* 1 2 3 */ 

       a = b; 
 

   { 

         int b = 4; 
         float c = 5.0; 
       printf("%d %d %f\n", a, b, c); /* 1 4 5.0 */ 
         a = b; 
          { 
           int c; 
 
           c = b; 
 

    printf("%d %d %d\n", a, b, c); /* 4 4 4 */ 

          } 
   printf("%d %d %f\n", a, b, c);  

/* 4 4 5.0 */ 

        } 
 printf("%d %d %d\n", a, b, c); 

 

/* 4 2 3 */ 

    

} 

    
     { 
 

 int a,b; 

 

 

. . . 

 

   { 

         float b; 
 

 

. . . 

 

   } 

 

 

. . . 

 

   { 

         float a; 
 

 

. . . 

 

   } 

 

  . . . 

 

}    

 36 

7.6.

 

Rodzaje zmiennych 

 
 

Zmienne w języku C posiadają dwa atrybuty: typ i rodzaj. 

 
Słowa kluczowe określające rodzaj zmiennej: 
 

auto 

 

extern 

 

register   

static 

 
 

7.6.1.

 

Rodzaj auto (zmienne automatyczne) 

 
 

Zmienne zadeklarowane wewnątrz funkcji lub bloku są rodzaju auto, 

chba że ich rodzj został określony w deklaracji. (Słowo auto można 
opuszczać). 
 
 

Zmienne tego rodzaju istnieją tylko w czasie wykonywania funkcji 

lub bloku w którym zostały zadeklarowane. 
 
 

7.6.2.

 

Rodzaj extern (zmienne zewnętrzne) 

 
 

Zmienne zadeklarowane poza funkcjami są rodzaju extern. (Słowo 

extern można opuścić). Zmienne te są zmiennymi globalnymi. 
 
Użycie słowa kluczowego extern w deklaracji zmiennej oznacza 
poszukiwanie zmiennej o tej samej nazwie w całym programie (nawet w 
innych plikach). 
 
Przykład. 
 

Plik p1.c: 

 

#include <stdio.h> 

 

int a = 1, b = 2, c = 3; 

 

int f(void); 

 
 

main() 

 

  { 

 

     

printf("%3d\n", f()); 

 

 

printf("%d %d %d\n", a, b, c); 

     } 

 

Plik p2.c: 

 37 

 

 

intf(void) 

 

 

  { 

 

 

   extern int a; 

 

 

   int b, c; 

 
 

 

   a = b = c = 4; 

 

 

   return (a + b + c); 

 

 

  } 

 
Uwaga. 
 

Użycie  zmiennych  globalnych  może  powodować  efekty 

uboczne działania funkcji. 
 
 
Wszystkie funkcje są funkcjami zewnętrznymi. 
 
 

7.6.3.

 

Rodzaj register (zmienne rejestrowe) 

 
 

Słowo kluczowe register sugeruje kompilatorowi aby umieścić daną 

zmienną w rejestrze procesora. Czas dostępu do zmiennych rejestrowych 
jest najkrótszy. 
 
Przykład. 
 

{ 

 

 register int i; 

 
 

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

 

 

. . . 

   

} 

 
Uwaga. 
 

register i; jest równoważne register int i; 

 
 

 38 

7.6.4.

 

Rodzaj static (zmienne statyczne) 

 
 

Użycie w deklaracji zmiennej słowa static powoduje: 

 
1.   Dla zmiennej lokalnej - zachowanie wartości przy ponownym wejsciu 

do funkcji lub bloku, w którym ta zmienna jest zadeklarowana. 
 

2.   Dla zmiennych globalnych - ograniczenie zakresu danej zmiennej 

zewnętrznej od miejsca zadeklarowania do końca danego pliku. 

 
Przykłady: 

 

void f(void) 

 

  { 

 

   static int licz = 0; 

 
      ++licz; 
 

   if (licz % 22 == 0) 

 

 

. . . 

 

   else 

 

 

. . . 

 

  } 

 
 
 

void f(void) 

 

  { 

 

 

. . . 

 

  } 

 
 

static int i; 

 
 

void g(void) 

 

  { 

 

 

. . . 

 

  } 

 
Uwaga. 
 

Można deklarować rodzaj funkcji jako static ograniczając jej zakres 

do jednego pliku. 

 39 

7.7.

 

Inicjowanie zmiennych 

 
 

Zmienne rodzaju extern i static są automatycznie inicjowane na 

wartość 0, chyba że w zostały zainicjowane w programie. 
 

Zmienne rodzaju auto i register nie są inicjowane. 

 

7.8.

 

Rekurencja 

 

Funkcja jest rekurencyjne, jeżeli w jej treści występuje wywołanie tej 

samej funkcji. 

 

Przykład. 
int sum(int n) 
  { 
   if (n <= 1) 
     

return n; 

   else 
 

return (n + sum(n-1)); 

  } 
 
sum(1)  

 

 

 

 

 

1 

sum(2) 

2 + sum(1)  

 

3 

sum(3) 

3 + sum(2) = 3 + (2+sum(1)) 6 

 
#include  

<stdio.h> 

main() 
  { 
   void pisz(void) 
   printf("Wprowadz tekst: "); 
   pisz(); 
   printf("\n\n"); 
  } 
void pisz(void) 
  { 
   int c; 
   if ((c = getchar()) != '\n') 
     pisz(); 
   putchar(c); 
  } 

 40 

8.

 

Tablice 1-wymiarowe 

 
int a[rozmiar]; 

/* a[0], a[1], ... , a[rozmiar-1] */ 

 
 

8.1.

 

Inicjowanie tablic 

 

inicjalizator_tablcy_jednowym ::= { 
listałinicjatorów } 
listałinicjatorów ::= inicjator {, inicjator}

0+

 

inicjator ::= wyrażenie 

 
float f[5] = { 0.0, 1.0, 2.0, 3.0, 4.0 };  
 
Jeżeli lista inicjatorów jest krótsza od ilości elementów tablicy, to 
pozostale elementy tablicy są inicjowane na wartość 0. 
int a[100] = {0}; 
 
Niezainicjowane tablice rodzaju extern lub static są automatycznie 
inicjowane na wartość 0. 
 
Tablica zadeklarowana bez podania rozmiaru a zainicjowana ma ilość 
elementów równą ilości inicjatorów. 

int a[] = { 2 , 3, 5, -7}; 

 

 

 

 

równoważne 

int a[4] = { 2, 3, 5, -7}; 
 
char s[] = "abc"; 
char s[] = {'a', 'b', 'c', '\0'}; 

 

8.2.

 

Indeksowanie 

 
 

a[wyrażenie]  

 
Zakres indeksów tablicy nie jest kontrolowany. 
 

 41 

8.3.

 

Wskaźniki 

 
 

x - zmienna   

&x - adres zmiennej 

 

int *p, i; 
 
 

p = 0; 

 

p = NULL;    

/* równowa

ż

ne p = 0; */ 

 

p = &i; 

 

p = (int *) 1776;   /* adres bezwzgl

ę

dny */ 

 
 
int a = 1, b = 2, *w; 
 
a   

 

b 

 

w 

 
  1 

 

 

  2  

   ----------> 

 
 
 

p = &a; 

a   

 

b 

 

w 

 
  1 

 

 

  2  

   ----------> 

 
 

b = *p; 

 

 

równowa

ż

ne 

 

b = a; 

 

Przykład. 

#include  

<stdio.h> 

 
main() 
  { 
   int i = 7, *w; 
 
 

w = &i; 

 

printf("%s%d\n%s%u\n", 

 

 

"Wartosc i : ", *w, 

 

 

"Adres i   : ", w); 

  } 

 42 

 
Zmienne wskaźnikowe mogą być inicjowane. 

 

int i, *w = &i; 

 
Przykłady. 

 

int i = 3, j = 5, *p = &i, *q = &j, *r; 

 

double w; 

 
p == &i 
 

 

p == (&i)   

 

 

 

 

 

 

 

 

 

 

 

 

1 

 
* * & p 
 

 

* (* (& p)) 

 

 

 

 

 

 

 

 

3 

 
r  = & x 
 

 

r = (& x)   

 

 

 

 

 

 

 

 

bł

ą

d 

 
7 * * p / * q + 7 
 

 

((7 * (* p)) / (* q)) + 7 

 

 

 

 

 

 

 

 

11 

 
* (r = & j) *= * p 
 

 

(* (r = (& j))) *= (* p)   

 

 

 

 

 

 

 

 

15 

 

 

 

Uwaga. 
W ANSI C konwersja typów wskaźnikowych jest niedozwolona, chyba że 
jednym z typów jest typ void *  lub  prawym argumentem stała 0. 
int *p;  

float *q;   

void *v; 

 Poprawne 

 

 

 

 

 

Błędne 

p = 0; 

 

 

 

 

 

p = 1; 

p = (int *) 1;  

 

 

 

v = 1; 

p = v = q;   

 

 

 

p = q; 

p = (int *) q; 

 

 43 

Operatora adresowania & nie wolno stosować do: 
  

- stałych 

 

 

 

 

&3 

 

- nazw tablic (nazwa tablicy jest stałą) 

 

 

 

int a[77]; 

 

 

 

&a 

 

- wyrażeń 

 

 

 

&(k + 99) 

 

- zmiennych rodzaju register 

 

 

 

register v; 

 

 

 

&v 

 
Operator adresowania może być użyty do elementu tablicy: 

 

&a[0] 

 

&a[i+j+3] 

 

8.4.

 

Przekazywanie parametrów przez referencję 

 
#include  

<stdio.h> 

void zamien(int *p, int *q) 
  { 
   int rob; 
 

rob = *p; 

 

*p = *q; 

 

*q = rob; 

  } 
 
main() 
  { 
   int i = 3, j = 5; 
   void zamien(int *, int *); 
 
 

zamien(&i, &j); 

 

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

 

/* 5 3 */ 

  } 

 
Aby osiągnąć efekt przekazania parametru przez referencję należy: 
1. Zadeklarować parametr funkcji jako wskaźnik. 
2. W treści funkcji użyć wartości wskazywanej przez wskaźnik. 
3. Przekazać w wywołaniu jako argument adres. 

 44 

8.5.

 

Tablice a wskaźniki 

 
Nazwa tablicy reprezentuje adres. 
Wskaźniki można indeksować. 
 

 

a[i] 

 

równoważne

 

 

*(a + i) 

 

p[i]  

 

 

 

 

*(p + i) 

 

Przykład. 

#define  

N  100 

 
int a[N], i, *p, sum = 0; 
 

p = a; 

 

rówoważne

 

 

p = &a[0]; 

 
p = a + 1;   

 

 

p = &a[1]; 

 
for (p = a; p < &a[N]; ++p) 
 

sum += *p; 

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

sum += *(a + i); 

 
p = a; 
for (i = 0; i < N; ++i) 
 

sum += p[i]; 

 

Wyrażenia niepoprawne: 

 

a = p 

++a 

 

a += 2  &a 

 
 

8.6.

 

Arytmetyka na wskaźnikach 

 

double a[2], *p, *q; 
p = a; 
q = p + 1;   

 

 

 

 

/* q = &a[1] */ 

printf("%d\n", q-p); 

 

 

 

/* 1 */ 

printf("%d\n", (int) q - (int) p);  

/* 8 */ 

 

 45 

8.7.

 

Tablice jako parametry funkcji 

 
Tablice przekazuje się jako parametry w postaci wskaźników. 
 

double sum(double a[], int n) 
  { 
   int i; 
   double sum = 0.0; 
 
 

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

 

  sum += a[i]; 

 

return sum; 

  } 
 

 

 

 

lub 

double sum(double *a, int n) 
  { 
    . . . 
 

Przykłady wywołań:

 (double v[100]) 

sum(v, 100)  

v[0]+v[1]+...+v[99] 

sum(v,88) 

 

 

V[0]+V[1]+...+V[87] 

sum(&v[7],k-7)  

v[7]+v[8]+...+v[k-1] 

sum(v+7, 2*k)   

v[7]+v[8]+...+v[2*k-6] 

 

8.8.

 

Napisy 

 
char *p = "abc"; 
 
printf("%s %s\n", p, p+1);  
 

 

 

 

/* wydrukuje sie abc bc */ 

 

 

 

"abc"[1] 

 

*("abc" +2)  - wyra

ż

enia poprawne 

 
char *p = "abcde";  

 

char s[] = "abcde"; 

 
p   

 

 

 

 

s 

 

  a b c d e \0   

 

a b c d e \n 

 
 
Przykład. 

 46 

/* Zliczanie słów w napisie */ 
 
#include 

<ctype.h> 

 
int licznik_slow(char *s) 
  { 
   int licz = o; 
 
 

while (*s != '\0') 

 

  { 

 

   while (isspace(*s))  /* pomijanie spacji */ 

 

 

++s; 

 

   if (*s != '\0')   

/* znaleziono słowo */ 

 

 

{ 

 

 

 ++licz; 

 

 

 while (!isspace(*s) && *s != '\0') 

 

 

 

++s; 

 

/* akceptowanie słowa */ 

    

} 

 

  } 

 

return licz; 

  } 

 
 

8.8.1.

 

Przetwarzanie napisów  

 #include <string.h> 

 
char *strcat(char *s1, const char *s2); 
 

Konkatenacja napisów s1 i s2. Wynikiem jest napis s1. 

 
int strcmp(const char *s1, const char *s2); 
 

Porównywanie napisów w porządku leksykograficznym. Wartością 

funkcji jest liczba ujemna jeżeli napis s1 poprzedza napis s2, zero gdy 
napisy są identyczne, lub liczba dodatnia (napis s2 jest wcześniejszy niż 
s1). 
  
char *strcpy(char *s1, const char *s2); 
 

Kopiowanie napisu s2 do s1. 

 

 47 

unsigned strlen(const char *s); 
 

Wartością funkcji jest liczba znaków napisu s. 

 
 

unsigned strlen(const char *s) 
  { 
   register int n; 
 

 

 

for (n = 0; *s != '\0'; ++s) 

 

 

++n; 

 

return n; 

  } 
 
 
char *strcat(char *s1, const char *s2) 
  { 
   register char *p = s1; 
 
 

while (*p) 

 

 

++p; 

 

while (*p++ = *s2++) 

 

 

; 

 

return s1; 

  } 

Przykłady. 

char 

s1[50] = "duzy ladny sloneczny dom", 

 

s2[] = "maly pokoj"; 

 
strlen(s1);  

 

 

 

 

24 

strlen(s2 + 5); 

 

 

 

 

5 

strcmp(s1, s2); 

 

 

 

 

warto

ść

 ujemna 

 
printf("%s",s1 + 11);   

 

sloneczny dom 

 
strcpy(s1 + 5, s2 +5); 
strcat(s1," bez okien"); 
printf("%s",s1); 

 

 

 

duzy pokoj bez okien 

 48 

9.

 

Tablice wielowymiarowe 

 

 

int a[100];  

/* 100 elementów */ 

 

int b[2][7]; 

 

/* 14 elementów */ 

 

int c[5][3][2]; /* 30 elementów */ 

 

 

Tablice są lokowane w spójnych obszarach pamięci. 

 

9.1.

 

Tablice 2-wymiarowe 

 

int a[3][5]; 

 
 

 

kol.1 

kol.2 kol.3 kol.4 kol.5 

w.1  

a[0][0] 

a[0][1] 

 

 

 

 

a[0][4] 

w.2  

a[1][0] 

a[1][1] 

 

 

 

 

a[1][4] 

w.3  

a[2][0] 

a[2][1] 

 

 

 

 

a[2][4] 

 

 

Wyra

ż

enia równowa

ż

ne do a[i][j]: 

 

 

*(a[i] + j) 

 

 

(*(a + i))[j] 

 

 

*((*(a +i)) + j) 

 

 

*(&a[0][0] + 5*i + j) 

Uwaga. 
a oznacza 

&a[0],

 a nie 

&a[0][0]

 

 
Jeżeli parametrem formalnym funkcji jest tablica wielowymiarowa, to 
muszą być podane wszystkie wymiary za wyjątkiem pierwszego. 
 
Przykład. 

int sum(int a[][5]) 
  { 
   int i, j, sum = 0; 
 

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

 

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

 

 

sum += a[i][j]; 

 

return sum 

  } 
 
int a[][5]  int (*a)[5] 

int a[3][5] 

 49 

9.2.

 

Tablice 3-wymiarowe 

 

 

int a[7][9][2]; 

 
a[i][j][k]   

*(&a[0][0][0] + 9*2*i + 2*j +k) 

 
int sum(int a[][9][2]) 
  { 
   int i, j, k, sum = 0; 
 

 

 

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

 

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

 

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

 

 

sum += a[i][j][k]; 

 

return sum 

  } 
 
int a[][9][2]   

int (*a)[9][2]  

int 

a[7][9][2] 
 
INICJALIZACJA TABLIC WIELOWYMIAROWYCH 
 
int a[2][3] = {1, 2, 3,  4, 5, 6}; 
int a[2][3] = {{1, 2, 3}, {4, 5, 6}}; 
int a[][3] = {{1, 2, 3}, {4, 5, 6}}; 
 
int a[2][2][3] = { 
 

 

{{1, 1, 0}, {2, 0, 0}}, 

 

 

{{3, 0, 0}, {4, 4, 0}} 

 

 

 

  }; 

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

int a[2][2][3] = {0}; - 

zerowanie

 

 50 

9.3.

 

Tablice wskaźników 

9.4.

 

Nierówne tablice 

 
 
#include 

<stdio.h> 

 
main() 
  { 
   char a[2][15] = {"abc","defgh"}; 
   char *p[2] = {"abc","defgh"}; 
 
  

. . . 

 

9.5.

 

Funkcje jako argumenty 

 

 

(k)

f

2

n

m

=

k

∑

 

 
 

k

1

=

f(k)

 

 
 

(k)

=

f(k)

sin

 

 

double sum_kw(double f(double), int m. int n) 
  { 
   int k; 
   double sum = 0.0; 
 
 

for (k = m; k <= n; ++k) 

 

  sum += f(k) * f(k); 

 

return sum; 

  } 
 

równoważnie 

 
double sum_kw(double (*f)(double), int m, int n) 
  { 
    . . . 

ale 

 51 

 

double *f(double); 
sum += f(k) * f(k)  albo  sum += (*f)(k) * (*f)(k) 

 
 

f - wskaźnik do funkcji 

 

*f - sama funkcja 

 

(*f)(k) - wywołanie funkcji 

 
Wywołanie. 
 

#include 

<stdio.h> 

 
main() 
  { 
   double f(double), g(double), 
      

sum_kw(double (*)(double), int, int); 

 
 

printf("funkcja f: %.7f\n", sum_kw(f,1,10000); 

     printf("funkcja sinus: %.7f\n", 
sum_kw(sin,2,15); 
  } 
 
double f(double x) 
  { 
   return 1.0 / x; 
  } 

 
 

 52 

10.

 

Argumenty main 

 

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

argc  

- ilość argumentów (argc >= 1) 

argv[0]   - nazwa programu  

( w MS DOS z pełną nazwą ścieżki  
    całość pisane wielkimi literami ) 

env 

 - zmienne środowiskowe 

 

 

 53 

11.

 

Definiowanie typów 

 
typedef 

char * string; 

typedef 

int 

 

CAL, STOPA, YARD; 

typedef 

float  wektor[10]; 

typedef 

double (*WFD)(double); 

 

 

 

 /* wsk. do funk. double */ 

 
CAL  

dl, szer; 

string  

s1 = "abc", s2="xyz"; 

wektor  

x; 

 

 

 

float x[10]; 

WFD  

f; 

 

 

 

double (*f)(double); 

 
#define 

N  3 

 
typedef 

double  

scalar; 

typedef 

scalar wektor[N]; 

typedef  

scalar tablica[N][N]; 

 

 

 

 

/* lub typedef wektor 

tablica[N]; */ 
 
void dodaj(wektor x, wektor y, wektor z) 
  { 
   int i; 
 

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

 

 

z[i] = x[i] + y[i]; 

  } 
 
scalar il_skal(wektor x, wektor y) 
  { 
   int i; 
   scalar sum = 0.0; 
 
 

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

 

 

sum += x[i] * y[i]; 

 

return sum; 

  } 
void mnm(tablica a, tablica b, tablica c) 

 54 

  { 
   int i, j, k; 
 
 

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

 

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

 

    { 

         

a[i][j] = 0.0; 

 

 

for (k = 0; k < N; ++k) 

 

 

  a[i][j] += b[i][k] * c[k][j]; 

         } 
  } 

 
 

 55 

12.

 

Struktury 

 

deklaracja_struktury ::= 
specyfikacja_struktury 
                               listałdeklaratorów; 
specyfikacja_struktury ::= struct nazwa | 
 

struct nazwa

op

 { { deklaracja_pola }

1+

 } 

nazwa ::= identyfikator 
deklaracja_pola ::= typ listałdeklaracji; 
listałdeklaratorów ::= deklarator {, deklarator 
}

0+

 

 
 

struct karta 
  { 
   int wart; 
   char kolor; 
  }; 

 

 

 

 

 

definicja typu 

 

struct karta k1, k2; 

 
 

 

 

 

lub 

 
struct karta 
  { 
   int wart; 
   char kolor; 
  } k1, k2; 
 
k1.wart = 3; 
k1.kolor = 'p'; 

 

k2 = k1; 
 
typedef struct karta karta; 
 
karta k3, k4, k5; 

 56 

 
struct owoc 
  { 
 

char *nazwa; 

 

int kalorie; 

  }; 
struct warzywo 
  { 
   char *nazwa; 
   int kalorie; 
  }; 
struct owoc a; 
struct warzywo b; 
a.nazwa 

 

b.nazwa 

 
struct karta 
  { 
   int wart; 
   char kolor; 
  } talia[52]; 
 
struct 
  { 
   int 

dzien, miesiac, rok; 

   char 

*nazwa_dnia[7]; 

   char   *nazwa_mies[12]; 
  } wczoraj, dzis, jutro; 
 
struct data 
  { 
   int 

dzien, miesiac, rok; 

   char 

*nazwa_dnia[7]; 

   char   *nazwa_mies[12]; 
  }; 
struct data wczoraj, dzis, jutro; 
typedef struct  

 

 

 

{ 

 

 

 float re; 

 

 

 float im; 

 

 

} complex; 

complex a, b, c[100]; 

 57 

12.1.

 

Dostęp do skłdników struktury 

 

 

zmienna_strukturalna.nazwa_pola 

 
Plik stud.h 
 

#define 

LICZBA_STUD 

100 

 
struct student 
   { 
    char *nazwisko; 
    int *nr_indeksu; 
    float ocena; 
   }; 

 

 

Plik stud.c 
 

#include "stud.h" 
 
main() 
  { 
   struct student st, rok[LICZBA_STUD]; 
   int i, licz = 0; 
 

. . . 

 

st.ocena = 4; 

 

st.nazwisko = "Kowalski"; 

 

st.nr_indeksu = 91017; 

 

. . . 

 

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

 

  licz += rok[i].ocena == 2; 

 

. . . 

 
Jeżeli wartością zmiennej wskaźnikowej jest adres struktury, to do jej 
składników można odwołać się przez: 
 
 

wskaźnik_do_struktury -> nazwa_składnika 

 
co jest równoważne odwałaniu 
 

(*wskaźnik_do_struktury).nazwa_składnika 

 

 

 58 

Uwaga. 
 

Nawiasy są konieczne. W przeciwnym przypadku otrzymamy 

 

 

 

*(wskaźnik_do_struktury.nazwa_składnika) 

  
co jest błędne, gdyż tylko do struktury można użyć  operatora ".", a nie do 
wskaźnika do struktury. 
 
Przykład.  
Dodawanie liczb zespolonych. 
 
Plik complex.h: 
 

struct complex 
  { 
 

double re; 

 

double im; 

  }; 
 
typedef 

struct complex complex; 

 

Plik complex.c: 
 

#include 

"complex.h" 

 
void dodaj(complex *a, complex *b, complex *c) 
  { 
 

a -> re = b -> re + c -> re; 

 

a -> im = b -> im + c -> im; 

  }; 
 
Przykład: 
struct student st, *p = &st; 
 
st.ocena = 4; 
st.nazwisko = "Kowalski"; 
st.nr_indeksu = 91017; 
 
st.ocena 
 

 

p->ocena 

 

 

 

 

4.0 

 59 

 
(*p).nr_indeksu 
 

 

p->nr_indeksu   

 

 

91017 

 
*p->nazwusko + 1 

 

 

(*(p->nazwisko))+1   

 

 

L 

 
*(p->nazwisko + 2) 
 

(p->nazwisko)[2] 

 

 

 

w 

 
 

12.2.

 

Struktury i funkcje 

 
 

Struktury tak jak wszystkie parametry są przekazywane przez wartość. 

W wywołanej procedurze powsaje lokalna kopia. Przy dużych strukturach 
może to być nieefektywne. Lepiej jest przekazywać adres do struktury. 
 
Przykład. 
 

typedef struct 
  { 
 

char 

 

 

 

nazwisko[25]; 

 

int 

 

 

 

nr_id; 

 

struct wydz  

wydzial; 

 

struct adres_dom 

*a_d; 

 

double 

 

 

pensja; 

 

. . . 

  } pracownik; 
 
struct wydz 
  { 
   char nazwa[20]; 
   int kod; 
  }; 
 
I sposób: 
pracownik wczytaj_dane(pracownik p) 
  { 
    

. . . 

 

printf("Kod wydzialu: "); 

 60 

 

scanf("%d", &k); 

 

p.wydzial.kod = k; 

   . . . 
 

return p; 

  } 
 
p.wydzial.kod     (p.wydzial).kod 
 
main() 
  { 
   pracownik p; 
 

. . . 

 

p = wczytaj_dane(p); 

 

/* dwa kopiowania */ 

 
II sposób: 
void wczytaj_dane(pracownik *p) 
  { 
    

. . . 

 

printf("Kod wydzialu: "); 

 

scanf("%d", &k); 

 

p->wydzial.kod = k; 

   . . . 
  } 
 
p->wydzial.kod     (p->wydzial).kod 
 
main() 
  { 
   pracownik p; 
 

. . . 

 

wczytaj_dane(&p); 

 

 

 61 

12.3.

 

Inicjalizacja struktur 

karta k = {8,'p'};  

/* ósemka pik */ 

 
complex a[3][3] =  
 

{ 

 

 {{1.0, -0.1},{2.0, 0.2}, (3.0, 0.3}}, 

 

 {{4.0, -0.5},{5.0, 0.5}, (6.0, 0.6}}, 

   };  /*  a[2][] zerowanie */ 
 
struct owoc o = {"gruszka", 150}; 
 
struct adres_dom  
  { 
 

char *ulica; 

 

char *miasto; 

 

long kod: 

  } adres = {"Wiejska 45A", "Bialystok", 15351}; 
 
struct adres_dom a_poprz = {0}; 

 
 

 62 

13.

 

Unie 

Skladnia unie  bazuje  na strukturach. 
 

 

 

union      u-tag { 

 

 

 

int    inval; 

 

 

 

float  fval  ; 

 

 

 

char   *pval; 

 

 

} uval; 

 
 

Zmienna 

uval

 bedzie posiadac wystarczajacy  obszar  pamieci 

aby  przechowac  najwiekszy  z  trzech  typow  
 
 Dowolny  typ  z tych  trzech  typow  moze  byc  przypisany  zmiennej  
uval.   Na programiste naklada sie odpowiedzialnosc sledzenia tego jaki 
typ jest aktualnie zapamietany w uni. 
 
 

 

Dostęp do  skladnikow  uni  

 

 

 

nazwa-uni.skladnik 

lub 

 

 

wskaznik-uni->skladnik 

 
czyli tak samo jak do skladnikow struktur. 
 
 Jesli  zmienna  utype jest  uzywana  do  sledzenia  biezacego  typu  
zapamietanego   w zmiennej uval, to mozna napisac: 

 
 

 

if (utype == INT) 

 

 

 

printf("%d\n", uval,ival); 

 

 

else if (utype == FLOAT) 

 

 

 

printf("%f\n", uval,fval); 

 

 

else if (utype == STRING) 

 

 

 

printf("%s\n", uval,pval); 

 

 

else 

 

 

 

printf("zly typ %d w typzl\n", 

utype); 

 63 

 

Unie moga wystepowac wewnatrz struktur i tablic.   

 
Notacja dostepu  do  skladnikow  uni  w  strukturze  jest  taka  sama jak  
notacja dostepu do skladnikow w zagniezdzonych strukturach.  
 
Na przyklad w tablicy strukturalnej zdefiniowanej nastepujaco: 

 

 

struct { 

 

 

 

 

char *name; 

 

 

 

 

int flags; 

 

 

 

 

int utype; 

 

 

 

 

unlon { 

 

 

 

 

 

int   ival; 

 

 

 

 

 

float fval; 

 

 

 

 

 

char *pval; 

 

 

 

 

} uval; 

 

 

} symtab [NSYM]; 

 
zmienna ival jest dostepowana przez 

 
 

symtab [i].uval.ival 

 
natomiast pierwszy znak lancucha pval przez 

 

 

*symtab [i].uval,ival 

 
Operacjami dozwolonymi na uniach sa:  

 

dostęp do skladnika  

 

pobieranie adresu.  

 
Unie nie  moga  byc  sobie  przypisywane, przesylane do funkcji ani tez 
przez funkcje zwracane.   
 
Wskazniki na unie  sa  uzywane  w  taki  sam  sposob  jak  wskazniki  na 
struktury. 

 64 

13.1.

 

Pola bitowe 

Składniki struktur i uni typu int lub unsigned mogą być deklarowane z 
określeniem ilości bitów przeznaczonych na reprezentację danego 
składnika. 
 
Przykład. 
 

struct Data 
  { 
 

unsigned d: 5; 

 

unsigned m : 4; 

 

unsigned r : 7; 

  }; 
 
struct Data d; 
 
d.r=99; 
d.m=10; 
d.d=1; 

 
Składnia: 
 

pole bitowe ::= { int | unsigned }

1

 {identyfikator}

opt

 : wyr 

 

wyr ::= stała_calkowita 

 
 
Uwagi: 
 
1. Nie wolno deklarować tablic pól bitowych. 
2. Pole bitowe bez nazwy oznacza przejście do następnego słowa. 
 

 

struct abc 

 

  { 

 

   unsigned a : 1, :0, b : 1, : 0, c : 1; 

 

  } 

 65 

14.

 

Modele pamieci 

 Rozdział ten dotyczy kompilitorów  
Turbo C, Borland C dla systemu MS-DOS. 

 
Specyfikacja modelu pamięci który będzie używany przez program. Model ten 
determinuje sposób adresowania zmiennych. 
 

  

Default = Small 

Segments 

Pointers 

Memory 

Model 

Code 

Data  Stack  Code 

Data 

BCC 

Option 

Tiny 

64K 

near 

near 

-mt 

Small 

64K 

64K 

near 

near 

-ms 

Medium 

1MB 

64K 

far 

near 

-mm 

Compact 

64K 

1MB 

near 

far 

-mc 

Large 

1MB 

1MB 

far 

far 

-ml 

Huge 

1MB 

64K 

each 

64K 

stack 

far 

far 

-mh 

   

 

  

Tiny

 

  

 

Modelu Tiny używa się do bardzimałych programów. 
Wszystkie rejestry segmtowe (CS, DS, ES, SS) są ustawione na te same adresy, 
wobec tego możesz używać łącznie 64K dla danych, kodu i stost. Wskaźniki są 
zawsze bliskie (near). 
Model Tiny umożliwia generowanie programów konwertowalnych do .COM z 
wykorzystaniem linkera z opcją TLINK /t.  
 
 

 Small

 

Modelu Smal używaj do średniej wielkości aplikacji. 
Dane i kod są umieszczane w rozłącznych segmentach więc dla kodu jest 64K i 
kolejne 64KB dla danych i kodu. 
Domyslnie są używane wskaźniki near. 

 66 

Medium

  

 
Jest to najlepszy model dla dużych programów, które nie przechowują w pamieci 
dużo danych. 
 
Dalekie wskaźniki są domyślne dla kodu, ale nie dla danych. Dane i stos są 
ograniczone do 64K ale kod może zajmować do 1MB. 
 
 

 Compact

 

 

Modelu Compact używa się gdy program ma mały kod ale potrzebyje adresów do 
dużej ilości danych. 
Model ten jest przeciwieństwem modelu Medium: Dalekie wskaźniki są domuślne 
dla danych ale nie dla kodu 
Kod zajmuje do 64 Kb podczas gdy dane do 1MB. 
 
Wszystkie funkcje są domyślnie near a wskaźnki na dane far. 

 
   

Large

 

 
 
 Tego modelu używa się tylko do bardzo dużych aplikacji. Wskaźniki zarówno 
dodanych jak i do kodu są dalekie (far) a wielkości wspólnie są ograniczone do 1MB. 
Wszystkie funkcje domyślnie są far. 

 
 
 

Huge

 

 
Tego modelu używa się tylko do bardzo dużych aplikacji. Wskaźniki zarówno 
dodanych jak i do kodu są dalekie (far).Wszystkie funkcje domyślnie są far. 
Borland C++ normalnie limituje wszystkie dane do 64 KB. W modelu Huge tak nie 
jest. Dopuszczalne jest aby pojedyńcze dane zajmowały ponad 64KB. 
Modal ten dopuszcza wielosegmentowe dane (każdy segmeny 64KB), do 1MB kodu 
i 64KB stos. Wszystkie funkcje i wskaźniki są domyślnie far. 
 
 
 

 67 

Tiny 

 
 
 
     

≤

 64 KB 

                          .COM 

 

Small 

≤

 64 KB 

 
 
 

≤

 64 KB 

 
 

Medium 

      N* 

≤

 64 KB 

 
 
 

≤

 64 KB 

 
 
 

Compact 

≤

 64 KB 

≤

 64 KB 

≤

 64 KB 

 
 

Large 

N * 

≤

 64 KB 

 
  

≤

 64 KB 

≤

 64 KB 

 
 

Huge 

 N* 

≤

 64 KB 

 
N * 

≤

 64 KB 

 

≤

 64 KB 

 

 

Kod 
Dane 
Heap 

↓

 

 
Stos  

↑

 

Kod 
Dane 
Heap 

↓

 

 
Stos 

↑

 

Far Heap 

↓

 

Kod 
Kod 
Dane 
Heap  

↓

 

 
Stos 

↑

 

Far Heap 

↓

 

Kod 
Dane 
Stos  

↑

 

Heap 

↓

 

Kod 
Kod 
Dane 
Stos 

↑

 

Heap 

↓

 

Kod 
Kod 
Dane 
Dane 
Stos 

↑

 

Heap  

↓

 

 68 

15.

 

Dynamiczny przydział pamięci 

15.1.

 

Funkcje alokacji pamięci 

void * malloc(size_t size); 

••••

 

przydziela obszar wielkości size  

••••

 

zwraca wskaźnik do przydzielonego obszaru 

••••

 

typ wskaźnika void * może być automatycznie konwertowany do 
dowolnego typu wskaźnikowego. 

••••

 

jeśli brak odpowiedniej ilości pamięci to zwraca NULL 

void *calloc(size_t nitems, size_t size); 

••••

 

przydziela obszar wielkości nitimes*size  

••••

 

dane przydzielonego bloku są ustawione na 0 

void *realloc(void *block, size_t size); 

••••

 

 zmienia przydział pamięci dla obszaru blok na wielkości size 

••••

 

umożliwia zwiększenie bądź zmniejszenie wcześniejszego 
przydziału pamięci 

••••

 

dane z realokowanego obszaru są kopiowane 

••••

 

jeśli size wynosi 0 to zwalnia pamięć przydzieloną dla block 

••••

 

jeśli block równa się NULL to funkcja działa jak malloc 

void free(void *block); 

••••

 

zwalnia przydział pamięci dla obszaru blok przydzielony wcześniej 
przez malloc, calloc lub realloc 

unsigned coreleft(void); 

••••

 

szacuje ilość wolnego miejsca na stercie 

••••

 

(DOS)dla modeli Compact Large i Huge istnieje  funkcja 

 

     unsigned long coreleft(void); 

 
void *memset(void *s, int c, size_t n); 

••••

 

ustawia n bajtów począwszy od *s na wartość c 

••••

 

#include <mem.h> 

 
Odpowiedniki powyższych funkcji do obsługo dalekiej sterty(dotyczy 
Small i Medium) 
void far *farmalloc(unsigned long nbytes); 
void far *farcalloc(unsigned long nunits, unsigned long unitsz); 
void farfree(void far * block); 
unsigned long farcoreleft(void); 
void far * far _fmemset (void far *s, int c, size_t n) 

 69 

15.2.

 

Tablice dynamiczne 

 
int t[20]; 

tablica 20 elementów typu int 

int *p; 

wskaźnik na typ int; 

 

main() 
{ 
int *p,i,N; 
 printf("Podaj ilo

ść

 elementów\n"); 

 scanf("%d",&N); 
 p=(int*)calloc(N,sizeof(int)); 

/* p=malloc(20* sizeof(int)); 

 

   memset(p,0,20*sizeof(int)); */ 

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

 

 *(p+i)=rand()%198-99; 

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

 

 printf("%4d",*(p+i)); 

printf("\n"); 
 realloc(p,2*N*sizeof(int)); 
 for(i=N;i<2*N;i++) 
 

 

 *(p+i)=rand()%198-99; 

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

 

 printf("%4d ",*(p+i)); 

free(p); 
} 
 
char* srev1(const char *s)                   
 

 

 

/* odwracanie napisu*/ 

{ 
char *p; 
int l=slen(s); 
 p=malloc(l+1); 
 p=p+l; 
 *p=0; 
  for(;*s;) 
 

 *p--=*s++; 

return ++p; 
} 

 70 

16.

 

Struktury listowe 

 

struct lista 
  { 
 

int dane; 

 

struct lista *nast; 

  } a; 
 
 

                 ------->       
 

dane 

 

nast 

 
 

struct lista b,c; 
 
a.dane = 1; 
b.dane = 2; 
c.dane = 3; 
a.nast = b.nast = c.nast = NULL; 
 
 

 

1 

NULL 

 

2 

NULL 

 

3 

NULL 

 
 

a.nast = &b; 
b.nast = &c; 
 

 

1 

  ----> 

2 

  ----> 

3 

NULL 

 

a.nast->dane 

 

 

 

 

2 

a.nast->nast->dane  

 

 

3 

 

 
NULL  - “zerowy”  wskażnik   
 
Zdefiniowany przez dołączenie jednego z plików 
alloc.h mem.h  stddef.h  stdio.h  stdlib.h   
a fizycznie zdefiniowane w  _null.h 

 71 

16.1.

 

Listy liniowe 

Plik lista.h: 

 
#include <stdlib.h> 
typedef 

char 

 

Dane; 

typedef 
struct lista_lin 
  { 
 

Dane 

    

d; 

 

struct lista_lin 

*nast; 

  } 
     Element,  
    *Lista;

 

16.1.1.

 

Dynamiczny przydział pamięci 

#include <stdlib.h>

   lub   

#include<alloc.h>

 

 
 

void *malloc(size_t size); 

 
Funkcja daje jako wskaźnik do obszaru pamięci o wielkońci rozmiar  
(w bajtach). Wynik jest typu void * , konwresja do konkretnego tupu nie 
jest konieczna. 
 

Lista pocz; 
 
pocz = (Lista)malloc(sizeof(Element)); 
pocz -> d = 'n'; 
pocz -> nast = NULL; 
 

 

pocz 

  ------>     n   

NULL 

 

pocz ->nast = (Lista)malloc(sizeof(Element)); 
pocz ->nast ->d = 'a'; 
pocz ->nast ->nast = NULL; 
 

 

 

pocz 

 ------->     n   

  ----> 

a 

NULL 

 

 72 

16.1.2.

 

Operacje na listach 

 
1)

 

Tworzenie listy 

2)

 

Obliczanie liczby Elementów 

3)

 

Szukanie Elementu 

4)

 

Łączenie list 

5)

 

Wstawianie Elementów 
a)

 

pomiędzy dwa wskazane Elementy 

b)

 

po wskazanym elemencie 

c)

 

po elemencie danych 

d)

 

przed elemantem danych 

6)

 

Przetworzenie (np. wypisanie) wszystkich Elementów listy 

7)

 

Usuwanie Elementów 

8)

 

Kasowanie całej listy 

9)

 

Odwracanie listy jednokierunkowej 

 
 

#include 

<stdlib.h> 

#include 

"lista.h" 

 
/* Tworzenie listy - wersja rekurencyjna */ 
 
Lista napis_na_liste(char s[]) 
  { 
   Lista 

pocz; 

 
 

if (*s) 

 

  { 

 

   pocz = (Lista)malloc(sizeof(Element)); 

 

   pocz -> d = *s; 

 

   pocz -> nast = napis_na_liste(s+1); 

 

   return pocz; 

 

  } 

 return NULL; 
 
  } 
 

 73 

/* Tworzenie listy - wersja iteracyjna */ 
 
Lista np_na_lst(char s[]) 
  { 
   Lista 

pocz = NULL, kon; 

 
 

if (s[0]) 

 

  { 

 

 

   pocz = (Lista)malloc(sizeof(Element)); 

 

   pocz -> d = *s; 

 

   kon = pocz; 

 

   for (; *++s ; ) 

 

 

{ 

 

 

 kon -> nast = (Lista)malloc   

 

 

 

 

 

 

 

(sizeof(Element)); 

 

 

 kon = kon -> nast; 

 

 

 kon -> d = *s; 

 

 

} 

 

   kon -> nast = NULL; 

 

  } 

 

return pocz; 

  } 

 
 

16.1.3.

 

Przetwarzanie list 

 

/* ilosc Elementów - wersja rekurencyjna */ 
  
int ilosc_Elementow(Lista pocz) 
  { 
    

if (pocz == NULL) 

 

  return 0; 

 

else 

 

  return (1 + ilosc_Elementow(pocz -> nast)); 

  } 
 

 74 

/* ilosc Elementów - wersja iteracyjna */ 
  
int il_el(Lista pocz) 
  { 
   int licz = 0; 
 

 

 

for ( ; pocz ; pocz = pocz ->nast) 

 

  ++licz; 

 

return licz; 

  } 
 
/* Ł

ą

czenie list */ 

void lacz_r(Lista a, Lista b) 
  { 
   if(a==NULL) a=b; 
   else 
 

if (a -> nast == NULL) 

 

  a -> nast = b; 

 

else  

 

  lacz(a -> nast, b); 

  } 
 
void lacz(Lista a, Lista b) 
  { 
 

if (a) 

 

 { 

 

  for(;a->nast;a=a -> nast) ; 

 

  a->nast=b; 

 

 } 

 

 else a=b; 

  } 
 
/* wstawianie Elementu */ 
/* wstawianie pomiedzy dwa wskazane Elementy */ 
 
void wstaw(Lista e1, Lista e2, Lista q) 
  { 
   q -> nast = e2; 
   e1 -> nast = q; 
  } 
 

 75 

 
         e1             e2 
                   
 
             q 
        
 
 
/* Szukanie Elementu  
 pocz 

–  

pocz

ą

tek listy 

 e 

- 

 

 pop 

- poprzedni Element listy   */ 

 
Lista szukaj(Lista pocz,Dane e,Lista *pop) 
{ 
 *pop=NULL; 
 while(pocz&& pocz->d!=e) 
  { 
  *pop=pocz; 
  pocz=pocz->nast; 
  } 
 return pocz; 
} 
 
 
         e            e->nast 
                   
 
              
        
 
 
/* wstawianie po wskazanym elemencie */ 
void wstaw_po(Lista e, Dane x) 
  { 
 

Lista q=(Lista)malloc(sizeof(Element)); 

 

q->d=x; 

 

q -> nast = e->nast; 

 

e -> nast = q; 

  } 
 

 

 

x 

 

 76 

 
pocz    psz            psz->nast 
                   
 
              
        
          newp 
 
pocz            pop     psz 
                   
 
              
                                  newp 
 
/* wstawianie po elemencie danych */ 
void wstaw_po_d(Lista *pocz,Dane s, Dane x) 
{ 
 Lista psz,pop,newp; 
 psz=szukaj(*pocz,s,&pop); 
 

 newp=(Lista)malloc(sizeof(Element)); 

 

 newp->d=x; 

 

 newp->nast=psz; 

 

 if(psz) 

 

  psz->nast=newp; 

 

 else 

 

  pop->nast=newp; 

} 
pocz   pop                  psz 
                   
 
              
           
          newp 
 
 
  pop   pocz psz 
                   
 
              
           
       newp 

s 

 

x 

 

 

 

 

x 

s 

 

 

x 

 

s 

x 

 77 

/* wstawianie przed Elementem danych */ 
void wstaw_przed_d(Lista *pocz,Dane s, Dane x) 
{ 
 Lista psz,pop,newp; 
 psz=szukaj(*pocz,s,&pop); 
 

 newp=(Lista)malloc(sizeof(Element)); 

 

 newp->d=x; 

 

 newp->nast=psz; 

 if(pop) 
 

 pop->nast=newp; 

 else 
 

 *pocz=newp; 

} 
 
/*wypisz Elementy listy */ 
void pisz_liste(Lista pocz) 
{ 
  printf("\n"); 
 
 while(pocz) 
 { 
  printf("%c ",pocz->d); 
  pocz=pocz->nast; 
 } 
} 
 
/* kasowanie Elementu */ 
 
Lista usun(Lista *pocz,Dane x) 
{ 
 Lista psz,pop; 
 psz=szukaj(*pocz,x,&pop); 
  if(psz) 
 

 { 

 

  if(pop) 

 

 

pop->nast=psz->nast; 

 

  else 

 

 

*pocz=psz->nast; 

 

  free(psz) 

 

 } 

} 

 78 

 
pocz   pop                  psz 
                   
 
              
          
 
/* kasowanie listy */ 
 
void kasuj_liste(Lista pocz) 
  { 
    

if (pocz != NULL) 

 

  { 

    

   kasuj_liste(pocz -> nast); 

 

   free(pocz); 

    

  } 

  } 
 
 
  n     pn                  po 
                   
 
              
           
 
/* odwracanie listy jednokierunkowej*/ 
 
Lista odwracanie(Lista *pn) 
{ 
 Lista po,n; 
 po=NULL;         
 while(*pn) 
 { 
  n=(*pn)->nast; 
  (*pn)->nast=po; 
  po=*pn; 
  *pn=n; 
 } 
return *pn=po; 
} 

s 

x 

 

3 

2 

1 

4 

 79 

16.2.

 

Listy dwukierunkowe 

typedef 

char 

 

Dane; 

 
struct lista_dwa 
  { 
   Dane 

    

d; 

   struct lista_dwa 

*nast,*pop; 

  }; 
 
typedef 

struct lista_dwa  Element2; 

typedef 

Element2 

 

 

*Lista2; 

 

16.2.1.

 

Tworzenie listy 

 

Lista2 napis_na_liste(char s[]) 
{ 
 

Lista2 

pocz = NULL, kon; 

 
 

if (*s) 

 

  { 

 

 

pocz = 

(Lista2)malloc(sizeof(Element2)); 
 

 

pocz -> d = *s; 

 

 

pocz->pop=NULL; 

 

 

kon = pocz; 

 

 

for (; *++s ;) 

 

 

{ 

 

 

 kon -> nast = (Lista2)malloc 

 

 

 

 

 

 

 

(sizeof(Element2)); 

 

 

 kon->nast->pop=kon; 

 

 

 kon = kon -> nast; 

 

 

 kon -> d = *s; 

 

 

} 

 

 

kon -> nast = NULL; 

 

  } 

 

return pocz; 

} 

 80 

16.2.2.

 

Operacje na listach 

Lista2 koniec(Lista2 pocz) 
{ 
 if(pocz) 
  while(pocz->nast) 
 

pocz=pocz->nast; 

 return pocz; 
} 
 
void pisz_n(Lista2 p) 
{ 
  printf("\n"); 
 while(p) 
 { 
 

pisz_d(p->d); 

 

p=p->nast; 

 } 
} 
 
Lista2 szukaj(Lista2 pocz,Dane x) 
{ 
 while(pocz && pocz->d!=x) 
  pocz=pocz->nast; 
 return pocz; 
} 
Lista2 usun(Lista2 *pocz,Dane x) 
{ 
 Lista2 pop,psz=szukaj(*pocz,x); 
  if(psz) 
  { 
 

 pop=psz->pop; 

 

 if(pop) 

 

  pop->nast=psz->nast; 

 

 else 

 

  *pocz=psz->nast; 

 

 if(psz->nast) 

 

  psz->nast->pop=pop; 

 

 free(psz); 

  } 
return *pocz; 
} 

 81 

17.

 

Stos 

 
 

 

szczyt 

----> Dane 

 

 

 

 

 

 

   

 
 

 

 

 

 

 

Dane 

 
 

 

 

 

 

 

Dane 

 

 

 

 

 

 

NULL 

 
Stos jest strukturą typu LIFO (Last In First Out). 
 
Prototypy funkcji: 
int pusty(Stos st);  

 

Wartosc 1, gdy stos pusty; 

 

 

 

 

 

 

0 w przypadku przeciwnym/ 

Dane wart(Stos st);   

 

Wartość elementu na szczycie stosu. 

void pop(Stos *st, Dane *d); 

Usuwa element ze szczytu stosu 

 

 

 

 

 

 

i daje jesgo wartość. 

void push(Stos *st, Dane d); 

Umiescza wartosc d na stosie. 

 
 
Plik stos.h: 
 

#define  

NULL 

 

0 

typedef 

char 

 

Dane; 

 
struct stos 
  { 
   Dane 

    

d; 

   struct stos *nast; 
  }; 
 
typedef 

struct stos 

Element; 

typedef 

Element 

 

*Stos; 

 
 

 82 

/* operacje na stosach */ 
int pusty(Stos st) 
  { 
 

return (st == NULL); 

  } 
Dane wart(Stos st) 
 { 
   return (st -> d); 
 } 
void pop(Stos *st, Dane *d) 
  { 
   Stos st1 = *st; 
 

if (!pusty(st1)) 

 

  { 

      *d = st1 -> d; 
 

   *st = st1 -> nast; 

 

   free(st1); 

       } 
 

else 

 

  printf("Stos jest pusty\n"); 

  } 
void push(Stos *st, Dane d) 
  { 
   Stos rob; 
 

rob = malloc(sizeof(Element)); 

 

rob -> d  = d; 

 

rob -> nast = *st; 

 

*st = rob; 

  } 
/* odwracanie napisu */ 
void odwroc(Dane s[]) 
  { 
   int i; 
   Stos st = NULL; 
 

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

 

  push(&st,s[i]); 

 

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

 

  pop(&st, &s[i]); 

  } 

 83 

17.1.

 

Stos i odwrotna notacja polska 

17.1.1.

 

Notacja polska  

Notacja ta bywa zwana też - od nazwiska jej twórcy- 

NOTACJĄ 

Ł

UKASIEWICZA 

 

 
Notacja infiksowa  

Notacja polska  Odwrotna notacja polska 

  x+y  

+ x y 

x y + 

2*(2-4)/5 

/ *2 -2 4 5 

2 2 4 - * 5 / 

 
Cechy notacji polskiej 


 

umożliwia zapis dowolnego wyrażenia bez konieczności użycia 
nawiasów 



 

ułatwia kontrole poprawności wyrażenia 



 

jest to notacja często stosowana w wiekszości kolkulatorów 

 


 

wymusza konieczność rozróżnienia operatorów binarnych i unarnych 
(np. + - ) 



 

skomplikowany zapis 

 

17.1.2.

 

Zamiana notacji infiksowej na odwrotną notacje polska 

Potrzebne są nam trzy stosy. 

••••

 

Stos wejściowy  

(WE)  

••••

 

Stos wynikowy  

(WY) 

••••

 

Stos pomocniczy   (POM) 

Założmy, że na stosie WE dane mamy wyrażenie rozbite na atomy i 
ułożone w takiej kolejmości aby pobieranie z niego danych odpowiadało 
kolejności pojawiania się atomów w wyrażeniu. Mogła by tu być użyta 
kolejka. 
Np. 2*(3+7) 

2 

* 

( 

3 

+ 

7 

) 

1)

 

Przetwarzamy wyrazenie pojawiające na stosie WE 

2)

 

Jeśli atom jest: 
a)

 

Liczbą 

to „wrzycamy” ja na stos (WY) 

b)

 

Nawiasem „(”  to „wrzycamy” ja na stos (POM) 

c)

 

Nawiasem „)”  to ze stos  (POM) zdejmujemy operator i kładziemy 

go na stos (WY) 
operacje tą powtarzamy az do momentu zdjęcia ze 
stosu (POM)  atomu „)”-tego atomu nie kładziemu na 
stosie 

 84 

d)

 

Operatorem O  sprawdzamy jaki operator jest na stosie (POM) 

-jeśli stos jest pusty to kładziemy operator O na stos 
(POM) 
-jeśli operator na stosie ma wyższy priorytet to 
kładziemy go z powrotem na stos (POM) i nastepnie 
dokładamy operator O 
- jeśli operator na stosie ma niższy bądź równy 
priorytet to kładziemy na stos (WY)  
 nastepnie powtarzamy operację dla kolejnego 
poeratora na stosie (POM) 
na koniec kładziemy operator O na sios (POM) 

3)

 

Gdy stos (WE) jest już pusty to przekładamy wszystkie pozostałe 
operatory ze stosu (POM) na stos (WY) 

4)

 

Otrzymujemy stos (WY) z wyrażeniem w odwrotnej notacji polskiej, 
ale od jego końca westarczy go tyklo odwrócić 

5)

 

Zamiast punktu 3) można przenieść dane ze stosu (WY) na stos (POM). 
Wtedy wynikiem jest stos (POM). 
 

17.1.3.

 

Kalkulator stosowy 

 
Potrzebne są nam dwa stosy. 

••••

 

Stos wejściowy  

(WE)  

••••

 

Stos wynikowy  

(WY) 

Założmy, że na stosie WE dane mamy wyrażenie w odwrotnej notacji 
polskiej rozbite na atomy. 
 
1)

 

Przetwarzamy wyrazenie pojawiające na stosie WE 

2)

 

Jeśli atom jest: 
a)

 

Liczbą 

to „wrzycamy” ja na stos (WY) 

b)

 

Operatorem O  to ze stosu (WY) pobiaramy arg2 

następnie ze stosu (WY) pobiaramy arg1 
i na stos (WY) wkładamy wynik wyrażenia 
arg1 O arg2  (zapis w notacji infiksowej) 
 

3)

 

Wynikiem jest liczba na stosie WE 

4)

 

Jeśli na stosie WE zabraknie argumentów, bądź jeśli zostanie więcej niż 
jedna liczba, oznacze to sytuację błędną. 
Możliwa jest zatem kontrola poprawności wprowadzonego wyrażenia.   

Przykład: 

 85 

 3- (4*5)*(6+7)/8  = -29.5 

1.

 

Zamiana na odwrotną notację polską 

1.

 

3 - ( 4 * 5 ) * ( 6 +  7 ) /8   WE 

          

  POM 

 

  WY 

 
2.

 

 - ( 4 * 5 ) * ( 6 +  7  ) /8    WE 

          

  POM 

 

3  WY  

 
3.

 

 ( 4 * 5 ) * ( 6 +  7  ) /8    WE 

          

-  POM 

 

3  WY 

 
4.

 

 4 * 5 ) * ( 6 +  7  ) / 8 

  WE 

          

( -  POM 

 

3  WY 

 
5.

 

5 ) * ( 6 +  7  ) / 8 

  WE 

          

* ( -  POM 

 

4 3  WY 

 
6.

 

 ) * ( 6 +  7  ) / 8 

  WE 

          

* ( -  POM 

 

 5 4 3  WY 

 
7.

 

 * ( 6 +  7  ) / 8 

  WE 

          

 -  POM 

 

  * 5 4 3  WY 

 
8.

 

 ( 6 +  7  ) / 8 

  WE 

          

* -  POM 

 

  * 5 4 3  WY 

 
9.

 

6 +  7  ) / 8 

  WE 

          

 ( * -  POM 

 

  * 5 4 3  WY 

10.

 

   +  7  ) / 8 

  WE 

          

 ( * -  POM 

 

  6 * 5 4 3  WY 

 
11.

 

    7  ) / 8 

  WE 

          

+  ( * -  POM 

 

  6 * 5 4 3  WY 

 
12.

 

     ) / 8 

  WE 

          

+  ( * -  POM 

 

7  6 * 5 4 3  WY 

 
13.

 

     / 8 

  WE 

          

   * -  POM 

 

+ 7  6 * 5 4 3  WY 

 
14.

 

   8 

  WE 

          

   / -  POM 

 

* + 7  6 * 5 4 3  WY 

 
15.

 

    

  WE 

          

   / -  POM 

 

8 * + 7  6 * 5 4 3  WY 

 
16.

 

A  

  WE 

          

  POM 

 

 - / 8 * + 7  6 * 5 4 3  WY 

 
16.

 

B  

  WE 

            3 4 5 * 6 7 + * 8  / -  POM 
 

  WY 

 

 86 

2. Wyliczenie wartości wyrażenia 
 
1.

 

  

3 4 5 * 6 7 + * 8  / -   WE 

  

  WY 

 
2.

 

 

 4 5 * 6 7 + * 8  / -   WE 

  

3  WY 

 
3.

 

 

  5 * 6 7 + * 8  / -   WE 

  

4 3  WY 

 
 
4.

 

 

   * 6 7 + * 8  / -   WE 

  

5 4 3  WY 

 
5.

 

 

    6 7 + * 8  / -   WE 

  

20 3  WY 

 
6.

 

 

     7 + * 8  / -   WE 

  

6 20 3  WY 

 
7.

 

 

      + * 8  / -   WE 

  

7 6 20 3  WY 

 
8.

 

 

       * 8  / -   WE 

  

13 20 3  WY 

 
9.

 

 

        8  / -   WE 

  

260 3  WY 

 
10.

 

 

          / -   WE 

  

 8 260 3  WY 

 
11.

 

  

   -   WE 

  

 32.5 3  WY 

 
12.

 

 

  WE 

  

 -29.5   WY 

 87 

18.

 

Drzewa binarne 

 
 

Drzewo jest skończonym zbiorem elementów zwanych węzłami. 

Drzewo posiada jeden wyróżniony element zwany korzeniem, pozostałe 
węzły tworzą rozłączne poddrzewa. Jeżeli węzeł r ma poddrzewa T

1

, T

2

, 

..., T

n

, to korzenie tych drzew są potomkami węzła r. Węzeł, który nie ma 

potomków nazywamy liściem. 
 
 

 

 

 

 

drzewo 

 

 

 

 

 

  a 

 

 

 

kkorzeń 

 
poddrzewo 
 
 

 

 

b 

 

  f 

 

 

g 

 

 
 
 

 

c 

d 

e 

  h                  liście 

 
 
Drzewami binarnymi nazywamy drzew, których węzły mają dwóch 
potomków. 
 
 
Plik drzewo.h: 
 

#define 

 

NULL 

 

0 

 
typedef 

 

char 

 

Dane; 

 
struct wezel 
 

{ 

 

 Dane         d; 

 

 struct wezel *lewy; 

 

 struct wezel *prawy;      

 

}; 

 
typedef struct wezel WEZEL; 
 
typedef WEZEL   

*DRZEWO; 

 88 

18.1.

 

Przeglądanie drzew binarnych 

Kierunek: 

 

LKP  

KLP  

LPK  

 

 

 

Lewe 

Korzeń 

Lewe 

 

 

 

Korzeń 

Lewe 

Prawe 

 

 

 

 

Prawe 

Prawe 

Korzeń 

 

void lkp(DRZEWO korzen) 
  { 
 

if (korzen != NULL) 

 

  { 

 

 

lkp(korzen -> lewy); 

 

 

printf("%c ", korzen -> d); 

 

 

lpk(korzen -> prawy); 

 

  } 

  } 

 
 

 

 

 

 

G 

 
 
 

 

 

D 

 

 

 

 

I 

 
 
 

B 

 

 

 

F 

 

H 

 

J 

 
 
A   

C   

E 

 
lpk :   A B C D E F G H I J 
 

void  klp(DRZEWO korzen) 
  { 
 

if (korzen != NULL) 

 

  { 

 

 

printf("%c ", korzen -> d); 

 

 

lkp(korzen -> lewy); 

 

 

lpk(korzen -> prawy); 

 

  } 

  } 

                   
klp:  

G D B A C F E I H J 

 89 

18.2.

 

Tworzenie drzewa binarnego 

 

DRZEWO nowy_wezel() 
 

{ 

 

 

return (malloc(sizeof(WEZEL))); 

 

} 

 
DRZEWO inic_wezel(Dane d1, DRZEWO p1, DRZEWO p2) 
  { 
 

DRZEWO t: 

 
 

t = nowy_wezel(); 

 

t -> d = d1; 

 

t -> lewy = p1; 

 

t -> prawy = p2; 

 

return t; 

  } 
 

Tworzenie drzew binarnego z tablicy: 
potomkami a[i] są: a[2*i+1] i a[2*i+2] 
 

DRZEWO tw_drzewo(Dane a[], int i, int ilosc) 
  { 
 

if (i >= ilosc) 

 

  return NULL; 

 

else 

 

  return (inic_wezel(a[i], 

 

 

 

 

 tw_drzewo(a, 2*i+1, ilosc), 

 

 

 

 

 tw_drzewo{a, 2*i+2, ilosc)); 

  } 
 
 

 90 

18.3.

 

Drzewa wielokierunkowe 

 
Drzewo wielokierunkowe -  
 

węzły mają dowolną liczbę potomków. 

 
Reprezentacja: 
 

Lista liniowa dla każdego węzła. 

 

Każda lista jest potomkiem jednego węzła. 

 

Tablica pierwszych potomków. 

 
 
 

 

t[0]  

 

 

a 

 
 
 

 

 

 

 

b 

 

 

f 

 

 

g 

 
 
 

 

 

c 

d  

e 

 

h 

 

 

NULL 

 
 

 

NULL 

  NULL 

NULL     NULL 

 
 
Plik w_drzewo.h: 
 

#define 

 

NULL  

0 

typedef 

 

char 

 

Dane; 

 
struct wezel 
  { 
 

int 

 

 

nr_pot; 

 

Dane 

 

 

d; 

 

struct wezel 

*r; 

  }; 
 
typedef struct wezel WEZEL; 
typedef WEZEL  *W_DRZEWO; 

 

 91 

Tworzenie węzła: 

W_DRZEWO nowy_wezel() 
  { 
    

return(malloc(sizeof{WEZEL))); 

  } 
W_DRZEWO inic_wezel(Dane d1, int num, W_DRZEWO rd) 
  { 
   W_DRZEWO rob: 
 
   rob = nowy(wezel); 
 

rob -> d = d1; 

 

rob -> nr_pot = num; 

 

rob -> r = rd; 

 

return rob; 

  } 
t[0] = inic_wezel('a', 1, NULL); 
t[1] = inic_wezel('b', 2, NULL); 
t[1] -> r = inic_wezel('f', 6, NULL); 
t[1] -> r -> r = inic_wezel('g', 7, NULL); 
t[2] = inic_wezel('c', 3, NULL); 
t[2] -> r = inic_wezel('d', 4, NULL); 
t[2] -> r -> r = inic_wezel('e', 5, NULL); 
t[3] = t[4] t[5] = NULL; 
t[6]  = inic_wezel('h', 8, NULL); 
t[7] = t[8] = NULL; 

18.4.

 

Przeglądanie drzewa wielokierunkowego 

 

void przeg(W_DRZEWO t, int ind) 
  { 
   W_DRZEWO rob; 
 
 

rob = t[ind]; 

 

while (rob != NULL) 

     { 
 

   printf("%c  %d\n", rob->d, rob->nr_pot); 

 

   przeg(t, rob->nr_pot); 

 

   rob = rob->r; 

       } 
  } 

 92 

19.

 

Preprocesor 

19.1.

 

Sklejanie wierszy 

Wiersze zakończone znakiem   \   są sklejane z następnym wierszem. 
Nastepuje to przed podziałem pliku na leksemy. 

int nazwa\ 
zmiennej; 

Definicja zmiennej 

nazwazmiennej 

 

Derektywy preprocesora dotyczą jednej lini kodu, jeśli dyrektywa jest dość 
długa to powyższa metoda może być użyteczna. 
 

19.2.

 

Dyrektywa #include 

 
#include 

< 

> 

#include  

" 

" 

 
Przykład. 
 

Plik prog.h: 

 

 

#include <stdio.h> 

 

 

#include <stdlib.h> 

 

 

. . . 

 

Plig prog.c: 

 

 

#include "prog.h" 

 
 

19.3.

 

Dyrektywa #define 

 

 

#define identyfikator wartość 

 

#define  

ILOSC_SEKUND_W_DOBIE  \ 

            (60 * 60 * 24) 
 
#define  

PI  

 

3.141592 

#define 

EOF 

 

 

(-1) 

#define  

MAXINT  

2147483647 

 

Przykład.