Język C, C++.

Krótka charakterystyka C i C++/

Języki C i C++ - uniwersalne,  do celów ogólnych.

W językach tych powstają aplikacje dla różnych systemów operacyjnych, w tym m.in. dla Windows, Unix, Linux, MacOS, BeoS.

Język C został zdefiniowany w 1972 r. przez Denisa M Ritchie z Bell Laboratories w New Jersey.

W 1988 r. powstało opracowanie tzw. standardu ANSI lub "ANSI C".

Język C jest językiem ogólnego zastosowania. Język w miarę prostoty, niezbyt obszerny, szerokiego zastosowania.
Charakteryzuje się także nowoczesnymi strukturami danych i bogatym zestawem operatorów.
Niezbyt abstrakcyjny (wydumany). C nie jest językiem "bardzo wysokiego poziomu", nie jest nawet "duży", i nie został opracowany dla jakiejś szczególnej dziedziny zastosowań.
Brak ograniczeń oraz ogólność powodują, że w wielu przypadkach jest wygodniejszy i bardziej sprawny od innych języków oprogramowania o pozornie większych możliwościach.
Można zrobić w nim w miarę wszystko. Ścisły związek z UNIX - ci sami twórcy. Tysiące funkcji bibliotecznych.
Język C pierwotnie miał ułatwiać tworzenie oprogramowania systemowego - UNIX. UNIX z definicji wyposażony w kompilator C.
 Język C można zakwalifikować jako język wysokiego poziomu (1:10 - źródło wynik).
Można również wykonać operacje zastrzeżone dla niskiego poziomu - elementy programowania niskiego poziomu.
Możliwość operowania adresami - operacje na adresach (np. wsk, *wsk, *(wsk+7)). Pozwala to wyeliminować wstawki w języku Asemblera.

Ogólna struktura programu w języku C

Cechą języka C/C+ jest możliwość budowy programu z wielu modułów. Modułem może byc każdy zbiór zawierający poprawny kod źródłowy.

Program w C zbudowany jest z funkcji.
Każda z nich może posiadać parametry oraz określony typ wartości. Aby można było wygenerować kod wynikowy programu (w DOS zbiór .EXE),
w jednym i tylko w jednym z modułów musi się znaleźć funkcja main(), od której rozpocznie się wykonywanie programu.
Moduł zawierający funkcję main() nazywa się modułem głównym.

Najprostszy wykonywalny program C:

int main(void)

  { 

    return 0;

  }

Program ten składa się tylko z bezparametrowej funkcji main, której wartość jest typu całkowitego (int).
Ciało funkcji zbudowane jest z instrukcji, które powinny znaleźć się w bloku wyznaczonym nawiasami kwadratowymi. Funkcja ta zwraca za pomocą instrukcji return wartość zero.

Skompiluje się również program w postaci:
main() { },  ewentualnie w postaci void main() { } lub  void main(void) { }

Ogólna struktura programu w C/C++

W profesjonalnych programach w nagłówku powinna być podana nazwa programu,
dane o autorze, prawa autorskie, przeznaczenie programu, data ostatniej aktualizacji programu, nazwa kompilatora, uwagi odnośnie kompilowania, linkowania, wykonania

Sekcja #include zawiera specyfikację włączanych plików bibliotecznych oraz własnych

Sekcja #define zawiera definicje stałych i makroinstrukcji

Następne sekcje to zmienne globalne oraz prototypy funkcji.
Muszą wystąpić przed ciałami funkcji, aby w dalszej części programu nie było odwołań do obiektów nieznanych kompilatorowi.
Jeżeli funkcje pozostałe umieszczone byłyby przed funkcją main() to specyfikowanie prototypów byłoby zbyteczne.

Włączenia tekstowe #include mogą w zasadzie wystąpić w dowolnym miejscu programu.
Zaleca się aby dłuższe funkcje lub grupy funkcji były umieszczane w osobnych plikach. Istnieje wówczas włączenia tych funkcji przez inne programy.
Zaleca się parametryzację i uniwersalizację opracowywanych modułów.

Podstawowy fragment (element) programu w języku C

 main()  /* klamra otwierająca - początek funkcji głównej
(jak begin w Pascalu)*/

 {   /* tu zaczyna się treść programu - w funkcji main()*/

  /* treść */         

 }    /* klamra zamykająca - jak end w Pascalu*/

/* - rozpoczęcie komentarza,   */ - koniec komentarza

W pisaniu programów rozróżniane są duże i małe litery - np. w main()

Język C/C++ nie ma instrukcji realizujących operacje we/wy.
Do tego celu służą funkcje bibliotek standardowych.
Użycie ich jest niezbędne, gdy trzeba pobrać dane od użytkownika i wysłać je na ekran.

Co potrzebne do programowania w C, C++

Do programowania w C potrzebne są

• komputer z SO Windows lub Linux,
• kompilator języka C,
• linker (zwykle jest z kompilatorem),
• przydatny tez debuger,
• edytor tekstowy.

Do tworzenia programów można wykorzystywać zintegrowane środowiska programistyczne jak:
firmy Borland: Turbo C, Borland C, Borland C++ Builder
Microsoft Visual C++,
Dev C++,
CodeBlocks
KDevelop (Linux) do KDE,
Eclipse

Do edycji można użyć dowolnego edytora tekstowego zapisującego pliki
w postaci czystego kodu ASCII,  typu Notatnik, Edit
lub np. Notepad ++, ConTEXT, które pozwalają  sprawdzać składnię
i podkolorowują odpowiednio tekst po wybraniu języka.

Do kompilacji można użyć środowiska programistycznego Borland C++  Compiler 5.5 – program BCC32.exe.

Kompilator ten jest darmowy, generuje 32-bitowy kod dla Windows, zawiera tylko niezbędne narzędzia uruchamiane z linii poleceń, jest prosty w instalacji i konfiguracji.

Najlepiej zainstalować w C:\BCC55.
W katalogu tym są podkatalogi: BIN, INCLUDE, LIB, HELP, EXAMPLES.

Pliki konfiguracyjne w katalogu C:\BCC55\BIN: BCC32.cfg i ILINK32.cfg  

Zawartość plików

Plik BCC32.cfg

-I"c:\Bcc55\include"

-L"c:\Bcc55\lib"

lub w innej wersji

-5

-O2

-I"c:\Bcc55\include"

-L"c:\Bcc55\lib"

Plik ILINK32.cfg - składa się z jednej linii

-L"c:\Bcc55\lib"

Można też dodać katalog C:\BCC55\BIN do ścieżki wyszukiwania
– dopisać w wierszu poleceń:
PATH=%PATH%;C:\BCC55\BIN  

Kompilacja programów przy pomocy BCC32.EXE:

Bcc32 program.c  lub  bcc32 program cpp
albo użycie np. programu bachowego np. bcc.bat  typu:

copy %1 c:\bcc5\bin

cd c:

cd \bcc55\bin

bcc32.exe %1

Kompilator BCC32 rozróżnia język, w którym został napisany program kompilowany na podstawie rozszerzenia pliku źródłowego.
Pliki z rozszerzeniem C są traktowane jako pliki klasycznego języka C (strukturalne).
Pliki z rozszerzeniem CPP są traktowane jako programy w języki C++
(strukturalne i technika obiektowo orientowana).

Pisanie programów

Pierwszy przykładowy  program

Przyjęło się, że pierwszy program napisany w dowolnym języku programowania, powinien wyświetlić tekst “Hello World!” (Witaj Świecie!).

Język C nie ma żadnych mechanizmów przeznaczonych do wprowadzania i wypisywania danych - trzeba zatem skorzystać z odpowiadających za to funkcji
-  w tym przypadku printf(), zawartej w standardowej bibliotece C (ang. C Standard Library)

Zawartość pliku hello.c – wersja w języku C

#include <stdio.h>

int main (void)

{

printf ("Hello World!");

return 0;

}

# - preprocesor - wstępny przetwarzacz - uwzględnia dodatkowe rzeczy
#include <stdio.h> - dołączenie nagłówków z biblioteki standardowej (ścieżka domyślnych przeszukiwań)
#include "program.h" - dołączenie programu z katalogu aktualnego - podwójne cudzysłowy

W języku C deklaracje funkcji bibliotecznych zawarte są w plikach  nagłówkowych  posiadających najczęściej rozszerzenie .h.

Przykład obrazuje, jak przy użyciu dyrektywy #include umieścimy w kodzie plik standardowej biblioteki C stdio.h
(Standard Input/Output.Headerfile) zawierającą definicję funkcji printf:

#include <stdio.h>

W nawiasach trójkątnych < > umieszcza się nazwy standardowych plików nagłówkowych.

Żeby włączyć inny plik nagłówkowy (np. własny), znajdujący się w katalogu z kodem programu, trzeba go wpisać w cudzysłów:  #include "mój_plik_nagłówkowy.h"

Mamy więc funkcję printf(), jak i wiele innych do wprowadzania i wypisywania danych,

W programie definiujemy główną funkcję main(), uruchamianą przy starcie programu, zawierającą właściwy kod.

Definicja funkcji zawiera, oprócz nazwy i kodu, także typ wartości zwracanej i argumentów pobierany.

Typem zwracany przez funkcję jest int (Integer), czyli liczba całkowita (w przypadku main() będzie to kod wyjściowy programu).
W nawiasach umieszczane są argumenty funkcji, tutaj zapis void oznacza ich pominięcie.

Funkcja main() jako argumenty może pobierać parametry linii poleceń, z jakimi program został uruchomiony, i pełną ścieżkę do katalogu z programem.

Kod funkcji umieszcza się w nawiasach klamrowych {  i  }.

Wszystkie polecenia kończymy średnikiem.
return; określa wartość jaką zwróci funkcja  (tu program).
Liczba zero zwracana przez funkcję main() oznacza, że program zakończył się bez błędów;
błędne zakończenie często (choć nie zawsze) określane jest przez liczbę jeden.

Funkcję main() kończymy nawiasem klamrowym zamykającym.

Wersja  programu  w C++

Zawartość pliku hello.cpp – wersja w języku C++

//  hello.cpp 

#include <iostream.h>
// preprocessor - dołączenie biblioteki  systemowej do funkcji cout – input ootput stream

int main()

{

cout << "Hello World!"; // wyświetlenie napisu

return 0;

}

Pierwszy własny  prosty  program – edycja i kompilacja przy pomocy BCC32

Program p1.c

Uruchamiamy edytor, np.  EDIT z parametrem nazwy pliku, czyli EDIT p1.c
lub notatnik ( zapisujemy plik jako wszystkie p1.c, bez txt)

Wpisujemy treść pliku

#include <stdio.h>

void main(void)

{

printf("Nazwisko Imie: Pierwszy program w C");

}

Uruchamiamy kompilator: BCC32 p1.c 
Utworzony zostanie plik p1.exe jeśli nie było błędów w treści pliku programu.

Korzystanie ze środowiska programistycznego Borlanda,
np. Turbo C – program TC.EXE
( TC.EXE, zwykle w katalogu C:\TC\BIN lub C:\Turbo\Bin)

Uruchamiamy TC.EXE.

Otwieramy plik p1.c – File, Open – wskazujemy plik
i kompilujemy program ALT C, Build  lub Alt F9.
Utworzony zostanie plik p1.exe

Uruchamiamy program ALT R lub CTRL F9.

By zobaczyć wyniki, należy przejść do ekranu użytkownika: Alt W – Menu Windows, User Screen lub bezpośrednio: Alt F5.

Skierowanie wyników programu do pliku (zamiast domyślnie na ekran):

Uruchamiamy program w wierszu poleceń DOS, z parametrami przekierowania wyników, czyli

Nazwa_programu > wynik 
lub Nazwa_programu >> wynik,
 (> - założenie nowego pliku, ewentualne skasowanie starego, >> - dopisanie do istniejącego) np.
p1.exe > w1.txt

Wyniki można obejrzeć w notatniku lub w DOS poleceniem type wynik .lub MORE wynik

Pomoc w TURBO C

Alt H

Np. ALT H, Index, wpisujemy szukane słowo (np.

Instrukcje podstawowe w C

Objaśnienia:

Instrukcja #include poleca kompilatorowi dołączyć do programu plik stdio.h (tzw. pseudonagłówkowy),
w którym zawarta jest m.in. definicja funkcji printf.

Bardzo często używa się też innych plików pseudonagłówkowych, np.  conio.h, math.h itp.
Wszystkie pliki *.h zawarte w nawiasach <>  znajdują się w podkatalogu INCLUDE.

Druga linijka z main zawiera rozpoczęcie funkcji głównej programu czyli main().

Nagłówek void main() to inaczej void main(void)
 void przed mian oznacza, że funkcja nie zwraca żadnego wyniku. (void )w nawiasie po main oznacza brak parametrów programu.

Deklaracja funkcji main może mieć inne formy, np.

int main() - funkcja w wyniku swojego działania zwróci wartość typu int i nie pobiera żadnych parametrów przy rozpoczęciu działania.

int main(void) - inny zapis, ale znaczenie takie samo jak wyżej

main() - jeszcze inny zapis, ale znaczenie takie samo jak wyżej

float main() - w tym przypadku wynikiem działania funkcji będzie typ float.

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

Po linii z main() zaczyna się nawiasem klamrowym otwierającym {
 ciało (treść) funkcji głównej i kończy na końcu nawiasem zamykającym }

Wewnątrz funkcji głównej jest instrukcja printf(), powodująca wyświetlenie na ekranie  tekstu, będącego jej parametrem (tekst w nawiasach w cudzysłowie).

Instrukcje kończymy średnikiem.

Po skompilowaniu czarny ekran i zaraz znika i dlatego trzeba dokonać modyfikacji programu.

Uruchamiamy edytor Edit lub notatnik, zapisujemy plik pod inną nazwą, np. p1a.c i modyfikujemy

Kompilacja: BCC32  p1a.c – w wyniku program skompilowany p1a.exe

Po uruchomieniu: p1a

W programie wprowadzono funkcje

clrscr() – kasowanie ekranu oraz
getch() – program czeka na naciśnięcie dowolnego klawisza.

Definicje tych funkcji są w pliku conio.h,
dlatego jest on dopisany w dyrektywie #include <conio.h>.

Zamiast getch() , można zastosować getchar()  lub  while(!kbhit())

\n to znak specjalny – powoduje przejście do nowej linii.
 Podobnie \t – tabulacja, \a – sygnał dźwiękowy.

Komentarze – oznaczone // - jednolinijkowy – w języku C++
 oraz oznaczone /*    komentarz */ - dłuższe, mogą zawierać  wiele linii – w języku C.
Kompilator nie czyta komentarzy, stosuje się dla wyjaśnienia programu

Program  p1b.c bez komentarzy

Po skompilowaniu: bcc32 p1d.c otrzymujemy p1d.exe.
Po uruchomieniu pokaże się ekran programu:

 Podsumowanie 1:

1. Mamy 2 rodzaje komentarzy i możemy w nich pisać uwagi, pomijane przez kompilator.
2. Aby zatrzymać pracę programu, używamy funkcji getch();.
3. Do czyszczenia ekranu służy funkcja clrscr();.
4. Na końcu funkcji main jest zwykle return 0;.
5. W tekście możemy używać tzw. znaków specjalnych, np. przejście do następnej linii \n.

Przykłady prostych programów

/* Program objw1.c  -  Obliczanie objętości walca   (startowy)      */

/*------------------------------------------------------*/

#include <stdio.h>

void main()

{

   float promien, wysokosc, objetosc;

   promien  = 3.3;

   wysokosc = 44.4;

   objetosc = 3.1415926 * promien * promien * wysokosc;

   printf("Objetosc walca = %f", objetosc);

}

/********************************************************/

/* Program daneos1.c  - dane osobowe*/

#include <stdio.h>
int main(void)
/* funkcja glowna, brak argumentow, zwraca typ calkowity int */

{

            char imie[20];  /* deklaracja tablicy znakow – łańcuch – tekst na 19 znaków
            int i;   /* deklaracja zmiennej całkowitej i

            printf("\nPodaj swoje imie ");  // wydruk napisu na ekran,\n – nowa linia

            gets(imie);   // wprowadzenie imienia

            puts("Ile masz lat? "); // wydruk napisu – funkcja puts()

            scanf("%d",&i);  // wprowadzenie lat

            printf("\n%s ma %d lat.",imie, i); // wyświetlenie imienia i lat

            return 0;   /* funkcja glowna zwraca 0 – pomyślny koniec */

}

Uwaga! Po uruchomieniu Alt F5 – ekran wyników.

Obliczenie pola prostokąta – 3 programy

/* -------------- polepros1.c  - boki a i b w programie ------------- */

void main(void)

{

float a, b;    // deklarujemy zmienne przechowujące boki prostokąta

  float pole; // deklarujemy zmienną zawierającą wynik obliczeń

  a = 5; b =10;    // przypisujemy im wartości

  pole = a * b; // obliczamy pole prostokąta (tu równe 50)

  printf("Pole = %f",pole);

  getch();

}

/*  ----------------polepros2.c  - z funkcja  -------------------------/*

• zestaw znaków
• nazwy i słowa zastrzeżone
• typy danych
• stałe
• zmienne i tablice
• deklaracje
• wyrażenia
• instrukcje

• litery małe i duże języka łacińskiego (angielskiego)
• cyfry 0..9
• znaki specjalne: ! * + \ " < # ( = | { > % ) ~ ; } / ^ - [ : , ? & _ ] ' . oraz znak odstępu (spacja)

Użycie odstępu w nazwie jest niedozwolone. Niektóre implementacje rozpoznają w nazwie do 8 znaków, inne więcej (do 32)

Słowa zastrzeżone

Są to słowa o szczególnym znaczeniu dla języka, których nie wolno używać programiście np. jako nazw zmiennych.

Standardowy zestaw znaków zastrzeżonych języka C:

Niektóre kompilatory mają niektóre lub cześć z następujących słów kluczowych

Niektóre kompilatory mogą mieć też rozpoznawać inne słowa zastrzeżone.

Podstawowe typy danych i rozmiary danych

W języku C występuje tylko kilka podstawowych typów danych:

• char - jeden bajt, zdolny pomieścić 1 znak
• int - typ całkowity
• float - typ zmiennopozycyjne pojedynczej precyzji
• double - typ zmiennopozycyjny podwójnej precyzji

Dodatkowo występuje kilka kwalifikatorów stosowanych z tymi podstawowymi typami. Kwalifikatory short i long odnoszą się do obiektów całkowitych

Szczegóły zależne są od konkretnej implementacji kompilatora języka C.

Są jeszcze inne typy danych jak: void (typ funkcji nie zwracającej wartosci), enum (typ wyliczeniowy) oraz typ wskaźnikowy.
Typ wyliczeniowy (enum) reprezentowany jest na 2 bajtach, wskaźnikowy na 2 lub 4 (w zależności od modelu pamięci), void nie jest reprezentowany.

TYPY, OPERATORY, WYRAŻENIA

Zmienne i stałe są podstawowymi obiektami danych, jakimi posługuje się program.
Deklaracje wprowadzają potrzebne zmienne oraz ustalają ich typy i ewentualnie wartości początkowe.
Operatory określają co należy z nimi zrobić.
Wyrażenia wiążą zmienne i stałe, tworząc nowe wartości.

Stałe

W C występują 4 rodzaje stałych: stałe całkowitoliczbowe, stałe rzeczywiste, stałe znakowe oraz łańcuchy znaków.
Wartosć stałej numerycznej nie może wykraczać poza dopuszczalne granice.

Stałe całkowitoliczbowe

W celu zainicjowania zmiennych typów int i long po znaku równości podajemy całkowitą stałą liczbową. Przykłady:
int l=100;
unsigned k=121;

int la = 0x2ffa;
long i = 25L; /* long */
long unsigned z = 1000lu; /* lub 1000UL */

Stała całkowita, jak np. 1234 jest obiektem typu int.
W stałej typu long na końcu występuje litera l lub L, jak 123456789L.
Stała całkowita nie mieszcząca się w zakresie int jest traktowana jako stała typu long.
W stałych typu unsigned na końcu występuje u lub U,
a końcówka ul lub UL oznacza stałą typu unsigned long.

Stałe rzeczywiste, zwane zmiennoprzecinkowymi reprezentują liczby dziesiętne.
Dozwolony zestaw znaków: 0..9 . + - E e (E lub e reprezentuje podstawę systemu tj. 10)
Uwagi: 1.2*10^-3 można zapisać 1.2E-3 lub 1.2e-3.

Stałe zmiennopozycyjne zawierają albo kropkę dziesiętną (np. 123.4),
albo wykładnik e (np. 1e-2) albo jedno i drugie.
Typem stałej zmiennopozycyjnej jest double, chyba, że końcówka stanowi inaczej. Występująca na końcu litera f lub F oznacza obiekt typu float,
a litera l lub L - typu long double.

Przykłady: 0. 2.  0.2   876.543   13.13E13    2.4e-5 2e8

Deklaracja i inicjalizacja zmiennych rzeczywistych - przykłady::

float s=123.16e10; /* 123.16*10^16 */
double x=10.;
long double x=.12398;
double xy=-123.45;

Stałe znakowe

Stała znakowa jest liczbą całkowitą; taką stałą tworzy jeden znak ujęty w apostrofy, np. 'x'.
Są to więc pojedyncze znaki zamknięte dwoma apostrofami.
Zestaw dowolnych widocznych znaków ASCII.
Wartością jest wartość kodu znaku w maszynowym zbiorze znaków.
Np. wartością stałej '0' jest liczba 48 - liczba nie mająca nic wspólnego z numeryczną wartością 0.

Pewne znaki niegraficzne mogą być reprezentowane w stałych znakowych i napisowych przez sekwencje specjalne, takie jak \n (znak nowego wiersza).

Przykłady: 'A' '#' ' '
char a='a';

Znaki z zestawu ASCII o kodach 0 do 31 są znakami sterującymi, niewidocznymi na wydrukach.
Znaki o kodach 0...127 są jednakowe dla wszystkich komputerów bazujących na kodzie ASCII.
Znaki o kodach 128...255 (kod rozszerzony ASCII) mogą się różnić na różnych komputerach.

Escape-sekwencje - sekwencje specjalne

Niektóre znaki "niedrukowalne" mogą być przedstawione w postaci tzw. escape-sekwencji, np. znak nowej linii jako sekwencja \n.
Pierwszym znakiem tej sekwencji jest backslash (\).
Sekwencja specjalna wygląda jak 2 znaki, ale reprezentuje tylko jeden znak

Dowolny znak przedstawiony w postaci escape-sekwencji może być podany jako
kod liczbowy ósemkowy lub szesnastkowy.

Np. litera K, wartość 10-na ASCII = 75 (wzorzec bitowy dla 1 bajtu = 01001011) ma odpowiednie escape-sekwencje:
\113 jako liczba ósemkowa 01 001 011
\x4B jako liczba szesnastkowa 0100 1011.

Przykłady tak zapisanych stałych znakowych: '\101', '\7', '\x20', '\xAB', '\x2c'
char lf='\n';

Ogólny format takiego zapisu:

• \ooo - dla systemu ósemkowego (o - cyfra 8-wa)
• \xhh - dla systemu szesnastkowego (h - cyfra 16-wa)

Stałe napisowe - napisy, łańcuchy znaków (stałe łańcuchowe)

Stała napisowa lub napis jest ciągiem złożonym z zera lub więcej znaków,
zawartym między znakami cudzysłowu, np. "Jestem napisem".
Stała łańcuchowa składa się z ciągu o dowolnej liczbie znaków.
Ciąg ten musi być ograniczony znakami cudzysłowu.
Przykłady:

"Wynik = "    
" + 2 mln $"  
"Linia nr 1\nLinia nr2"              
""     
"A + B =  "

Łańcuchy mogą zawierać escape-sekwencje.
Łańcuchem pustym są same cudzysłowy.
Łańcuch w sposób niejawny jest zakończony znakiem nul czyli \0.
Dlatego np. stała znakowa 'K' nie jest równoważna łańcuchowi "K".

Łańcuch znaków (napis) można traktować jako tablicę złożoną ze znaków, uzupełnioną na końcu znakiem '\0'
Taka reprezentacja oznacza, że praktycznie nie ma ograniczenia dotyczącego długości tekstów. Programy muszą jednak badać cały tekst, by określić jego długość,
np. strlen(s) ze standardowej biblioteki.

Przykład:
Napis "Katowice" , który może być zadeklarowany jako tablica jednowymiarowa, której elementami są znaki, np.
char napis[] = "Katowice"

Deklaracja i inicjalizacja łańcuchów - przykłady:

char s[10]="\n\fAndrzej\x60";
char str[20]={'\n','\f', 'A', 'n', 'd', 'r', 'z', 'e', 'j', '\x60', '\0'};
char *str1 = "Andrzej Zalewski autor podręcznika" "Programowanie w języku C/C++"

Stałe wyliczeniowe (enumeration constant)

Stałe wyliczeniowe tworzą zbiór stałych o określonym zakresie wartości.
Wyliczenie jest listą wartości całkowitych, np.
enum boolean {NO, YES};
Pierwsza nazwa na liście wyliczenia ma wartość 0, następna 1 itd., chyba że nastąpi jawnie podana wartość.

Przykłady:

enum KOLOR {CZERWONY, NIEBIESKI, ZIELONY, BIAŁY, CZARNY}

KOLOR staje się nazwą wyliczenia, powstaje nowy typ.
Do CZERWONY zostaje przypisana wartość 0, do niebieski 1, zielony 2 itd.
Każda stała wyliczeniowa ma wartość całkowitą.
Jeśli specjalnie się nie określi, to pierwsza stała przyjmie wartość 0, druga 1 itd.

enum KOLOR {red=100, blue, green=500, white, black=700};

red  przyjmie wartość 100, blue 101, green 500, white 501, black 700

enum escapes{BELL='\a', BACKSPACE='\b', TAB='\t', NEWLINE='\n', VTAB='\v', RETURN='\r'};

enum months {JAN=1, FEB, MAR, APR , MAY, JUL, AUG, SEP, OCT, NOV, DEC};

Stałe symboliczne - makrodefinicje

Stała symboliczna jest nazwą przedstawiającą inną stałą - numeryczną, znakową lub tekstową.
Definicję stałej symbolicznej umożliwia instrukcja #define:

#define NAZWA tekst

gdzie NAZWA jest nazwą stałej symbolicznej, a tekst jest związanym z tą nazwą łańcuchem znaków

Przykłady:

Makrodefinicje proste:

#define identyfikator <ciąg-jednostek-leksykalnych>

#define PI 3.14159

#define TRUE 1

#define FALSE 0

#define NAPIS1 Siemianowice

#define IMIE "Andrzej"          

// (puts(IMIE) rozwija w tekst puts("Andrzej")

#define IMIE_I_NAZWISKO IMIE+"Zalewski"      

#define WCZYTAJ_IOSTREAM_H #include <iostream.h>    

Makrodefinicje parametryczne

#define identyfikator(idPar1, idPar2,...) ciąg_jedn_leksykalnych

Np.

#define ILORAZ(a,b) ((a)/(b))

//- makrodefinicja ILORAZ - parametry w nawiasach!

#define SUMA(a,b) ((a)+(b))

W trakcie kompilacji nazwy stałych symbolicznych są zastąpione przez odpowiadające im łańcuchy znaków.
Ułatwia to parametryzację programu, a także umożliwia zastępowanie często niewygodnych w pisaniu sekwencji programu,
tworzenie makrodefinicji, tworzenie własnych dialektów języka, czy nawet języków bezkompilatorowych
(na bazie kompilatora C).

Przykład z walcem, z zastosowaniem pseudoinstrukcji #define

/*******************************************************/

/*  Program  p8.c                                    */

/*  Obliczanie objetosci walca        ( #define )    */

/*------------------------------------------------------*/

#include <stdio.h>

#define PI        3.1415926

#define PROMIEN   3.3

#define WYSOKOSC 44.4

#define WYNIK    printf("Objetosc walca = %f", objetosc)

main()

{

   float promien, wysokosc, objetosc;

   promien  = PROMIEN;

   wysokosc = WYSOKOSC;

   objetosc = PI * promien * promien * wysokosc;

   WYNIK;

}

/********************************************************/

Wynik programu:
Objetosc walca = 1519.010254

Dzięki #define program jest bardziej czytelny. Stała PI może być użyta wielokrotnie, wartości danych są widoczne na początku.

Użycie dużych liter jako nazwy stałej symbolicznej nie jest obowiązkowe ale zalecane.

Zmienne

Zmienną nazywamy nazwę (identyfikator) reprezentującą określony typ danych.
Zmienna jest to pewien fragment pamięci o ustalonym rozmiarze, który posiada własny identyfikator (nazwę) oraz może przechowywać pewną wartość, zależną od typu zmiennej.

W chwili rozpoczęcia pracy programu zmienna powinna posiadać nadaną wartość początkową (nie powinna być przypadkowa).
W trakcie pracy programu wartości zmiennych ulegają zwykle zmianom.
Należy przewidzieć zakres zmienności tych zmiennych.

W języku C wszystkie zmienne muszą być zadeklarowane przed ich użyciem, zwykle na początku funkcji przed pierwszą wykonywaną instrukcją.

Deklaracja zapowiada właściwości zmiennych.
Deklaracja składa się ona z nazwy typu i listy zmiennych, jak np.
int fahr, celsius;

W języku C oprócz podstawowych typów: char, short, int, long, float, double występują także tablice, struktury, unie,
wskaźniki do tych obiektów oraz funkcje zwracające ich wartości.

W przypadku zmiennych nalezy zwrócić uwagę na 2 zasadnicze rzeczy:

• nadanie wartości początkowej
• oszacowanie zakresu zmienności

/********************************************************/

/*  Program  p9.c                                 */

/*  Obliczanie objetosci walca     ( zmienne )    */

/*------------------------------------------------------*/

#include <stdio.h>

#define PI        3.1415926

#define PROMIEN   3.3

#define WYNIK    printf("Objetosc walca = %f", objetosc)

main()

{

   float promien, wysokosc, objetosc;

   int i;

   promien  = PROMIEN;

   objetosc = PI * promien * promien * wysokosc;   /* uwaga */

   WYNIK;

   i=40000;                                   /* uwaga */

   printf("\ni = %i ", i);

}

/********************************************************/

Efekt wykonania:

Objetosc walca = 0.000000

i = -25536

Objetosc walca = 0.000000

i = -25536

Objętość walca jest równa 0, bo nie została zainicjalizowana zmienna 'wysokosc' - przez domniemanie kompilator przyjął 0.
Na wydruku i widać, że nastąpiło przekroczenie dopuszczalnego zakresu zmiennej 'i' typu int.

Zmienne mogą być automatyczne oraz zmienne zewnętrzne.

Zmienne automatyczne pojawiają się i znikają razem z wywołaniem funkcji.
Zmienne zewnętrzne to zmienne globalne, dostępne przez nazwę w dowolnej funkcji programu.

Zmienna zewnętrzna musi być zdefiniowana dokładnie jeden raz na zewnątrz wszystkich funkcji - definicja przydziela jej pamięć.
Taka zmienna musi być też zadeklarowana w każdej funkcji, która chce mieć do niej dostęp. Można to zrobić albo przez jawną deklarację extern, albo niejawnie przez kontekst.
Jeśli definicja zmiennej zewnętrznej pojawia się w pliku źródłowym przed użyciem zmiennej w konkretnej funkcji, to nie ma potrzeby umieszczania w tej funkcji deklaracji extern.

Deklaracje

Deklaracje umożliwiają wyspecyfikowanie grup zmiennych określonego typu.

Większość kompilatorów dopuszcza nadanie wartości początkowej zmiennej w deklaracji (inicjalizację).

Wszystkie zmienne muszą być zadeklarowane przed użyciem.
W deklaracji określa się typ, a następnie wymienia jedną lub kilka zmiennych tego typu, np.

int lower, upper;
char c, line[1000];

W deklaracjach można nadawać zmiennym wartości początkowe, np.

char esc='\';
int i=0;
float eps=1.0e-5;
int limit=MAXLINE+1;

Jeśli zmienna nie jest automatyczna, to jej wartość początkową nadaje się tylko raz - jakby przed rozpoczęciem programu; jej inicjatorem musi być wyrażenie stałe.
Zmiennym automatycznym jawnie określone wartości początkowe nadaje się za każdym razem przy wywołaniu funkcji lub przy wejściu do zawierającego je bloku.
Zmiennym zewnętrznym i statycznym przez domniemanie nadaje się wartość pocz. zero.
Zmienne automatyczne  bez jawnie określonej wartości pocz. mają wartości przypadkowe (śmiecie).

Kwalifikator const mówi, że wartość zmiennej będzie stała.

const double e=2.71828182;
const char mas[]="Uwaga:";

Deklarację const można stosować również do tablicowych paramentów funkcji, by wskazać, że funkcja nie może zmieniać tablicy:

int strlen(const char[]);

Przykład programu – deklaracje i działania podstawowe

Wyrażenia

Wszystko co zwraca wartość jest wyrażeniem.
Wyrażeniem może być samodzielny element, np. liczba, stała, zmienna.
Może to być też kombinacja w/w elementów połączonych znakami operatorów,
 np. arytmetycznych lub logicznych.

Przykłady:

• 3.2
• PI
• a=a+b;
• x=y;
• x<LAFA;
• k == m;
• y = x = a+b;
• x != y
• b[i-2] = a[j+1];

Instrukcje

Instrukcje są to fragmenty tekstu programu (zwykle linie), które powodują jakąś czynność komputera w trakcie wykonywania programu.

Instrukcje można podzielić na grupy:

Instrukcje obliczające wartości wyrażeń,
np. a=b+c;

Każda taka instrukcja musi być zakończona średnikiem

Instrukcje grupujące (złożone) - ograniczone klamrami { }, 

np.

{

  a=3;

  b=2.2;

  p=a*b;

  printf("Pole=%f",p);

}

Instrukcje sterujące, np. while, if...

Instrukcje wywołania funkcji
Np.
int funkcja_d(int a, int b, float c);
int k;
k=funkcja_d(5, 6, 17.33);

Przykład programu z  użyciem zmiennych  -  prosty kalkulator.

Program, który poprosi nas o wpisanie dwóch liczb i wykona na nich podstawowe działania matematyczne: zsumuje je, odejmie, pomnoży i podzieli.

Wersja programu  do  wczytania  2 liczb a i b typu całkowitego:

//Program kalk1a.c

// Wczytuje 2 liczby całkowite I wyświetla na ekranie

#include <stdio.h>

#include <conio.h>

int main ()

{

        int a,b; //deklaracja zmiennych a i b

        clrscr();

        printf("Podaj liczbe a: ");

        scanf("%d",&a); // wczytanie liczby a

        printf("Podaj liczbe b: ");

        scanf("%d",&b);  // wczytanie liczby b

        printf("Wpisane liczby a i b : %d, %d.\n",a,b);

        printf("\nNacisnij Enter ");

        getch(); // czekanie na Enter

        return 0 ;

}

Typ int (integer) oznacza, że zmienna może przyjmować wartości całkowite z zakresu +/- 32767.  
Jeżeli zamierzamy używać w programie dużych liczb wtedy zamiast typu int używamy typu long.
Kompilator już wie, że w kodzie programu będą pojawiać się zmienne a i b i wie ile pamięci musi zarezerwować na ich przechowanie.

Następnie wypisujemy na ekranie komunikat, który prosi nas o wpisanie liczby.
Program zatrzyma się w tym miejscu i będzie czekał dotąd, aż napiszemy liczbę i zatwierdzimy je ENTERem.
Funkcja scanf() służy do odczytu wprowadzonych danych z klawiatury
Wzorzec konwersji określa typ zmiennej, którą wpiszemy z klawiatury lub wypiszemy na ekranie.

Poniższa tabela przedstawia deklaracje zmiennych określonego typu, odpowiednie dla nich wzorce konwersji oraz przykłady ich użycia:

Program kalkulator, wykonujący podstawowe obliczenia matematyczne

/* Program kalk1.c */

#include <stdio.h>

#include <conio.h>

int main() /* funkcja glowna */

{

int a,b; /* deklaracja zmiennych całkowitych a i b */

int suma,roznica,iloczyn;

float iloraz; /* deklaracja zmiennej rzeczywistej */

clrscr();  /* kasowanie ekranu */

printf("Prosty kalkulator\n");

printf("\nPodaj liczbe a: ");

scanf("%d",&a);  /* wczytanie liczby a */

printf("Podaj liczbe b: ");

scanf("%d",&b); /* wczytanie liczby b */

/* obliczenia */

suma=a+b;

roznica=a-b;

iloczyn=a*b;

iloraz=(float)a/(float)b; /* operator rzutowania w dzieleniu */

/* Wydruk wynikow */

printf("\nWyniki dzialan:\n");

printf("\nSuma:    %d  ",suma);

printf("\nRoznica: %d  ",roznica);

printf("\nIloczyn: %d  ",iloczyn);

printf("\nIloraz:  %f  ",iloraz);

getch(); /* czeka na naciśniecie klawisza */

return 0 ;

}

Zmienne typów liczbowych mogą przyjmować wartości tylko z określonych przedziałów liczbowych.

Podsumownie 2:

1. Aby wczytać liczbę należy użyć funkcji scanf w postaci: scanf("wzorzec",&zmienna);
   
2. Aby wypisać wczytaną w ten sposób liczbę należy użyć funkcji printf,
   która służy do wypisywania komunikatów.
   Postać funkcji: printf("Komunikat wzorzec",zmienna);
   
3. W funkcji scanf zawsze przed nazwą zmiennej używamy znaku &,
   a nie robimy tego przy używaniu funkcji printf.
   
4. Zmienna służy do przechowania danych, których wartość ustala się w trakcie działania programu i może być zmieniana.
   
5. Każda zmienna musi być zadeklarowana przed jej użyciem jako zmienna odpowiedniego typu: int,  float  itp.
   
6. Do wypisywania komunikatów służy funkcja printf, a do wczytywania zmiennych funkcja scanf.
   
7. Do poprawnego użycia obu funkcji należy znać podstawowe wzorce konwersji: %d, %f, %s.

Operacje na znakach i  łańcuchach znaków

Typy znakowe:  - deklaracja char zmienna.
pojedynczy znak: char znak; 
łańcuch znaków (napis, słowo) – char *napis lub char napis[n];

Wzorzec konwersji przy wyświetleniu lub wczytywaniu zmiennej typu char to

%c dla pojedynczego znaku (łańcucha jednoznakowego)

 %s dla łańcucha dłuższego niż 1 znak

Przykład operacji na słowach i łańcuchach:

/* znaki1.c */

#include <stdio.h>

#include <conio.h>

#include <string.h>

main (void)

{

char znak1,znak2,znak3; //deklaracja znaków

char *slowo1; // *slowo2;

char slowo2[20];

clrscr();  // czyszczenie ekranu

znak1='a';

znak2=102; // znak w postaci kodu dziesiętnego ASCII – litera f

slowo1="Imie"; // wpisujemy własne imię

printf("Podaj znak3: "); scanf("%c",&znak3); // podajemy jakiś znak

printf("\nPodaj slowo2: "); scanf("%s",slowo2); // wpisujemy słowo

printf("\nZmienne zawieraja znaki: ");

printf("znak1 (a), znak2 (102), znak3 (wprowadzony): %c %c %c  ",znak1,znak2,znak3);

printf("\noraz slowa: ");

printf("slowo1, slowo2: %s %s  ",slowo1, slowo2);

getch();

return 0 ;

}

Przypisać wartość zmiennej jednoznakowej możemy na kilka sposobów:

• w apostrofach: zmienna='a';
• poprzez przypisanie kodu znaku: zmienna=97;
• poprzez wczytanie znaku z klawiatury funkcją scanf(): scanf("%c",&zmienna);

Przypisanie wartości do zmiennej dla łańcucha dłuższego niż jeden znak odbywa się podobnie jak w pierwszym przypadku, z
tą jednak różnicą, że zamiast apostrofów (') należy używać cudzysłowia (

Program, który podaje kod wciśniętego przez nas klawisza:

#include <stdio.h> 

#include <conio.h> 

#include <string.h> 

main (void) 

{ 

char znak;

int kod; 

clrscr();

printf("Wciśnij znak na klawiaturze: \n"); 

scanf("%c",&znak);

printf("Kod wciśniętego znaku to: %d \n",znak); 

printf("Podaj kod znaku: \n"); 

scanf("%d",&kod); 

printf("Znak o podanym kodzie to: %c \n",kod); 

getch(); 

return 0 ; 

} 

Przykładowa zawartość ekranu po wykonaniu programu:

Wciśnij znak na klawiaturze:

a

Kod wciśniętego znaku to: 97

Podaj kod znaku: 100

Znak o podanym kodzie to: d

Do odczytania długości łańcucha służy funkcja strlen().

 Przykład:

#include <stdio.h> 

#include <conio.h> 

#include <string.h> 

main (void) 

{ 

int dlugosc; 

char *lancuch; 

clrscr();

lancuch="Adam Nowak"; 

dlugosc=strlen(lancuch); 

printf("Lancuch '%s' ma: %d znaków \n",lancuch, dlugosc); 

printf("Pierwsza litera łańcucha to: %c \n",lancuch[0]); 

printf("Ostatnia litera łańcucha to: %c \n",lancuch[dlugosc-1]); 

getch(); 

return 0 ; 

} 

W języku C w wielu przypadkach liczenie zaczyna się od zera, a nie od jedynki.
Dlatego na pierwszy znak łańcucha wskazuje odwołanie: lancuch[0], na drugi: lancuch[1] itd. Ostatni znak łańcucha jest to zawsze znak \0.

Inne  funkcje operujące  na łańcuchach.
M. Inn. to
strcat() - łączy dwa łańcuchy,
strcmp() - porównuje dwa łańcuchy rozróżniając małe i duże litery,
strlwr() i strupr() - zamienia w danym łańcuchu duże litery na małe i odwrotnie,
strrev() - odwraca kolejność znaków w łańcuchu,
strset() - wypełnia łańcuch danym znakiem.

Podsumowanie 3:

1. Zmienne liczbowe mogą zawierać się w pewnych zakresach, których nie można przekraczać.
2. Deklaracja zmiennej znakowej: char znak;
   a zmiennej łańcuchowej: char *slowo;
3. Wartość zmiennej znakowej można przypisać w programie poprzez umieszczenie znaku w apostrofach lub przez napisanie jego kodu.
4. Wartość zmiennej łańcuchowej można przypisać w programie poprzez umieszczenie napisu w cudzysłowie.
5. Zmienne znakowe i łańcuchowe można wczytywać z klawiatury używając funkcji scanf()
    i odpowiednich wzorców konwersji: %s dla ciągu znaków i %c dla pojedynczego znaku.
6. Każdy znak posiada swój kod ASCII.
7. Kod ASCII mają również znaki nie przedstawione na klawiaturze komputera. np. ß, ö, à.
8. Łańcuch, który wygląda jak liczba nie liczbą.
   Istnieją funkcje, które potrafią przekonwertować łańcuch liczbowy do postaci liczby.
9. Mając dany łańcuch, możemy odczytać dowolny jego znak używając nawiasów kwadratowych. Pierwszy wpisany znak ma numer 0, a nie 1.
10. Każdy ciąg kończy znak '\0'.
11. Długość łańcucha można ograniczyć przy deklaracji, np.: char slowo[10];
12. Łańcuchy można ze sobą porównywać, łączyć, odwracać w nich kolejność liter, zmieniać małe litery na duże i odwrotnie, a także przeszukiwać, kopiować na siebie itp.
    Nazwy funkcji, które to wykonują zawsze zaczynają się na 'str' (z angielskiego: string).

Wejście i wyjście programu

Do podstawowych funkcji języka C, umożliwiających komunikację z otoczeniem należą:

·        dla operacji wejścia: getchar, gets, scanf;

·        dla operacji wyjścia: putchar, puts, printf

W DOS, wyniki wysyłane na ekran mogą być przy pomocy znaku potoku wysłane do pliku lub na drukarkę.
Np.
p11 > Wynik.txt                     (do pliku)
p11 > PRN                             (na drukarkę)

Funkcja  putchar: int putchar(int)

Funkcja wysyła pojedynczy znak na zewnątrz (do standardowego strumienia wyjściowego stdout, standardowo na ekran)
Funkcja (makro) zwraca wartość wypisanego znaku lub EOF (jako sygnał błędu).

Przykład:

/********************************************************/

/*  Program  p12.c                                    */

/*                            ( putchar )            */

/*------------------------------------------------------*/

#include <stdio.h>

#define SPACJA 32

main()

{

  char napis[] = "ABCDEFGHIJKLMNOPQRS...";

  int znak = 73;

  /* wyprowadzanie pojedynczych znakow

     przy pomocy funkcji  putchar   */

  putchar('\n');     putchar(znak);     putchar(SPACJA);

  putchar(55);       putchar(SPACJA);   putchar('Z');

  putchar(SPACJA);   putchar('\066');   putchar(SPACJA);

  putchar('\x3A');   putchar('\n');     putchar(napis[0]);

  putchar(SPACJA);   putchar(napis[4]); putchar(SPACJA);

  putchar(znak+'\066'-52);              putchar('\n');

}

/********************************************************/

Wynik:

I 7 Z 6 :

A E K

Funkcja puts: int puts(const char *s);

Wysyła łańcuch s do standardowego strumienia wyjściowego (stdout) i dołącza znak końca wiersza.
W przypadku powodzenia operacji wartość jest nieujemna, w przeciwnym wypadku EOF.

/********************************************************/

/*  Program  p13.c                                    */

/*                             ( puts )               */

/*------------------------------------------------------*/

#include <stdio.h>

#define NOWA_LINIA putchar('\n')

main()

{

  char napis[] = "ABCDEFGHIJKLMNOPQRS...";

  /* wyprowadzanie pojedynczych linii tekstu

     przy pomocy funkcji  puts            */

  NOWA_LINIA; puts(napis); NOWA_LINIA;

  puts("To jest praktyczna funkcja");

  puts("\066\067\x2B\x2A itd.");

}

/********************************************************/

Wynik:

ABCDEFGHIJKLMNOPQRS...

To jest praktyczna funkcja

67+* itd.

Funkcja printf()

Wyprowadza wynik przetwarzania w różnych formatach.

printf (łańcuch, lista argumentów)                  lub inaczej
printf(ciag_formatujący, lista parametrów);

Ciąg formatujący jest zwykłym ciągiem znaków do wyświetlenia na ekranie.
Jednak niektóre znaki mają funkcję specjalną i nie zostaną one po prostu wyświetlone.
Takim właśnie znakiem jest znak % .
 Gdy funkcja printf()  go napotka to wie, że po nim wystąpi określenie rodzaju argumentu i formatu jego wyświetlenia na ekranie.

Ogólnie ciąg formatujący ma zapis :

% [flagi] [szerokość] [precyzja] [modyfiktor wielkości] typ_parametru

Tylko "typ_parametru" musi wystąpić po znaku % ,
natomiast parametry podane w nawiasach kwadratowym są opcjonalne i może ich w ogóle nie być (tak jest w przedstawionym przykładzie).

Przykład:

/********************************************************/

/*  Program  p14.c                                    */

/*                            ( printf  /1/ )        */

/*------------------------------------------------------*/

#include <stdio.h>

main()

{

  int  k = 21101;  /* liczba dziesietna */

  printf("\nk(_10) = %i   k(_8) = %o    k(_16) = %X", k, k, k);

}

/********************************************************/

Wynik:

k(_10) = 21101   k(_8) = 51155    k(_16) = 526D

Formaty realizowane przez funkcję printf (znaki typu w łańcuchach formatujących)

Najczęściej stosowane typy parametrów

Przykłady:

Wyniki:

Przykład  użycia dla zmiennej w  poniższym  programie (modyfikacja programy powyżej).

Wynik:

Funkcja getchar

int getchar(void)

Funkcja odczytuje znak ze standardowego strumienia wejściowego (stdin) i zwraca go po dokonaniu konwersji bez rozszerzenia znakowego.
Funkcja przy każdym wywołaniu podaje następny znak z wejścia lub EOF, gdy napotkała koniec pliku. W przypadku błędu lub końca zbioru wartością funkcji jest EOF.
Stała symboliczna EOF jest zdefiniowana w nagłówku <stdio.h>.
Jej wartoscią jest na ogół -1, ale e testach należy używać EOF.
Zadaniem funkcji jest wprowadzenie pojedynczego znaku do pamięci komputera.

Syntaktycznie postać funkcji jest następująca:
c = getchar();    gdzie c jest typu char.

Po każdym wywołaniu funkcja getchar pobiera ze strumienia znaków następny znak i wraca z jego zawartością. Zawartością zmiennej jest następny znak z wejścia.

Przykłady:

#include <stdio.h>

/* przepisz wejscie na wyjście, wersja 1 */

main()

{

 int c;

 c = getchar(); /* przeczytaj znak */

 while (c != EOF) /* dopóki znak nie jest znakiem konca pliku (Ctrl Z) */

  {

        putchar(c);  /* wypisz przeczytany znak */

        c=getchar(); /* przeczytaj nastepny znak */

  }

}

TYPY ZMIENNYCH I WZORCE KONWERSJI

Zmienne służą do tego, aby zapamiętać sobie tymczasową wartość (którą potem można zmienić w każdej chwili według potrzeby).
Dane w programie umieszczane są w postaci tzw. zmiennych.

Zmienna jest to pewien fragment pamięci o ustalonym rozmiarze, który posiada własny identyfikator (nazwę) oraz może przechowywać pewną wartość, zależną od typu zmiennej.

Deklaracja zmiennych

typ nazwa_zmiennej;

Oto deklaracja zmiennej o nazwie “wiek” typu “int” czyli liczby całkowitej:

int wiek;

Zmiennej w momencie zadeklarowania można od razu przypisać wartość (inicjalizować):

int wiek = 16;

W języku C zmienne deklaruje się na samym początku bloku (czyli przed pierwszą instrukcją).

Język C nie inicjalizuje zmiennych lokalnych.
Oznacza to, że w nowo zadeklarowanej zmiennej znajdują się śmieci - to, co wcześniej zawierał przydzielony zmiennej fragment

pamięci.
Aby uniknąć ciężkich do wykrycia błędów, dobrze jest inicjalizować (przypisywać

wartość) wszystkie zmienne w momencie zadeklarowania.

Zasięg zmiennej

Zmienne globalne i lokalne

Zmienne globalne - obejmujące zasięgiem cały program

Zmienne mogą być dostępne dla wszystkich funkcji programu — nazywamy je wtedy zmiennymi

globalnymi.

Deklaruje się je przed wszystkimi funkcjami programu:

Przykład

#include <stdio.h>

int a,b; /* nasze zmienne globalne */

void func1 ()

{

/* instrukcje */

a=3;

/           * dalsze instrukcje */

}

int main ()

{

b=3;

a=2;

return 0;

}

Zmienne globalne, jeśli programista nie przypisze im innej wartości podczas definiowania,

są inicjalizowane wartością  0.

Zmienne lokalne – o zasięgu obejmującym pewien blok.

Zmienne, które funkcja deklaruje do “własnych potrzeb” nazywamy zmiennymi lokalnymi.

Nasuwa się pytanie: “czy będzie błędem nazwanie tą samą nazwą zmiennej globalnej

i lokalnej?”. Otóż odpowiedź może być zaskakująca: nie. Natomiast w danej funkcji da się

używać tylko jej zmiennej lokalnej. Tej konstrukcji należy, z wiadomych względów, unikać.

int a=1; /* zmienna globalna */

int main()

{

int a=2; /* to już zmienna lokalna */

printf("%d", a); /* wypisze 2 */

}

Czas życia zmiennych

Czas życia zmiennych to czas od momentu przydzielenia dla zmiennej miejsca w pamięci (stworzenie

obiektu) do momentu zwolnienia miejsca w pamięci (likwidacja obiektu).

Zakres ważności to część programu, w której nazwa znana jest kompilatorowi.

Przykład

main()

{

int a = 10;

{ /* otwarcie lokalnego bloku */

int b = 10;

printf("%d %d", a, b);

} /* zamknięcie lokalnego bloku, zmienna b jest usuwana */

printf("%d %d", a, b); /* BŁĄD: b juz nie istnieje */

} /* tu usuwana jest zmienna a */

Zdefiniowano dwie zmienne typu int.
Zarówno a i b istnieją przez cały program (czas życia).
Nazwa zmiennej a jest znana kompilatorowi przez cały program.
Nazwa zmiennej b jest znana tylko w lokalnym bloku, dlatego nastąpi błąd w ostatniej instrukcji.

Stałe

Stała pozostanie taka sam w trakcie przebiegu programu.
Nadaje się jej wartość w czasie pisania programu a nie w czasie działania.

Stała, różni się od zmiennej tym, że nie można jej przypisać innej wartości w trakcie

działania programu.

Stałą deklaruje się z użyciem słowa kluczowego const:

const typ nazwa_stałej=wartość;

Dobrze jest używać stałych w programie, ponieważ unikniemy wtedy przypadkowych pomyłek
a kompilator może często zoptymalizować ich użycie (np. od razu podstawiając ich wartość do kodu).

Przykład:

const  int  WARTOSC_POCZATKOWA=5;

int  i=WARTOSC_POCZATKOWA;

WARTOSC_POCZATKOWA=4; /* tu kompilator zaprotestuje */

int  j=WARTOSC_POCZATKOWA;

Stałe symboliczne

Stała symboliczna jest nazwą zastępującą ciąg znaków

#define NAZWA tekst

Np.

#define PI  3.1415926

#define MIEJSCOWOSC Sosnowiec

#define WYNIK printf(("Pole=%d\f %”,pole1)

#define WZOR1 (a*b)

Typy zmiennych:

Określając typ zmiennej  przekazuje się kompilatorowi informację, ile pamięci trzeba zarezerwować dla zmiennej, a także w jaki sposób wykonywać na nim operacje.

Jeśli potrzebujemy w pewnym miejscu programu innego typu danych to stosujemy rzutowanie.
W takim wypadku stosujemy konwersję (rzutowanie) jednej zmiennej na inną zmienną

Istnieją wbudowane i zdefiniowane przez użytkownika typy danych.

W języku C wyróżniamy następujące podstawowe typy zmiennych.

• char – typ znakowy - jednobajtowe liczby całkowite, służy do przechowywania znaków;
• int- liczby całkowite - typ całkowity, o długości domyślnej dla danej architektury komputera;
• float – liczby rzeczywiste - typ zmiennopozycyjny (zwany również zmiennoprzecinkowym), reprezentujący liczby rzeczywiste (4 bajty);
• double – liczby rzeczywiste - typ zmiennopozycyjny podwójnej precyzji (8 bajtów);

• short - liczby całkowite krótkie
• long - liczby całkowite długie
• long double - liczby zmiennoprzecinkowe podwójnej precyzji długie

Typ int przeznaczony jest do liczb całkowitych. 



Liczby te możemy zapisać na kilka sposobów:

System dziesiętny: np. 21; 13; 45; 156

System ósemkowy (oktalny): np. 010;  027.    (Cyfry 0 ..7) 

Cyfra 8 nie jest dozwolona.

Jeżeli chcemy użyć takiego zapisu musimy zacząć liczbę od 0.

System szesnastkowy (heksadecymalny), np.  0x10, 0xff.

Aby użyć takiego systemu musimy poprzedzić liczbę ciągiem 0x. 

Wielkość znaków w takich literałach nie ma znaczenia.

Typ float dla liczb zmiennoprzecinkowych

Ten typ oznacza liczby zmiennoprzecinkowe czyli ułamki.
Istnieją dwa sposoby zapisu:

• System dziesiętny, np.   10.256, 3.14  (z kropką dziesiętna)
• System "naukowy" – wykładniczy, np. 6e2 (czyli  6 * 10² )
    3.4e-3  (czyli 3.4 * 10^(-3_

Typ double dla liczb zmiennoprzecinkowych

Double - czyli "podwójny" - oznacza liczby zmiennoprzecinkowe podwójnej precyzji.
Oznacza to, że liczba taka zajmuje zazwyczaj w pamięci dwa razy więcej miejsca niż float (np. 64 bity wobec 32 dla float), ale ma też dwa razy lepszą dokładność.

Domyślnie ułamki wpisane w kodzie są typu double. Możemy to zmienić dodając na końcu literę "f":
1.4f (znaczy float),  1.4 (znaczy double)

Typ char dla znaków

Jest to typ znakowy, umożliwiający zapis znaków ASCII.
Może też być traktowany jako liczba z zakresu 0..255.
Znaki zapisujemy w pojedynczych cudzysłowach (czasami nazywanymi apostrofami),
by odróżnić je od łańcuchów tekstowych (pisanych w podwójnych cudzysłowach).

Np. ‘A’, ‘a’, ‘!’, ‘$’

Pojedynczy cudzysłów ' zapisujemy '\''
a null (czyli zero, które między innymi kończy napisy) tak: '\0'

Inne znaki specjalne

• '\a' - alarm (sygnał akustyczny terminala)
• '\b' - backspace (usuwa poprzedzający znak)
• '\f' - wysuniecie strony (np. w drukarce)
• '\r' - powrót kursora (karetki) do początku wiersza
• '\n' - znak nowego wiersza
• '\"' - cudzysłów
• '\'' - apostrof
• '\\' - ukośnik wsteczny (backslash)
• '\t' - tabulacja pozioma
• '\v' - tabulacja pionowa
• '\?' - znak zapytania (pytajnik)
• '\ooo' - liczba zapisana w systemie oktalnym (ósemkowym), gdzie 'ooo' należy zastąpić trzycyfrową liczbą w tym systemie
• '\xhh' - liczba zapisana w systemie heksadecymalnym (szesnastkowym), gdzie 'hh' należy zastąpić dwucyfrową liczbą w tym systemie, np. ‘\xAFF’

Specyfikatory – signed, unsigned, short, long

słowa kluczowe, które postawione przy typie danych zmieniają jego znaczenie.

signed – liczba ze znakiem i unsigned – nieujemna (bez znaku)

short i long są wskazówkami dla kompilatora, by zarezerwował dla danego typu mniej (odpowiednio - więcej) pamięci.
Mogą być zastosowane do dwóch typów: int i double (tylko long), mając różne znaczenie.
Jeśli przy short lub long nie napiszemy, o jaki typ nam chodzi, kompilator przyjmie wartość domyślną czyli int.

Przykłady

Operatory i wyrażenia

Do wykonania obliczeń zmieniających dane w informacje, niezbędne są operatory. Operator to symbol mówiący komputerowi, jak ma przetwarzać dane.

Operatory, z punktu widzenia liczby argumentów dzielimy na dwuargumentowe i jednoargumentowe.

a op b - op jest operatorem 2-argumentowym, np. a+b; a*b; a/b; a%b;

op a - op jest operatorem jednoargumentowym, np. -a; -(a+b); !a

Można je pogrupować wg cech funkcjonalnych na grupy:

• operatory arytmetyczne
• operatory porównania - relacyjne
• operatory logiczne
• operatory bitowe
• operatory przypisania
• operatory unarne
• operatory rozmiaru
• operatory konwersji
• operator warunkowy
• operator przecinkowy
• operatory wskazywania

Operatory

Najczęściej używane operatory:

Operatory arytmetyczne

Operatory arytmetyczne można podzielić na 3 grupy:

• operatory inkrementacji i dekrementacji: --Op, ++Op, Op--, Op++
• operatory addytywne: "+" i "-"
• operatory multiplikatywne: "*', "/", "%"

Operatory te używane są do wykonywania działań matematycznych.

W języku C występuje pięć dwuargumentowych operatorów arytmetycznych:

• dodawanie  +
• odejmowanie  -
• mnożenie  *
• dzielenie  /
• modulo - reszta z dzielenia %  określona tylko dla liczb całkowitych (dzielenie modulo).

Brak jest operatora potęgowania (realizuje to funkcja biblioteczna pow)

Jeżeli dzielimy zmienne lub liczby całkowite przy pomocy operatora /,
to wynik zawsze będzie liczbą całkowitą.
Z operatora % korzystamy do obliczenia reszty z dzielenia liczb całkowitych.

 
Kolejność działań jest identyczna jak w matematyce.

Dzielenie całkowite obcina część ułamkową wyniku.

Przykład:

int x,y, a=5, b=2;

x=a/b;            /* w wyniku x otrzyma wartość 2 */

y=a%b;            /* y => 1  - reszta z dzielenia */

x % y daje w wyniku resztę dzielenia x przez y.
Operatora % nie można stosować do danych typu float i double

Należy pamiętać, że (w pewnym uproszczeniu) wynik operacji jest typu takiego jak największy z argumentów.
Oznacza to, że operacja wykonana na dwóch liczbach całkowitych nadal ma typ całkowity nawet jeżeli wynik przypiszemy do zmiennej rzeczywistej.

Przykłady:

wypisze  3.0, a nie 3.5.

Odnosi się to nie tylko do dzielenia, ale także mnożenia, np.:

prawdopodobnie da o wiele mniejszy wynik niż byśmy się spodziewali.

Aby wymusić obliczenia rzeczywiste  należy zmienić typ jednego z argumentów na liczbę rzeczywistą po prostu zmieniając literał lub korzystając z rzutowania, np.: