C (język programowania)

C – imperatywny, proceduralny język programowania ogólnego przeznaczenia, stworzony na początku lat 70. XX wieku przez Dennisa Ritchiego, ówczesnego pracownika Bell Labs. W języku C powstały narzędzia systemowe dla Uniksa, a potem również kod systemu Unix. Język C został ustandaryzowany w 1989 roku przez ANSI. Od tego czasu jego rozwojem zajmuje się grupa robocza w ramach ISO.

C

Logo języka
Pojawienie się	1972
Paradygmat	imperatywny (proceduralny)
Typowanie	statyczne (słabe)
Implementacje	Borland Turbo C, GCC, Microsoft Visual C, MinGW, LLVM, Tiny C Compiler
Pochodne	C++, Java, C#
Aktualna wersja stabilna	C18 (czerwiec 2018)
Aktualna wersja testowa	C2x
Twórca	Dennis Ritchie
Platforma sprzętowa	wieloplatformowy
Platforma systemowa	wieloplatformowy
Strona internetowa

Język C powstawał jako rozwinięcie języka B, wzbogacając się stopniowo o kolejne funkcje. Okresy najszybszego rozwoju języka C to lata 1972–1973 oraz 1977–1979. Z kolei lata 1980. to czas zdobywania przez niego popularności, czego efektem była dostępność kompilatorów dla praktycznie wszystkich używanych wtedy architektur komputerów i systemów operacyjnych.

C jest jednym z popularniejszych języków programowania. Służy zarówno do pisania elementów systemów operacyjnych, jak i aplikacji użytkowych. Mimo to spotyka się z krytyką z powodu pewnych decyzji projektowych, takich jak priorytety operatorów lub nadmiernie lakoniczna składnia.

Historia

Początki C są ściśle związane z rozwojem systemu Unix, napisanego pierwotnie przez Dennisa Ritchiego i Kena Thompsona w asemblerze na komputer PDP-7. Późniejsza wersja systemu, przeznaczona na maszynę PDP-11, również powstała w asemblerze.

Thompson czuł potrzebę wykorzystania języka wyższego poziomu do napisania narzędzi systemowych dla Uniksa. Początkowo próbował przygotować kompilator Fortranu, lecz dość szybko porzucił ten pomysł. W zamian stworzył własną, okrojoną wersję BCPL, którą nazwał B. W języku tym powstało niewiele narzędzi, ponieważ wynikowe programy były powolne oraz nie mogły korzystać z adresowania poszczególnych bajtów pamięci (funkcji dostępnej np. w PDP-11).

Wczesny rozwój

Dennis Ritchie rozpoczął w 1972 roku rozwijanie języka B. Jedną z pierwszych zmian było dodanie typów danych dla zmiennych. Początkowo dostępne były dwa: znakowy (char) i całkowitoliczbowy (int). Wprowadzono również sposób deklarowania zmiennych typu wskaźnikowego oraz odwołań do funkcji. Tak znaczące zmiany spowodowały, że Ritchie nadał językowi nową nazwę: C.

Zgodnie z sugestią Alana Snydera, na początkowym etapie rozwoju języka Ritchie rozdzielił operatory koniunkcji i alternatywy na bitowe (składające się z pojedynczego symbolu) oraz logiczne (złożone z dwóch znaków). W języku B oba warianty oznaczano w taki sam sposób, a odpowiednie działanie było wybierane przez interpreter, w zależności od kontekstu.

Kompilator C, wraz z kilkoma programami napisanymi w tym języku, został dołączony do drugiej wersji systemu Unix. Latem 1973 jądro tego systemu zostało przepisane w języku C.

Do tego czasu wprowadzono również do składni języka obsługę struktur. Mniej więcej w tym samym czasie powstała pierwsza wersja preprocesora. Umożliwiała ona dołączanie plików zewnętrznych (dyrektywa #include) oraz wykonywanie prostych podstawień (definiując makra bez parametrów z użyciem #define). Funkcjonalności takie jak kompilacja warunkowa czy parametryzowane makra zostały wprowadzone niedługo później – przez Mike’a Leska oraz Johna Reisera. Na tym etapie rozwoju języka preprocesor stanowił opcjonalny dodatek, który nie musiał być uruchamiany w trakcie kompilacji.

Około 1977 roku Dennis Ritchie, Ken Thompson i Stephen Johnson skupili się na przenośności oprogramowania napisanego w C. W tym celu przyjrzeli się często wykorzystywanym konstrukcjom i zachowaniom, które były zależne od architektury komputera. Ponadto Johnson napisał kompilator pcc, w którym oddzielono część związaną z architekturą od części uniwersalnej, co ułatwiło wspieranie nowych platform sprzętowych oraz utrzymanie tych już wspieranych.

K&R C

W 1978 opublikowane zostało pierwsze wydanie książki The C Programming Language (wyd. polskie Język C, 1987), autorstwa Briana Kernighana i Dennisa Ritchiego. Stanowiła ona pierwszą, nieformalną, specyfikację języka C. Wersja ta bywa nazywana C78, gdzie nazwa pochodzi od roku wydania. Inne skrócone określenie, K&R C, pochodzi od nazwisk autorów książki.

Jeszcze przed publikacją książki do języka C włączono kwalifikatory short i long, pozwalające określić wielkość zmiennej typu całkowitoliczbowego, a także specyfikator unsigned, oznaczający liczby nieujemne.

W specyfikacji C78 złożone operatory przypisania uzyskały jednoznaczną składnię. Do roku 1976 instrukcja „zmniejsz wartość zmiennej i o 10” mogłaby zostać napisana jako: i =- 10, co jest bardzo podobne do polecenia zapisania w zmiennej i wartości -10. Nowe symbole cechowała zamieniona kolejność operatora i znaku równości, np. -= zamiast =-. Dwuznaczne oznaczenia wywodziły się jeszcze z języka B i sposobu przetwarzania kodu przez jego analizator składni.

W książce Kernighana i Ritchiego znalazł się również opis biblioteki wejścia/wyjścia. Podwaliny pod nią położył w 1972 roku Mike Lesk, pisząc „przenośną bibliotekę wejścia/wyjścia”. W następnych latach, wraz z pracami nad przenośnością systemu Unix, została ona rozwinięta i usprawniona. Funkcje biblioteczne nie zostały przez autorów książki uznane za część języka, lecz dodatek do niego.

Autorzy publikacji wspomnieli również o planowanym zniesieniu większości ograniczeń dotyczących struktur. Do 1980 roku możliwe stało się przekazywanie ich jako parametry funkcji oraz bezpośrednie przypisywanie. Jedynie brak notacji dla literału powodował, że nie były typem pierwszoklasowym. W okresie po wydaniu książki do języka trafiło również wsparcie dla typów wyliczeniowych oraz funkcji niezwracających żadnej wartości, choć o tych kwestiach nie można znaleźć informacji w I wydaniu publikacji Kernighana i Ritchiego.

Język taki, jak opisany przez Kernighana i Ritchiego w 1978 roku nie przewidywał żadnej możliwości określenia typów przyjmowanych przez parametry funkcji. Powstały odrębne narzędzia, takie jak lint, które przeprowadzały analizę kodu bardziej rygorystyczną niż kompilator, a następnie zgłaszały problemy ze spójnością i przestrzeganiem dobrych praktyk.

Książka Język C nie stanowiła ścisłego standardu. Miejscami pozostawiała miejsce do interpretacji szczegółów języka. To, w połączeniu z dalszym rozwojem i popularyzacją C na różnych platformach, spowodowało potrzebę standaryzacji.

W latach 80. XX wieku Bjarne Stroustrup stworzył język C++, który stanowił rozszerzenie C, dodające przede wszystkim wsparcie dla programowania obiektowego. Dodatków tych nie wcielono do C, a C++ został niezależnie ustandaryzowany przez ANSI i ISO.

ANSI C i ISO C

W 1983 roku, ANSI sformowała komitet X3J11, którego celem było „sformułowanie jasnego, spójnego i jednoznacznego standardu C, który skodyfikuje powszechnie istniejący język w sposób promujący zgodność programów z różnymi środowiskami uruchomieniowymi”. Odpowiedni dokument przyjęto w 1989 roku jako standard ANSI X3.159-1989 „Język programowania C”. Opisana w nim wersja języka jest zwykle określana jako ANSI C lub C89 (od daty publikacji).

Rok później, w 1990 standard ANSI C został przyjęty (ze zmianami redakcyjnymi) przez Międzynarodową Organizację Normalizacyjną jako ISO/IEC 9899:1990. Ta wersja bywa również nazywana C90 lub ISO C, choć opisuje ten sam język, co dokument ANSI.

Oprócz dodatków autorstwa Ritchiego, zaimplementowanych po publikacji książki Język C, komitet standaryzacyjny ANSI wprowadził do języka np. prototypy funkcji czy wskaźniki na nieznany typ (void*). W C89 pojawiła się także możliwość deklarowania typów parametrów funkcji w nagłówku, ale starsza składnia pozostała dopuszczalna dla zgodności z istniejącym kodem. Standard wzbogacił również preprocesor o dodatkowe instrukcje, takie jak #elif oraz wsparcie dla łączenia napisów (operator ##). Wzorując się na języku C++ zaadaptowano również składnię i znaczenie kwalifikatorów typu const i volatile.

Podczas prac nad językiem Kernighan i Ritchie nie skupiali się na ustandaryzowaniu biblioteki standardowej. Odpowiednie funkcje dostarczał system Unix, niezależnie od stosowanego kompilatora. Implementacje C na innych platformach były wyposażone w biblioteki, które starały się naśladować to, co było dostępne na Uniksie, jednak nie istniały wytyczne określające zestaw procedur, jakie muszą być udostępnione programistom. Komitet ANSI przygotował opis biblioteki standardowej języka C, wymagający dostarczenia programiście odpowiednich funkcji o ściśle określonym działaniu i przeznaczeniu.

W 1995 roku została opublikowana poprawka do standardu, wprowadzająca obsługę wielobajtowych kodowań znaków (ang. wide characters, typ wchar_t), wraz z zestawem funkcji do operacji na składających się z nich napisach. Inne zmiany obejmują dodanie pliku nagłówkowego iso646.h, definiującego makra, których można użyć do zastąpienia niektórych operatorów słowami, jak and zamiast && czy not_eq zamiast !=. Oprócz istniejących już trójznaków (będących innym sposobem zapisania pewnych symboli), wprowadzono 6 dwuznaków o tym samym zastosowaniu: <:, :>, <%, %>, %: i %:%:. W poprawce ustanowiono również wymóg, by implementacje ustawiały makro __STDC_VERSION__ na wartość 199409, co ma wskazywać na zgodność z nowszą wersją standardu.

C99

Druga wersja standardu języka C została opublikowana przez ISO w 1999 roku. Zaczerpnęła z języka C++ funkcje inline i komentarze jednoliniowe (rozpoczynające się sekwencją //). Zdefiniowano wtedy również kolejne typy danych: long long int (minimum 64-bitowa liczba całkowita) oraz typ logiczny _Bool, który może przyjmować jedynie wartości 0 oraz 1 (wraz z makrami bool, true i false). W tej wersji standardu dodano także kolejny kwalifikator typu restrict.

Od standardu C99 zdefiniowany jest sposób obsługi liczb zespolonych w języku. Służą do tego typy z określeniami _Imaginary oraz _Complex, przechowujące – odpowiednio – wartości urojone oraz zespolone. Kwalifikatorów tych można używać jedynie z typami zmiennoprzecinkowymi.

W 1999 roku do języka C wprowadzono także obsługę tablic o długości ustalanej w czasie działania programu. Implementacje wspierające wersję C99 powinny ustawić makro __STDC_VERSION__ na 199901.

C11

Kolejna edycja standardu została przyjęta w grudniu 2011. Podczas prac nad nią, komitety odpowiedzialne za języki C i C++ współpracowały ze sobą, by zachować wzajemną zgodność obu na tyle, na ile to możliwe. W tej wersji standardu zadecydowano, że tablice o zmiennej długości oraz typy zespolone staną się funkcjonalnością opcjonalną (C99 wymagał, by kompilatory je wspierały). Rozbudowano również bibliotekę standardową o procedury sprawdzające zakres i granice obszaru pamięci podczas operowania na napisach. Z powodu licznych podatności usunięto funkcję gets(), zastępując ją bezpieczniejszą gets_s().

Publikując tę wersję standardu, komitet ustandaryzował wsparcie dla wielowątkowości, m.in. definiując sposoby zarządzania i synchronizowania wątków oraz wprowadzając typy atomowe (w tym kwalifikator typu _Atomic). Umożliwiono również oznaczenie funkcji bez powrotu słowem kluczowym _Noreturn, co pozwala kompilatorom na pewne optymalizacje generowanego kodu.

W 2011 roku do języka C wprowadzono także mechanizm definiowania makr generycznych ze względu na typ parametrów oraz wsparcie dla literałów napisowych w standardach Unicode i UTF-8.

W tej wersji __STDC_VERSION__ przyjmuje wartość 201112.

C17 / C18

Czwarta wersja standardu nie przyniosła żadnych znaczących zmian w języku w stosunku do C11. Dokument przyjęty przez ISO w czerwcu 2018 przyniósł poprawki i uściślenia tekstu, dlatego zmiany w zachowaniu kompilatorów po jego implementacji wynikają z interpretacji niejednoznacznych zapisów. Jedyną zmianą normatywną było nadanie wartości 201710 makro __STDC_VERSION__.

Iteracja ta bywa nazywana C17, jak i C18.

C23

Piąta wersja standardu określa C23.

Składnia

Formalna gramatyka języka C jest opisana w standardzie ISO C. Podział kodu na linie oraz białe znaki są ignorowane. Ich stosowanie jest obowiązkowe jedynie, kiedy służą rozdzieleniu poszczególnych jednostek leksykalnych.

Program w języku C zapisywany jest w plikach źródłowych, które nie muszą być kompilowane w tym samym czasie. Plik źródłowy razem z plikami dołączonymi dyrektywą #include tworzy jednostkę tłumaczenia, która po przetłumaczeniu na kod maszynowy może być konsolidowana z innymi w celu stworzenia wykonywalnego programu.

Identyfikatory

Identyfikator stanowi nazwę obiektu, funkcji, etykiety itp. Może on oznaczać różne byty w różnych momentach wykonywania programu. Istotna jest jedynie określona liczba znaków w nazwie. W przypadku, gdy dwa identyfikatory różnią się jedynie znakami na nieistotnych pozycjach, zachowanie jest nieokreślone. Minimalna znacząca długość jest zależna od implementacji i może się różnić w zależności od sposobu linkowania określanego przezeń bytu, choć standard wymaga, by przynajmniej 63 pierwsze znaki identyfikatorów wewnętrznych i 31 początkowych znaków identyfikatorów zewnętrznych było znaczących.

Identyfikatory mogą składać się jedynie z liter, cyfr i znaku podkreślenia, choć cyfra nie może występować na pierwszym miejscu. Aby zastosować w nazwie znaki spoza tego zbioru, konieczne jest użycie sekwencji ucieczki \uxxxx lub \Uxxxxxxxx (gdzie x to cyfra szesnastkowa). Na potrzeby kompilatora i powiązanej z nim biblioteki zarezerwowane są identyfikatory zaczynające się dwoma znakami podkreślenia lub podkreśleniem z następującą po nim wielką literą.

W zależności od tego, do czego odwołuje się identyfikator, należy on do jednej z przestrzeni nazw:

• etykiety;
• nazwy struktur, unii i typów wyliczeniowych;
• pola struktur i unii (niezależne przestrzenie dla każdej struktury i unii);
• pozostałe.

Ponadto każdy identyfikator ma swój zakres widoczności, zależny od miejsca deklaracji.

Z identyfikatorem może być skojarzony jeden z trzech sposobów łączności: zewnętrzna, wewnętrzna lub brak. Łączność decyduje o tym, czy dwa identyczne identyfikatory w różnych miejscach programu odnoszą się do tego samego bytu:

• identyfikatory o łączności zewnętrznej odnoszą się do tego samego obiektu lub funkcji w obrębie całego programu,
• identyfikatory o łączności wewnętrznej oznaczają ten sam byt w ramach jednej jednostki tłumaczenia,
• identyfikatory bez łączności za każdym razem odnoszą się do innego obiektu.

Wyrażenia

Ciąg operatorów i operandów stanowi w języku C wyrażenie. Oznacza ono obliczenie wartości lub odwołanie do obiektu. W trakcie jego wywoływania mogą także występować skutki uboczne (na przykład inkrementacja zmiennej). Kolejność obliczania wartości i zachodzenia skutków ubocznych jest nieokreślona, lecz zgodna z pierwszeństwem operatorów. Standard języka C gwarantuje, że zdarzą się one przed następnym punktem sekwencyjnym.

Jeżeli tego samego obiektu dotyczy więcej niż jeden skutek uboczny i nie są one rozdzielone punktem sekwencyjnym, wtedy zachowanie jest nieokreślone. Takie punkty wprowadzane są:

• w trakcie wywoływania funkcji: przed rozpoczęciem obliczania argumentów funkcji oraz przed skokiem do funkcji;
• między obliczeniem wartości operandów &&, ||, ,;
• między obliczeniem wartości pierwszego operandu ?: a drugiego lub trzeciego;
• między wywołaniem kolejnych pełnych wyrażeń;
• w momencie powrotu z funkcji bibliotecznych oraz w niektórych przypadkach w trakcie ich działania.

Operatory

W języku C są zdefiniowane następujące operatory:

• arytmetyczne: +, -, *, /, %
• bitowe: ~, &, ^, |
• dostępu: ., ->
• grupowania wyrażeń: ()
• inkrementacji i dekrementacji: ++, --
• logiczne: !, &&, ||
• porównania: <, >, <=, >=, ==, !=
• przesunięcia bitowego: <<, >>
• przypisania: =
• przypisania złożonego: *=, /=, %=, +=, -=, <<=, >>=, &=, ^=, |=
• rozmiaru obiektu: sizeof
• rzutowania: (typ)
• sekwencyjny: ,
• warunkowy: ?:
• wskaźnikowe: *, &, []
• wyrównania dla typu: _Alignof
• wywołania funkcji: ()

Obiekty

Obiekt (zwany też zmienną), według standardu języka C, to region pamięci środowiska wykonawczego, mogący reprezentować wartości. Wyrażenie, które może odwoływać się do obiektu jest l-wartością. Jej typ określa, w jaki sposób interpretować zawartość obiektu.

Przykładem l-wartości jest identyfikator obiektu. Może nią być również rezultat dereferencji wskaźnika.

Deklaracja obiektu polega na podaniu typu danych oraz opcjonalnie klasy pamięci i sposobu linkowania, po których występuje przynajmniej jeden identyfikator tworzonego obiektu (lub obiektów).

Funkcje

W języku C rozróżniane są:

• deklaracja funkcji – polega na podaniu zwracanego typu, nazwy funkcji oraz listy parametrów (być może pustej); kończy się średnikiem
• definicja funkcji – składa się z deklaracji oraz listy instrukcji, objętej w nawiasy klamrowe ({...}).

Definicje funkcji w języku C nie mogą być zagnieżdżane.

Funkcje w języku C nie mogą być przeciążane, ale istnieje mechanizm definiowania funkcji o zmiennej liczbie argumentów.

Instrukcje sterujące

Wykorzystanie instrukcji if i switch do realizacji równoważnych fragmentów kodu.

W języku C można wyróżnić trzy klasy instrukcji sterujących. Pierwszą z nich są polecenia umożliwiające warunkowe wykonanie fragmentów kodu. Do tej grupy należą:

• if ... else – pozwala na wykonanie jednej z dwóch gałęzi kodu na podstawie wartości typu logicznego,
• switch – wykonuje jeden z wielu bloków kodu na podstawie porównania wartości liczbowej z wyrażeniami w poszczególnych etykietach case.

Schemat blokowy pętli for.

Druga grupa instrukcji sterujących służy realizacji pętli. Każda z nich jest wykonywana tak długo, jak podany warunek jest prawdziwy. Składają się na nią:

• while – warunek jest sprawdzany przed każdą iteracją;
• do ... while – warunek jest sprawdzany po każdej iteracji;
• for – pozwala na określenie instrukcji, która wykona się przed pierwszą iteracją oraz instrukcji do wywołania po każdym przebiegu pętli.

Ostatnią grupę stanowią instrukcje skoku. Należą do nich:

• goto – realizuje skok do etykiety o podanej nazwie, ale nie jest możliwe wyjście z aktualnie wykonywanej funkcji;
• continue – przerywa wykonywanie bieżącej iteracji pętli i przechodzi do kolejnej;
• break – przerywa wykonywanie pętli lub instrukcji switch;
• return – przerywa wykonywanie bieżącej funkcji i opcjonalnie przekazuje wartość do miejsca wywołania.

Dyrektywy preprocesora

Dyrektywy preprocesora rozpoczynają się od znaku # i muszą znajdować się w osobnych liniach (dopuszczalne jest by przed symbolem kratki znajdowały się spacje).

Preprocesor w języku C pozwala na manipulację kodem źródłowym przed właściwą kompilacją. Wspiera mechanizmy kompilacji warunkowej (dyrektywa #if i jej warianty) oraz dołączania innych plików źródłowych (#include). Odpowiada również za rozwijanie makr (zdefiniowanych przy użyciu #define).

Dzięki dyrektywie #pragma możliwe jest przekazywanie instrukcji specyficznych dla kompilatora.

Komentarze

W języku C występują komentarze liniowe i blokowe. Ich zawartość przetwarzana jest przez kompilator wyłącznie w celu znalezienia końca komentarza (symbolizowanego odpowiednią sekwencją lub końcem linii). Do ich wprowadzenia służą znaki /* (blokowy, kończy się */) oraz // (liniowy, trwa do końca linii). Sekwencje te tracą swoje znaczenie, jeśli znajdują się w literale tekstowym lub wewnątrz innego komentarza.

W trakcie kompilacji, komentarze zastępowane są znakiem spacji.

Typy danych

Typ danych określa zbiór wartości, które może przyjąć dany obiekt, jak również dozwolone operacje na nim. Język udostępnia zestaw typów podstawowych oraz mechanizmów konstruowania typów pochodnych.

Szczególnym typem danych w C jest typ pusty void, który nie przechowuje żadnej wartości. W związku z tym można wykorzystywać go jedynie w sytuacjach, gdy wartość nie jest wymagana – np. jako lewy argument operatora , lub w charakterze instrukcji. Rzutowanie tego typu na jakikolwiek inny typ, zarówno jawne, jak i niejawne jest niedozwolone. Słowem void oznacza się między innymi funkcje nie zwracające nic.

Typy podstawowe

W języku C istnieje kilka bazowych typów danych, które można dookreślać z użyciem odpowiednich słów kluczowych w celu uzyskania odpowiedniego zakresu wartości. Służą do przechowywania liczb całkowitych (char i int) oraz zmiennoprzecinkowych (float i double).

Razem z typem int można stosować kwalifikatory short oraz long. Pozwalają one programiście wykorzystywać typy danych krótsze i dłuższe niż naturalne dla danej architektury. Ponadto nazwę każdego typu, służącego do przechowywania liczb całkowitych, można również poprzedzić słowem signed lub unsigned, aby określić, czy dany obiekt ma być w stanie przechowywać liczby ujemne. Reprezentacja bitowa wartości, które można zapisać zarówno w wariancie signed, jak i unsigned danego typu jest w obu wariantach taka sama.

Standard języka C nie ustala w sposób sztywny zakresów wartości, jakie muszą się zmieścić w obiektach poszczególnych typów. Podobnie nie są określone ich rozmiary w bitach lub bajtach. Od implementacji języka wymaga się, by poszczególne typy danych pozwalały na przechowywanie przynajmniej liczb z ustalonego przedziału, a w przypadku typu logicznego _Bool – by miał rozmiar wystarczający do zmieszczenia wartości 0 i 1.

Minimalne zakresy wartości dla typów całkowitoliczbowych

Typ	Minimalny zakres	Minimalny rozmiar w bitach
signed char	$\langle -2^{7}+1,\;2^{7}-1\rangle$	8
unsigned char	$\langle 0,\;2^{8}-1\rangle$	8
short int	$\langle -2^{15}+1,\;2^{15}-1\rangle$	16
unsigned short int	$\langle 0,\;2^{16}-1\rangle$	16
int	$\langle -2^{15}+1,\;2^{15}-1\rangle$	16
unsigned int	$\langle 0,\;2^{16}-1\rangle$	16
long int	$\langle -2^{31}+1,\;2^{31}-1\rangle$	32
unsigned long int	$\langle 0,\;2^{32}-1\rangle$	32
long long int	$\langle -2^{63}+1,\;2^{63}-1\rangle$	64
unsigned long long int	$\langle 0,\;2^{64}-1\rangle$	64

W powyższej tabeli zebrano minimalne wymagania stawiane dostępnym w C typom całkowitoliczbowym. Dodatkowym ograniczeniem, stawianym przez standard jest to, aby kolejne typy miały zakres niemniejszy od poprzednich. Na przykład obiekt typu short nie może być dłuższy niż int, który z kolei musi być niedłuższy od long.

Użycie kwalifikatora long jest dopuszczalne również w połączeniu z typem double, choć standard C nie gwarantuje, że uzyskany w ten sposób typ będzie miał większą pojemność niż wyjściowy. Podobnie jak w przypadku liczb całkowitych, dostępne typy zmiennoprzecinkowe również nie mają sztywno określonego zakresu wartości oraz minimalnej dokładności.

W czasie, gdy ukazało się pierwsze wydanie książki Język C Kernighana i Ritchiego, dopuszczalna była również konstrukcja long float, równoważna typowi double, jednak została ona zniesiona przez standard ANSI C.

Minimalne wymagania standardu języka C wobec typów zmiennoprzecinkowych

Cecha	float	double	long double
Liczba dziesiętnych cyfr znaczących	6	10	10
Największa liczba dodatnia	$10^{37}$	$10^{37}$	$10^{37}$
Najmniejsza dodatnia liczba znormalizowana	$10^{-37}$	$10^{-37}$	$10^{-37}$
Epsilon maszynowy	$10^{-5}$	$10^{-9}$	$10^{-9}$

Do typów podstawowych należy również wyliczenie. Składa się ono z listy stałych symbolicznych, każda o wartości będącej liczbą całkowitą. Typy wyliczeniowe funkcjonalnie są równoważne całkowitoliczbowym.

Typy pochodne

Z niezerowej liczby obiektów tego samego typu można stworzyć tablicę. Jej elementy są ułożone w pamięci komputera po kolei i bez żadnych przerw, a dostęp do nich można uzyskać za pomocą składni tablica[indeks], gdzie indeksy rozpoczynają się od zera. Do raz utworzonej zmiennej typu tablicowego nie jest możliwe przypisanie innej tablicy. Kiedy nazwa tablicy zostanie użyta w wyrażeniu, dokonuje się jej niejawna konwersja na wskaźnik do zerowego elementu tablicy. Wskaźnik ten nie może być użyty w charakterze l-wartości.

Do przechowywania adresu obiektu określonego typu służą wskaźniki. Dozwolone jest wykonywanie na nich niektórych operacji arytmetycznych. Dowolny wskaźnik można przyrównać do zera (oznaczającego literał pusty, zapisywany też jako NULL). Porównywanie oraz odejmowanie dwóch wskaźników jest zdefiniowane wyłącznie wtedy, kiedy dotyczą one tej samej tablicy lub – wyłącznie w przypadku porównywania – tego samego obiektu złożonego. Do wartości wskaźnika można również dodać lub odjąć dowolną liczbę całkowitą. Zabronione jest wykonywanie innych działań, takich jak mnożenie czy dzielenie. W działaniach arytmetycznych, w których biorą udział liczby całkowite oraz wskaźniki, liczba jest traktowana jako liczba elementów tablicy odpowiedniego typu, a nie liczba bajtów.

Jedna lub kilka zmiennych może tworzyć strukturę. W przeciwieństwie do tablic, takie składowe mogą być różnych typów, a poszczególne pola rozróżnia się z użyciem ich identyfikatorów. Każda struktura stanowi odrębną przestrzeń nazw, toteż pole o tej samej nazwie może występować w kilku strukturach. Zagnieżdżanie struktur jest dozwolone – składowe mogą również być strukturami. Standard ISO C zabrania natomiast rekursywnego zagnieżdżania struktury samej w sobie. Mimo to struktura może zawierać wskaźnik na inną strukturę tego samego typu. Zarówno przypisywanie do zmiennej typu strukturalnego nowej wartości, jak i przekazywanie jej jako argument oraz zwracanie z funkcji są dopuszczalnymi operacjami.

Układ składowych w pamięci jest zależny od implementacji, z pewnymi wyjątkami: pierwsze pole musi się zaczynać od razu na początku struktury (tak by wskaźnik na strukturę był równy co do wartości wskaźnikowi na jej pierwsze pole), a ponadto pola muszą następować w pamięci w tej samej kolejności, co w deklaracji. Dopuszcza się jednak istnienie niewykorzystanych i nienazwanych przestrzeni w środku oraz na końcu struktury.

Struktury mogą zawierać również pola bitowe, które pozwalają na określenie rozmiaru obiektu z dokładnością do bitów. Takie pola w trakcie kompilacji są umieszczane w odpowiednio dużej, adresowalnej jednostce pamięci. Jeżeli ma ona wystarczający rozmiar, by pomieścić sąsiednie pola, zostaną one w niej razem upakowane. Standard ISO C nie określa kolejności, w której przylegające do siebie pola bitowe są przechowywane w pamięci. Pobieranie adresu pola bitowego jest niedozwolone.

Przykładowa deklaracja struktury opisującej węzeł pewnego drzewa:

struct tnode {
    char *word;
    int count;
    struct tnode *left;
    struct tnode *right;
}

Typem podobnym do struktur są unie. Pozwalają one przechowywać wartości różnych typów pod tym samym adresem, z poszanowaniem ograniczeń dotyczących ich ułożenia w pamięci. Unia ma przynajmniej taki rozmiar, jak największa spośród jej składowych. Wszystkie operacje, które są dopuszczalne dla struktur, można wykonywać również na uniach.

Standard języka C definiuje również typy atomowe, choć stanowią one opcjonalną funkcjonalność, która nie musi być obsługiwana przez implementacje. Biblioteka standardowa dostarcza funkcje pozwalające m.in. na zmianę wartości zmiennych takich typów w sposób atomowy, tj. z gwarancją, że operacja nie zostanie przerwana przez inne działanie na tej samej zmiennej.

W języku C dostępne są także typy danych opisujące funkcje. Zawierają one informacje o typie parametrów oraz wartości zwracanej. Zmienna typu funkcyjnego, jeśli nie jest argumentem operatora pozyskania adresu &, niejawnie przekształca się we wskaźnik do funkcji. Wywołania, dokonywane za pośrednictwem wskaźników nie są przez standard rozróżniane od tych zawierających wprost nazwę funkcji.

Aliasy typów

W języku C dostępny jest mechanizm pozwalający na zdefiniowanie synonimów dla istniejących typów danych. Aliasowanie nie tworzy nowego typu, zatem obiekty utworzone z użyciem zarówno pierwotnej, jak i nowej nazwy mają identyczne właściwości.

Mechanizm ten wykorzystuje się między innymi w celu zapewnienia przenośności oprogramowania podczas wykorzystania typów zależnych od docelowej architektury. Przykładem takiego zastosowania są size_t i ptrdiff_t, pochodzące z biblioteki standardowej języka C. Przechowują one liczby całkowite, lecz ich dokładny typ zależy od implementacji.

Inny powód, dla którego typom nadawane są nowe nazwy, to ułatwienie zrozumienia programu poprzez nadanie opisowych nazw bardziej złożonym konstrukcjom. Poniższe trzy deklaracje funkcji są sobie równoważne:

// fv jest aliasem dla funkcji przyjmującej parametr int i nie zwracającej żadnej wartości
typedef void fv(int);
// pfv to alias dla wskaźnika na funkcję taką jak powyżej
typedef void (*pfv)(int);

// Równoważne deklaracje:
void (*signal(int, void (*)(int)))(int);
fv *signal(int, fv *);
pfv signal(int, pfv);

Kwalifikatory typów

Kwalifikatory typów nadają specyficzne znaczenia wyrażeniom, które są l-wartością. Można je ze sobą dowolnie łączyć.

const

Oznacza wartość, która nie może być zmieniana. Próba modyfikacji tak zdefiniowanego obiektu przez l-wartość usuwającą to ograniczenie jest zachowaniem niezdefiniowanym. Obiekty zdefiniowane statycznie jako const mogą zostać umieszczone w pamięci z dostępem tylko do odczytu.

volatile

Oznacza, że wartość wyrażenia jest nieprzewidywalna lub może mieć nieznane efekty uboczne. Jest to wskazówka dla kompilatora, aby nie dokonywał w obrębie tego wyrażenia żadnych optymalizacji. W środowisku wieloprocesorowym może to oznaczać, że zmienna jest dostępna z wielu wątków równocześnie. Statyczne obiekty volatile są odpowiednim wyborem przy modelowaniu układów wejścia/wyjścia mapowanego w przestrzeni adresowej procesora. Próba modyfikacji tak zdefiniowanego obiektu przez l-wartość usuwającą to ograniczenie jest zachowaniem niezdefiniowanym.

restrict

Kwalifikator typu wskaźnikowego będący wskazówką optymalizacyjną dla kompilatora, że dostęp do wszelkich danych obiektu dokonywany jest jedynie przez podany wskaźnik.

_Atomic

Oznacza wartość, do której możliwy ma być dostęp za pomocą niepodzielnej instrukcji. Szczegółowy zestaw dostępnych operacji i typów danych jest zdefiniowany w dedykowanym pliku nagłówkowym <stdatomic.h>.

identyfikator przestrzeni adresowej

Systemy wbudowane używają procesorów, które mają wiele różnych i rozłącznych przestrzeni adresowych. Możliwe jest określanie, że obiekt ma być umieszczony w określonej przestrzeni za pomocą dedykowanych kwalifikatorów. Przykładowo dla procesora Intel 8051 dostępne są kwalifikatory pamięci code, data, idata, bdata, xdata, far i pdata. Natomiast kompilator C dla z/OS wspiera __callback, __far, __fdptr, __ptr32 i __ptr64. Rozszerzenia dotyczące wsparcia różnych przestrzeni adresowych implementuje również kompilator GNU C na przykład __flash, __memx, __far, __ea, __seg_fs lub __seg_gs. Ich dostępność zależy od docelowego procesora, na który jest kompilowany kod.

Zarządzanie pamięcią

Standard języka C gwarantuje, że na czas życia obiektu zostanie mu przydzielona pamięć. Ponadto przez cały ten czas dany obiekt będzie dostępny pod stałym adresem i będzie przechowywał ostatnio zapisaną wartość. Momenty utworzenia i zniszczenia obiektu są zależne od przypisanej mu klasy pamięci. Dostęp do pamięci nie jest kontrolowany przez język, ale próby odczytu lub zapisu pod nieprawidłowymi adresami mogą skończyć się naruszeniami ochrony pamięci.

Każdy obiekt (poza polami bitowymi) składa się z ciągłej sekwencji bajtów, których kolejność i sposób kodowania wartości może zależeć od implementacji.

Po upłynięciu czasu życia zmiennej, wszelkie odwołania do niej prowadzą do niezdefiniowanego zachowania. Podobnie wartość wskazywana przez wskaźnik staje się nieokreślona, kiedy wskazywany obiekt kończy życie.

Klasy pamięci

Deklarując obiekt, można wskazać jego klasę pamięci, która określa między innymi jego czas życia i zasięg widoczności. Zmienne lokalne, o ile nie użyto żadnego specyfikatora klasy pamięci, są deklarowane jako zmienne automatyczne. Wartości niezainicjalizowanych zmiennych są niezdefiniowane i mogą mieć wartość zależną od kompilatora lub od tego, co akurat było w pamięci. Są one dostępne przez cały czas wykonywania bloku, gdzie zostały zadeklarowane. W przypadku rekurencyjnego wkroczenia do tego samego bloku, za każdym razem tworzona jest osobna instancja obiektu. Tę klasę pamięci można również określić jawnie słowem kluczowym auto.

Podobne do zmiennych automatycznych są zmienne rejestrowe. Zadeklarowanie obiektu ze słowem register sugeruje kompilatorowi, by umieścił go w pamięci o szybkim dostępie (np. rejestrze procesora). Ostateczny wybór rodzaju pamięci, w której znajdzie się zmienna, należy jednak do kompilatora. Niezależnie od tego, czy obiekt zlokalizowany będzie w pamięci adresowalnej, zabronione jest pobieranie adresu zmiennej rejestrowej.

Innym rodzajem zmiennych są zmienne statyczne (deklarowane słowem static). Pamięć dla nich inicjalizowana jest w momencie uruchomienia programu i od tego momentu wszystkie odwołania dotyczą tego samego regionu pamięci. W przypadku, gdy zmienną lokalną zadeklarowano jako statyczną, będzie ona przechowywała tę samą wartość pomiędzy różnymi wywołaniami funkcji. Z kolei statyczne zmienne zewnętrzne charakteryzują się linkowaniem wewnętrznym, co oznacza, że nie są widoczne na zewnątrz jednostki tłumaczenia, w której je zadeklarowano.

Obiektowi można również nadać klasę extern, która jawnie informuje, że cechuje się on linkowaniem zewnętrznym. Jest to domyślna własność zmiennych deklarowanych na zewnątrz funkcji. Zmienne statyczne i zewnętrzne są inicjalizowane zerem, jeśli nie podano żadnej wartości początkowej.

Istnieje również klasa pamięci _Thread_local, której czas życia jest powiązany z wątkiem. Obiekty zadeklarowane w ten sposób są tworzone w momencie rozpoczęcia wątku. Dostęp pośredni do zmiennych tego rodzaju należących do innych wątków wywołuje zachowanie zależne od implementacji.

Formalnie, specyfikatorem klasy pamięci jest także typedef. Zalicza się go do tej grupy dla wygody, choć nie służy do deklarowania pamięci.

Alokacja pamięci

Biblioteka języka C udostępnia funkcje służące do alokacji pamięci o arbitralnie wybranym rozmiarze (malloc i odmiany). Zwracają one wskaźnik do pierwszego bajtu obszaru pamięci, który można następnie rzutować na dowolny inny typ wskaźnikowy. Zarezerwowany w ten sposób zakres, w zależności od wywołanej funkcji, może być zainicjalizowany samymi zerami, lecz nie musi. Czas życia obiektów w alokowanej jawnie pamięci trwa od jej przydzielenia aż do zwolnienia za pomocą funkcji free.

Zastosowanie ręcznej alokacji pamięci może prowadzić do wystąpienia błędów w kodzie, wynikających np. z odwołań do wiszących wskaźników, ale także przepełnienia bufora i próby powtórnej dealokacji. Obecne w programie podatności mogą zależeć od wykorzystanego algorytmu rezerwacji pamięci.

Przykład „Hello world”

Program „Hello world” napisany odręcznie przez Briana Kernighana

Program wyświetlający na ekranie napis „Hello world” był pierwszym fragmentem kodu w języku C, umieszczonym w książce Język C. Składnia kodu z pierwszego wydania tej książki odbiega od późniejszych standardów. Program ten, w bardzo podobnej formie, znajdował się również w dokumencie Programming in C: A Tutorial, przygotowanym przez B. Kernighana w 1974 roku.

main()
{
    printf("hello, world");
}

Powyższy kod prawdopodobnie nie zostanie skompilowany, jeśli nie wymusi się na kompilatorze przyjęcia standardu C90. Nowsza wersja tego programu, rozumiana przez współczesne kompilatory, wygląda następująco:

#include <stdio.h>

int main(void){
    printf("hello, world");
}

Pierwsza linijka tego kodu informuje preprocesor, aby dołączył w to miejsce zawartość pliku stdio.h, który wchodzi w skład biblioteki standardowej języka C. Zadeklarowane w nim są procedury odpowiadające za obsługę wejścia i wyjścia, w tym printf. Następnie definiowana jest funkcja main. To od niej rozpoczyna się wykonanie programu napisanego w C. Funkcja ta nie przyjmuje żadnych argumentów i zwraca wartość całkowitą. Wewnątrz nawiasów klamrowych znajduje się lista instrukcji, które zostaną wywołane po uruchomieniu programu.

W przykładowym programie funkcja main składa się z jednej instrukcji: wywołania printf z argumentem "hello, world". Służy ono do wyświetlenia tekstu na ekranie. Mogłaby się tam znaleźć jeszcze instrukcja return, ale zgodnie ze standardem ISO C, umieszczenie jej w funkcji main jest opcjonalne. Zwrócona do systemu operacyjnego zostanie wtedy wartość 0. Wartość zwracana przez funkcję main to tzw. kod wyjścia (ang. exit status albo return code), a wartość 0 zazwyczaj oznacza udane wykonanie programu.

Zastosowania

Zastosowania języka C

Głównym celem, który przyświecał Dennisowi Ritchiemu przy tworzeniu języka C było ułatwienie pisania oprogramowania systemowego. Potrzebny był język wysokopoziomowy, ale jednocześnie tak wydajny jak asembler. Z tego też powodu C bywa nazywany „wysokopoziomowym asemblerem”. Powstały w nim m.in. Unix i jądro Linux. W praktyce dla każdej nowej architektury język C jest pierwszym dostępnym językiem programowania poza asemblerem.

W latach 80. XX wieku C zdobył popularność również wśród twórców oprogramowania aplikacyjnego. Jego głównymi konkurentami były wtedy BASIC i Pascal. C miał nad obydwoma przewagę, będąc dość ściśle ustandaryzowanym i pozbawionym niezgodnych ze sobą odmian. Ponadto zapewniał w tamtym czasie najpełniejsze wsparcie dla programowania strukturalnego, pozwalając również na hermetyzację kodu.

Zastosowanie języka C pozwoliło części producentów oprogramowania zrezygnować ze stosowania języka asemblera. W ten sposób postąpiono np. z Oracle Database w 1983 roku, co pozwoliło na osiągnięcie jego przenośności. W konsekwencji, Oracle Database 3 stało się pierwszym silnikiem relacyjnych baz danych, który można było uruchomić zarówno na komputerach typu mainframe, minikomputerach jak i komputerach osobistych. W C został napisany również najpopularniejszy na świecie silnik bazodanowy, SQLite.

Innymi przykładami oprogramowania przygotowanego w języku C są serwer HTTP Apache, biblioteka kryptograficzna OpenSSL, a także gry Doom i Quake.

Środowiska wykonawcze dla programów napisanych w innych językach również powstają z wykorzystaniem kodu w C. Dotyczy to np. Java Runtime Environment, CPythona (referencyjnej implementacji Pythona) czy interpretera PHP. Ponadto C bywa także stosowany jako język pośredni dla kompilatorów języków wyższego poziomu. Takie kompilatory zostały napisane m.in. dla Basica, Pythona czy Prologa. Niektóre języki wymagają jednak cech, których C nie oferuje, np. rekurencji ogonowej albo wsparcia dla odśmiecania pamięci. Z tego powodu zaprojektowano m.in. C--.

Popularność

Język C, przez ponad 20 lat prowadzenia rankingu TIOBE Index (od 2001 roku), plasował się na jednym z dwóch czołowych miejsc, trzykrotnie zdobywając miano „języka roku”, nadawane językowi, który odnotuje najwyższy wzrost wskaźnika rankingowego rok do roku. Z kolei w PYPL – alternatywnym rankingu popularności języków programowania – liczone łącznie języki C i C++ osiągnęły w czerwcu 2022 piątą lokatę.

Badanie projektów open source na platformie GitHub z 2014 roku wskazało, że ok. 60% linii kodu źródłowego napisanych było w C, choć znajdowały się one jedynie w 10% przebadanych repozytoriów. Autorzy badania są zdania, że tak wysoka wartość pierwszego wskaźnika może wynikać w faktu, iż w C powstały znaczące części systemów operacyjnych, m.in. jądro Linux i jego odmiany, które należą do projektów o największej bazie kodu.

Według Stack Overflow Developer Survey 2022, co szósty profesjonalny programista zna język C. Większość respondentów (60%) oceniła go jednak jako „przerażający” (w dwustopniowej skali, drugą opcją było „uwielbiany”). Natomiast 4,3% osób zadeklarowało, że chce rozpocząć pracę z tym językiem.

Wpływ

Popularność i szerokie zastosowanie języka C ma bezpośredni wpływ na składnię lub semantykę innych języków programowania. Przede wszystkim najbardziej podobnym i kompatybilnym jest język C++, który powstawał jako rozszerzenie „C z klasami”. Inne języki wykazujące podobieństwa do składni C to między innymi C#, csh, D, Go, IDL, Java (w zasadzie do C++), JavaScript, Objective-C, OpenCL, OpenGL, PAWN, Perl, PHP, tudzież Swift.

Krytyka

C charakteryzuje się słabym typowaniem. Jego specyfikacja pozwala na rzutowanie typów wskaźnikowych na dowolne inne typy wskaźnikowe. W konsekwencji dowolny region pamięci może być traktowany tak, jakby zawierał dane dowolnego typu. Jednocześnie narzędzia wspomagające pisanie kodu nie są w stanie sprawdzić, czy konwersja typów jest sensowna. W C jest ponadto dozwolone przypisanie wartości do zmiennej innego typu. Jako przykład słabości wynikającej ze słabego typowania, I. Pohl i D. Edelson podali typową implementację funkcji, zmieniającej małe litery na wielkie. Wykorzystuje ona operacje arytmetyczne na liczbach całkowitych oraz zmiennych typu char, mimo działania – na poziomie koncepcji – wyłącznie w dziedzinie znakowej. Powszechne wykorzystanie wskaźników, pozwalających na niskopoziomowy dostęp do pamięci jest czynnikiem osłabiającym bezpieczeństwo programów. Niejawna konwersja typów całkowitoliczbowych (zmiana szerokości oraz możliwości przechowywania liczb ujemnych) oraz ciche przekroczenia zakresu wartości również należą do częstych przyczyn błędów oprogramowania, objawiających się w szczególności tam, gdzie dokonywane są operacje pamięciowe i prowadzą zwykle do przepełnienia buforów.

Mimo deklarowania tablic jako składające się z określonej liczby elementów, nie istnieje mechanizm sprawdzający, czy programista odwołuje się do elementu wewnątrz tablicy; co więcej, dozwolone jest używanie ujemnych indeksów, aby odwołać się do obiektów leżących w pamięci przed zerowym. Przeszkadza to w implementacji np. odśmiecania pamięci, ale też stanowi powszechne źródło trudnych do wykrycia błędów w oprogramowaniu. Możliwość zapisu danych poza tablicę bywa wykorzystywana jako wektor ataku, prowadzącego do uzyskania kontroli nad systemem komputerowym poprzez wstrzyknięcie do programu odpowiednio spreparowanych poleceń lub zmianę stanu innych zmiennych.

Wielowymiarowe tablice są w rzeczywistości tablicami jednowymiarowymi, co w przeszłości utrudniało pisanie funkcji wykonujących np. obliczenia macierzowe. W pierwotnej wersji standardu język C nie wspierał obsługi tablic o zmiennej (to znaczy ustalanej dopiero w momencie działania programu) liczbie elementów, w tym przekazywania takich tablic jako argumentów funkcji. Dlatego do adresowania np. elementów macierzy wykorzystywano pomocniczą tablicę wskaźników do pierwszych elementów każdego wiersza.

Innym problemem, który podnoszono jest niekonsekwencja twórców standardu, objawiająca się w określeniach void i void*. Pierwsze z nich oznacza brak wartości. Zatem zgodnie z logiką konstruowania typów, ten drugi powinien być wskaźnikiem na wartość pustą. W rzeczywistości jednak jest to wskaźnik na wartość dowolnego typu. Jeszcze inne zastosowanie słowa void, niezwiązane z desygnowaniem typu, to wskazanie, że funkcja nie przyjmuje żadnych argumentów.

Z perspektywy czasu niektóre decyzje dotyczące składni okazały się nieoptymalne. Jedną z nich jest niższy priorytet operatorów bitowych niż porównania, co wymusza pisanie konstrukcji takich jak (a & mask) == b, które bez nawiasów działałyby niezgodnie z intencją programisty. Inną z częściej spotykanych pułapek jest zamienienie operatorów porównania (==) i przypisania (=). Kod napisany w ten sposób pozostaje poprawny składniowo, więc pomyłka nie zostanie zgłoszona przez kompilator. Innym operatorem, który utrudnia zrozumienie programu jest przecinek, pozwalający na wykonanie kilku wyrażeń w jednej instrukcji. Ten sam symbol oddziela od siebie np. argumenty funkcji.

Sama składnia deklarowania typów pochodnych również może konfundować. Założenie, że sposób deklaracji odpowiada sposobowi użycia zmiennej danego typu, spowodowało, że trzeba je czytać od środka na zewnątrz. Jest to konwencja trudna do uchwycenia przez wiele osób. Tego mankamentu dałoby się uniknąć, gdyby operator dereferencji był przyrostkowym, a nie przedrostkowym, jak to ma miejsce w C.

Cechy języka, krytykowane jako trudne do odczytania lub zrozumienia, bywają również wykorzystywane do celowego zaciemniania kodu, czego skrajnym przypadkiem są programy zgłaszane do konkursu IOCCC.

Standard języka C opisuje wiele sytuacji, dla których zachowanie jest niezdefiniowane lub nieokreślone. Daje to pewne pole manewru na różne optymalizacje w zależności od platformy sprzętowej. W rezultacie ten sam kod skompilowany na różnych kompilatorach lub z różnymi opcjami kompilacji może się inaczej zachowywać. W szczególności standard C nie określa, w jaki sposób przechowywane są w pamięci wielobajtowe wartości skalarne. Większość programów polega jedynie na domyślnym zachowaniu zapewnionym przez ABI. Nie zapewnia ono jednak przenośności między różnymi platformami. Jest to jeden z głównych powodów nieprzenaszalności kodu, który ujawnia się podczas wymiany danych poprzez pamięć współdzieloną, masową lub ich transmisję. Jedną z naczelnych zasad ducha programowania w C jest tworzenie wydajnego kodu nawet za cenę jego przenośności.

Niezainicjowana zmienna to problem, który dotyczy wielu języków programowania. Błąd ten powstaje z winy programisty. Jest on trudny do wykrycia, gdyż taki program może się zupełnie inaczej zachowywać w środowisku diagnostycznym pod kontrolą debuggera niż w środowisku produkcyjnym lub wręcz w kolejnych wykonaniach przy takich samych danych wejściowych. Kompilator języka jedynie rezerwuje dla zmiennej obszar w pamięci, a jej wartość jest taka jaka wynika ze stanu bitów, która się w tej pamięci aktualnie znajduje. Kompilator często ostrzega o próbie dostępu do niezainicjowanej zmiennej.

Bibliografia

• Brian W. Kernighan, Dennis M. Ritchie, Język ANSI C, DanutaD. Kruszewska (tłum.), MarekM. Kruszewski (tłum.), wyd. 7, Warszawa: Wydawnictwa Naukowo-Techniczne, 2002, ISBN 83-204-2719-3  (pol.).
• ISO/IEC9899:2017 Draft [online], 2017  (ang.).

Linki zewnętrzne

• Krzysztof Diks, Wstęp do programowania w języku C (materiały dydaktyczne MIMUW na studia informatyczne)
• Mike Banahan, Declan Brady, Mark Doran, The C Book, Second Edition (ang.), Addison-Wesley 1991, ISBN 0-201-54433-4, wersja online.