Język C

Informacje wstępne

Struktura programu

Program w języku C zazwyczaj składa się z deklaracji plików nagłówkowych, definicji funkcji i procedur oraz wyróżnionej funkcji main, która jest domyślnie wywoływana w momencie uruchomienia programu. Funkcja ta zwraca wartość typu int.

// deklaracje plików nagłówkowych
#include <stdio.h>
// definicje funkcji i procedur
void procedure1(){
  // ciało procedury
}
int function1(int arg){
  // ciało funkcji
}
int main(){
  // ciało głównej funkcji
}

Komentarze w kodzie mogą przyjmować postać dwóch slashy // i wtedy obowiązują do końca linijki.

Kompilacja i uruchamianie programu

Aby wykonać program napisany w języku C, należy najpierw dokonać jego kompilacji, tzn. przetłumaczenia jego kodu źródłowego na ciąg instrukcji niskiego poziomu, zrozumiałych przez procesor. W systemach uniksopodobnych kompilacja odbywa się za pomocą polecenia gcc, które wymaga podania nazwy pliku do skompilowania, np.

$ gcc prog1.c

W wyniku wywołania tego polecenia, tworzony jest plik a.out, który może zostać bezpośrednio uruchomiony. Przy uruchamianiu programu, jego Nazwa musi zostać poprzedzona kropką i slashem, np.

$ ./a.out

Aby określić nazwę generowanego pliku, możemy skorzystać z opcji -o, np.

$ gcc prog1.c -o prog1

Wtedy można wywołać program korzystając z tej nazwy:

$ ./prog1

Podstawowe operacje wejścia/wyjścia

Aby móc komunikować się z użytkownikiem uruchamiającym program, konieczna jest znajomość co najmniej dwóch wywołani ze standardowej biblioteki C – printf oraz fgets. Oba wywołania są zdefiniowane w bibliotece sdtio.

printf

Wywołanie printf pozwala wypisać na ekran wartości różnych typów zmiennych. Pierwszym argumentem tego wywołania jest format komunikatu, który może składać się ze zwykłych znaków oraz wyrażeń, które są zastępowane wartościami pozostałych argumentów tego wywołania.

Najprostsze wywołanie wygląda następująco:

printf("Hello world.\n")

• s – łańcuch znaków
• c – pojedynczy znak
• d – liczba całkowita
• ld – długa liczba całkowita
• f – liczba zmiennopozycyjna

int i = 10;
float f = 20.0;
printf("Zmienna i: %d, zmienna f: %f",i,f);

fgets

Odczytanie komunikatu użytkownika jest nieco bardziej skomplikowane. Ze względów bezpieczeństwa nie wykorzystuje się wywołania gets, które ma najprostszą postać. Wywołanie fgets wymaga aż trzech argumentów: zmiennej, która reprezentuje tablicę, w której ma być umieszczony wynik, maksymalnej liczby czytanych znaków oraz nazwy strumienia, z którego odczytujemy znaki. W domyślnej postaci czyta znaki do końca linii (o ile nie przekroczona byłaby maksymalna liczba znaków przekazana w wywołaniu).

char napis[31];
fgets(napis,31,stdin);

Przykładowy program wczytujący komunikat użytkownika i wypisujący go na ekran wygląda następująco:

#include <stdio.h>
int main(){
        char napis[31];
        fgets(napis,31,stdin);
        printf("%s\n",napis);
}

Podstawowe operacje konwersji

Ponieważ język C nie pozwala na automatyczną konwersję pomiędzy typami danych, aby móc operować na danych liczbowych dostarczanych przez użytkownika, konieczne jest przeprowadzenie konwersji pomiędzy łańcuchem znaków, a odpowiednim type liczbowym.

Metody konwersji definiowane są w bibliotece stdlib, dlatego wymagają załączenia pliku nagłówkowego <stdlib.h>

atoi, atol

Metody atoi oraz atol pozwalają na konwersję łańcucha znaków na liczbę całkowitą typu int oraz typu long. Jako swój argument przyjmują łańcuch znaków w postaci tablicy i zwracają wartość całkowitą.

Przykładowo, jeśli chcemy obliczyć sumę wartości wprowadzonych przez użytkownika możemy napisać następujący program:

#include <stdio.h>
#include <stdlib.h>
int main(){
    int liczba1, liczba2;
    char napis[11];
    printf("Wprowadź pierwszą liczbę: ");
    fgets(napis,11,stdin);
    liczba1 = atoi(napis);
    printf("Wprowadź drugą liczbę: ");
    fgets(napis,11,stdin);
    liczba2 = atoi(napis);
    printf("Suma wprowadzonych liczb wynosi %d\n",liczba1 + liczba2);
}

atof

Funkcja atof jest odpowiednikiem funkcji atoi, ale służy do konwersji liczb zmiennopozycyjnych. Jako argument przyjmuje łańcuch znaków, natomiast zwracana wartość jest typu double.

Typy danych

Podstawowe typy danych

Każda zmienna używana w języku C musi mieć określony typ, który określa zbiór wartości, jakie może ona przyjmować oraz wyznacza operacje, jakie mogą być wykonywane na wartościach przypisanych do zmiennej.

• dodawania +, odejmowanie -
• mnożenie * , dzielenie całkowice /
• dzielenie modulo %

• int – typ reprezentujący liczby całkowite
• long – jak int reprezentujacy wartosci całkowiet, ale o większym zakresie wartości
• float – typ reprezentujący liczby rzeczywiste pojedynczej precyzji
• double – typ reprezentujący liczby rzeczywiste podwójnej precyzji
• char – typ reprezentujący znaki

Zmienne w programach napisanych w C deklarowane są za pomocą słowa kluczowego reprezentującego typ zmiennej, po którym następuje list nazwa_zmiennych zakończona średnikami.

Przykład

int liczba_calkowita;
float liczba_rzeczywista;
char znak1,znak2;

W powyższym przykładzie definiowanych są 4 zmienne: liczba_calkowita, liczba_rzeczywista, znak1 oraz znak2. Pierwsza zmienna jest typu całkowitego, druga rzeczywistego, a trzecia i czwarta znakowego.

Typ tablicowy

Typ tablicowy pozwala na definiowanie zmiennych, które składają się z tablic elementów jednakowego typu. Elementy tablicy mogą być typu prostego lub złożonego (np. tablicowego). Pozwala to na definiowanie np. tablic tablic (którym w matematyce odpowiada pojęcie macierzy).

Każda zmienna typu tablicowego musi określać swój rozmiar oraz typ elementów. Typ elementów określany jest przez nazwę typu składowego występującą przed nazwą zmiennej. Rozmiar tablicy podawany jest jako liczba całkowita ujęta w nawiasy kwadratowe po nazwie zmiennej. Elementy tablicy indeksowane są od 0.

Przykład

int wektor[10];
int macierz[10][10];

W powyższym przykładzie definiowane są dwie zmienne, spośród których pierwsza jest tablicą składającą się z 10 elementów typu całkowitego, druga zaś jest tablicą 10 tablic składających się z 10 elementów typu całkowitego.

Dostęp do elementów tablicy odbywa się za pomocą operatora indeksowania [], który pojawia się po nazwie zmiennej i zawiera indeks elementu. Za pomocą tego operatora można zarówno odczytywać jak i przypisywać wartości poszczególnym elementom tablicy. Indeks elementu, do którego następuje dostęp, musi być większy lub równy 0 oraz mniejszy od rozmiaru tablicy.

Przykład

int main(){
    int wektor1[10];
    int pierwszy_element;
    //przypisanie wartości do pierwszego elementu tablicy wektor1
    wektor1[0] = 1;
    //odczyt wartości pierwszego elementu tablicy wektor1
    pierwszy_element = wektor1[1]
    //poniższe przypisanie jest niepoprawne, gdyż wartość przypisywana dla indeksu spoza górnego limitu
    wektor1[20] = 100;
    //poniższe przypisanie nie spowoduje błędu, ponieważ znak niejawnie konwertowany jest 
    //na liczbę całkowitą, na podstawie swojego położenia w tablicy ASCII
    wektor1[0] = 'a';
}

Jak to zostało wcześniej wskazane, elementy tablicy mogą być typu złożonego, w szczególności typu tablicowego. Konstrukcje tego rodzaju pozwalają na definiowanie np. tablic tablic, inaczej zwanych tablicami dwuwymiarowymi. Na tej samej zasadzie można tworzyć tablice trój-, cztero- czy n-wymiarowe.

Aby odwołać się do podstawowego elementu takiej struktury, należy określić dwa indeksy – tablicy pierwszego i drugiego rzędu. Można to zrobić zestawiając ze sobą dwa operatory indeksowania.

W przypadku tablic dwuwymiarowych, pierwszy indeks zwany jest indeksem wierszowym, natomiast drugi – kolumnowym.

Przykład

int main(){
  int macierz1[10][3];
  // przypisanie wartości 1 elementowi stojącemu w pierwszym wierszu i pierwszej kolumnie zmiennej macierz1
  macierz1[0][0] = 1;
  //przypisanie wartości 2 elementowi stojącemu w pierwszym wierszu i trzeciej kolumnie zmiennej macierz1
  macierz1[0][2] = 2;
  //przypisanie wartości 3 elementowi stojącemu w trzecim wierszu i pierwszej kolumnie zmiennej macierz1
  macierz1[2][0] = 3;
  //przypisanie poprawne
  macierz1[3][0] = 4;
  //przypisanie niepoprawne - drugi indeks nie jest mniejszy niż rozmiar tablicy
  macierz1[0][3] = 5;
}

Instrukcje

Instrukcje występujące w kodzie programu napisanego w języku C odpowiadają blokom lub grupom bloków połączonych strzałkami, występującym na schematach blokowych.

• instrukcja pusta
• instrukcja grupująca
• instrukcje decyzyjne
• pętle

Instrukcja pusta składa się z jednego średnika ”;” i jak wskazuje jej nazwa, jest ignorowana. Pozostałe typy instrukcji omówione są poniżej.

Instrukcja grupująca

Instrukcja ta pozwala na traktowanie sekwencji instrukcji jak pojedynczej instrukcji. Instrukcja ta składa się z otwierającego nawiasu klamrowego “{”, listy instrukcji oddzielonych średnikami (najczęściej zapisywanych w kolejnych wierszach programu), a kończy nawiasem klamrowym zamykającym “}”.

Ogólna postać instrukcji grupującej przedstawiona jest poniżej:

{
  //instrukcja_1;
  //instrukcja_2;
  //...
}

Przykład

W poniższym przykładzie instrukcja grupująca obejmuje trzy operacje przypisania wartości do zmiennych, odpowiednia a, b i c.

int main(){
    int a,b,c;
    {
        a = 5;
        b = 2;
        c = a * b;
    }
}

Instrukcji grupująca nie posiada swojego bezpośredniego odpowiednika w schematach blokowych. Każdy fragment schematu blokowego, w którym wszystkie ścieżki wykonania zaczynają się i kończą w tych samych punktach może być objęty instrukcją grupującą.

Powyższemu przykładowi odpowiada po prostu sekwencja bloków obliczeniowych:

Instrukcja warunkowa i instrukcja selekcji

W języku C, podobnie jak w schematach blokowych, występują dwie instrukcje decyzyjne (odpowiadają one blokowi warunkowemu oraz blokowi selekcji): warunkowa i selekcji.

Instrukcja warunkowa

Instrukcja warunkowa pozwala na wykonanie alternatywnych ścieżek programu, w zależności od spełnienia określonego warunku logicznego. Instrukcja ta składa się ze słowa kluczowego if, po którym następuje ujęte w nawiasy okrągłe wyrażenie logiczne, po nim zaś następuje instrukcja, która wykonywana jest, gdy warunek logiczny jest prawdziwy. Po tej instrukcji może nastąpić słowo kluczowe else, wraz z instrukcją, która jest wykonywana, jeśli warunek logiczny nie zachodzi. W poprawnej instrukcji warunkowej nie musi jednak występować klauzula else.

Ogólny schemat instrukcji warunkowej przedstawiony jest poniżej.

if(wyr_log)
  //instrukcja_1;
else
  //instrukcja_2;
//instrukcja_3;

Kod który następuje po drugiej instrukcji (w przypadku wystąpienia klauzuli else) lub pierwszej (w przypadku przeciwny) wykonywany jest niezależnie od tego, czy wyrażenie logiczne jest prawdziwe, czy fałszywe. Powyższemu przykładowi na schemacie blokowym odpowiadałaby następująca grupa bloków:

Ponieważ w instrukcji warunkowej w poszczególnych alternatywnych ścieżkach wykonania programu może wystąpić tylko jedna instrukcja, w celu wykonania większej liczby instrukcji, konieczne jest wykorzystanie instrukcji grupującej (patrz poniższy przykład).

Wyrażenia logiczne występujące w instrukcji warunkowej mogą stanowić alternatywę lub koniunkcję wyrażeń logicznych. Alternatywa logiczna zapisywana jest za pomocą operatora ||, natomiast koniunkcja za pomocą operatora &&. Negacja zapisywana jest za pomocą operatora !.

Przykład

#include <stdio.h> 
#include <stdlib.h>
int main(){
  int rok, liczba_dni, dni_w_lutym;
  char napis[31];
  printf("Wprowadź rok: ");
  fgets(napis,31,stdin);
  rok = atoi(napis);
  if ((rok % 4 == 0 && ((rok % 100 != 0) || (rok % 400 == 0))){
    liczba_dni = 366;
    dni_w_lutym = 29;
  } else {
    liczba_dni = 365;
    dni_w_lutym = 28;
  }
  printf("W roku %d jest %d dni.\n",rok,liczba_dni);
  printf("Luty ma w tym roku %d dni.\n",dni_w_lutym);
}

Powyższy fragment kodu ustala wartość zmiennych liczba_dni oraz dni_w_lutym na podstawie wartości zmiennej rok. (Lata przestępne wypadają co cztery lata, z wyjątkiem lat będących wielokrotnością 100 ale nie będących wielokrotnością 400). Zastosowano w nim wyrażenie logiczne składające się z alternatywy, negacji oraz koniunkcji, a także przedstawiono zastosowanie instrukcji grupującej w kontekście instrukcji warunkowej.

Ponadto w przykładzie tym wykorzystane są funkcje i procedury biblioteczne printf, fgets oraz atoi (o funkcjach i procedurach czytaj dalej). Pierwsza procedura pozwala wyprowadzać komunikaty na zewnątrz wykonywanego programu (zazwyczaj na ekran monitora). Druga procedura pozwala wczytać wartość wprowadzoną z klawiatury do zmiennej. Natomiast funkcja atoi pozwala na konwersję napisu do wartości liczbowej.

Przykładowe wykonanie programu mogłoby wyglądać następująco:

Wprowadź rok: 2000
W roku 2000 jest 366 dni.
Luty ma w tym roku 29 dni.

Instrukcja selekcji

Instrukcja selekcji służy do wyboru jednej spośród wielu możliwych ścieżek realizacji algorytmu. Instrukcja ta składa się ze słowa kluczowego switch, po którym następuje nazwa zmiennej ujęta w nawiasy okrągłe oraz otwierający nawias klamrowy. Każda alternatywna ścieżka realizacji algorytmu zaczyna się od słowa kluczowego case, po którym występuje stała oraz dwukropek oznaczający początek listy instrukcji, które mają zostać zrealizowane dla tej opcji. List instrukcji kończy się słowem kluczowym break.

W ogólnym przypadku można łączyć kilka opcji w jedną (jeśli wprowadzi się kolejną instrukcję case bez słowa kluczowego break lub jeśli poda się zakres stałych w postaci dolnego i górnego ograniczenia i trzykropka występującego pomiędzy nimi).

Ogólna postać instrukcji selekcji przedstawiona jest poniżej:

switch(zmienna){
  case stala1 :
    //instr_1;
    break;
  case stala2 :
    //instr_2;
    break;
  case stala3 :
  case stala4 :
    //instr_3;
    break;
}

Instrukcji selekcji na schematach blokowych odpowiada blok selekcji:

Przykład

#include <stdio.h>
int main(){
  char napis[2];
  printf("Wprowadź znak: ");
  fgets(napis,2,stdin);
  switch(napis[0]){
    case '.' :
    case ',' :
    case '!' :
      printf("znak przestankowy\n");
      break;
    case '0' ... '9' :
      printf("cyfra\n");
      break;
    case 'a' ... 'z' :
    case 'A' ... 'Z' :
      printf("litera\n");
      break;
    case ' ' :
      printf("spacja\n");
      break;
  }
}

W powyższym przykładzie instrukcja selekcji wykorzystywana jest do opisywania niektórych typów znaków występujących jako pierwszy znak zmiennej napis.

Przykładowe wykonanie programu mogłoby wyglądać następująco:

Wprowadź znak: .

znak przestankowy

Pętle

Schematy blokowe nie dostarczają żadnych specjalnych mechanizmów do tworzenia pętli (czyli fragmentów algorytmu, które wykonywana są wielokrotnie). W większości języków programowania istnieją jednak instrukcje, które pozwalają na łatwe definiowanie pętli, gdyż są one stosowane bardzo często.

• while
• do ... while
• for

W zasadzie każda pętla może być skonstruowana przy użyciu dowolnej z tych instrukcji. Tym niemniej, zazwyczaj użycie wybranej instrukcji jest wygodniejsze w tych albo innych przypadkach.

Pętla while

Pętla tworzona z wykorzystaniem instrukcji while jest najprostszym typem pętli. Pozwala ona na wykonywanie pewnej instrukcji tak długo, jak długo spełniony jest określony warunek logiczny.

Pętla tego rodzaju składa się ze słowa kluczowego while, po którym występuje warunek logiczny, a po nim instrukcja, która ma być wykonywana.

Ogólna postać pętli while przedstawiona jest w poniższym przykładzie:

while(wyr_log)
  //instrukcja_1;

Dosyć jasne jest, że jeśli początkowo warunek logiczny jest spełniony i w instrukcji wykonywanej w ramach pętli nie dokonywane jest żadne obliczenie, które może spowodować zmianę wartości warunku logicznego, to pętla ta będzie wykonywała się w nieskończoność.

Pętli while odpowiada następujący schemat blokowy:

Przykład

#include <stdio.h>
int main(){ 
  char znak;
  while(!feof(stdin)){
    znak = getchar();
    printf("%c\n",znak);
  }
}

a
a
1
1
g
g
[Ctrl+D]

do 
  //instrukcja_1;
while(wyr_log);

#include <stdio.h> 
int main(){
  char znak;
  do {
    printf("Wprowadź znak i naciśnij [enter]. Aby zakończyć wprowadź 'k'\n");
    znak = getchar();
    printf("Wprowadziłeś %c\n",znak);
    getchar();
  } while(znak != 'k');
}

Wprowadź znak i naciśnij [enter]. Aby zakończyć wprowadź 'k'
a
Wprowadziłeś a
G
Wprowadziłeś G
k
Wprowadziłeś k

for(indeks = war_1; indeks < war_2; indeks++)
  //instrukcja_1;

#include <stdio.h>
int main(){
  const n = 5;
  int indeks;
  int liczby[n];
  char napis[11];
  for(indeks = 0; indeks < n; indeks++){
    printf("Wprowadź %d. liczbę całkowitą: ",indeks+1);
    fgets(napis,11,stdin);
    liczby[indeks] = atoi(napis);
  }
  for(indeks = n-1; indeks >= 0; indeks--){ 
    printf("%d\n",liczby[indeks]);
  }
}

Wprowadź 1. liczbę: 10
Wprowadź 2. liczbę: 2
Wprowadź 3. liczbę: 4
Wprowadź 4. liczbę: 1
Wprowadź 5. liczbę: 12
12
1
4
2
10

typ_rezultatu nazwa_funkcji(typ_1 argument_1, typ_2 argument_2){
  //ciało funkcji
}

zmienn = nazwa_funkcji(argument_1, argument_2, ...);

#include <stdio.h>
int potega(int podstawa, int wykladnik){
  int indeks, rezultat;
  rezultat = 1;
  for(indeks = 0; indeks < wykladnik; index++){
    rezultat = rezultat * podstawa;
  }
  return rezultat;
}
int main(){
  int wartosc; 
  wartosc = potega(2,3);
  printf("Trzecią potęgą liczby 2 jest : %d\n",wartosc);
  wartosc = potega(3,4);
  printf("Czwartą potęgą liczby 3 jest : %d\n",wartosc);
}

Trzecią potęgą liczby 2 jest : 8
Czwartą potęgą liczby 3 jest : 81

void nazwa_procedury(typ_1 argument_1, typ_2 argument_2){
  //ciało procedury 
}

void wypisz_liczbe(int liczba){
  printf("Liczba posiada wartość %d\n",liczba);
}
int main(){
  wypisz_liczbe(5);
  wypisz_liczbe(10); 
  //wywołanie niepoprawne - brak argumentu
  wypisz_liczbe();
  //wywołanie niepoprawne - niewłaściwy typ argumentu
  wypisz_liczbe("aa");
}

Liczba posiada wartość 5
Liczba posiada wartość 10