PROGRAMOWANIE KOMPUTERÓW

Instrukcja

• Ogólna postać

if (wyrażenie)
instrukcja

else
instrukcja

• Wykonywana jest dokładnie jedna z dwóch

instrukcji związanych z if-else.

• Jeśli wyrazenie jest prawdą (nie 0), to

wykonywana jest instrukcja

; jeśli nie,

wykonywana jest instrukcja

• Każda instrukcja może być pojedynczą

instrukcją lub ciągiem instrukcji ujętą w
nawiasy klamrowe.

Operatory inkrementacji

i dekrementacji

• ++
• --

• mogą być używane jako operatory prefiksowe

(przed zmienną, np. ++n) albo postfiksowe (po

zmiennej, np. n++)

• Przykład: jeśli n jest równe 5, to

x = n++;

ustawia x na 5, ale

x = ++n;

ustawia x na 6; obydwa przypisania ustawiają n na

Operatory bitowe

bitwise AND

bitwise inclusive OR

bitwise exclusive OR

<< left shift

>> right shift

one's complement (unary)

Operator bitowy AND

• Działa na wartościach całkowitych
• Przykład:

108

& 217

= 72

Operatory bitowe -

przykłady

• 6 & 11 =
• 4 | 1 =
• 7 ^ 2 =
• 5 >> 2

• 3 << 2=
• ~0

2
5
5
1
12
-1

(por. z !0)

Ujemne liczby

całkowite:

dlaczego ~0 jest równe

-1

• Unsigned

0: 0000
1: 0001
2: 0010
...

15:

1111

• Signed
  -8: 1000
  -2: 1110
  -1: 1111

0: 0000
1: 0001
2: 0010
7: 0111

...

Strumienie wejściowe i

wyjściowe

krótki przegląd

• Standardowe wejście: stdin
• Standardowe wyjście: stdout
• Stand. strumień błędów:

stderr

• Szczegóły zostaną omówione później
• Normalnie strumienie te są związane z

konsolą:

– stdin z klawiaturą
– stdout i stderr z terminalem tekstowym

• Strumienie mogą być przekierowywane

testapp.exe <dane.txt >wyniki.txt

Wejście znakowe

• Odczytanie pojedynczego znaku lub

EOF:

int getc(FILE *stream);

powyższa deklaracja nazywana jest

prototypem

• Przykład:

int c;
c = getc(stdin);

• Czytanie jednego znaku z stdin:

int getchar(void);

• getchar()

działa jak

getc(stdin)

Wyjście znakowe

• Zapis pojedynczego znaku do

strumienia:

int putc(int c, FILE *stream);

• Przykład:

putc(’A’,stdout);

• Zapis pojedynczego znaku do stdout:

int putchar(int c);

• putchar(’A’)

działa jak

putc(’A’,stdout)

• Zwracana wartość: wypisany znak

Kopiowanie plików

#include <stdio.h>

/* kopiowanie wejścia na wyjście:

pierwsza wersja */

   main()
   {
       int c;
       c = getchar();
       while (c != ‘q’) {
           putchar(c);
           c = getchar();
       }
       return 0;
   }

Kopiowanie plików - druga

wersja

#include <stdio.h>

/* copy input to output; 2nd version */

   main()
   {
       int c;

       while ((c = getchar()) != ‘q’)
           putchar(c);

       return 0;
   }

Liczenie znaków

#include <stdio.h>

/* count characters in input; 1st version */

   main()
   {
       long nc;

       nc = 0;
       while (getchar() != ‘q’)
           ++nc;
       printf("%ld\n", nc);

       return 0;
   }

Liczenie znaków - druga

wersja

#include <stdio.h>

/* count characters in input; 2nd version */

   main()
   {
       double nc;
       for (nc = 0; getchar() != ‘q’; ++nc)
           ;
       printf("%.0f\n", nc);
       return 0;
   }

Liczenie wierszy

#include <stdio.h>

/* count lines in input */

   main()
   {
       int c, nl;

nl = 0;

/* the number of lines so far */

while ((c = getchar()) != ‘q’)
if (c == '\n')

/* new line found */

               ++nl;
       printf("%d\n", nl);
       return 0;
   }

Zmienne w pamięci

• Każda zmienna pamiętana jest w

pewnym miejscu pamięci ... lub w

rejestrze procesora

•

Adres

zmiennej jest

indeksem

tej

komórki pamięci, w której znajduje się

pierwszy bajt zmiennej

• Liczba bajtów zajmowanych przez

zmienną zależy od jej typu; operator

sizeof informuje o tym rozmiarze:

sizeof(type)

Wskaźniki

• Wskaźnik jest adresem, pod którym

znajduje się zwykle coś użytecznego

• Definiowanie zmiennej przechowującej

adres:

<type> *<variable>

• Przykład:

int *pti;

• Pobieranie adresu, pod którym

przechowywana jest zmienna: operator &

int x;
pti = &x;

Wskaźniki przykład

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

int main(void)
{
char*p[3]={
"tak","nie",
"byc moze.Zmien postac

pytania„

};
char nap[80];
printf("wprowadz pytanie\n");
gets(nap);
printf(p[strlen(nap)%3]);
return 0;}

/*WYNIK:
wprowadz pytanie
tak
tak
wprowadz pytanie
Nnnnn
byc moze.Zmien postac
pytania*/

scanf

• ...aby przeczytać z wejścia coś bardziej

złożonego niż pojedynczy znak

• scanf

jest odpowiednikiem

printf

dla

strumienia wejściowego

• udostępnia wiele podobnych konwersji

jak

printf

, ale w przeciwnym kierunku

• Prototyp:

int scanf(char *format, ...)

• scanf

wymaga wskaźników do

zmiennych

Przykład

scanf

#include <stdio.h>

main() {

int x;
printf(” Podaj liczbę: ”);
scanf(”%d”, &x);
printf(”Kwadrat %d wynosi %d\n”, x, x*x);
return 0;

}

/*WYNIK:
Podaj liczbę:5
Kwadrat 5 wynosi
25*/

Tablice

• Definiują więcej “zmiennych” jedną

definicją

• Składnia:

<typ> <zmienna>[liczba_elementów]

• Przykład:

int a[10];

• Indeksowanie: od 0 - jaki jest ostatni

indeks?

• Dostęp:

a[5] = 17;

Łańcuchy znakowe jako

tablice

• Definiowanie zmiennej

przechowującej łańcuchy (teksty):
jako tablicy znaków:

char nazwa[długość]

na przykład:

char s[20];

• Na końcu łańcucha jest znak ’\0’

• Uwaga na długość!
• Funkcje operujące na łańcuchach

Operacje na

wskaźnikach

• Wskaźniki mogą być:

– porównywane
– odejmowane
– powiększane o wartość całkowitą

(skalowaną!)

– pomniejszane o wartość całkowitą

(skalowaną!)

• Dodanie 1 do wskaźnika powiększa

adres
o

rozmiar wskazywanego typu

Dodawanie liczby

całkowitej

do wskaźnika

double *pd;
double t[10];
pd = &(t[5]);
printf(”%p\n”,pd);

/* 0065FB60 */

pd = pd + 3;
printf(”%p\n”,pd);

/* 0065FB78 */

/* teraz pd wskazuje na t[8] */

0x18 = 24
=
= 3*8

Wskaźniki i tablice

• Nazwa tablicy jest synonimem

adresu jej początkowego elementu

• Przykład:

double x[5];
double *p;
p = x;

/* tak jak p = &(x[0]); */

*p = 12;
p++;

/* teraz p wskazuje na x[1] */

*p = 13;

/* tutaj x[0]=12, x[1]=13 */

Wyprowadzenie łańcucha

bez użycia

printf

#include <stdio.h>

main()
{
char s[]="Hello again!\n";
char *p;
p=s;
while (*p)
putchar (*p++);

return 0;
}

WYNIKI:
Hello again!

Nasza pamięć

• Człowiek dysponuje (co najmniej)

dwoma rodzajami pamięci:

– dużą

: trwałą, ale trudną w zapisie

(czas zapisu jest długi)

– małą

: zanikającą w ciągu kilku

sekund, ale łatwą do zapisania

Funkcje

• Człowiek potrafi analizować jednocześnie

około 7 obiektów

• Co stanie się, jeśli program ma więcej niż

7 linii?

• Program należy podzielić na funkcje:

– Zapisać kilka linii kodu i nadać im nazwę
– Uruchamiać je stosując nazwę

• Oczywiście, nie jest to jedyny powód, dla

którego należy stosować funkcje...

Przykład Funkcji podnoszenia do

potęgi

#include <stdio.h>
/* power:  podnoszenie base to n-tej potęgi;
            n >= 0 */
    int power(int base, int n)
    {
        int i, p;   /* zmienne lokalne */
        p = 1;
        for (i = 1; i <= n; ++i)
            p = p * base;
        return p;
    }
main(){
        int i;
        for (i = 0; i < 10; ++i)
            printf("%d %d %d\n",
            i, power(2,i), power(-3,i));
        return 0;}

Sterowanie -

dokończenie

• Konstrukcje poznane do tej pory:

– if
– if-else
– while
– for

• Inne:

– do-while
– switch
– break
– continue

Pętla

do-while

• Składnia:

instrukcja

while (wyrazenie);

• Przyklad:

int n;

    do {
      printf(”Podaj liczbę dodatnią: ”);
      scanf(”%d”,&n);
    } while (n<=0);

Instrukcja

switch

•Składnia:

switch (wyrażenie) {

case wyrazenie-stale: instrukcje

default: instrukcje

}

•Przykład:

switch (c=getchar()) {

case ’+’:

printf("Plus");

break;

case ’-’:

printf("Minus");

break;

default: printf("Inny znak");

}

Przerywanie pętli

•Czasem potrzebne okazuje się
przerwanie pętli w inny sposób niż
przy testowaniu warunku

•Instrukcja

break

daje możliwość

wyjścia z pętli

for, while

, tak

jak ze

switch

•break

powoduje, że przerywana

jest najbardziej wewnętrzna pętla
lub

switch

kalkulator Przykład

switch,

break

#include<stdio.h>
#include<stdlib.h>

int main(void){
int i,j;
char dz;
printf("wprowadz dzialanie\n");
scanf("%d%c%d",&i,&dz,&j);
switch(dz){
case '+':printf("%d",i+j);
break;
case'-':printf("%d",i-j);
break;
case'/':if(j)printf("%d",i/j);
break;
case'*':printf("%d",i*j);}
return 0;}

/*WYNIKI
wprowadz dzialanie
3-2
1
wprowadz dzialanie
4*5
20
wprowadz dzialanie
4+5
9
wprowadz dzialanie
4/2
2
*/

Pomijanie iteracji:

continue

• Instrukcja

continue

jest podobna do

break

, jest stosowana rzadziej

• Powoduje rozpoczęcie kolejnej iteracji

for

while

, lub

bez dokańczania

bieżącej

• W pętli

while

oznacza to

natychmiastowe przejście do

testowania warunku

• W pętli

for

, sterowanie przechodzi do

części „inkrementującej”

• Instrukcja

continue

nie dotyczy

switch

. Zastosowana w tej instrukcji

pomija iterację pętli, w której

umieszczono

switch

continue

: przykład

• Przetwarzanie

tylko

nieujemnych

elementów tablicy a

• Ujemne wartości są pomijane

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

{
if (a[i] < 0)

/* skip negative elements */

continue;

... /* do positive elements */

}

oto

i etykiety

• W C dostępna jest instrukcja

goto

i etykiety do

opisywania celu skoku

• Formalnie, instrukcję

goto

można zastąpić innymi

• W praktyce łatwo jest pisać kod bez

goto

• Sytuacja,

której

goto

jest

przydatne:

przerywanie zagnieżdżonych pętli w sytuacji

wystąpienia błędu:

for (

...

)

for (

...

) {

...

               if (katastrofa)
                   goto error;
           }

...

error:

/* clean up the mess */

oto

: inny przykład

• Ustalenie, czy dwie tablice a i b mają

wspólny element:

    for (i = 0; i < n; i++)
        for (j = 0; j < m; j++)
            if (a[i] == b[j])
                goto found;

/* nie znaleziono wsp. elem. */

...
found:

/* znaleziono: a[i] == b[j] */

...

Unikanie

oto

• Kod zawierający

goto

może zawsze zostać

zapisany bez tej instrukcji, choć czasem wymaga

to wprowadzenia dodatkowych zmiennych i

wydłużenia kodu:

  found = 0;
  for (i = 0; i < n && !found; i++)
     for (j = 0; j < m && !found; j++)
         if (a[i] == b[j])
             found = 1;
  if (found)

/* znaleziono: a[i-1] == b[j-1] */

...
else

/* nie znaleziono el. wsp. */

...

Document Outline