Tekst źródłowy strony C (język programowania)

{{wyróżnienie|AnM}}
{{Język programowania infobox
 | nazwa                  = C
 | logo                   = The C Programming Language logo.svg
 | data                   = 1972
 | paradygmat             = [[Programowanie imperatywne|imperatywny]] ([[programowanie proceduralne|proceduralny]])
 | typowanie              = [[Typowanie statyczne|statyczne]] ([[Typowanie słabe|słabe]])
 | implementacje          = [[Borland Turbo C]], [[GNU Compiler Collection|GCC]], [[Microsoft Visual Studio|Microsoft Visual C]], [[MinGW]], [[LLVM]], [[Tiny C Compiler]]
 | pochodne               = [[C++]], [[Java]], [[C Sharp|C#]]
 | wersja                 = C23 (październik 2024)<ref name="ISO2024">{{Cytuj |tytuł = ISO/IEC 9899:2024 |data dostępu = 2025-02-08 |opublikowany = ISO |url = https://www.iso.org/standard/82075.html |język=en}}</ref>{{odn|ISO/IEC9899:2024|s=i}}
 | wersja testowa         = C2y{{odn|ISO/IEC9899:2024|s=i}}
 | twórca                 = [[Dennis Ritchie]]
 | licencja               = 
 | platforma              = [[wieloplatformowość|wieloplatformowy]]
 | system                 = [[wieloplatformowość|wieloplatformowy]]
 | wikibooks              = C
 | commons                = Category:C_(programming_language)
 | www                    = 
}}
'''C''' – [[Programowanie imperatywne|imperatywny]], [[Programowanie proceduralne|proceduralny]] [[język programowania]] ogólnego przeznaczenia<ref name="GitHub100k" />, stworzony na początku lat 70. XX wieku przez [[Dennis Ritchie|Dennisa Ritchiego]], ówczesnego pracownika [[Bell Labs]]. W języku C powstały narzędzia systemowe dla [[Unix|Uniksa]], a potem również kod systemu Unix. Język C został ustandaryzowany w 1989 roku przez [[American National Standards Institute|ANSI]]. Od tego czasu jego rozwojem zajmuje się grupa robocza w ramach [[Międzynarodowa Organizacja Normalizacyjna|ISO]].

Język C powstawał jako rozwinięcie języka [[B (język programowania)|B]], wzbogacając się stopniowo o kolejne funkcje. Okresy najszybszego rozwoju języka C to lata 1972–1973 oraz 1977–1979. Z kolei lata 80. to czas zdobywania przez niego popularności, czego efektem była dostępność [[kompilator]]ów dla praktycznie wszystkich używanych wtedy [[Architektura komputera|architektur komputerów]] i [[System operacyjny|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 [[Oprogramowanie użytkowe|aplikacji użytkowych]]. Mimo to spotyka się z krytyką z powodu pewnych decyzji projektowych, takich jak priorytety [[Operator (programowanie)|operatorów]] lub nadmiernie lakoniczna składnia.

== Historia ==
Początki C są ściśle związane z rozwojem systemu [[Unix]], napisanego pierwotnie przez [[Dennis Ritchie|Dennisa Ritchiego]] i [[Ken Thompson|Kena Thompsona]] w [[asembler]]ze na komputer [[PDP-7]]. Późniejsza wersja systemu, przeznaczona na maszynę [[PDP-11]], również powstała w asemblerze<ref name="Ritchie1993">{{Cytuj |autor = [[Dennis Ritchie|Dennis M. Ritchie]] |tytuł = The development of the C language |czasopismo = ACM SIGPLAN Notices |data = 1993-03-01 |data dostępu = 2022-01-15 |issn = 0362-1340 |wolumin = 28 |numer = 3 |s = 201–208 |doi = 10.1145/155360.155580 |url = https://www.bell-labs.com/usr/dmr/www/chist.pdf |archiwum = https://web.archive.org/web/20220107182926/https://www.bell-labs.com/usr/dmr/www/chist.pdf |zarchiwizowano = 2022-01-07 |język = en}}</ref>.

Thompson czuł potrzebę wykorzystania języka wyższego poziomu do [[Programowanie systemowe|napisania narzędzi systemowych]] dla Uniksa. Początkowo próbował przygotować kompilator [[Fortran]]u, lecz dość szybko porzucił ten pomysł. W zamian stworzył własną, okrojoną wersję [[BCPL]], którą nazwał [[B (język programowania)|B]]. W języku tym powstało niewiele narzędzi, ponieważ wynikowe [[Program komputerowy|programy]] były powolne oraz nie mogły korzystać z adresowania poszczególnych bajtów [[Pamięć operacyjna|pamięci]] (funkcji dostępnej np. w PDP-11)<ref name="Ritchie1993" />.

=== Wczesny rozwój ===
Dennis Ritchie rozpoczął w 1972 roku rozwijanie języka B. Jedną z pierwszych zmian było dodanie [[Typ danych|typów danych]] dla [[Zmienna (informatyka)|zmiennych]]. Początkowo dostępne były dwa: [[Znakowy typ danych|znakowy]] (<code>char</code>) i [[Liczba całkowita (typ danych)|całkowitoliczbowy]] (<code>int</code>). Wprowadzono również sposób deklarowania zmiennych typu [[Wskaźnik (typ danych)|wskaźnikowego]] oraz odwołań do [[Podprogram|funkcji]]. Tak znaczące zmiany spowodowały, że Ritchie nadał językowi nową nazwę: C<ref name="Ritchie1993" />.

Zgodnie z sugestią [[Alan Snyder|Alana Snydera]], na początkowym etapie rozwoju języka Ritchie rozdzielił operatory [[Koniunkcja (logika)|koniunkcji]] i [[Alternatywa|alternatywy]] na [[Operator bitowy|bitowe]] (składające się z pojedynczego symbolu) oraz [[Operator logiczny|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 (program komputerowy)|interpreter]], w zależności od kontekstu<ref name="Ritchie1993" />.

[[Kompilator]] C, wraz z kilkoma programami napisanymi w tym języku, został dołączony do drugiej wersji systemu Unix<ref>{{Cytuj |autor = [[Douglas McIlroy|M. Douglas McIlroy]] |tytuł = A Research UNIX Reader: Annotated Excerpts from the Programmer’s Manual, 1971-1986 |url = https://www.cs.dartmouth.edu/~doug/reader.pdf |s = 10 |data dostępu = 2022-01-15 |archiwum = https://web.archive.org/web/20211101183445/https://www.cs.dartmouth.edu/~doug/reader.pdf |zarchiwizowano = 2021-11-01 |język = en}}</ref>. Latem 1973 [[Jądro systemu operacyjnego|jądro]] tego systemu zostało przepisane w języku C<ref name="Ritchie1993" />.

Do tego czasu wprowadzono również do [[Syntaktyka (logika)|składni]] języka obsługę [[Struktura (programowanie)|struktur]]. Mniej więcej w tym samym czasie powstała pierwsza wersja [[preprocesor]]a. Umożliwiała ona dołączanie [[Plik danych|plików]] zewnętrznych (dyrektywa <code>#include</code>) oraz wykonywanie prostych podstawień (definiując [[Makro|makra]] bez parametrów z użyciem <code>#define</code>). Funkcjonalności takie jak [[kompilacja warunkowa]] czy parametryzowane makra zostały wprowadzone niedługo później – przez {{link-interwiki|Mike Lesk|tekst=Mike’a Leska|Q=Q731229}} oraz [[John Reiser|Johna Reisera]]. Na tym etapie rozwoju języka preprocesor stanowił opcjonalny dodatek, który nie musiał być uruchamiany w trakcie [[Kompilator|kompilacji]]<ref name="Ritchie1993" />.

Około 1977 roku Dennis Ritchie, Ken Thompson i [[Stephen C. Johnson|Stephen Johnson]] skupili się na [[Przenośność oprogramowania|przenośności]] oprogramowania napisanego w C<ref name="Ritchie1993" />. W tym celu przyjrzeli się często wykorzystywanym konstrukcjom i zachowaniom, które były zależne od [[Architektura komputera|architektury komputera]]. Ponadto Johnson napisał kompilator ''{{link-interwiki|Portable C Compiler|tekst=pcc|Q=Q279523}}'', 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<ref name="Johnson1978">{{Cytuj |autor = [[Stephen C. Johnson]]; [[Dennis Ritchie|Dennis M. Ritchie]] |tytuł = Portability of C Programs and the UNIX System |url = https://www.bell-labs.com/usr/dmr/www/portpap.pdf |s = 4 |data dostępu = 2022-01-15 |archiwum = https://web.archive.org/web/20211218212919/https://www.bell-labs.com/usr/dmr/www/portpap.pdf |zarchiwizowano = 2021-12-18 |język = en}}</ref><ref name="Ritchie1993" />.

=== K&R C ===
W 1978 opublikowane zostało pierwsze wydanie książki ''The C Programming Language'' (wyd. polskie ''Język C'', 1987{{odn|Kernighan|Ritchie|2002|s=13}}), autorstwa [[Brian Kernighan|Briana Kernighana]] i [[Dennis Ritchie|Dennisa Ritchiego]]. Stanowiła ona pierwszą, nieformalną, [[Specyfikacja techniczna|specyfikację]] języka C<ref name="Ritchie1993" />. 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<ref name="manC">{{Cytuj |autor = Gabor Kovesdan |tytuł = c78(7) manual page |url = https://nxmnpg.lemoda.net/7/c78 |data dostępu = 2022-01-15 |archiwum = https://web.archive.org/web/20210814213202/https://nxmnpg.lemoda.net/7/c78 |zarchiwizowano = 2021-08-14 |język = en}}</ref>.

Jeszcze przed publikacją książki do języka C włączono kwalifikatory <code>short</code> i <code>long</code>, pozwalające określić wielkość zmiennej typu całkowitoliczbowego, a także specyfikator <code>unsigned</code>, oznaczający liczby nieujemne<ref>{{Cytuj |autor = [[Dennis Ritchie|Dennis M. Ritchie]]; [[Brian Kernighan]] |tytuł = The C Programming Language |wydanie = 1 |miejsce = Englewood Cliffs |wydawca = Prentice-Hall |data = 1978 |isbn = 0131101633 |s = 34 |język = en}}</ref>.

W specyfikacji C78 złożone operatory [[Przypisanie|przypisania]] uzyskały jednoznaczną składnię. Do roku 1976 instrukcja „zmniejsz wartość zmiennej <code>i</code> o 10” mogłaby zostać napisana jako: <code>i&nbsp;=-&nbsp;10</code>, co jest bardzo podobne do polecenia zapisania w zmiennej <code>i</code> wartości -10. Nowe symbole cechowała zamieniona kolejność [[Operator (programowanie)|operatora]] i znaku równości, np. <code>-=</code> zamiast <code>=-</code>. Dwuznaczne oznaczenia wywodziły się jeszcze z języka B i sposobu przetwarzania kodu przez jego [[Analizator składniowy|analizator składni]]<ref name="Ritchie1993" />.

W książce Kernighana i Ritchiego znalazł się również opis biblioteki [[Standardowe strumienie|wejścia/wyjścia]]. Podwaliny pod nią położył w 1972 roku Mike Lesk, pisząc „przenośną [[Biblioteka programistyczna|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<ref name="Ritchie1993" /><ref>{{Cytuj |autor = [[Dennis Ritchie|Dennis M. Ritchie]]; [[Brian Kernighan]] |tytuł = The C Programming Language |wydanie = 1 |miejsce = Englewood Cliffs |wydawca = Prentice-Hall |data = 1978 |isbn = 0131101633 |s = 143 |język = en}}</ref>.

Autorzy publikacji wspomnieli również o planowanym zniesieniu większości ograniczeń dotyczących struktur<ref>{{Cytuj |autor = [[Dennis Ritchie|Dennis M. Ritchie]]; [[Brian Kernighan]] |tytuł = The C Programming Language |wydanie = 1 |miejsce = Englewood Cliffs |wydawca = Prentice-Hall |data = 1978 |isbn = 0131101633 |s = 121 |język = en}}</ref>. Do 1980 roku możliwe stało się przekazywanie ich jako [[Parametr (informatyka)|parametry funkcji]] oraz bezpośrednie przypisywanie. Jedynie brak notacji dla [[literał]]u powodował, że nie były [[Typ pierwszoklasowy|typem pierwszoklasowym]]. W okresie po wydaniu książki do języka trafiło również wsparcie dla [[Wyliczeniowy typ danych|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<ref name="Ritchie1993" />.

Język taki, jak opisany przez Kernighana i Ritchiego w 1978 roku nie przewidywał żadnej możliwości określenia [[Typ danych|typów]] przyjmowanych przez parametry funkcji<ref name="Ritchie1993" />. 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ść oprogramowania|spójnością]] i przestrzeganiem dobrych praktyk<ref name="Johnson1978" />.

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<ref name="Ritchie1993" />.

W latach 80. XX wieku [[Bjarne Stroustrup]] stworzył język [[C++]], który stanowił rozszerzenie C, dodające przede wszystkim wsparcie dla [[Programowanie obiektowe|programowania obiektowego]]. Dodatków tych nie wcielono do C, a C++ został niezależnie ustandaryzowany przez ANSI i ISO<ref>{{Cytuj |autor = [[Bjarne Stroustrup]] |tytuł = A history of C++ |czasopismo = ACM SIGPLAN Notices |data = 1993-03 |data dostępu = 2022-07-24 |wolumin = 28 |numer = 3 |doi = 10.1145/154766.155375 |url = https://www.researchgate.net/publication/269031890_A_history_of_C |język = en}}</ref>.

=== ANSI C i ISO C ===
W 1983 roku, [[American National Standards Institute|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 [[Biblioteka uruchomieniowa|środowiskami uruchomieniowymi]]”. Odpowiedni dokument przyjęto w 1989 roku jako standard ANSI X3.159-1989 „Język programowania C”<ref name="Ritchie1993" />. Opisana w nim wersja języka jest zwykle określana jako ANSI C lub C89 (od daty publikacji)<ref name="manC" />.

Rok później, w 1990 standard ANSI C został przyjęty (ze zmianami redakcyjnymi) przez [[Międzynarodowa Organizacja Normalizacyjna|Międzynarodową Organizację Normalizacyjną]] jako ISO/IEC 9899:1990<ref name="Ritchie1993" /><ref name="manC" />. Ta wersja bywa również nazywana C90 lub ISO C, choć opisuje ten sam język, co dokument ANSI<ref name="manC" />.
[[Plik:C function declaration C78, C89.png|mały|Styl definiowania funkcji wprowadzony w ANSI&nbsp;C (u&nbsp;góry) oraz poprzedni, używany w K&R&nbsp;C (u&nbsp;dołu)]]
Oprócz dodatków autorstwa Ritchiego, zaimplementowanych po publikacji książki ''Język C'', komitet standaryzacyjny ANSI wprowadził do języka np. [[Prototyp (oprogramowanie)#Prototyp funkcji|prototypy funkcji]] czy wskaźniki na nieznany typ (<code>void*</code>). 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{{#tag:ref|Składnia z C78 została wycofana dopiero wraz z publikacją standardu C23 w 2024 roku{{odn|ISO/IEC9899:2024|s=674}}|group=uwaga}}. Standard wzbogacił również [[preprocesor]] o dodatkowe instrukcje, takie jak <code>#elif</code> oraz wsparcie dla łączenia napisów ([[Operator (programowanie)|operator]] <code>##</code>)<ref name="Gass">{{Cytuj |autor = Mark Gass |tytuł = Using the New Features in ANSI C |url = https://support.sas.com/resources/papers/proceedings-archive/SUGI88/Sugi-13-229%20Gass.pdf |data dostępu = 2022-01-15 |język = en}}</ref>. Wzorując się na języku [[C++]] zaadaptowano również składnię i znaczenie kwalifikatorów typu <code>const</code> i <code>volatile</code><ref>{{Cytuj |tytuł = Rationale for the ANSI C Programing Language |wydawca = Sillicon Press |s = 52 |data = 1990 |isbn = 0-929306-07-4}}</ref>.

Podczas prac nad językiem Kernighan i Ritchie nie skupiali się na ustandaryzowaniu [[Biblioteka standardowa|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 [[Biblioteka standardowa języka C|biblioteki standardowej języka C]], wymagający dostarczenia programiście odpowiednich funkcji o ściśle określonym działaniu i przeznaczeniu<ref name="Gass" />.

W 1995 roku została opublikowana poprawka do standardu, wprowadzająca obsługę wielobajtowych [[Zestaw znaków|kodowań znaków]] ({{Ang.|wide characters}}, typ <code>wchar_t</code>), wraz z zestawem funkcji do operacji na składających się z nich napisach<ref>{{Cytuj |autor = David Lindnerr; Finnbarr P. Murphy |tytuł = ISO C Amendment 1 (MSE) |data dostępu = 2022-06-29 |url = https://unix.org/version2/whatsnew/login_mse.html |język = en}}</ref>. Inne zmiany obejmują dodanie pliku nagłówkowego <code>iso646.h</code>, definiującego makra, których można użyć do zastąpienia niektórych operatorów słowami, jak <code>and</code> zamiast <code>&&</code> czy <code>not_eq</code> zamiast <code>!=</code>. Oprócz istniejących już trójznaków (będących innym sposobem zapisania pewnych symboli), wprowadzono 6 dwuznaków o tym samym zastosowaniu: <code><:</code>, <code>:></code>, <code><%</code>, <code>%></code>, <code>%:</code> i <code>%:%:</code><ref name="C1995">{{Cytuj |tytuł = ISO/IEC 9899:1990/Amendment 1:1995 |data = 1995 |s = 1, 2, 7 |język = en}}</ref><ref>{{Cytuj |tytuł = ISO/IEC 9899:1990 |data = 1990 |s = 10–11 |język = en}}</ref>. W poprawce ustanowiono również wymóg, by implementacje ustawiały makro <code>__STDC_VERSION__</code> na wartość 199409, co ma wskazywać na zgodność z nowszą wersją standardu<ref name="C1995" />.

=== C99 ===
Druga wersja standardu języka C została opublikowana przez ISO w 1999 roku. Zaczerpnęła z języka C++ funkcje <code>inline</code> i [[Komentarz (informatyka)|komentarze]] jednoliniowe (rozpoczynające się sekwencją <code>//</code>). Zdefiniowano wtedy również kolejne typy danych: <code>long long int</code> (minimum 64-bitowa [[Liczba całkowita (typ danych)|liczba całkowita]]) oraz [[Logiczny typ danych|typ logiczny]] <code>_Bool</code>, który może przyjmować jedynie wartości 0 oraz 1<ref name="Benson2017">{{Cytuj |autor = Deepu Benson |tytuł = Different C Standards: The Story of C |data = 2017-04-17 |data dostępu = 2022-06-28 |opublikowany = Open Source For You |url = https://www.opensourceforu.com/2017/04/different-c-standards-story-c/ |język = en}}</ref><ref name="Kulkarni2016">{{Cytuj |autor = Shrirang A. Kulkarni |tytuł = C99 features in GCC on Fedora |data = 2016-12-09 |data dostępu = 2022-06-28 |opublikowany = Fedora Magazine |url = https://fedoramagazine.org/c99-features-gcc-fedora/ |język = en}}</ref> (wraz z [[Makro|makrami]] <code>bool</code>, <code>true</code> i <code>false</code>)<ref name="ISO/IEC9899:1999">{{Cytuj |tytuł = ISO/IEC 9899:1999 |data = 1999 |s = 160, 170, 253 |url = https://www.open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf |język = en}}</ref>.<!-- s. 253 --> W tej wersji standardu dodano także kolejny kwalifikator typu <code>restrict</code><ref name="Kulkarni2016" />.

Od standardu [[C99]] zdefiniowany jest sposób obsługi [[Liczby zespolone|liczb zespolonych]] w języku. Służą do tego typy z określeniami <code>_Imaginary</code> oraz <code>_Complex</code><ref name="Benson2017" />, przechowujące – odpowiednio – wartości [[Liczby urojone|urojone]] oraz zespolone. Kwalifikatorów tych można używać jedynie z [[Liczba zmiennoprzecinkowa|typami zmiennoprzecinkowymi]]<ref name="ISO/IEC9899:1999" />.<!-- s. 170 -->

W 1999 roku do języka C wprowadzono także obsługę tablic o długości ustalanej w czasie działania programu<ref name="Kulkarni2016" />. Implementacje wspierające wersję C99 powinny ustawić makro <code>__STDC_VERSION__</code> na 199901<ref name="ISO/IEC9899:1999" />.<!-- s. 160 -->

=== 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ą [[Kompatybilność (informatyka)|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ż [[Biblioteka standardowa|bibliotekę standardową]] o procedury sprawdzające zakres i granice obszaru pamięci podczas operowania na [[Tekstowy typ danych|napisach]]. Z powodu licznych podatności usunięto funkcję <code>gets()</code>, zastępując ją bezpieczniejszą <code>gets_s()</code><ref name="Kalev2012">{{Cytuj |autor = Danny Kalev |tytuł = C11: A New C Standard Aiming at Safer Programming |data = 2012-06-25 |data dostępu = 2022-06-29 |opublikowany = SmartBear.com |url = https://smartbear.com/en/blog/c11-a-new-c-standard-aiming-at-safer-programming/ |język = en}}</ref>.

Publikując tę wersję standardu, komitet ustandaryzował wsparcie dla [[Wielowątkowość|wielowątkowości]], m.in. definiując sposoby zarządzania i synchronizowania [[Wątek (informatyka)|wątków]] oraz wprowadzając typy atomowe (w tym kwalifikator typu <code>_Atomic</code>). Umożliwiono również oznaczenie funkcji bez powrotu słowem kluczowym <code>_Noreturn</code>, co pozwala kompilatorom na pewne [[Optymalizacja kodu wynikowego|optymalizacje generowanego kodu]]<ref name="Kalev2012" />.

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ł łańcuchowy|literałów napisowych]] w standardach [[Unicode]] i [[UTF-8]]<ref name="Kalev2012" />.

W tej wersji <code>__STDC_VERSION__</code> przyjmuje wartość 201112<ref name="Dakeshov2020">{{Cytuj |autor = Elnar Dakeshov |tytuł = C11 and C17 Standard Support Arriving in MSVC |data = 2020-09-14 |data dostępu = 2022-06-29 |opublikowany = C++ Team Blog |url = https://devblogs.microsoft.com/cppblog/c11-and-c17-standard-support-arriving-in-msvc/ |język = en}}</ref>.

=== C17 / C18 ===
Czwarta wersja standardu nie przyniosła żadnych znaczących zmian w języku w stosunku do C11<ref name="Gustedt2018">{{Cytuj |autor = Author Jens Gustedt |tytuł = C17 |data = 2018-04-17 |data dostępu = 2022-06-29 |opublikowany = Jens Gustedt’s Blog |url = https://gustedt.wordpress.com/2018/04/17/c17/ |język = en}}</ref>. Dokument przyjęty przez ISO w czerwcu 2018<ref name="ISO2018">{{Cytuj |tytuł = ISO/IEC 9899:2018 |data = 2018-06 |data dostępu = 2022-06-29 |opublikowany = ISO |url = https://www.iso.org/cms/render/live/en/sites/isoorg/contents/data/standard/07/45/74528.html |język = en}}</ref> przyniósł poprawki i uściślenia tekstu, dlatego zmiany w zachowaniu kompilatorów po jego implementacji wynikają z interpretacji niejednoznacznych zapisów<ref name="Gustedt2018" />. Jedyną zmianą normatywną było nadanie wartości 201710 makro <code>__STDC_VERSION__</code><ref name="Dakeshov2020" />.

Iteracja ta bywa nazywana C17<ref name="Gustedt2018" />, jak i C18<ref name="ANSI2018">{{Cytuj |tytuł = The Current C Programming Language Standard – ISO/IEC 9899:2018 (C18) – ANSI Blog |data = 2018-11-13 |data dostępu = 2022-06-29 |opublikowany = The ANSI Blog |url = https://blog.ansi.org/2018/11/c-language-standard-iso-iec-9899-2018-c18/ |język = en}}</ref>.

=== C23 ===
Piątą wersję standardu języka C opublikowano w październiku 2024 roku<ref name="ISO2024" />. Jest ona potocznie określana jako C23{{odn|ISO/IEC9899:2024|s=i}}. W odróżnieniu od poprzedniego wydania standardu, w tym wprowadzono normatywne zmiany{{odn|ISO/IEC9899:2024|s=674-677}}.

Począwszy od C23, liczby całkowite muszą być reprezentowane w [[Kod uzupełnień do dwóch|kodzie uzupełnień do dwóch]]. Poprzednio, dopuszczalne były również [[Kod uzupełnień do jedności|uzupełnianie do jedności]] oraz [[Kod znak-moduł|znak-moduł]]. Wraz z tą zmianą, skorygowano minimalne wymagane zakresy liczb dla poszczególnych typów całkowitoliczbowych ze znakiem: ich dolny kres obniżył się o jeden (np. C17 oczekiwał, aby w typie <code>signed char</code> mieściły się liczby do -127{{odn|ISO/IEC9899:2017|s=20}}, od C23 musi to być -128{{odn|ISO/IEC9899:2024|s=23}}){{odn|ISO/IEC9899:2024|s=674}}.

Wprowadzony w C99 typ logiczny, który do tej pory nazywał się <code>_Bool</code>, zmienił nazwę na <code>bool</code>. Podobnie, <code>true</code> i <code>false</code>, będące wcześniej makrami, promowano na słowa kluczowe. Podobnie uczyniono z kilkoma innymi słowami kluczowymi, mającymi wcześniej formę, rozpoczynającą się od znaku podkreślenia i wielkiej litery{{odn|ISO/IEC9899:2024|s=674}}.

W C23 zrezygnowano również z przestarzałej składni definiowania funkcji, w której typu parametrów były określane pomiędzy nawiasem okrągłym a klamrowym, rozpoczynającym ciało funkcji. W tej wersji porzucono także dawne znaczenie pustej listy parametrów w deklaracji funkcji: teraz zawsze oznacza to, iż nie przyjmuje ona żadnego argumentu{{odn|ISO/IEC9899:2024|s=674}}. Wcześniej, pusta lista parametrów była traktowana jako oznaczenie nieznanej listy parametrów (niekoniecznie pustej){{Odn|ISO/IEC9899:2017|s=96}}.

== Składnia ==
[[Gramatyka formalna|Formalna gramatyka]] języka C jest opisana w standardzie ISO C{{odn|ISO/IEC9899:2017|s=i}}. Podział kodu na linie oraz [[Znaki niedrukowalne|białe znaki]] są ignorowane. Ich stosowanie jest obowiązkowe jedynie, kiedy służą rozdzieleniu poszczególnych [[Jednostka leksykalna|jednostek leksykalnych]]<ref>{{Cytuj |rozdział = 1.6. White Space |tytuł = The GNU C Reference Manual |data dostępu = 2022-03-13 |opublikowany = GNU |url = https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html}}</ref>.

Program w języku C zapisywany jest w plikach źródłowych, które nie muszą być [[Kompilator|kompilowane]] w tym samym czasie. Plik źródłowy razem z plikami dołączonymi dyrektywą <code>#include</code> tworzy jednostkę tłumaczenia, która po przetłumaczeniu na [[Język maszynowy|kod maszynowy]] może być [[Konsolidacja (informatyka)|konsolidowana]] z innymi w celu stworzenia wykonywalnego [[Program komputerowy|programu]]{{odn|ISO/IEC9899:2017|s=9}}.

=== Identyfikatory ===
[[Identyfikator (programowanie)|Identyfikator]] stanowi nazwę obiektu, funkcji, etykiety itp. Może on oznaczać różne byty w różnych momentach wykonywania programu{{odn|ISO/IEC9899:2017|s=28}}. 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{{odn|ISO/IEC9899:2017|s=43}}, 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{{odn|ISO/IEC9899:2017|s=20}}.

Identyfikatory mogą składać się jedynie z [[Litera|liter]], [[Cyfry arabskie|cyfr]] i [[znak podkreślenia|znaku podkreślenia]], choć cyfra nie może występować na pierwszym miejscu{{odn|ISO/IEC9899:2017|s=43}}. Aby zastosować w nazwie znaki spoza tego zbioru, konieczne jest użycie {{link-interwiki|Sekwencja ucieczki|tekst=sekwencji ucieczki|Q=Q1366300}} <code>\uxxxx</code> lub <code>\Uxxxxxxxx</code> (gdzie <code>x</code> to [[Szesnastkowy system liczbowy|cyfra szesnastkowa]]){{odn|ISO/IEC9899:2017|s=44}}. 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ą{{odn|ISO/IEC9899:2017|s=132|loc=§7.1.3 Reserved identifiers}}.

W zależności od tego, do czego odwołuje się identyfikator, należy on do jednej z [[Przestrzeń nazw|przestrzeni nazw]]{{odn|ISO/IEC9899:2017|s=29}}:
* [[Etykieta (informatyka)|etykiety]];
* nazwy [[Struktura (programowanie)|struktur]], [[Unia (programowanie)|unii]] i [[Wyliczeniowy typ danych|typów wyliczeniowych]];
* [[Pole (informatyka)|pola]] struktur i unii (niezależne przestrzenie dla każdej struktury i unii);
* pozostałe.

Ponadto każdy identyfikator ma swój [[Zasięg (programowanie)|zakres widoczności]], zależny od miejsca deklaracji{{odn|ISO/IEC9899:2017|s=28}}.

Z identyfikatorem może być skojarzony jeden z trzech sposobów [[Konsolidacja (informatyka)|łą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{{odn|ISO/IEC9899:2017|s=29}}:

* 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 (programowanie)|operatorów]] i [[operand]]ów stanowi w języku C [[Wyrażenie (informatyka)|wyrażenie]]. Oznacza ono obliczenie wartości lub odwołanie do obiektu. W trakcie jego wywoływania mogą także występować [[Skutek uboczny (informatyka)|skutki uboczne]]{{odn|ISO/IEC9899:2017|s=55}} (na przykład inkrementacja zmiennej{{odn|ISO/IEC9899:2017|s=61}}). Kolejność obliczania wartości i zachodzenia skutków ubocznych jest nieokreślona, lecz zgodna z [[Kolejność wykonywania działań|pierwszeństwem]] operatorów. Standard języka C gwarantuje, że zdarzą się one przed następnym {{link-interwiki|Punkt sekwencyjny|tekst=punktem sekwencyjnym|Q=Q2041271}}{{odn|ISO/IEC9899:2017|s=12}}.

Jeżeli tego samego obiektu dotyczy więcej niż jeden skutek uboczny i nie są one rozdzielone punktem sekwencyjnym, wtedy zachowanie jest {{link-interwiki|Nieokreślone zachowanie (informatyka)|tekst=nieokreślone|Q=Q4318017}}{{odn|ISO/IEC9899:2017|s=12}}{{odn|ISO/IEC9899:2017|s=55}}. Takie punkty wprowadzane są{{odn|ISO/IEC9899:2017|s=366}}:
* w trakcie wywoływania funkcji: przed rozpoczęciem obliczania argumentów funkcji oraz przed skokiem do funkcji;
* między obliczeniem wartości operandów <code>&&</code>, <code>||</code>, <code>,</code>;
* między obliczeniem wartości pierwszego operandu <code>?:</code> a drugiego lub trzeciego;
* między wywołaniem kolejnych pełnych wyrażeń;
* w momencie powrotu z funkcji [[Biblioteka programistyczna|bibliotecznych]] oraz w niektórych przypadkach w trakcie ich działania.

==== Operatory ====
W języku C są zdefiniowane następujące operatory{{odn|ISO/IEC9899:2017|s=57–75}}:
{{Układ wielokolumnowy|szerokość=20em|1=<nowiki/>
* arytmetyczne: <code>+</code>, <code>-</code>, <code>*</code>, <code>/</code>, <code>%</code>
* bitowe: <code>~</code>, <code>&</code>, <code>^</code>, <code>{{!}}</code>
* dostępu: <code>.</code>, <code>-></code>
* grupowania wyrażeń: <code>()</code>
* inkrementacji i dekrementacji: <code>++</code>, <code>--</code>
* logiczne: <code>!</code>, <code>&&</code>, <code>{{!}}{{!}}</code>
* porównania: <code><</code>, <code>></code>, <code><=</code>, <code>>=</code>, <code>==</code>, <code>!=</code>
* przesunięcia bitowego: <code><<</code>, <code>>></code>
* przypisania: <code>=</code>
* przypisania złożonego: <code>*=</code>, <code>/=</code>, <code>%=</code>, <code>+=</code>, <code>-=</code>, <code><<=</code>, <code>>>=</code>, <code>&=</code>, <code>^=</code>, <code>{{!}}=</code>
* rozmiaru obiektu: <code>sizeof</code>
* rzutowania: <code>(typ)</code>
* sekwencyjny: <code>,</code>
* warunkowy: <code>?:</code>
* wskaźnikowe: <code>*</code>, <code>&</code>, <code>[]</code>
* wyrównania dla typu: <code>_Alignof</code>
* wywołania funkcji: <code>()</code>
}}

=== Obiekty ===
Obiekt (zwany też zmienną{{odn|Kernighan|Ritchie|2002|s=256}}), według standardu języka C, to region [[Pamięć operacyjna|pamięci]] środowiska wykonawczego, mogący reprezentować [[Dane|wartości]]{{odn|ISO/IEC9899:2017|s=5}}. Wyrażenie, które może odwoływać się do obiektu jest [[L-wartość|l-wartością]]. Jej typ określa, w jaki sposób interpretować zawartość obiektu{{odn|ISO/IEC9899:2017|s=40}}.

Przykładem l-wartości jest identyfikator obiektu. Może nią być również rezultat [[Dereferencja|dereferencji]] wskaźnika{{odn|ISO/IEC9899:2017|s=40}}.

[[Deklaracja (informatyka)|Deklaracja]] obiektu polega na podaniu [[Typ danych|typu danych]] oraz opcjonalnie klasy pamięci i sposobu [[Linkowanie|linkowania]], po których występuje przynajmniej jeden identyfikator tworzonego obiektu (lub obiektów){{odn|ISO/IEC9899:2017|s=78–80}}.

=== Funkcje ===
W języku C rozróżniane są<ref>{{Cytuj |rozdział = 5. Functions |tytuł = The GNU C Reference Manual |data dostępu = 2022-03-13 |opublikowany = GNU |url = https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html |język = en}}</ref>:
* deklaracja funkcji – polega na podaniu zwracanego typu, nazwy funkcji oraz listy [[Parametr (informatyka)|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 (<code>{...}</code>).

[[Definicja (programowanie)|Definicje]] funkcji w języku C nie mogą być zagnieżdżane<ref name="PohlEdelson1988" />.

Funkcje w języku C nie mogą być [[Przeciążanie funkcji|przeciążane]]<ref>{{Cytuj |autor = Kalsoom Bibi |tytuł = Function Overloading in C |data dostępu = 2022-03-13 |url = https://linuxhint.com/function-overloading-c/ |język = en}}</ref>, ale istnieje mechanizm definiowania funkcji o [[Zmienna liczba argumentów|zmiennej liczbie argumentów]]<ref>{{Cytuj |rozdział = 5.5 Variable Length Parameter Lists |tytuł = The GNU C Reference Manual |data dostępu = 2022-03-13 |opublikowany = GNU |url = https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html |język = en}}</ref>.

=== Instrukcje sterujące ===
[[Plik:C if switch.png|mały|Wykorzystanie instrukcji <code>if</code> i <code>switch</code> do realizacji równoważnych fragmentów kodu.]]
W języku C można wyróżnić trzy klasy [[Instrukcja sterująca|instrukcji sterujących]]. Pierwszą z nich są polecenia umożliwiające [[Instrukcja warunkowa|warunkowe]] wykonanie fragmentów kodu. Do tej grupy należą{{odn|ISO/IEC9899:2017|s=108}}:
* <code>if ... else</code> – pozwala na wykonanie jednej z dwóch gałęzi kodu na podstawie wartości [[Logiczny typ danych|typu logicznego]],
* <code>switch</code> – wykonuje jeden z wielu bloków kodu na podstawie porównania [[Liczba całkowita (typ danych)|wartości liczbowej]] z wyrażeniami w poszczególnych etykietach <code>case</code>.
[[Plik:For-loop-diagram.svg|mały|Schemat blokowy pętli <code>for</code>.]]
Druga grupa instrukcji sterujących służy realizacji [[Pętla (informatyka)|pętli]]. Każda z nich jest wykonywana tak długo, jak podany warunek jest prawdziwy. Składają się na nią{{odn|ISO/IEC9899:2017|s=109–110}}:
* <code>while</code> – warunek jest sprawdzany przed każdą [[Iteracja|iteracją]];
* <code>do ... while</code> – warunek jest sprawdzany po każdej iteracji;
* <code>for</code> – 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ą [[Instrukcja skoku|instrukcje skoku]]. Należą do nich{{odn|ISO/IEC9899:2017|s=110–112}}:
* <code>goto</code> – realizuje skok do etykiety o podanej nazwie, ale nie jest możliwe wyjście z aktualnie wykonywanej funkcji;
* <code>continue</code> – przerywa wykonywanie bieżącej iteracji pętli i przechodzi do kolejnej;
* <code>break</code> – przerywa wykonywanie pętli lub instrukcji <code>switch</code>;
* <code>return</code> – przerywa wykonywanie bieżącej funkcji i opcjonalnie przekazuje wartość do miejsca wywołania.

=== Dyrektywy preprocesora ===
Dyrektywy [[preprocesor]]a rozpoczynają się od znaku <code>#</code> i muszą znajdować się w osobnych liniach (dopuszczalne jest by przed symbolem kratki znajdowały się spacje){{odn|ISO/IEC9899:2017|s=118}}.

[[CPP (preprocesor)|Preprocesor w języku C]] pozwala na manipulację [[Kod źródłowy|kodem źródłowym]] przed właściwą [[Kompilator|kompilacją]]. Wspiera mechanizmy [[Kompilacja warunkowa|kompilacji warunkowej]] (dyrektywa <code>#if</code> i jej warianty) oraz dołączania innych plików źródłowych (<code>#include</code>). Odpowiada również za rozwijanie [[Makro|makr]] (zdefiniowanych przy użyciu <code>#define</code>){{odn|ISO/IEC9899:2017|s=118–121}}{{odn|Kernighan|Ritchie|2002|s=305}}.

Dzięki dyrektywie <code>#pragma</code> możliwe jest przekazywanie instrukcji specyficznych dla kompilatora{{odn|ISO/IEC9899:2017|s=127}}<ref group="uwaga>na przykład <code>[[pragma once|#pragma once]]</code></ref>.

=== Komentarze ===
W języku C występują [[Komentarz (informatyka)|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 <code>/*</code> (blokowy, kończy się <code>*/</code>) oraz <code>//</code> (liniowy, trwa do końca linii). Sekwencje te tracą swoje znaczenie, jeśli znajdują się w [[Literał łańcuchowy|literale tekstowym]] lub wewnątrz innego komentarza{{odn|ISO/IEC9899:2017|s=54}}.

W trakcie kompilacji, komentarze zastępowane są znakiem spacji{{odn|ISO/IEC9899:2017|s=9}}.

== Typy danych ==
[[Typ danych]] określa zbiór wartości, które może przyjąć dany obiekt, jak również dozwolone operacje na nim{{odn|Kernighan|Ritchie|2002|s=60}}. Język udostępnia zestaw typów podstawowych oraz mechanizmów konstruowania typów pochodnych{{odn|Kernighan|Ritchie|2002|s=257–258}}.

Szczególnym typem danych w C jest [[Pusty typ danych|typ pusty]] <code>void</code>, 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 <code>,</code> lub w charakterze [[Instrukcja (informatyka)|instrukcji]]. [[Konwersja typu|Rzutowanie]] tego typu na jakikolwiek inny typ, zarówno jawne, jak i niejawne jest niedozwolone{{odn|Kernighan|Ritchie|2002|s=262}}. Słowem <code>void</code> oznacza się między innymi funkcje nie zwracające nic{{odn|Kernighan|Ritchie|2002|s=258}}.

=== 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 [[Liczba całkowita (typ danych)|liczb całkowitych]] (<code>char</code> i <code>int</code>) oraz [[Liczba zmiennoprzecinkowa|zmiennoprzecinkowych]] (<code>float</code> i <code>double</code>){{odn|Kernighan|Ritchie|2002|s=61}}.

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

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 [[bit]]ach lub [[bajt]]ach{{odn|Kernighan|Ritchie|2002|s=61}}. Od [[Implementacja (informatyka)|implementacji]] języka wymaga się, by poszczególne typy danych pozwalały na przechowywanie przynajmniej liczb z ustalonego [[Przedział (matematyka)|przedziału]]{{odn|ISO/IEC9899:2017|s=20}}, a w przypadku typu logicznego <code>_Bool</code> – by miał rozmiar wystarczający do zmieszczenia wartości 0 i 1{{odn|ISO/IEC9899:2017|s=31}}.
{| class="wikitable"
|+ Minimalne zakresy wartości dla typów całkowitoliczbowych{{odn|ISO/IEC9899:2024|s=23}}
!Typ
!Minimalny zakres
!Minimalny rozmiar w bitach
|-
|<code>signed char</code>
|<math>\langle -2^7, \; 2^7 - 1 \rangle</math>
|8
|-
|<code>unsigned char</code>
|<math>\langle 0, \; 2^8 - 1 \rangle</math>
|8
|-
|<code>short int</code>{{#tag:ref|Możliwe jest również stosowanie skróconej nazwy, bez członu <code>int</code>{{odn|ISO/IEC9899:2017|s=80}}.|group=uwaga|name=int}}
|<math>\langle -2^{15}, \; 2^{15} - 1 \rangle</math>
|16
|-
|<code>unsigned short int</code>{{#tag:ref||group=uwaga|name=int}}
|<math>\langle 0, \; 2^{16} - 1 \rangle</math>
|16
|-
|<code>int</code>
|<math>\langle -2^{15}, \; 2^{15} - 1 \rangle</math>
|16
|-
|<code>unsigned int</code>{{#tag:ref||group=uwaga|name=int}}
|<math>\langle 0, \; 2^{16} - 1 \rangle</math>
|16
|-
|<code>long int</code>{{#tag:ref||group=uwaga|name=int}}
|<math>\langle -2^{31}, \; 2^{31} - 1 \rangle</math>
|32
|-
|<code>unsigned long int</code>{{#tag:ref||group=uwaga|name=int}}
|<math>\langle 0, \; 2^{32} - 1 \rangle</math>
|32
|-
|<code>long long int</code>{{#tag:ref||group=uwaga|name=int}}
|<math>\langle -2^{63}, \; 2^{63} - 1 \rangle</math>
|64
|-
|<code>unsigned long long int</code>{{#tag:ref||group=uwaga|name=int}}
|<math>\langle 0, \; 2^{64} - 1 \rangle</math>
|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 <code>short</code> nie może być dłuższy niż <code>int</code>, który z kolei musi być niedłuższy od <code>long</code>{{odn|Kernighan|Ritchie|2002|s=61}}.

Użycie kwalifikatora <code>long</code> jest dopuszczalne również w połączeniu z typem <code>double</code>, 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{{odn|Kernighan|Ritchie|2002|s=62}}.

W czasie, gdy ukazało się pierwsze wydanie książki ''Język C'' Kernighana i Ritchiego, dopuszczalna była również konstrukcja <code>long float</code>, równoważna typowi <code>double</code>, jednak została ona zniesiona przez standard ANSI C{{odn|Kernighan|Ritchie|2002|s=258}}.
{| class="wikitable"
|+ Minimalne wymagania standardu języka C wobec typów zmiennoprzecinkowych{{odn|ISO/IEC9899:2017|s=24–25}}
!Cecha
!<code>float</code>
!<code>double</code>
!<code>long double</code>
|-
|Liczba dziesiętnych [[Cyfry znaczące|cyfr znaczących]]
|6
|10
|10
|-
|Największa liczba dodatnia
|<math>10^{37}</math>
|<math>10^{37}</math>
|<math>10^{37}</math>
|-
|Najmniejsza dodatnia [[Liczba zmiennoprzecinkowa#Podstawa matematyczna|liczba znormalizowana]]
|<math>10^{-37}</math>
|<math>10^{-37}</math>
|<math>10^{-37}</math>
|-
|[[Epsilon maszynowy]]
|<math>10^{-5}</math>
|<math>10^{-9}</math>
|<math>10^{-9}</math>
|}
Do typów podstawowych należy również [[Wyliczeniowy typ danych|wyliczenie]]. Składa się ono z listy [[Stała (informatyka)|stałych symbolicznych]], każda o wartości będącej liczbą całkowitą. Typy wyliczeniowe funkcjonalnie są równoważne [[Liczba całkowita (typ danych)|całkowitoliczbowym]]{{odn|Kernighan|Ritchie|2002|s=65}}{{odn|Kernighan|Ritchie|2002|s=258}}.

=== Typy pochodne ===
Z niezerowej liczby obiektów tego samego typu można stworzyć [[Tablica (informatyka)|tablicę]]{{odn|ISO/IEC9899:2017|s=32}}. Jej elementy są ułożone w pamięci komputera po kolei i bez żadnych przerw{{odn|Kernighan|Ritchie|2002|s=136}}, a dostęp do nich można uzyskać za pomocą składni <code>''tablica''[''indeks'']</code>, gdzie indeksy rozpoczynają się od zera{{odn|Kernighan|Ritchie|2002|s=45}}{{#tag:ref|Operator indeksowania tablic <code>tab[i]</code> jest z definicji równoważny wyrażeniu <code>*(tab+i)</code>, a zatem indeksowanie jest przemienne. Konsekwencją tego faktu jest że zapisy <code>tab[i]</code> oraz <code>i[tab]</code> są równoważne i odnoszą się do i-tego elementu tablicy <code>tab</code>{{odn|Kernighan|Ritchie|2002|s=288}}.|group=uwaga}}. Do raz utworzonej zmiennej typu tablicowego nie jest możliwe [[przypisanie]] innej tablicy{{odn|Kernighan|Ritchie|2002|s=138}}. 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{{Odn|ISO/IEC9899:2017|s=40}}.

Do przechowywania adresu obiektu określonego typu służą [[Wskaźnik (typ danych)|wskaźniki]]{{odn|Kernighan|Ritchie|2002|s=130–131}}. 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 <code>NULL</code>){{odn|Kernighan|Ritchie|2002|s=141–143}}. 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{{Odn|ISO/IEC9899:2017|s=67, 69}}. 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{{odn|Kernighan|Ritchie|2002|s=141–143}}. 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<ref group="uwaga">Oznacza to, że dodanie liczby <code>n</code> do wskaźnika <code>ptr</code> na typ <code>T</code> zwróci nowy wskaźnik o adresie <code>ptr + n * sizeof(T)</code>. Podobnie, odjęcie od siebie dwóch wskaźników, zwróci różnicę indeksów tabeli, odpowiadających wskazywanym elementom.</ref>{{Odn|ISO/IEC9899:2017|s=67}}.

Jedna lub kilka zmiennych może tworzyć [[Struktura (programowanie)|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{{odn|Kernighan|Ritchie|2002|s=173–175}}. Każda struktura stanowi odrębną [[przestrzeń nazw]], toteż pole o tej samej nazwie może występować w kilku strukturach{{odn|Kernighan|Ritchie|2002|s=174}}{{odn|ISO/IEC9899:2017|s=29}}. Zagnieżdżanie struktur jest dozwolone – składowe mogą również być strukturami. Standard ISO C zabrania natomiast [[Rekurencja|rekursywnego]] zagnieżdżania struktury samej w sobie. Mimo to struktura może zawierać wskaźnik na inną strukturę tego samego typu{{odn|ISO/IEC9899:2017|s=81}}. Zarówno przypisywanie do zmiennej typu strukturalnego nowej wartości, jak i przekazywanie jej jako argument oraz zwracanie z funkcji są dopuszczalnymi operacjami{{odn|Kernighan|Ritchie|2002|s=175–176}}.

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 [[Deklaracja (informatyka)|deklaracji]]. Dopuszcza się jednak istnienie niewykorzystanych i nienazwanych przestrzeni w środku oraz na końcu struktury{{odn|ISO/IEC9899:2017|s=82}}.

Struktury mogą zawierać również [[Pole bitowe|pola bitowe]], które pozwalają na określenie rozmiaru obiektu z dokładnością do bitów{{odn|Kernighan|Ritchie|2002|s=200}}. 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{{odn|ISO/IEC9899:2017|s=82}}. Pobieranie adresu pola bitowego jest niedozwolone{{odn|ISO/IEC9899:2017|s=64}}.

Przykładowa deklaracja struktury opisującej węzeł pewnego [[Drzewo binarne|drzewa]]{{odn|Kernighan|Ritchie|2002|s=188}}:<syntaxhighlight lang="c">
struct tnode {
    char *word;
    int count;
    struct tnode *left;
    struct tnode *right;
}
</syntaxhighlight>Typem podobnym do struktur są [[Unia (programowanie)|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{{odn|Kernighan|Ritchie|2002|s=198–200}}.

Standard języka C definiuje również typy atomowe, choć stanowią one opcjonalną funkcjonalność, która nie musi być obsługiwana przez implementacje{{odn|ISO/IEC9899:2017|s=33}}. Biblioteka standardowa dostarcza funkcje pozwalające m.in. na zmianę wartości zmiennych takich typów w sposób [[Operacja atomowa|atomowy]], tj. z gwarancją, że operacja nie zostanie przerwana przez inne działanie na tej samej zmiennej{{odn|ISO/IEC9899:2017|s=206–209}}.

W języku C dostępne są także typy danych opisujące [[Podprogram|funkcje]]. Zawierają one informacje o typie [[Parametr (informatyka)|parametrów]] oraz wartości zwracanej{{odn|ISO/IEC9899:2017|s=32}}. Zmienna typu funkcyjnego, jeśli nie jest argumentem operatora pozyskania adresu <code>&</code>, niejawnie przekształca się we wskaźnik do funkcji{{odn|ISO/IEC9899:2017|s=40}}. Wywołania, dokonywane za pośrednictwem wskaźników nie są przez standard rozróżniane od tych zawierających wprost nazwę funkcji{{odn|ISO/IEC9899:2017|s=58}}.

=== 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{{odn|Kernighan|Ritchie|2002|s=197}}.

Mechanizm ten wykorzystuje się między innymi w celu zapewnienia [[Przenośność oprogramowania|przenośności oprogramowania]] podczas wykorzystania typów zależnych od docelowej [[Architektura komputera|architektury]]. Przykładem takiego zastosowania są <code>size_t</code> i <code>ptrdiff_t</code>, pochodzące z [[Biblioteka standardowa języka C|biblioteki standardowej języka C]]{{odn|Kernighan|Ritchie|2002|s=197–198}}. Przechowują one liczby całkowite, lecz ich dokładny typ zależy od implementacji{{odn|Kernighan|Ritchie|2002|s=270–271}}.

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{{odn|Kernighan|Ritchie|2002|s=198}}. Poniższe trzy deklaracje funkcji są sobie równoważne{{odn|ISO/IEC9899:2017|s=100}}:
<syntaxhighlight lang="c">
// 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);
</syntaxhighlight>

=== Kwalifikatory typów ===
Kwalifikatory typów nadają specyficzne znaczenia wyrażeniom, które są [[l-wartość|l-wartością]]{{odn|ISO/IEC9899:2017|s=87}}. Można je ze sobą dowolnie łączyć{{odn|ISO/IEC9899:2017|s=87}}.
; <code>const</code>: Oznacza wartość, która nie może być zmieniana<ref>{{Cytuj |url = https://www.ibm.com/docs/en/i/7.1?topic=qualifiers-const-type-qualifier |tytuł = The const type qualifier |praca = IBM docs |opublikowany = ibm.com |data dostępu = 2022-07-10}}</ref>. Próba modyfikacji tak zdefiniowanego obiektu przez l-wartość usuwającą to ograniczenie jest zachowaniem niezdefiniowanym{{odn|ISO/IEC9899:2017|s=87, 408, 473}}. Obiekty zdefiniowane statycznie jako <code>const</code> mogą zostać umieszczone w [[Pamięć tylko do odczytu|pamięci z dostępem tylko do odczytu]]<ref name="rationale53">{{Cytuj |tytuł = Rationale for the ANSI C Programing Language |wydawca = Sillicon Press |s = 53 |data = 1990 |isbn = 0-929306-07-4}}</ref>.
; <code>volatile</code>: Oznacza, że wartość wyrażenia jest nieprzewidywalna lub może mieć nieznane efekty uboczne{{odn|ISO/IEC9899:2017|s=88}}. Jest to wskazówka dla kompilatora, aby nie dokonywał w obrębie tego wyrażenia żadnych optymalizacji<ref>{{Cytuj |url = https://www.ibm.com/docs/en/i/7.1?topic=qualifiers-volatile-type-qualifier |tytuł = The volatile type qualifier |praca = IBM docs |opublikowany = ibm.com |data dostępu = 2022-07-10}}</ref>. W środowisku [[Wieloprocesorowy system komputerowy|wieloprocesorowym]] może to oznaczać, że zmienna jest dostępna z wielu [[Wątek (informatyka)|wątków]] równocześnie<ref name="rationale53" />. Statyczne obiekty <code>volatile</code> są odpowiednim wyborem przy modelowaniu [[Układ wejścia-wyjścia|układów wejścia/wyjścia]] mapowanego w [[Przestrzeń adresowa|przestrzeni adresowej]] procesora<ref name="rationale53" />. Próba modyfikacji tak zdefiniowanego obiektu przez l-wartość usuwającą to ograniczenie jest zachowaniem niezdefiniowanym{{odn|ISO/IEC9899:2017|s=87–88}}.
; <code>restrict</code>: 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{{odn|ISO/IEC9899:2017|s=88}}.
; <code>_Atomic</code>: Oznacza wartość, do której możliwy ma być dostęp za pomocą [[Operacja atomowa|niepodzielnej instrukcji]]. Szczegółowy zestaw dostępnych operacji i typów danych jest zdefiniowany w dedykowanym pliku nagłówkowym <code><stdatomic.h></code>{{odn|ISO/IEC9899:2017|s=200–209}}.
; ''identyfikator przestrzeni adresowej'': [[System wbudowany|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<ref>{{Cytuj |rozdział = Named address spaces and named-register storage classes |tytuł = Programming languages – C – Extensions to support embedded processors |url = https://standards.iso.org/ittf/PubliclyAvailableStandards/c051126_ISO_IEC_TR_18037_2008.zip |wydanie = 2 |data = 2008-06-15 |id = ISO/IEC TR 18037:2008(E) |s = 37, 38}}</ref>. Przykładowo dla procesora [[Intel 8051]] dostępne są kwalifikatory pamięci <code>code</code>, <code>data</code>, <code>idata</code>, <code>bdata</code>, <code>xdata</code>, <code>far</code> i <code>pdata</code><ref>{{Cytuj |url = https://www.keil.com/support/man/docs/c51/c51_le_memtypes.htm |tytuł = Memory Types |praca = Cx51 User’s Guide |opublikowany = keil.com |data dostępu = 2022-07-10 |język = en}}</ref>. Natomiast kompilator C dla [[z/OS]] wspiera <code>__callback</code>, <code>__far</code>, <code>__fdptr</code>, <code>__ptr32</code> i <code>__ptr64</code><ref>{{Cytuj |url = https://www.ibm.com/docs/en/zos/2.5.0?topic=declarations-type-qualifiers |tytuł = Type qualifiers |praca = IBM Documentation |opublikowany = ibm.com |data dostępu = 2022-07-10 |język = en}}</ref>. Rozszerzenia dotyczące wsparcia różnych przestrzeni adresowych implementuje również kompilator GNU C na przykład <code>__flash</code>, <code>__memx</code>, <code>__far</code>, <code>__ea</code>, <code>__seg_fs</code> lub <code>__seg_gs</code>. Ich dostępność zależy od docelowego procesora, na który jest kompilowany kod<ref>{{Cytuj |url = https://gcc.gnu.org/onlinedocs/gcc-7.1.0/gcc/Named-Address-Spaces.html |tytuł = Named Address Spaces |praca = Using the GNU Compiler Collection |opublikowany = gcc.gnu.org |data dostępu = 2022-07-10}}</ref>.

== Zarządzanie pamięcią ==
Standard języka C gwarantuje, że na czas życia obiektu zostanie mu przydzielona [[Pamięć operacyjna|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{{odn|ISO/IEC9899:2017|s=30}}. Dostęp do pamięci nie jest kontrolowany przez język<ref name=":0" />, ale próby odczytu lub zapisu pod nieprawidłowymi adresami mogą skończyć się [[Naruszenie ochrony pamięci|naruszeniami ochrony pamięci]]<ref>{{Cytuj |tytuł = Identify what's causing segmentation faults (segfaults) |data dostępu = 2022-08-21 |opublikowany = University Information Technology Services – Indiana University |url = https://kb.iu.edu/d/aqsj |język = en}}</ref>.

Każdy obiekt (poza [[Pole bitowe|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{{odn|ISO/IEC9899:2017|s=33}}.

Po upłynięciu czasu życia zmiennej, wszelkie odwołania do niej prowadzą do niezdefiniowanego zachowania. Podobnie wartość wskazywana przez [[Wskaźnik (typ danych)|wskaźnik]] staje się nieokreślona, kiedy wskazywany obiekt kończy życie{{odn|ISO/IEC9899:2017|s=30}}.

=== 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 (programowanie)|zasięg widoczności]]. [[Zmienna lokalna|Zmienne lokalne]], o ile nie użyto żadnego specyfikatora klasy pamięci, są deklarowane jako zmienne automatyczne{{odn|Kernighan|Ritchie|2002|s=256}}. Wartości niezainicjalizowanych zmiennych są niezdefiniowane i mogą mieć wartość zależną od kompilatora lub od tego, co akurat było w pamięci<ref>{{Cytuj |rozdział = 2 Data Types |tytuł = The GNU C Reference Manual |data dostępu = 2022-08-20 |opublikowany = GNU |url = https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html |język = en}}</ref>. Są one dostępne przez cały czas wykonywania [[Instrukcja blokowa|bloku]], gdzie zostały zadeklarowane<ref group="uwaga">W przypadku, gdy obiekt jest tablicą o zmiennej długości, jego czas życia rozpoczyna się w momencie napotkania deklaracji, a nie wejścia do bloku.</ref>. W przypadku [[Rekurencja|rekurencyjnego]] wkroczenia do tego samego bloku, za każdym razem tworzona jest osobna [[Instancja (programowanie)|instancja]] obiektu. Tę klasę pamięci można również określić jawnie słowem kluczowym <code>auto</code>{{odn|ISO/IEC9899:2017|s=30}}.

Podobne do zmiennych automatycznych są zmienne rejestrowe. Zadeklarowanie obiektu ze słowem <code>register</code> sugeruje kompilatorowi, by umieścił go w pamięci o szybkim dostępie (np. [[Rejestr procesora|rejestrze procesora]]{{odn|Kernighan|Ritchie|2002|s=119}}). 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 [[Adres pamięci|adresu]] zmiennej rejestrowej{{odn|ISO/IEC9899:2017|s=79}}.

Innym rodzajem zmiennych są [[Zmienna statyczna|zmienne statyczne]] (deklarowane słowem <code>static</code>). Pamięć dla nich inicjalizowana jest w momencie uruchomienia programu i od tego momentu wszystkie odwołania dotyczą tego samego regionu pamięci{{odn|ISO/IEC9899:2017|s=30}}. 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{{odn|Kernighan|Ritchie|2002|s=119}}.

Obiektowi można również nadać klasę <code>extern</code>, która jawnie informuje, że cechuje się on linkowaniem zewnętrznym. Jest to domyślna własność zmiennych deklarowanych na zewnątrz funkcji{{odn|Kernighan|Ritchie|2002|s=304}}. Zmienne statyczne i zewnętrzne są inicjalizowane zerem, jeśli nie podano żadnej wartości początkowej{{odn|ISO/IEC9899:2017|s=115}}.

Istnieje również klasa pamięci <code>_Thread_local</code>, której czas życia jest powiązany z [[Wątek (informatyka)|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{{odn|ISO/IEC9899:2017|s=30}}.

Formalnie, specyfikatorem klasy pamięci jest także <code>typedef</code>. Zalicza się go do tej grupy dla wygody, choć nie służy do deklarowania pamięci{{odn|Kernighan|Ritchie|2002|s=278}}.

=== Alokacja pamięci ===
Biblioteka języka C udostępnia funkcje służące do [[Alokacja pamięci|alokacji pamięci]] o arbitralnie wybranym rozmiarze (<code>malloc</code> i odmiany). Zwracają one wskaźnik do pierwszego bajtu obszaru pamięci, który można następnie [[Konwersja typu|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 <code>free</code>{{odn|ISO/IEC9899:2017|s=253–254}}.

Zastosowanie ręcznej alokacji pamięci może prowadzić do wystąpienia błędów w kodzie, wynikających np. z odwołań do {{link-interwiki|Wiszący wskaźnik|tekst=wiszących wskaźników|Q=Q1642293}}, ale także [[Przepełnienie bufora|przepełnienia bufora]] i próby powtórnej dealokacji. Obecne w programie podatności mogą zależeć od wykorzystanego algorytmu rezerwacji pamięci<ref>{{Cytuj |autor = Yves Younan; Wouter Joosen; Frank Piessens; Hans Van den Eynden |tytuł = Improving memory management security for C and C++ |czasopismo = International Journal of Secure Software Engineerin |data = 2010-04 |data dostępu = 2022-07-24 |wolumin = 1 |numer = 2 |doi = 10.4018/jsse.2010040104 |url = https://www.researchgate.net/publication/220510504_Improving_Memory_Management_Security_for_C_and_C |język = en}}</ref>.

== Przykład „Hello world” ==
[[Plik:Hello World Brian Kernighan 1974.jpg|alt=Kartka papieru do drukarki z odręcznie napisanym kodem w języku C. Poniżej podpis autora.|mały|Program „[[Hello world]]” napisany odręcznie przez [[Brian Kernighan|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''<ref>{{Cytuj |autor = [[Dennis Ritchie|Dennis M. Ritchie]]; [[Brian Kernighan]] |tytuł = The C Programming Language |data = 1978 |isbn = 0131101633 |wydanie = 1 |miejsce = Englewood Cliffs |wydawca = Prentice-Hall |s = 6 |język = en}}</ref>. Składnia kodu z pierwszego wydania tej książki odbiega od późniejszych standardów<ref name="Ctutorial">{{Cytuj |tytuł = C Language Tutorial => Original „Hello, World!” in K&R C |data dostępu = 2022-04-12 |opublikowany = riptutorial.com |url = https://riptutorial.com/c/example/3675/original--hello--world---in-k-r-c}}</ref>. Program ten, w bardzo podobnej formie, znajdował się również w dokumencie ''Programming in C: A Tutorial'', przygotowanym przez [[Brian Kernighan|B.&nbsp;Kernighana]] w 1974 roku<ref>{{Cytuj |autor = [[Brian Kernighan|Brian W. Kernighan]] |tytuł = Programming in C: A Tutorial |s = 1 |data = 1974 |data dostępu = 2022-04-12 |opublikowany = [[Bell Labs|Bell Laboratories]] |url = https://www.bell-labs.com/usr/dmr/www/ctut.pdf |archiwum = http://web.archive.org/web/20220322215231/https://www.bell-labs.com/usr/dmr/www/ctut.pdf |zarchiwizowano = 2022-03-22 |język = en}}</ref><ref>{{Cytuj |autor = [[Dennis Ritchie|Dennis M. Ritchie]] |tytuł = C Reference Manual |s = 25 |data dostępu = 2022-04-12 |opublikowany = Bell Telephone Laboratories |url = https://archives.scovetta.com/pub/compsci/C/cman.pdf |archiwum = http://web.archive.org/web/20220412181635/https://archives.scovetta.com/pub/compsci/C/cman.pdf |zarchiwizowano = 2022-04-12 |język = en}}</ref>.<syntaxhighlight lang="c">
main()
{
    printf("hello, world");
}
</syntaxhighlight>Powyższy kod prawdopodobnie nie zostanie skompilowany, jeśli nie wymusi się na [[kompilator]]ze przyjęcia standardu C90. Nowsza wersja tego programu, rozumiana przez współczesne kompilatory, wygląda następująco<ref name="Ctutorial" />:<syntaxhighlight lang="c">
#include <stdio.h>

int main(void){
    printf("hello, world");
}
</syntaxhighlight>Pierwsza linijka tego kodu informuje [[preprocesor]], aby dołączył w to miejsce zawartość pliku <code>stdio.h</code>, który wchodzi w skład [[Biblioteka standardowa języka C|biblioteki standardowej języka&nbsp;C]]{{odn|Kernighan|Ritchie|2002|s=25}}. Zadeklarowane w nim są procedury odpowiadające za obsługę wejścia i wyjścia, w tym <code>printf</code>{{odn|Kernighan|Ritchie|2002|s=322–325}}. Następnie definiowana jest funkcja <code>main</code>. To od niej rozpoczyna się wykonanie programu napisanego w C. Funkcja ta nie przyjmuje żadnych [[Parametr (informatyka)|argumentów]] i zwraca wartość całkowitą. Wewnątrz nawiasów klamrowych znajduje się lista instrukcji, które zostaną wywołane po uruchomieniu programu{{odn|Kernighan|Ritchie|2002|s=24–25}}.

W przykładowym programie funkcja <code>main</code> składa się z jednej [[Instrukcja (informatyka)|instrukcji]]: wywołania <code>printf</code> z argumentem <code>"hello, world"</code>. Służy ono do wyświetlenia tekstu na ekranie{{odn|Kernighan|Ritchie|2002|s=25}}. Mogłaby się tam znaleźć jeszcze instrukcja <code>return</code>, ale zgodnie ze standardem ISO&nbsp;C, umieszczenie jej w funkcji <code>main</code> jest opcjonalne. Zwrócona do [[System operacyjny|systemu operacyjnego]] zostanie wtedy wartość 0{{odn|ISO/IEC9899:2017|s=11}}. Wartość zwracana przez funkcję <code>main</code> to tzw. {{link-interwiki|kod wyjścia|Q=Q2553232}} ([[Język angielski|ang.]] ''exit status'' albo ''return code''), a wartość 0 zazwyczaj oznacza udane wykonanie programu<ref>{{Cytuj |rozdział = 5.7 The main Function |tytuł = The GNU C Reference Manual |data dostępu = 2022-03-13 |opublikowany = GNU |url = https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html}}</ref><ref>{{cytuj | autor=Piotr Szawdyński | tytuł = [lekcja] Podstawy programowania w C++ | data dostępu = 2022-08-20 | opublikowany = cpp0x.pl | url = https://cpp0x.pl/kursy/Kurs-C++/Poziom-1/Podstawy-programowania-w-C++/7}}</ref>.

== Zastosowania ==
[[Plik:The C Programming Language.png|mały|Zastosowania języka C]]
Głównym celem, który przyświecał Dennisowi Ritchiemu przy tworzeniu języka C było ułatwienie pisania [[System operacyjny|oprogramowania systemowego]]. Potrzebny był [[Język wysokiego poziomu|język wysokopoziomowy]], ale jednocześnie tak wydajny jak [[asembler]]<ref>{{Cytuj |autor = P. Fazio; K. Gowri |tytuł = Structural analysis software and the C programming language |czasopismo = Computers & Structures |data = 1987 |wolumin = 25 |numer = 3 |s = 463 |doi = 10.1016/0045-7949(87)90138-6 |język = en}}</ref>. Z tego też powodu C bywa nazywany „wysokopoziomowym asemblerem”<ref name="Jones-HLA">{{Cytuj |autor = Russel Jones |tytuł = The C programming language: Popularity grows for the high-level assembly language |czasopismo = Data Processing |data = 1985-12 |wolumin = 27 |numer = 10 |s = 35–38 |doi = 10.1016/0011-684X(85)90032-2 |język = en}}</ref>. Powstały w nim m.in. [[Unix]]<ref name="Jones-HLA" /> i jądro [[Linux (jądro)|Linux]]<ref>{{Cytuj |tytuł = Programming Language – The Linux Kernel documentation |data dostępu = 2022-06-10 |opublikowany = www.kernel.org |url = https://www.kernel.org/doc/html/latest/process/programming-language.html |język = en}}</ref>. W praktyce dla każdej nowej architektury język C jest pierwszym dostępnym językiem programowania poza asemblerem<ref name="next7000">{{Cytuj |autor=Robert Chatley, Alastair Donaldson, Alan Mycroft |url=https://link.springer.com/content/pdf/10.1007%2F978-3-319-91908-9_15.pdf |tytuł=The next 7000 programming languages |s=§2.2 ''Systems programming and the rise of C'' |doi=10.1007/978-3-319-91908-9_15}}</ref>.

W latach 80. XX wieku C zdobył popularność również wśród twórców [[Oprogramowanie użytkowe|oprogramowania aplikacyjnego]]. Jego głównymi konkurentami były wtedy [[BASIC]] i [[Pascal (język programowania)|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 [[Programowanie strukturalne|programowania strukturalnego]], pozwalając również na [[Hermetyzacja (informatyka)|hermetyzację kodu]]<ref name="Jones-HLA" />.

Zastosowanie języka C pozwoliło części producentów oprogramowania zrezygnować ze stosowania języka asemblera<ref name="Jones-HLA" />. 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 [[Model relacyjny|relacyjnych baz danych]], który można było uruchomić zarówno na komputerach typu [[mainframe]], [[minikomputer]]ach jak i [[Komputer osobisty|komputerach osobistych]]<ref>{{Cytuj |autor = Lance Ashdown, Donna Keesling, Tom Kyte |rozdział = Brief History of Oracle Database |tytuł = Introduction to Oracle Database |data dostępu = 2022-06-10 |opublikowany = Oracle Help Center |url = https://docs.oracle.com/en/database/oracle/oracle-database/21/cncpt/introduction-to-oracle-database.html#GUID-43F9DD5C-8D8C-4E61-A2B4-5C05907D3CEC |język = en}}</ref>. W C został napisany również najpopularniejszy na świecie silnik bazodanowy, [[SQLite]]<ref>{{Cytuj |tytuł = SQLite Home Page |data dostępu = 2022-06-10 |opublikowany = www.sqlite.org |url = https://www.sqlite.org/index.html |język = en}}</ref>.

Innymi przykładami oprogramowania przygotowanego w języku C są [[Apache HTTP Server|serwer HTTP Apache]]<ref>{{Cytuj |autor = "Apache Software Foundation" |tytuł = apache/httpd |data =  |data dostępu = 2022-06-10 |opublikowany = GitHub |url = https://github.com/apache/httpd |język = en}}</ref>, biblioteka kryptograficzna [[OpenSSL]]<ref>{{Cytuj |autor = "OpenSSL Project" |tytuł = openssl/openssl: TLS/SSL and crypto library |data =  |data dostępu = 2022-06-10 |opublikowany = GitHub |url = https://github.com/openssl/openssl |język = en}}</ref>, a także gry [[Doom (gra komputerowa 1993)|Doom]]<ref>{{Cytuj |autor = Paul C. Schuytema |tytuł = The Lighter Side Of Doom |czasopismo = Computer Gaming World |data = 1994-08 |wolumin = 121 |s = 140, 142 |url = https://www.cgwmuseum.org/galleries/issues/cgw_121.pdf |język = en}}</ref> i [[Quake]]<ref>{{Cytuj |autor = "id-Software" |tytuł = id-Software/Quake: Quake GPL Source Release |data dostępu = 2022-06-10 |opublikowany = GitHub |url = https://github.com/id-Software/Quake |język = en}}</ref>.

[[Biblioteka uruchomieniowa|Środowiska wykonawcze]] dla programów napisanych w innych językach również powstają z wykorzystaniem kodu w C. Dotyczy to np. [[Java Runtime Environment]]<ref>{{Cytuj |tytuł = The Java(tm) Language: An Overview |data = 2008-02-22 |data dostępu = 2022-06-10 |opublikowany = web.archive.org |url = https://web.archive.org/web/20080222200518/http://java.sun.com/docs/overviews/java/java-overview-1.html |język = en}}</ref>, [[CPython]]a (referencyjnej implementacji [[Python]]a)<ref>{{Cytuj |autor = "Python Software Foundation" |tytuł = python/cpython: The Python programming language |data dostępu = 2022-06-10 |opublikowany = GitHub |url = https://github.com/python/cpython |język = en}}</ref> czy interpretera [[PHP]]<ref>{{Cytuj |autor = "The PHP Group" |tytuł = php/php-src: The PHP Interpreter |data dostępu = 2022-06-10 |opublikowany = GitHub |url = https://github.com/php/php-src |język = en}}</ref>. 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 [[Prolog (język programowania)|Prologa]]<ref>{{Cytuj |autor = D. Bohdan |tytuł = Compilers targeting C |data = 2021-06-30 |data dostępu = 2022-06-10 |opublikowany = GitHub |url = https://github.com/dbohdan/compilers-targeting-c/blob/master/README.md |język = en}}</ref>. Niektóre języki wymagają jednak cech, których C nie oferuje, np. [[Rekurencja ogonowa|rekurencji ogonowej]] albo wsparcia dla [[Odśmiecanie pamięci|odśmiecania pamięci]]. Z tego powodu zaprojektowano m.in. [[C--]]<ref>{{Cytuj |autor = Simon Peyton Jones; Thomas Nordin; Dino Oliva |tytuł = C--: A portable assembly language |czasopismo = Implementation of Functional Languages |data = 1997 |doi = 10.1007/BFb0055421 |język = en}}</ref>.

== Popularność ==
Język C, przez ponad 20 lat prowadzenia rankingu {{link-interwiki|TIOBE Index|Q=Q389713}} (od 2001 roku), plasował się na jednym z dwóch czołowych miejsc, trzykrotnie zdobywając miano „języka roku”<ref>{{Cytuj |tytuł = C: TIOBE Index |data dostępu = 2022-06-13 |opublikowany = TIOBE |url = https://www.tiobe.com/tiobe-index/c/ |język = en}}</ref>, nadawane językowi, który odnotuje najwyższy wzrost wskaźnika rankingowego rok do roku<ref>{{Cytuj |rozdział = Programming Language Hall of Fame |tytuł = TIOBE Index |data dostępu = 2022-06-13 |opublikowany = TIOBE |url = https://www.tiobe.com/tiobe-index/#PLHoF |język = en}}</ref>. 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ę<ref>{{Cytuj |tytuł = PYPL PopularitY of Programming Language index |data dostępu = 2022-06-13 |opublikowany = pypl.github.io |url = https://pypl.github.io/PYPL.html |archiwum = https://web.archive.org/web/20220611162627/https://pypl.github.io/PYPL.html |język = en}}</ref>.

Badanie projektów [[Otwarte oprogramowanie|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 [[Repozytorium|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<ref name="GitHub100k">{{Cytuj |autor = Tegawendé F. Bissyandé; Ferdian Thung; David Lo; Lingxiao Jiang; Laurent Réveillère |tytuł = Popularity, Interoperability, and Impact of Programming Languages in 100,000 Open Source Projects |data = 2013-07 |data dostępu = 2022-06-24 |miejsce = Kioto |opublikowany = 37th Annual International Computer Software & Applications Conference (COMPSAC 2013) |url = https://hal.archives-ouvertes.fr/hal-00809451 |język = en}}</ref>.

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<ref>{{Cytuj |rozdział = Technology |tytuł = Stack Overflow Developer Survey 2022 |data dostępu = 2022-06-22 |opublikowany = Stack Overflow |url = https://survey.stackoverflow.co/2022/#technology |język = en}}</ref>.

=== Wpływ ===
Popularność i szerokie zastosowanie języka C ma bezpośredni wpływ na składnię lub semantykę innych języków programowania<ref name="next7000" />. Przede wszystkim najbardziej podobnym i kompatybilnym jest język [[C++]], który powstawał jako rozszerzenie „C z klasami”<ref>{{Cytuj | autor=Bjarne Stroustrup |tytuł=A History of C++: 1979−1991 |url=https://www.stroustrup.com/hopl2.pdf |data dostępu=2022-08-13 |doi=10.1145/154766.155375 |czasopismo=ACM SIGPLAN Notices |wolumin=28 |numer=3 |s=271-297}}</ref>. Inne języki wykazujące podobieństwa do składni C to między innymi [[C Sharp|C#]]<ref>{{Cytuj |autor=Ian Chivers |tytuł=Essential C# fast |data=2003 |wydawca=Springer| s=4 |doi=10.1007/978-1-4471-0075-1 |cytat={{j|en|In terms of syntax, it belongs in the same family of programming languages as C, C++ and Java}} |issn=1439-975X}}</ref>, [[csh]]<ref>{{Cytuj |autor=Chuck Easttom |tytuł=System Forensics, Investigation and Response |data=2013 |wydawca=Jones & Bartlett Publishers |s=188 |cytat={{j|en|it uses very C-like syntax}} |isbn=128403108X}}</ref>, [[D (język programowania)|D]]<ref>{{Cytuj |autor=Walter Bright, Andrei Alexandrescu, Michael Parker |tytuł=Origins of the D programming language |czasopismo=Proceedings of the ACM on Programming Languages |data=czerwiec 2020 |wolumin=4 |numer=HOPL |s=73:18 |cytat={{j|en|D intentionally looks very much like C and C++}} |doi=10.1145/3386323}}</ref>, [[Go]]<ref>{{Cytuj |autor=Dušan Stojanović |tytuł=Building Server-side and Microservices with Go |cytat={{j|en|Sytactically, Go is similar to C, but many "features" are borrowed from other languages}} |s=10}}</ref>, [[Język opisu interfejsu|IDL]]<ref>{{Cytuj |autor=Martin Gudgin |tytuł=Essential IDL: Interface Design for COM |data=2001 |wydawca=Addison-Wesley |s=6 |cytat={{j|en|IDL has syntax based on the C programming language}} |isbn=0201615959}}</ref>, [[Java]]<ref>{{Cytuj |autor=Dhiraj Kumar Baraik |tytuł=Modern JAVA : Functional Programming |data=2021 |s=13 |cytat={{j|en|Its syntax is similar to C and C++}}}}</ref> (w zasadzie do C++<ref>{{Cytuj |autor=Autorzy David Reilly, Michael Reilly |tytuł=Java Network Programming and Distributed Computing |data=2002 |wydawca=Addison-Wesley Professional |s=28 |cytat={{j|en|oryginally modified C++ compiler}} |isbn=0201710374}}</ref>), [[JavaScript]]<ref>{{Cytuj |autor r=Aaron Gustafson |rozdział=Introduction to JavaScript |autor=Jennifer Niederst Robbins |tytuł=Web Design in a Nutshell: A Desktop Quick Reference |data=2006 |wydawca=O'Reilly Media |s=465 |cytat={{j|en|similar to the C programming language and share similar syntax}} |isbn=1449379095}}</ref>, [[Objective-C]]<ref>{{Cytuj |autor=Andrew M. Duncan |tytuł=Objective-C Pocket Reference |data=2002 |wydawca=O'Reilly Media |s=1 |cytat={{j|en|Objective-C uses C syntax}} |isbn=059655219X}}</ref>, [[OpenCL]]<ref>{{Cytuj |autor=Unnikrishnan Cheramangalath, Rupesh Nasre, Y. N. Srikant |tytuł=Distributed Graph Analytics: Programming, Languages, and Their Compilation |data=2020 |wydawca=Springer Nature |s=14 |cytat={{j|en|has C-like syntax}} |isbn=3030418863}}</ref>, [[OpenGL]]<ref>{{Cytuj |autor=Dan Ginsburg, Budirijanto Purnomo, Dave Shreiner, Aaftab Munshi |tytuł=OpenGL ES 3.0 Programming Guide |data=2014 |wydawca=Addison-Wesley Professional |wydanie=2 |s=98 |cytat={{j|en|the syntax bears great similarity to that seen in the C programming language}} |isbn=0133440125}}</ref>, [[PAWN]]<ref>{{Cytuj |autor=Jason Gregory |tytuł=Game Engine Architecture |s=§16.9.3.5 ''Pawn/Small/Small-C'' |cytat={{j|en|C-like scripting language}} |isbn=1351974270}}</ref>, [[Perl]]<ref>{{Cytuj |autor=Adam McDaniel |tytuł=Perl and Apache: Your visual blueprint for developing dynamic Web content |data=2010 |wydawca=John Wiley & Sons |s=3 |cytat={{j|en|The Perl programming language uses a syntax structure that is very similar to C in design}} |isbn=0470944382}}</ref>, [[PHP]]<ref>{{Cytuj |autor=K. L. JAMES |tytuł=THE INTERNET: A USER’S GUIDE |data=2010 |wydawca=PHI Learning |wydanie=2 |s=210 |cytat={{j|en|Syntax of PHP language is similar to C or C++}} |isbn=8120340299}}</ref>, tudzież [[Swift (język programowania LLVM)|Swift]]<ref>{{Cytuj |redaktor=Kurubacak, Gulsun; Altinpulluk, Hakan |tytuł=Mobile Technologies and Augmented Reality in Open Education |data=2017 |wydawca=IGI Global |s=128 |cytat={{j|en|The swift script uses a C-like syntax to describe data, application components, invocation of application components, and the data flow among the invocations}} |isbn=1522521119}}</ref>.

== Krytyka ==
C charakteryzuje się [[Typowanie słabe|słabym typowaniem]]. Jego specyfikacja pozwala na rzutowanie [[Wskaźnik (typ danych)|typów wskaźnikowych]] na dowolne inne typy wskaźnikowe. W konsekwencji dowolny region [[Pamięć operacyjna|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 typu|konwersja typów]] jest sensowna<ref>{{Cytuj |autor = Satish Chandra, Thomas Reps |tytuł = Physical type checking for C |data = 1999-09-01 |data dostępu = 2022-06-13 |isbn = 978-1-58113-137-6 |miejsce = New York, NY, USA |wydawca = Association for Computing Machinery |s = 66 |doi = 10.1145/316158.316183 |język = en}}</ref>. W C jest ponadto dozwolone przypisanie wartości do [[Zmienna (informatyka)|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 <code>char</code>, mimo działania – na poziomie koncepcji – wyłącznie w [[Dziedzina (matematyka)|dziedzinie]] znakowej<ref name="PohlEdelson1988">{{Cytuj |autor = Ira Pohl; Daniel Edelson |tytuł = A to Z: C language shortcomings |czasopismo = Computer Languages |data = 1988 |wolumin = 13 |numer = 2 |s = 51–64 |doi = 10.1016/0096-0551(88)90009-4 |język = en}}</ref>. Powszechne wykorzystanie wskaźników, pozwalających na niskopoziomowy dostęp do pamięci jest czynnikiem osłabiającym [[Bezpieczeństwo teleinformatyczne|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łnienie bufora|przepełnienia buforów]]<ref name=":0">{{Cytuj |autor = Periklis Akritidis |tytuł = Practical memory safety for C |czasopismo = Technical Report |data = 2011-06 |data dostępu = 2022-07-24 |issn = 1476-2986 |wolumin = 798 |miejsce = Cambridge |wydawca = University of Cambridge Department of Computer Science and Technology |s = 15, 24 |url = https://www.cl.cam.ac.uk/techreports/UCAM-CL-TR-798.pdf |język = en}}</ref>.

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<ref name="Joyner1996">{{Cytuj |autor = Ian Joyner |rozdział = Generic C Criticisms |tytuł = C++??: A Critique of C++ |data = 1996-12 |data dostępu = 2022-06-15 |wydanie = 3 |url = http://www.elj.com/cppcv3/s4/ |archiwum = https://web.archive.org/web/20000823031011/http://www.elj.com/cppcv3/s4/}}</ref>; co więcej, dozwolone jest używanie ujemnych indeksów, aby odwołać się do obiektów leżących w pamięci przed zerowym{{odn|Kernighan|Ritchie|2002|s=139}}. Przeszkadza to w implementacji np. [[Odśmiecanie pamięci|odśmiecania pamięci]], ale też stanowi powszechne źródło trudnych do wykrycia [[Błąd (informatyka)|błędów]] w oprogramowaniu<ref name="Joyner1996" />. Możliwość zapisu danych poza tablicę bywa wykorzystywana jako wektor [[cyberatak|ataku]], prowadzącego do uzyskania kontroli nad [[System komputerowy|systemem komputerowym]] poprzez wstrzyknięcie do programu odpowiednio spreparowanych poleceń lub zmianę stanu innych zmiennych<ref>{{Cytuj |autor = Marek Wrona |tytuł = Niebezpieczeństwo komputerowe |data = cop. 2000 |data dostępu = 2022-08-16 |isbn = 83-7243-076-4 |miejsce = Warszawa |wydawca = Wydaw. RM |s = 40-46 |oclc = 749501645}}</ref>.

Wielowymiarowe tablice są w rzeczywistości tablicami jednowymiarowymi, co w przeszłości utrudniało pisanie funkcji wykonujących np. obliczenia macierzowe<ref name="Press1992">{{Cytuj |autor = William H. Press; Saul A. Teukolsky; William T. Vetterling; Brian P. Flannery |tytuł = Numerical Recipes in C: The Art of Scientific Computing |data = 1992 |isbn = 0521431085 |wydanie = 2 |miejsce = Cambridge |wydawca = Cambridge University Press |s = 22 |język = en}}</ref><ref name="Joyner1996" />. 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{{odn|ISO/IEC9899:2017|s=xv}}, w tym przekazywania takich tablic jako argumentów funkcji. Dlatego do adresowania np. elementów [[macierz]]y wykorzystywano pomocniczą tablicę wskaźników do pierwszych elementów każdego wiersza<ref name="Press1992" />.

Innym problemem, który podnoszono jest niekonsekwencja twórców standardu, objawiająca się w określeniach <code>void</code> i <code>void*</code>. 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 <code>void</code>, niezwiązane z desygnowaniem typu, to wskazanie, że funkcja nie przyjmuje żadnych [[Argument (informatyka)|argumentów]]<ref name="Joyner1996" />.

Z perspektywy czasu niektóre decyzje dotyczące składni okazały się nieoptymalne. Jedną z nich jest niższy [[Kolejność wykonywania działań|priorytet operatorów]] bitowych niż porównania, co wymusza pisanie konstrukcji takich jak <code>(a & mask) == b</code>, które bez nawiasów działałyby niezgodnie z intencją programisty<ref name="Ritchie1993" />. Inną z częściej spotykanych pułapek jest zamienienie operatorów porównania (<code>==</code>) i przypisania (<code>=</code>). 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 [[Instrukcja (informatyka)|instrukcji]]. Ten sam symbol oddziela od siebie np. argumenty funkcji<ref name="PohlEdelson1988" />.

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 [[Dereferencja|dereferencji]] był przyrostkowym, a nie przedrostkowym, jak to ma miejsce w C<ref name="Ritchie1993" />.

Cechy języka, krytykowane jako trudne do odczytania lub zrozumienia, bywają również wykorzystywane do celowego [[Zaciemnianie kodu|zaciemniania kodu]], czego skrajnym przypadkiem są programy zgłaszane do konkursu [[International Obfuscated C Code Contest|IOCCC]]<ref>{{Cytuj |autor = Dan Gopstein, Jake Iannacone, Yu Yan, Lois DeLong, Yanyan Zhuang |tytuł = Understanding misunderstandings in source code |data = 2017-08-21 |isbn = 978-1-4503-5105-8 |opis = ESEC/FSE 2017: Proceedings of the 2017 11th Joint Meeting on Foundations of Software Engineering |miejsce = Nowy Jork |wydawca = Association for Computing Machinery |s = 129–139 |doi = 10.1145/3106237.3106264 |język = en}}</ref>.

Standard języka C opisuje wiele sytuacji, dla których zachowanie jest {{link-interwiki|zachowanie niezdefiniowane|tekst=niezdefiniowane|Q=Q1964707}} lub {{link-interwiki|zachowanie nieokreślone|tekst=nieokreślone|Q=Q4318017}}. 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ć<ref>{{Cytuj |autor = Robert C. Seacord |tytuł = Effective C: An Introduction to Proffesional C Programming |data = 2020 |s = xxv |isbn = 978-1-71850-104-1 |lccn = 2020017147}}</ref>. W szczególności standard C nie określa, w jaki sposób przechowywane są w pamięci [[Kolejność bajtów|wielobajtowe wartości skalarne]]. Większość programów polega jedynie na domyślnym zachowaniu zapewnionym przez [[Interfejs binarny aplikacji|ABI]]. Nie zapewnia ono jednak przenośności między różnymi platformami<ref>{{Cytuj |autor = David Delmas; Abdelraouf Ouadjaout; Antoine Miné |rozdział = Static Analysis of Endian Portability by Abstract Interpretation |redaktor = Cezara Drăgoi; Suvam Mukherjee; Kedar Namjoshi |tytuł = Static Analysis |czasopismo = Lecture notes in computer science |wolumin = 12913 |opis=28th International Symposium, SAS 2021, Chicago, IL, USA, October 17–19, 2021, Proceedings |data = 2021 |s = 103 |isbn = 978-3-030-88805-3 |issn = 0302-9743 |doi = 10.1007/978-3-030-88806-0_5}}</ref>. 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ę<ref>{{Cytuj |autor = Max Domeika |tytuł = Software Development for Embedded Multi-core Systems |data = 2008 |s = 95 |isbn = 978-0-7506-8539-9}}</ref>. Jedną z naczelnych zasad ducha programowania w C jest tworzenie wydajnego kodu nawet za cenę jego przenośności<ref>{{Cytuj |tytuł = Rationale for the ANSI C Programing Language |wydawca = Sillicon Press |s = 3 |data = 1990 |isbn = 0-929306-07-4 |cytat = {{j|en|Make it fast, even if it is not guaranteed to be portable}}}}</ref>.

{{link-interwiki|Niezainicjowana zmienna|Q=Q2912653}} to problem, który dotyczy wielu języków programowania<ref>{{Cytuj |redaktor=Hubertus B. Keller, Erhard Plödereder |tytuł=Reliable Software Technologies Ada-Europe 2000: 5th Ada-Europe International Conference Potsdam, Germany, June 26-30, 2000, Proceedings |wydawca=Springer |data=2006 |s=38}}</ref>. Błąd ten powstaje z winy programisty<ref>{{Cytuj |autor=Yung-Hsiang Lu |tytuł=Intermediate C Programming |data=2015 |wydawca=CRC Press |s=36 |isbn=1498711642}}</ref>. Jest on trudny do wykrycia, gdyż taki program może się zupełnie inaczej zachowywać w środowisku diagnostycznym pod kontrolą [[debugger]]a niż w środowisku produkcyjnym<ref>{{Cytuj |autor=Andreas Zeller |tytuł=Why Programs Fail: A Guide to Systematic Debugging |data=2009 |wydawca=Elsevier |s=89 |isbn=0080923003}}</ref> lub wręcz w kolejnych wykonaniach przy takich samych danych wejściowych<ref>{{Cytuj |autor=Sartaj Sahni, Robert F. Cmelik, Bob Cmelik |tytuł=Software Development in C |wydawca=Silicon Press |data=1995 |s=164 |isbn=0929306163}}</ref>. 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<ref>{{Cytuj |autor=Randall Hyde |tytuł=Write Great Code, Vol. 2: Thinking Low-Level, Writing High-Level |wydawca=No Starch Press |data=2004 |s=336 |isbn=1593270658}}</ref>. Kompilator często ostrzega o próbie dostępu do niezainicjowanej zmiennej<ref>{{Cytuj |autor=Robert C. Seacord |tytuł=	The CERT® C Coding Standard, Second Edition: 98 Rules for Developing Safe, Reliable, and Secure Systems |wydanie=2 |wydawca=Addison-Wesley Professional |data=2014 |s=56 |isbn=0133805298}}</ref>.

== Uwagi ==
{{Uwagi}}

== Przypisy ==
{{Przypisy}}

== Bibliografia ==
* {{Cytuj |autor = *[[Brian Kernighan|Brian W. Kernighan]];* [[Dennis Ritchie|Dennis M. Ritchie]] |tytuł = Język ANSI C |data = 2002 |isbn = 83-204-2719-3 |wydanie = 7 |inni = Danuta Kruszewska (tłum.); Marek Kruszewski (tłum.) |miejsce = Warszawa |wydawca = [[Wydawnictwa Naukowo-Techniczne]] |język = pl |odn = {{odn/id|Kernighan|Ritchie|2002}} }}
* {{Cytuj |tytuł = ISO/IEC9899:2017 Draft |data = 2017 |url = https://web.archive.org/web/20181230041359if_/http://www.open-std.org/jtc1/sc22/wg14/www/abq/c17_updated_proposed_fdis.pdf |język = en |odn = {{odn/id|ISO/IEC9899:2017}}}}
* {{Cytuj |tytuł = ISO/IEC 9899:2024 — N3220 working draft |data = 2024 |data dostępu = 2025-02-08 |opublikowany = www.open-std.org |url = https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3220.pdf |archiwum = https://web.archive.org/web/20250126132458/https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3220.pdf |język = en |odn = {{odn/id|ISO/IEC9899:2024}}}}

== Linki zewnętrzne ==
{{wikibooks|C}}
{{wikibooks|C/Biblioteka standardowa/Indeks alfabetyczny}}
* Krzysztof Diks, [http://wazniak.mimuw.edu.pl/index.php?title=Wst%C4%99p_do_programowania_w_j%C4%99zyku_C ''Wstęp do programowania w języku C''] (materiały dydaktyczne [[Wydział Matematyki, Informatyki i Mechaniki Uniwersytetu Warszawskiego|MIMUW]] na studia informatyczne)
* Mike Banahan, Declan Brady, Mark Doran, [http://publications.gbdirect.co.uk/c_book/ ''The C Book, Second Edition''] {{lang|en}}, Addison-Wesley 1991, {{ISBN|0-201-54433-4}}, wersja ''online''.

{{Języki programowania}}

{{Kontrola autorytatywna}}

[[Kategoria:C (język programowania)| ]]