1. Wstęp
   1. O podręczniku
   2. O języku C
   3. Czego potrzebujesz
   4. Używanie kompilatora
2. C dla początkujących
   1. Pierwszy program
   2. Podstawowe wiadomości
   3. Zmienne w C
   4. Operatory
   5. Instrukcje sterujące
   6. Podstawowe procedury wejścia i wyjścia
   7. Funkcje
   8. Preprocesor
   9. Biblioteka standardowa
   10. Czytanie i pisanie do plików
   11. Ćwiczenia
3. Zaawansowany C
   1. Tablice
   2. Wskaźniki
   3. Napisy
   4. Typy złożone
   5. Tworzenie bibliotek
   6. Więcej o kompilowaniu
   7. Zaawansowane operacje matematyczne
   8. Powszechne praktyki
   9. Przenośność programów
   10. Łączenie z innymi językami
   11. Ćwiczenia
4. Dodatek A
   1. Składnia
   2. Przykłady z komentarzem
5. Przypisy

Niniejszy podręcznik stanowi przewodnik dla początkujących programistów w języku programowania C.

Ten podręcznik ma nauczyć programowania w C od podstaw do poziomu zaawansowanego. Do zrozumienia rozdziału dla początkujących wymagana jest jedynie znajomość podstawowych pojęć z zakresu algebry oraz terminów komputerowych. Doświadczenie w programowaniu w innych językach bardzo pomaga, ale nie jest konieczne.

Oczywiście, że możesz. Mało tego, będziemy zadowoleni z każdej pomocy – możesz pisać rozdziały lub tłumaczyć je z angielskiej wersji tego podręcznika. Nie musisz pytać się nikogo o zgodę - jeśli chcesz, możesz zacząć już teraz. Prosimy jedynie o zapoznanie się ze stylem podręcznika, użytymi w nim szablonami i zachowanie układu rozdziałów. Propozycje zmiany spisu treści należy zgłaszać na stronie dyskusji. Konwencje użyte w podręczniku opisane są w module Konwencje.

Jeśli znalazłeś jakiś błąd, a nie umiesz go poprawić, koniecznie powiadom o tym fakcie autorów tego podręcznika za pomocą strony dyskusji danego modułu książki. Dzięki temu przyczyniasz się do rozwoju tego podręcznika.

Informacje ważne oznaczamy w następujący sposób:

Uwaga! Ważna informacja!

Dodatkowe informacje, które odrobinę wykraczają poza zakres podręcznika, a także wyjaśniają kwestie niezwiązane bezpośrednio z językiem C, oznaczamy tak:

Wyjaśnienie

Ponadto kod w języku C będzie prezentowany w następujący sposób:

#include <stdio.h>

int main (int argc, char *argv[])
{
  return 0;
}

Innego rodzaju przykłady, dialog użytkownika z konsolą i programem, wejście / wyjście programu, informacje teoretyczne będą wyglądały tak:

typ zmienna = wartość;

Więcej o konwencjach przyjętych w kodzie w module Konwencje

Istotny wkład w powstanie podręcznika mają:

• CzarnyZajaczek
• Derbeth
• Kj
• mina86

Dodatkowo w rozwoju podręcznika pomagali między innymi:

• Lrds
• Noisy

• podręcznik C Programming na anglojęzycznej wersji Wikibooks, licencja GFDL
• Brian W. Kernighan, Dennis M. Ritchie, Język ANSI C
• ISO C Committee Draft, 18 stycznia 1999
• Bruce Eckel, Thinking in C++. Rozdział Język C w programie C++.

Wikipedia, nasz siostrzany projekt, zawiera artykuł na temat C (język programowania).

C jest językiem programowania wysokiego poziomu. Jego nazwę interpretuje się jako następną literę po B (nazwa jego poprzednika), lub drugą literę języka BCPL (poprzednik języka B).

• proceduralny^[1]
• imperatywny
• ogólnego przeznaczenia
• wystandaryzowany

W 1947 roku trzej naukowcy z Bell Telephone Laboratories - William Shockley, Walter Brattain i John Bardeen - stworzyli pierwszy tranzystor; w 1956 roku, w MIT skonstruowano pierwszy komputer oparty wyłącznie na tranzystorach: TX-O; w 1958 roku Jack Kilby z Texas Instruments skonstruował układ scalony. Ale zanim powstał pierwszy układ scalony, pierwszy język wysokiego poziomu został już napisany.

W 1954 powstał Fortran (Formula Translator), który zapoczątkował napisanie języka Fortran I (1956). Później powstały kolejno:

• Algol 58 - Algorithmic Language w 1958 r.
• Algol 60 (1960)
• CPL - Combined Programming Language (1963)
• BCPL - Basic CPL (1967)
• B (1969)

i C w oparciu o B.

B został stworzony przez Kena Thompsona z Bell Labs; był to język interpretowany, używany we wczesnych, wewnętrznych wersjach systemu operacyjnego UNIX. Inni pracownicy Bell Labs, Thompson i Dennis Ritchie, rozwinęli B, nazywając go NB; dalszy rozwój NB dał C - język kompilowany. Większa część UNIX-a została ponownie napisana w NB, a następnie w C, co dało w efekcie bardziej przenośny system operacyjny. W 1978 roku wydana została książka pt. "The C Programming Language", która stała się pierwszym podręcznikiem do nauki języka C.

Możliwość uruchamiania UNIX-a na różnych komputerach była główną przyczyną początkowej popularności zarówno UNIX-a, jak i C; zamiast tworzyć nowy system operacyjny, programiści mogli po prostu napisać tylko te części systemu, których wymagał inny sprzęt, oraz napisać kompilator C dla nowego systemu. Odkąd większa część narzędzi systemowych była napisana w C, logiczne było pisanie kolejnych w tym samym języku.

Kilka z obecnie powszechnie stosowanych systemów operacyjnych takich jak Linux, Microsoft Windows zostało napisanych w języku C.

W 1978 roku Ritchie i Kerninghan opublikowali pierwszą książkę nt. języka C - "The C Programming Language". Owa książka przez wiele lat była swoistym "wyznacznikiem", jak programować w języku C. Była więc to niejako pierwsza standaryzacja, nazywana od nazwisk twórców "K&R". Oto nowości, wprowadzone przez nią do języka C w stosunku do jego pierwszych wersji (pochodzących z początku lat 70.):

• możliwość tworzenia struktur (słowo struct)
• dłuższe typy danych (modyfikator long)
• liczby całkowite bez znaku (modyfikator unsigned)
• zmieniono operator "=+" na "+="

Ponadto producenci kompilatorów (zwłaszcza AT&T) wprowadzali swoje zmiany, nieobjęte standardem:

• funkcje nie zwracające wartości (void) oraz typ void*
• funkcje zwracające struktury i unie
• przypisywanie wartości strukturom
• wprowadzenie słowa kluczowego const
• utworzenie biblioteki standardowej
• wprowadzenie słowa kluczowego enum

Owe nieoficjalne rozszerzenia zagroziły spójności języka, dlatego też powstał standard, regulujący wprowadzone nowinki. Od 1983 roku trwały prace standaryzacyjne, aby w 1989 roku wydać standard C89 (poprawna nazwa to: ANSI X3.159-1989). Niektóre zmiany wprowadzono z języka C++, jednak rewolucję miał dopiero przynieść standard C99, który wprowadził m.in.:

• funkcje inline
• nowe typy danych (np. long long int)
• nowy sposób komentowania, zapożyczony od C++ (//)
• przechowywanie liczb zmiennoprzecinkowych zostało zaadaptowane do norm IEEE
• utworzono kilka nowych plików nagłówkowych (stdbool.h, inttypes.h)

standard C99 jest dostępny tutaj.

Rozwój języka C trwał dalej. Na dzień dzisiejszy normą obowiązującą jest norma C11. Wprowadzono w niej m.in. wsparcie programowania równoległego.

Zobacz

• makro __STDC_VERSION__
• flagi kompilatora starujące dialektami C: gcc -std=c1x
• C Standardy kodowania, formatowanie kodu

Język C został opracowany jako strukturalny język programowania do celów ogólnych. Przez całą swą historię (czyli ponad 30 lat) służył do tworzenia przeróżnych programów - od systemów operacyjnych po programy nadzorujące pracę urządzeń przemysłowych. C, jako język dużo szybszy od języków interpretowanych (Perl, Python) oraz uruchamianych w maszynach wirtualnych (np. C#, Java) może bez problemu wykonywać złożone operacje nawet wtedy, gdy nałożone są dość duże limity czasu wykonywania pewnych operacji. Jest on przy tym bardzo przenośny - może działać praktycznie na każdej architekturze sprzętowej pod warunkiem opracowania odpowiedniego kompilatora. Często wykorzystywany jest także do oprogramowywania mikrokontrolerów i systemów wbudowanych. Wiele interpreterów języków skryptowych (Perl, PHP, Python. Ruby) jest napisanych w języku C.

Kolejną zaletą C jest jego dostępność - właściwie każdy system typu UNIX posiada kompilator C, w C pisane są funkcje systemowe. Dzięki temu w języku C można pisać aplikacje współpracujące z systemem uniksopodobnym (poprzez interfejs programowy systemu operacyjnego, np. POSIX). Przykładowym zastosowaniem jest programowanie równoległe poprzez funkcje "POSIX threads" albo dynamiczne ładowanie bibliotek (np. interpreter język Perl jest w stanie skompilować fragment kodu do poziomu bilioteki i ją podlinkować dynamicznie). Temat jest opisany w książkach o programowaniu systemu UNIX.

Problemem w przypadku C jest zarządzanie pamięcią, które nie wybacza programiście błędów, niewygodne operowanie napisami i niestety pewna liczba "kruczków", które mogą zaskakiwać nowicjuszy. Na tle młodszych języków programowania, C jest językiem dosyć niskiego poziomu więc wiele rzeczy trzeba w nim robić ręcznie, jednak zarazem umożliwia to robienie rzeczy nieprzewidzianych w samym języku (np. implementację liczb 128 bitowych), a także łatwe łączenie C z Asemblerem.

Język C jest dosyć okrojony, tzn. nie posiada wbudowanych bibliotek do typowych struktur danych i algorytmów (w przeciwieństwie do np. C++, Javy). Istnieją co prawda darmowe biblioteki, jednak są one rozwijane oddzielnie.

W przypadku konieczności dużej optymalizacji aplikacji dla danego sprzętu konkurencją staje się język asemblera. W większych projektach programiści sięgają często po obiektowy C++ (np. gry, CAD). W świecie oprogramowania biznesowego wykorzystywane są raczej technologie o szybszym procesie tworzenia aplikacji i mniejszym nacisku na wydajność (np. Java).

Standard C99 zbliżył możliwości języka C do języka Fortran. Dodano niektóre funkcje matematyczne i rozbudowano optymalizację dynamicznie alokowanej pamięci. Standard C11 przyniósł programowanie równoległe. W praktyce wiele zależy od kompilatora. Osiągi narzędzi GNU dla C i Fortranu obu języków bywają zbliżone. Język Fortran posiada jednak np. kotablice oraz obiekty nie występujące w języku C.

Z drugiej strony biblioteka GSL (GNU Scientific Library) jest przykładem projektu, który pomimo upływu czasu nadal wykorzystuje standard ANSI C. Jedną z przyczyn jest dążenie do przenośności. Implementacja liczb zmiennoprzecinkowych w standardzie o podwójnej precyzji została uznana za wystarczającą. W miarę upływu czasu w komputerach są dostępne wyższe precyzje (np. w standardzie C99 jest precyzja rozszerzona (long double)), w procesorach IBM POWER 9 jest możliwa precyzja poczwórna. Tworzenie w pełni uniwersalnego oprogramowania jest w praktyce niemożliwe (bo projekt się zaczyna coraz szybciej rozrastać). "Niech program najpierw w ogóle działa poprawnie, a dopiero potem działa szybko" (złota rada w książce Bruce Eckel-a, "Thinking in C++").

Pomimo sędziwego już wieku (C ma ponad 40 lat) nadal jest on jednym z najczęściej stosowanych języków programowania. Doczekał się już swoich następców, z którymi w niektórych dziedzinach nadal udaje mu się wygrywać. Widać zatem, że pomimo pozornej prostoty i niewielkich możliwości język C nadal spełnia stawiane przed nim wymagania. Warto zatem uczyć się języka C, gdyż nadal jest on wykorzystywany (i nic nie wskazuje na to, by miało się to zmienić), a wiedza którą zdobędziesz ucząc się C na pewno się nie zmarnuje. Składnia języka C, pomimo że przez wielu uważana za nieczytelną, stała się podstawą dla takich języków jak C++, C# czy też Java.

Nowoczesny C

• Modern C and What We Can Learn From It - Luca Sas [ ACCU 2021 ]
• "New" Features in C - Dan Saks

Wbrew powszechnej opinii nauczenie się któregoś z języków programowania (w tym języka C) nie jest takie trudne. Do nauki wystarczą Ci:

Język C jest bardzo przenośny, więc będzie działał właściwie na każdej platformie sprzętowej i w każdym nowoczesnym systemie operacyjnym.
Potrzebny będzie komputer z dowolnym systemem operacyjnym, takim jak FreeBSD, Linux, Windows.

• Kompilator języka C jest programem który tłumaczy kod źródłowy napisany przez nas do języka asembler, a następnie do postaci zrozumiałej dla komputera (maszyny cyfrowej), czyli do postaci ciągu zer i jedynek które sterują pracą poszczególnych elementów komputera. Kompilator języka C można dostać za darmo.

Przykładem są:

• gcc pod systemy uniksowe,
  • gcc - kompilacja pod systemy uniksowe,
• DJGPP pod systemy DOS,
• MinGW
• lcc pod systemy typu Windows,
• w64devkit: Portable C and C++ Development Kit for x64 Windows by Portable C and C++ Development Kit for x64 Windows
• wieloplatformowy Clang (część pakietu LLVM)
• Oracle Studio

Jako kompilator C może dobrze służyć kompilator języka C++ (różnice między tymi językami przy pisaniu prostych programów są nieistotne). Spokojnie możesz więc użyć na przykład Microsoft Visual C++® lub kompilatorów firmy Borland. Jeśli lubisz eksperymentować, wypróbuj Tiny C Compiler, bardzo szybki kompilator o ciekawych funkcjach. Możesz ponadto wypróbować interpreter języka C. Więcej informacji na Wikipedii.

• Linker - najczęściej dostarczany jest razem z kompilatorem. Jest to program uruchamiany po etapie kompilacji jednego lub kilku plików źródłowych (pliki z rozszerzeniem *.c, *.cpp lub innym), po procesie kompilacji. Linker łączy wszystkie skompilowane pliki źródłowe i inne funkcje bibliotek (np. printf, scanf) które były użyte (dołączone do naszego programu poprzez użycie dyrektywy #include) w naszym programie, a nie były zdefiniowane w naszych plikach źródłowych. Wywoływany jest on na ogół automatycznie przez kompilator, przez co nie musimy się martwić jego obsługą.

Systemy uniksowe oferują wiele edytorów przydatnych dla programisty, jak choćby vim i Emacs w trybie tekstowym, Kate w KDE czy gedit w GNOME. Zwykły notatnik Windowsa wystarcza do pisania prostych programów w C, choć dla wygody można spróbować poszukać w Internecie innych, wygodniejszych narzędzi, takich jak np. Notepad++. Odpowiednikiem Notepad++ w systemie uniksowym jest SciTE. Narzędziami oferującymi więcej niż edytor tekstu są IDE (zintegrowane środowiska programistyczne, opisane niżej).

• strace ^[2]= narzędzie do analizy kodu badające interakcję programu z jądrem systemu operacyjnego. Śledzi wywołania systemowe oraz sygnały w procesie.

Debugger jest to program, który umożliwia prześledzenie (poznanie wartości poszczególnych zmiennych na kolejnych etapach wykonywania programu) linijka po linijce wykonywania naszej aplikacji. Używa się go w celu określenia czemu nasz program nie działa po naszej myśli lub aby zbadać okoliczności występowania błędów. Aby użyć debuggera kompilator musi dołączyć dodatkowe informacje do skompilowanego programu. Przykładowymi debuggerami są: gdb pod Linuksem, lub debugger wchodzący w skład MS Visual Studio.

Zamiast osobnego kompilatora i edytora, możesz wybrać zintegrowane środowisko programistyczne (integrated development environment, IDE). Zawiera ono wszystkie potrzebne narzędzia w jednym: debuger, analizer kodu, podświetlanie składni i - najważniejsze - kompilator oraz linker. Jeśli pisalibyśmy tylko w zwykłym edytorze tekstowym, to:

1. Utrudnione jest wychwycenie błędów – wszystko wygląda jednostajnie. Pamiętajmy, że nawet drobna literówka składniowa może spowodować, że program po prostu się nie skompiluje. IDE zazwyczaj po nieudanej kompilacji pokazuje gdzie powstał błąd, który poprawiamy i ponownie kompilujemy
2. Edytor tekstu nie zawiera kompilatora (tak samo notepad++ i inne wzbogacone o podświetlanie składni), więc żeby uruchomić program będziemy musieli zaopatrzyć się w jakieś IDE
3. Pomimo dużej liczby opcji, IDE nadaje się zarówno dla początkujących jak i zaawansowanych programistów.

Wśród narzędzi które nie są niezbędne, ale zasługują na uwagę, można wymienić Valgrinda^[3] – specjalnego rodzaju debugger. Valgrind kontroluje wykonanie programu i wykrywa nieprawidłowe operacje w pamięci oraz wycieki pamięci. Użycie Valgrinda jest proste - kompilujemy program, jak do debugowania, następnie podajemy jako argument Valgrindowi.^[4] Istnieje wersja z gui dla Gnome : Alleyoop^[5]

Istnieją również specjalistyczne programy do analizy kodu, np.:^[6]

• Lint (obecnie już nie używane)
• Splint - rozszerzona wersja Linta^[7]
• Frama C^[8]

• formatter.org
• codebeautify

• c-reduce to narzędzie redukujące ilość kodu c,c++ lub OpenCl w przypadku raportowania błędów kompilacji

1. ↑ quora: Is-C-a-non-procedure-language-or-not
2. ↑ Co skrywa przed Tobą program „Hello World!”? Poznaj jego tajemnice. Dodane przez Robert Bałdyga 29 kwietnia, 2018 w kategorii Linux
3. ↑ Valgrind
4. ↑ Manual jak używać Valgrinda
5. ↑ alleyoop - okienkowa wersja Valgrinda
6. ↑ List of tools for static code analysis
7. ↑ splint - strona domowa
8. ↑ frama-c - is an extensible and collaborative platform dedicated to source-code analysis of C software. It is Open Source software. It works on Windows and Unix (Linux, Mac OS X,…)

Język C jest językiem kompilowanym, co oznacza, że potrzebuje specjalnego programu - kompilatora - który tłumaczy kod źródłowy, pisany przez człowieka, na język rozkazów danego komputera. W skrócie działanie kompilatora sprowadza się do czytania tekstowego pliku z kodem programu, raportowania ewentualnych błędów i produkowania pliku wynikowego.

Kompilator uruchamiamy:

• ze zintegrowanego środowiska programistycznego (ang. IDE)
• z konsoli (linii poleceń)
• online

Przejść do konsoli można dla systemów:

• typu UNIX w trybie graficznym użyć programów gnome-terminal, konsole albo xterm,
• Windows "Wiersz polecenia" (można go znaleźć w menu Akcesoria albo uruchomić wpisując w Start -> Uruchom... "cmd").

Lista kompilatorów

• w ang. wikipedii

Wikipedia, nasz siostrzany projekt, zawiera artykuł na temat GCC.

GCC (ang. GNU Compiler Collection)^[1] jest to darmowy zestaw kompilatorów, m.in. języka C (gcc) rozwijany w ramach projektu GNU. Dostępny jest on na dużą ilość platform sprzętowych, obsługiwanych przez takie systemy operacyjne jak: AIX, *BSD, Linux, Mac OS X, SunOS, Windows. Na niektórych systemach (np. Windows) nie jest on jednak dostępny automatycznie. Należy zainstalować odpowiednie narzędzia (poprzedni rozdział).

W bashu:

 export CC="gcc" CFLAGS="-O3 -Wall"

W csh:

setenv CC "gcc"

Możesz dodać to polecenie do pliku ~/.bashrc, aby ustawić to ustawienie na stałe.

gcc --version

Otrzymujemy (przykładowy wynik):

gcc (Ubuntu/Linaro 4.8.1-10ubuntu9) 4.8.1
Copyright (C) 2013 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

lub w c :^{[2] [3]}

#include <stdio.h>
#include <stdlib.h>
 
int main()
{
  printf("GCC_VERSION = %d.%d.%d \n", __GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__);
  return 0;
}

Przykładowy wynik :

 GCC_VERSION = 4.8.4

Z pomocą komendy:^[4]

echo "//" | gcc -xc++ -E -v -

przykładowy wynik :

 
Using built-in specs.
COLLECT_GCC=gcc
Target: x86_64-linux-gnu
Configured with: ../src/configure 
-v 
--with-pkgversion='Ubuntu 4.8.4-2ubuntu1~14.04' 
--with-bugurl=file:///usr/share/doc/gcc-4.8/README.Bugs 
--enable-languages=c,c++,java,go,d,fortran,objc,obj-c++ 
--prefix=/usr 
--program-suffix=-4.8 
--enable-shared 
--enable-linker-build-id 
--libexecdir=/usr/lib 
--without-included-gettext 
--enable-threads=posix 
--with-gxx-include-dir=/usr/include/c++/4.8 
--libdir=/usr/lib 
--enable-nls 
--with-sysroot=/ 
--enable-clocale=gnu 
--enable-libstdcxx-debug 
--enable-libstdcxx-time=yes 
--enable-gnu-unique-object 
--disable-libmudflap 
--enable-plugin 
--with-system-zlib 
--disable-browser-plugin 
--enable-java-awt=gtk 
--enable-gtk-cairo 
--with-java-home=/usr/lib/jvm/java-1.5.0-gcj-4.8-amd64/jre 
--enable-java-home 
--with-jvm-root-dir=/usr/lib/jvm/java-1.5.0-gcj-4.8-amd64 
--with-jvm-jar-dir=/usr/lib/jvm-exports/java-1.5.0-gcj-4.8-amd64 
--with-arch-directory=amd64 
--with-ecj-jar=/usr/share/java/eclipse-ecj.jar 
--enable-objc-gc 
--enable-multiarch 
--disable-werror 
--with-arch-32=i686 
--with-abi=m64 
--with-multilib-list=m32,m64,mx32 
--with-tune=generic 
--enable-checking=release 
--build=x86_64-linux-gnu 
--host=x86_64-linux-gnu 
--target=x86_64-linux-gnu
Thread model: posix
gcc version 4.8.4 (Ubuntu 4.8.4-2ubuntu1~14.04) 
COLLECT_GCC_OPTIONS='-E' '-v' '-mtune=generic' '-march=x86-64'
 /usr/lib/gcc/x86_64-linux-gnu/4.8/cc1plus 
 -E 
 -quiet 
 -v 
 -imultiarch x86_64-linux-gnu 
 -D_GNU_SOURCE - 
 -mtune=generic 
 -march=x86-64 
 -fstack-protector 
 -Wformat 
 -Wformat-security
ignoring duplicate directory "/usr/include/x86_64-linux-gnu/c++/4.8"
ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu"
ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/4.8/../../../../x86_64-linux-gnu/include"
#include "..." search starts here:
#include <...> search starts here:
 /usr/include/c++/4.8
 /usr/include/x86_64-linux-gnu/c++/4.8
 /usr/include/c++/4.8/backward
 /usr/lib/gcc/x86_64-linux-gnu/4.8/include
 /usr/local/include
 /usr/lib/gcc/x86_64-linux-gnu/4.8/include-fixed
 /usr/include/x86_64-linux-gnu
 /usr/include
End of search list.
# 1 "<stdin>"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 1 "<command-line>" 2
# 1 "<stdin>"
COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/4.8/:/usr/lib/gcc/x86_64-linux-gnu/4.8/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/4.8/:/usr/lib/gcc/x86_64-linux-gnu/
LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/4.8/:/usr/lib/gcc/x86_64-linux-gnu/4.8/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/4.8/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/4.8/../../../:/lib/:/usr/lib/
COLLECT_GCC_OPTIONS='-E' '-v' '-mtune=generic' '-march=x86-64'

Lista :

• COMPILER_PATH
• LIBRARY_PATH
• C_INCLUDE_PATH

Z użyciem tylko gcc ^[5]

 gcc -E -Wp,-v -xc /dev/null
 

 
ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu"
ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/11/include-fixed"
ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/11/../../../../x86_64-linux-gnu/include"
#include "..." search starts here:
#include <...> search starts here:
 /usr/lib/gcc/x86_64-linux-gnu/11/include
 /usr/local/include
 /usr/include/x86_64-linux-gnu
 /usr/include
End of search list.
# 0 "/dev/null"
# 0 "<built-in>"
# 0 "<command-line>"
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 0 "<command-line>" 2
# 1 "/dev/null"

Lista symboli compilatora :^[6]

gcc -dM -E - < /dev/null

Za pomocą komendy file sprawdzamy plik wynikowy:

file a.out

Przykładowy wynik:

a.out: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.24, BuildID[sha1]=0x4f7368b40e4eeee54307e8491e0f2ace1405d841, not stripped

Możemy również użyć komendy: readlf^[7]

Za pomocą komendy ldd sprawdzamy jakich bibliotek używa plik wynikowy:

ldd a.out

przykładowy wynik:

	linux-vdso.so.1 =>  (0x00007fff4ad68000)
	libm.so.6 => /lib/x86_64-linux-gnu/libm.so.6 (0x00007fc5c7758000)
	libgomp.so.1 => /usr/lib/x86_64-linux-gnu/libgomp.so.1 (0x00007fc5c7549000)
	libpthread.so.0 => /lib/x86_64-linux-gnu/libpthread.so.0 (0x00007fc5c732b000)
	libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007fc5c6f63000)
	/lib64/ld-linux-x86-64.so.2 (0x00007fc5c7a7f000)

• -L ( od ang Library) - pokazuje katalog gdzie są pliki binarne biblioteki
• -E - powoduje wygenerowanie kodu programu ze zmianami, wprowadzonymi przez preprocesor
• -S - zamiana kodu w języku C na kod asemblera (komenda: gcc -S plik.c spowoduje utworzenie pliku o nazwie plik.s, w którym znajdzie się kod asemblera)
• -c - kompilacja bez łączenia z bibliotekami
• -Ikatalog - ustawienie domyślnego katalogu z plikami nagłówkowymi na katalog, (duża litera i, od ang. Include)
• -lbiblioteka - (mała litera l) : wymusza łączenie programu z podaną biblioteką = dołącza skompilowaną bibliotekę (np. -lGL)
• -M = opcja preprocesora powodująca wypisanie ( dodanie do pliku Makefile) wymaganych opcji kompilacji. Jest używnaie przez gccmakedep program

Typowe zestawy flag

• -Wall -Wextra -march=native -std=c99

Opcje sterujące dialektem C^[8]

• std
• pedantic
• ansi

Domyślny standard języka zależy od wersji kompilatora^[9]

Mikroarchitektura procesora ( march )

Sprawdzamy za pomocą cat lub gcc : ^[10]

  gcc -c -Q -march=native --help=target

przykładowy wynik :

The following options are target specific:
  -m128bit-long-double        		[disabled]
  -m16                        		[disabled]
  -m32                        		[disabled]
  -m3dnow                     		[disabled]
  -m3dnowa                    		[disabled]
  -m64                        		[enabled]
  -m80387                     		[enabled]
  -m8bit-idiv                 		[disabled]
  -m96bit-long-double         		[enabled]
  -mabi=                      		sysv
  -mabm                       		[enabled]
  -maccumulate-outgoing-args  		[disabled]
  -maddress-mode=             		short
  -madx                       		[disabled]
  -maes                       		[enabled]
  -malign-data=               		compat
  -malign-double              		[disabled]
  -malign-functions=          		0
  -malign-jumps=              		0
  -malign-loops=              		0
  -malign-stringops           		[enabled]
  -mandroid                   		[disabled]
  -march=                     		haswell
  -masm=                      		att
  -mavx                       		[enabled]
  -mavx2                      		[enabled]
  -mavx256-split-unaligned-load 	[disabled]
  -mavx256-split-unaligned-store 	[disabled]
  -mavx512bw                  		[disabled]
  -mavx512cd                  		[disabled]
  -mavx512dq                  		[disabled]
  -mavx512er                  		[disabled]
  -mavx512f                   		[disabled]
  -mavx512ifma                		[disabled]
  -mavx512pf                  		[disabled]
  -mavx512vbmi                		[disabled]
  -mavx512vl                  		[disabled]
  -mbionic                    		[disabled]
  -mbmi                       		[enabled]
  -mbmi2                      		[enabled]
  -mbranch-cost=              		0
  -mcld                       		[disabled]
  -mclflushopt                		[disabled]
  -mclwb                      		[disabled]
  -mcmodel=                   		32
  -mcpu=                      		
  -mcrc32                     		[disabled]
  -mcx16                      		[enabled]
  -mdispatch-scheduler        		[disabled]
  -mdump-tune-features        		[disabled]
  -mf16c                      		[enabled]
  -mfancy-math-387            		[enabled]
  -mfentry                    		[enabled]
  -mfma                       		[enabled]
  -mfma4                      		[disabled]
  -mforce-drap                		[disabled]
  -mfp-ret-in-387             		[enabled]
  -mfpmath=                   		387
  -mfsgsbase                  		[enabled]
  -mfused-madd                		
  -mfxsr                      		[enabled]
  -mglibc                     		[enabled]
  -mhard-float                		[enabled]
  -mhle                       		[disabled]
  -mieee-fp                   		[enabled]
  -mincoming-stack-boundary=  		0
  -minline-all-stringops      		[disabled]
  -minline-stringops-dynamically 	[disabled]
  -mintel-syntax              		
  -mlarge-data-threshold=     		0x10000
  -mlong-double-128           		[disabled]
  -mlong-double-64            		[disabled]
  -mlong-double-80            		[enabled]
  -mlwp                       		[disabled]
  -mlzcnt                     		[enabled]
  -mmemcpy-strategy=          		
  -mmemset-strategy=          		
  -mmmx                       		[enabled]
  -mmovbe                     		[enabled]
  -mmpx                       		[disabled]
  -mms-bitfields              		[disabled]
  -mmwaitx                    		[disabled]
  -mno-align-stringops        		[disabled]
  -mno-default                		[disabled]
  -mno-fancy-math-387         		[disabled]
  -mno-push-args              		[disabled]
  -mno-red-zone               		[disabled]
  -mno-sse4                   		[disabled]
  -mnop-mcount                		[disabled]
  -momit-leaf-frame-pointer   		[disabled]
  -mpc32                      		[disabled]
  -mpc64                      		[disabled]
  -mpc80                      		[disabled]
  -mpclmul                    		[enabled]
  -mpcommit                   		[disabled]
  -mpopcnt                    		[enabled]
  -mprefer-avx128             		[disabled]
  -mpreferred-stack-boundary= 		0
  -mprefetchwt1               		[disabled]
  -mprfchw                    		[disabled]
  -mpush-args                 		[enabled]
  -mrdrnd                     		[enabled]
  -mrdseed                    		[disabled]
  -mrecip                     		[disabled]
  -mrecip=                    		
  -mrecord-mcount             		[disabled]
  -mred-zone                  		[enabled]
  -mregparm=                  		0
  -mrtd                       		[disabled]
  -mrtm                       		[disabled]
  -msahf                      		[enabled]
  -msha                       		[disabled]
  -mskip-rax-setup            		[disabled]
  -msoft-float                		[disabled]
  -msse                       		[enabled]
  -msse2                      		[enabled]
  -msse2avx                   		[disabled]
  -msse3                      		[enabled]
  -msse4                      		[enabled]
  -msse4.1                    		[enabled]
  -msse4.2                    		[enabled]
  -msse4a                     		[disabled]
  -msse5                      		
  -msseregparm                		[disabled]
  -mssse3                     		[enabled]
  -mstack-arg-probe           		[disabled]
  -mstack-protector-guard=    		tls
  -mstackrealign              		[enabled]
  -mstringop-strategy=        		[default]
  -mtbm                       		[disabled]
  -mtls-dialect=              		gnu
  -mtls-direct-seg-refs       		[enabled]
  -mtune-ctrl=                		
  -mtune=                     		haswell
  -muclibc                    		[disabled]
  -mveclibabi=                		[default]
  -mvect8-ret-in-mem          		[disabled]
  -mvzeroupper                		[disabled]
  -mx32                       		[disabled]
  -mxop                       		[disabled]
  -mxsave                     		[enabled]
  -mxsavec                    		[disabled]
  -mxsaveopt                  		[enabled]
  -mxsaves                    		[disabled]

  Known assembler dialects (for use with the -masm-dialect= option):
    att intel

  Known ABIs (for use with the -mabi= option):
    ms sysv

  Known code models (for use with the -mcmodel= option):
    32 kernel large medium small

  Valid arguments to -mfpmath=:
    387 387+sse 387,sse both sse sse+387 sse,387

  Known data alignment choices (for use with the -malign-data= option):
    abi cacheline compat

  Known vectorization library ABIs (for use with the -mveclibabi= option):
    acml svml

  Known address mode (for use with the -maddress-mode= option):
    long short

  Known stack protector guard (for use with the -mstack-protector-guard= option):
    global tls

  Valid arguments to -mstringop-strategy=:
    byte_loop libcall loop rep_4byte rep_8byte rep_byte unrolled_loop
    vector_loop

  Known TLS dialects (for use with the -mtls-dialect= option):
    gnu gnu2

Używamy :

 -march=native

lub tutaj

 -march=haswell

Plik :^[11]

int main() {


  int a = 0;


  while (a < 100) {
    a++;
  }


  a = 0;
  do {
    a++;
  }while(a < 100);


  for ( a=0; a < 100; ++a){ 
    a++;}


  return 0;
}

Skompilujemy :

 gcc -S l.c -Wall

Oprócz pliku a.out otrzymamy dodatkowy plik z rozszerzeniem "s":

a.out  l.c  l.s

który zawiera kodem assemblera :

	.file	"l.c"
	.text
	.globl	main
	.type	main, @function
main:
.LFB0:
	.cfi_startproc
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register 6
	movl	$0, -4(%rbp)
	jmp	.L2
.L3:
	addl	$1, -4(%rbp)
.L2:
	cmpl	$99, -4(%rbp)
	jle	.L3
	movl	$0, -4(%rbp)
.L4:
	addl	$1, -4(%rbp)
	cmpl	$99, -4(%rbp)
	jle	.L4
	movl	$0, %eax
	popq	%rbp
	.cfi_def_cfa 7, 8
	ret
	.cfi_endproc
.LFE0:
	.size	main, .-main
	.ident	"GCC: (Ubuntu 5.4.1-2ubuntu1~16.04) 5.4.1 20160904"
	.section	.note.GNU-stack,"",@progbits

Użycie flagi v powoduje wydrukowanie na standardowym wyjściu błędu (ang. standard error output) komend uruchamianych w trakcie kompilacji oraz wersji programu kompilatora ^[12]

gcc -v

przykładowy wynik:

 Using built-in specs.
 COLLECT_GCC=gcc
 COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/4.8/lto-wrapper
 Target: x86_64-linux-gnu
 Configured with: ../src/configure -v --with-pkgversion='Ubuntu/Linaro 4.8.1-10ubuntu9' --with-bugurl=file:///usr/share/doc/gcc-4.8/README.Bugs --enable-languages=c,c++,java,go,d,fortran,objc,obj-c++ --prefix=/usr --program-suffix=-4.8 --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --with-gxx-include-dir=/usr/include/c++/4.8 --libdir=/usr/lib --enable-nls --with-sysroot=/ --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --enable-gnu-unique-object --enable-plugin --with-system-zlib --disable-browser-plugin --enable-java-awt=gtk --enable-gtk-cairo --with-java-home=/usr/lib/jvm/java-1.5.0-gcj-4.8-amd64/jre --enable-java-home --with-jvm-root-dir=/usr/lib/jvm/java-1.5.0-gcj-4.8-amd64 --with-jvm-jar-dir=/usr/lib/jvm-exports/java-1.5.0-gcj-4.8-amd64 --with-arch-directory=amd64 --with-ecj-jar=/usr/share/java/eclipse-ecj.jar --enable-objc-gc --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --with-tune=generic --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu
Thread model: posix
gcc version 4.8.1 (Ubuntu/Linaro 4.8.1-10ubuntu9)

Od wersji 4.8 kompilatory C i C++ z GNU Compiler Collection są wyposażone we wbudowane wykrywacze błędów pamięci i wątków ( ang. Address and Thread Sanitizers) ^[13][14]

Rodzaje nieprawidłowych dostępów do pamięci, które można dziś wykryć, to:

• Dostęp poza zakresem dla obiektów lokalnych, globalnych i sterty
• Dostępy typu „use-after-free” dla obiektów sterty

Opcje instrumentacji programu ( ang. Program Instrumentation Options ) ^[15]

• -fsanitize=style -fsanitize-recover -fsanitize-recover=style
• -fasan-shadow-offset=number -fsanitize-sections=s1,s2,...
• -fsanitize-undefined-trap-on-error -fbounds-check

Offline :

man gcc

lub w postaci pliku tekstowego:^[16]

man gcc | col -b > gcc.txt

lub info:

info gcc

Online :

• Strona domowa projektu GNU GCC
  
• Strona podręcznika systemu UNIX (man)
• stackoverflow questions tagged gcc

Program gccmakedep tworzy zależności w plikach makefile za pomocą

gcc -M

gccmakedep

Aby skompilować kod języka C za pomocą kompilatora G++, napisany wcześniej w dowolnym edytorze tekstu, należy uruchomić program z odpowiednimi parametrami. Podstawowym parametrem, który jest wymagany, jest nazwa pliku zawierającego kod programu który chcemy skompilować.

gcc kod.c

Rezultatem kompilacji będzie plik wykonywalny, z domyślną nazwą (w systemach Unix jest to "a.out").

Jest to metoda niezalecana, ponieważ w przypadku, gdy skompilujemy w jednym katalogu kilka plików z kodem, kolejne pliki wykonywalne zostaną nadpisane i w rezultacie otrzymamy tylko jeden (ostatni) skompilowany kod. Aby wymusić na G++ nazwę pliku wykonywalnego musimy skorzystać z parametru "-o <nazwa>":

gcc -o program kod.c

W rezultacie otrzymujemy plik wykonywalny o nazwie program.

Pracując nad złożonym programem składającym się z kilku plików źródłowych (.c), możemy skompilować je niezależnie od siebie, tworząc tak zwane pliki typu obiekt, z rozszerzeniem .o (ang. Object File). Następnie możemy stworzyć z nich jednolity program w procesie konsolidacji (linkowaniu). Jest to bardzo wygodne i praktyczne rozwiązanie ze względu na to, iż nie jesteśmy zmuszeni kompilować wszystkich plików tworzących program za każdym razem na nowo, a jedynie te, w których wprowadziliśmy zmiany Aby skompilować plik bez linkowania używamy parametru "-c <plik>":

gcc -o program1.o -c kod1.c
gcc -o program2.o -c kod2.c

Otrzymujemy w ten sposób pliki typu obiekt program1.o i program2.o. A następnie tworzymy z nich program główny:

gcc -o program program1.o program2.o

Możemy użyć również flag, m.in. aby włączyć dokładne, rygorystyczne sprawdzanie napisanego kodu (co może być przydatne, jeśli chcemy dążyć do perfekcji), używamy przełączników:

gcc kod.c -o program -Werror -Wall -W -pedantic -ansi

Zobacz podręcznik Borland C++ Compiler.

Jedną z najbardziej podstawowych umiejętności, które musi posiąść początkujący programista jest umiejętność rozumienia komunikatów o różnego rodzaju błędach, które sygnalizuje kompilator. Wszystkie te informacje pomogą Ci szybko wychwycić ewentualne błędy (których na początku zawsze jest bardzo dużo). Nie martw się, że na początku dość często będziesz oglądał wydruki błędów, zasygnalizowanych przez kompilator - nawet zaawansowanym programistom się to zdarza. Kompilator ma za zadanie pomóc Ci w szybkiej poprawie ewentualnych błędów, dlatego też umiejętność analizy komunikatów o błędach jest tak ważna.

Zaczynamy analizę od pierwszego komunikatu kompilatora. Poprawiamy błąd i ponownie kompilujemy (może wtedy znikną pozostałe błędy).

Język komunikatów zależy od zmiennych środowiska, np.:^[17]

• LANG
• LC_CTYPE
• LC_MESSAGES
• LC_ALL

echo $LANG
pl_PL.UTF-8

Kompilator jest w stanie wychwycić błędy składniowe, które z pewnością będziesz popełniał. Kompilator GCC wyświetla je w następującej formie:

 nazwa_pliku.c:numer_linijki:opis błędu

Kompilator dość często podaje także nazwę funkcji, w której wystąpił błąd.

Przykładowo, błąd deklaracji zmiennej w pliku test.c:

#include <stdio.h>

int main ()
{
 intr r;
 printf ("%d\n", r);
}

Spowoduje wygenerowanie następującego komunikatu o błędzie:

test.c: In function ‘main’:
test.c:5: error: ‘intr’ undeclared (first use in this function)
test.c:5: error: (Each undeclared identifier is reported only once
test.c:5: error: for each function it appears in.)
test.c:5: error: syntax error before ‘r’
test.c:6: error: ‘r’ undeclared (first use in this function)

Co widzimy w raporcie o błędach?

W linii 5 użyliśmy nieznanego (undeclared) identyfikatora intr - kompilator mówi, że nie zna tego identyfikatora, jest to pierwsze użycie w danej funkcji i że więcej nie ostrzeże o użyciu tego identyfikatora w tej funkcji. Ponieważ intr nie został rozpoznany jako żaden znany typ, linijka intr r; nie została rozpoznana jako deklaracja zmiennej i kompilator zgłasza błąd składniowy (syntax error). W konsekwencji r nie zostało rozpoznane jako zmienna i kompilator zgłosi to jeszcze w następnej linijce, gdzie używamy r.

error: initializer element is not constant

Ten błąd powstaje gdy:

• za pomocą jednej instrukcji deklarujemy i inicjujemy zmienną
• do nadania wartości używamy wyrażenia a nie za stałej wartości (liczba)

Rozwiązaniem jest rozdzielenie deklaracji i inicjalizacji na 2 instrukcje.

Ostrzeżenie: niejawna deklaracja funkcji, np.:

t.c:696:17: warning: implicit declaration of function ‘dDrawLine’

powstanie gdy:

• nie dołączymy odpowiedniej biblioteki zawierającej deklarację funkcji,
• deklaracja własnej funkcji będzie zawarta w programie ale nie zostanie rozpoznana z powodu błędów składniowych

Inny błąd :

membership_new.c:63:9: error: expected ‘,’ or ‘;’ before ‘int’

przyczyna: w linii poprzedzającej linię 63 brak na końcu średnika (;) lub przecinka (,)

Przykładowy komunikat:

/usr/bin/ld: cannot find -lXmu

Problem jest związany z opcją oznaczoną literą l linkera (ld):^[18]

-llibrary

Linker nie może znaleźć biblioteki liblibrary, czyli w tym przypadku libXmu.

Sprawdzamy czy mamy taką biblioteką zainstalowaną, jeśli nie to szukamy pakietu libXmu np. w menadżerze pakietów Synaptic (w Ubuntu libXmu-dev) i instalujemy go.

Nowy błąd ( pojawił się po zainstalowanie clang)

/usr/bin/ld: cannot find -lstdc++: No such file or directory

Oznacza że link symboliczny ( ang. symbolic link) libstdc++.so wskazuje na nieistniejacy plik^[19]

cd /usr/lib; ls

Możliwości

• nie ma pliku libstdc++.so w katalogu /usr/lib/
• są 2 pliki libstdc++.so

sudo apt-get update && sudo apt-get upgrade

Znajdujemy plik biblioteki libstdc++.so.6

sudo find / -name libstdc++.so.6

i tworzymy plik:

sudo ln -s /usr/lib/x86_64-linux-gnu/libstdc++.so.6 /usr/lib/libstdc++.so

Komunikat "undefined references" pochodzi głównie z linkera.

Przykładowy komunikat dotyczący biblioteki matematycznej: ^[20]

undefined reference to 'pow' collect2: error: ld returned 1 exit status

Może być spowodowany kolejnością linkowania bibliotek, np w pliku MAKFILE, dobra kolejność:

LIBS =  -lcairo -lmpfr -lm 

zła:

LIBS =  -lm -lcairo -lmpfr

Komunikat :

  undefined reference to symbol 'pow@@GLIBC_2.2.5'

• przyczyna: ( użycie funkcji pow z biblioteki math
• rozwiązanie : dodać -lm do opcji kompilacji

r1.c:194:3: error: stray ‘\342’ in program
r1.c:194:3: error: stray ‘\210’ in program
r1.c:194:3: error: stray ‘\222’ in program

Błąd ten jest spowodowany występowaniem w kodzie innych znaków niż ASCI^[21]. Prawdopodobnie skopiowano znaki z innego programu, np.:

• pliku pdf
• pliku/programu Microsoft Word
• kalkulatora gcalctool

Rozwiązanie:

• usuń skopiowany tekst
• wpisz go ręcznie

• You have a buffer overflow! ^[22]

Nie. Zamiast tego umieszczasz w źródle kod specyficzny dla kompilatora/platformy/systemu operacyjnego i otaczasz go odpowiednimi instrukcjami ifdef.

  
#ifdef __GNUC__
/*code for GNU C compiler */
#elif _MSC_VER
/*usually has the version number in _MSC_VER*/
/*code specific to MSVC compiler*/
#elif __BORLANDC__
/*code specific to borland compilers*/
#elif __MINGW32__
/*code specific to mingw compilers*/
#endif

GCC ma tę funkcję w wersji 4.3, jeśli zostanie o to poproszony podczas kompilacji kodu: Nowy przełącznik wiersza poleceń

-frecord-gcc-switches 

powoduje, że wiersz poleceń użyty do wywołania kompilatora zostanie zapisany w pliku obiektowym to się tworzy. Dokładny format tego nagrania zależy od formatu docelowego i pliku binarnego, ale zwykle ma formę sekcji notatki zawierającej tekst ASCII.

• C/Więcej o kompilowaniu: make/Makefile
• Kompilacja w systemie Linux
• Compiler explorer by Matt Godbolt
• pkg-config search path
• GNU C Compiler Internals w angielskiej wersji wikibooks

1. ↑ GCC (ang. GNU Compiler Collection)
2. ↑ nadeausoftware : C/C++ tip: How to detect the compiler name and version using compiler predefined macros
3. ↑ gcc.gnu.org onlinedocs : Common-Predefined-Macros.html
4. ↑ CONTROLLING #INCLUDE IN C++ by BRIAN FITZGERALD
5. ↑ stackoverflow question: what-are-the-gcc-default-include-directories
6. ↑ Commands using gcc
7. ↑ Dive into ELF files using readelf command by Himanshu Arora
8. ↑ gcc gnu ver. 13.2.0: C-Dialect-Options
9. ↑ stackoverflow question: what-is-the-default-c-std-standard-version-for-the-current-gcc-especially-on-u
10. ↑ gentoo wiki : GCC optimization march
11. ↑ stackoverflow question : which-loop-is-faster-in-c-while-loop-or-do-while-loop
12. ↑ Opcje gcc
13. ↑ developers redhat blog: address-and-thread-sanitizers-gcc
14. ↑ gavinchou : gcc-address-sanitizer
15. ↑ gnu online docs : gcc-11.3.0 Instrumentation-Options
16. ↑ GCC and Make by Chua Hock-Chuan
17. ↑ 3.19 Environment Variables Affecting GCC
18. ↑ Dokumentacja Gcc: 3.13 Options for Linking
19. ↑ stackoverflow question: usr-bin-ld-cannot-find-lstdc-for-ubuntu-while-trying-to-swift-build-perfe
20. ↑ [ http://stackoverflow.com/questions/12824134/undefined-reference-to-pow-in-c-despite-including-math-h Undefined reference to pow( ) in C, despite including math.h ]
21. ↑ gcc: error: stray ‘\342’ in program - www.giannistsakiris.com
22. ↑ quora : What-does-stack-smashing-detected-terminated-mean-How-can-we-correct-it?

Jak napisać pierwszy program ?

Pierwszy, minimalny program, który daje się skompilować i uruchomić:

Tworzymy katalog na nasz projekt. W katalogu tworzymy plik z rozszerzeniem ".c". W konsoli systemu Linux można to zrealizować następująco:

touch program_test_1.c

Następnie przechodzimy do edycji pliku przy pomocy edytora tekstowego ("programistycznego"). Można to wykonać np. edytorem Notepad++ (Windows) lub mcedit, vim, (Linux)

Wpisujemy do pliku treść programu

void main(){}

Należy zaznaczyć, że jest to postać skrajnie "skoncentrowana".

Kompilujemy program. W systemie Linux popularny jest kompilator gcc.

gcc program_test_1.c

Kompilator powinien utworzyć plik wykonywalny o domyślnej nazwie "a.out".

Uruchamiamy program. W konsoli systemu Linux piszemy:

./a.out

Co prawda program nic nie robi, ale możemy go traktować jako szkielet do dalszych prób.

W kompilatorze gcc możemy zmienić nazwę wydawanego programy przy pomocy flagi -o. Przykładowo w konsoli systemu Linux:

gcc program_test_1.c -o test_1.run

Możemy zrobić kod bardziej czytelnym

/*
* Każdy program języka C musi zawierać podprogram (funkcję) o nazwie "main". 
* Jest to pierwszy wykonywany fragment algorytmu
*/

/*
* funkcja "main" nie wydaje żadnych wartości, zatem jest typu "void"
* funkcja "main" nie pobiera żadnych parametrów, zatem ma "puste" nawiasy main()
*/
void
main()
{/* początek bloku funkcji "main" */

    /* miejsce na deklaracje zmiennych */
    /* brak */

    /* miejsce na instrukcje */
    /* brak */

}/* koniec bloku funkcji "main" */

/*

https://www.quora.com/How-can-I-print-%E2%80%9Cwelcome%E2%80%9D-without-using-in-C
Steve Baker

*/ 

/*
* Marcin Kulbaka 2021
*/

/*
* Deklaracja funkcji "puts". 
* Funkcja służy do wypisywania danych na ekranie.
* Została ona już napisana i wchodzi w skład standardowej biblioteki C.
* Deklaracja podaje jednie nagłówek tej funkcji.
* Mówi, że przy "typowej" kompilacji będziemy korzystać z
* funkcji "puts" zawartej w jakiejś bibliotece (domyślnie - standardowej bibliotece C)
*/
int puts(const char *s);
 

/*
* Funkcja główna "main". Tutaj
*/

int 
main ()
{/* main */

    /*** miejsce na zmienne ***/
    /* brak */

    /*** miejsce na instrukcje ***/

    /* wypisz na ekranie napis przy pomocy funkcji "puts" */
    puts ( "Hello world " ) ;

    /* zakończ funkcję zwracając wartość 0 (domyślnie oznacza to poprawne wykonanie zadania) */
    return 0;

}/* main */

Przyjęło się, że pierwszy program napisany w dowolnym języku programowania powinien wyświetlić tekst "Hello World!" (Witaj Świecie!). Sam język C nie ma żadnych mechanizmów przeznaczonych do wprowadzania i wypisywania danych, możemy jednak skorzystać z dostępnych rozwiązań - w tym przypadku gotowej funkcji puts, która umieszcza podany tekst na "strumieniu wyjściowym programu", co da nam efekt wyświetlenia napisu na ekranie (podobnie jak w Pascalu używa się do tego procedur. Pascalowskim odpowiednikiem funkcji puts jest writeln).

Funkcja ta jest zawarta w zbiorze wielu gotowych funkcji zwanym standardową biblioteką C (ang. C Standard Library). W języku C deklaracje funkcji zawarte są w plikach nagłówkowych^[1]. Taki plik dołączymy do naszego programu przy pomocy dyrektywy #include ^[2]. Interesuje nas plik stdio.h, zawierający niezbędny dla kompilatora opis funkcji puts, który dołączyć do programu możemy w poniższy sposób:

#include <stdio.h>

W programie definiujemy główną funkcję main, będzie to punkt startu dla naszego programu. Definicja funkcji zawiera jej nazwę, listę przyjmowanych argumentów, typ zwracanej wartości (wyniku) oraz kod funkcji.

int main (void) 
{
   return 0;
}

Nasza funkcja main zawiera tylko jedno polecenie do wykonania: zakończ funkcję z wynikiem 0. Liczba ta będzie zwrócona do systemu operacyjnego jako wynik działania programu. W pierwszej linijce oprócz nazwy funkcji zawarliśmy także informację o typie zwracanej wartości: int (integer), czyli liczba całkowita, a w nawiasach o nie przyjmowaniu żadnych parametrów (słowo void (pustka) w liście argumentów).

Kod funkcji umieszcza się w nawiasach klamrowych { i }, kolejne polecenia rozdzielone są średnikami.

Ostatecznie kod będzie wyglądał jak poniżej:

#include <stdio.h>
int main (void)
{
   puts ("Hello World!");
   return 0;
}

Napisy umieszcza się wewnątrz pary cudzysłowów. Teraz wystarczy program skompilować i uruchomić.

• kompilacja podstawowa i zaawansowana
• błędy kompilacji

Dotychczas zobaczyliśmy najprostszą kompilację:

gcc plik_z_kodem_programu.c

Przy poprawnej kompilacji (Braku błędów) jest plik wykonywalny "a.out".

Opcja "-o" pozwala zmienić nazwę pliku wyjściowego.

Warto też używać opcji sygnalizujących możliwe błędy, pomimo zgodności z zasadami składni. Typową flagą jest "-Wall". Pozwala ona poznać więcej wątpliwości kompilatora co do naszego programu.

gcc -Wall program_1.c -o program_1.run

Wątpliwości dotyczące kompilacji można poznać nieraz przez poszukiwanie odpowiedzi w Internecie. Przykładem forum z masą pytań jest / było forum Stackoverflow i wyszukiwarki internetowe. Można znaleźć pytania dotyczące typowych problemów z kompilacją.

Nie ukrywam, że język C nie należy do najprostszych i znaczne przerabianie programu prowadzi np. do obecności niewykorzystywanych zmiennych. Stąd ważne jest precyzyjne zdefiniowanie celu kodowania. Jeżeli dobrze wiemy, co mamy zakodować, wówczas praca z językiem C może się zmienić zasadniczo. Problem z praktycznym realizowaniem języka C w swoich projektach jest generalnie znany w świecie.

Jeśli nie nadaliśmy innej nazwy przy kompilacji to standardowe wpisujemy w konsoli:

./a.out

Jeśli nie możesz skompilować powyższego programu, mogłeś popełnić literówkę przy przepisywaniu go. Więcej informacji o kompilacji tutaj.

Jeśli udało Ci się pomyślnie skompilować i uruchomić program, jest możliwe, że jedyne co zaobserwowałeś to mignięcie okienka konsoli. Dzieje się tak, ponieważ nasz program wraz z wykonaniem swojego zadania (wypisanie komunikatu) kończy działanie, nie czekając na reakcję użytkownika. Problem nie występuje, jeśli uruchomimy aplikację z poziomu linii poleceń (np. w oknie konsoli).

Dodajmy do naszego programu polecenie wczytania pojedynczego znaku z wejścia (w zwykłym przypadku oznacza to oczekiwanie, aż użytkownik wciśnie jakiś klawisz na klawiaturze) - zadanie to wykona funkcja getch.

#include <stdio.h>
int main (void)
{
   puts ("Hello World!");
   getch();
   return 0;
}

Tym razem program nie może zakończyć działania, póki nie wczyta znaku - dopiero po naciśnięciu dowolnego klawisza zamknie się okno konsoli (w przypadku zwykłego uruchomienia programu). Nasz pierwszy program gotowy!

• pierwszy program C w podręczniku Programowanie w systemie UNIX

Dla właściwego zrozumienia języka C nieodzowne jest przyswojenie sobie pewnych ogólnych informacji.

Jak każdy język programowania, C sam w sobie jest niezrozumiały dla procesora. Został on stworzony w celu umożliwienia ludziom łatwego pisania kodu, który może zostać przetworzony na kod maszynowy. Program, który zamienia kod C na wykonywalny kod binarny, to kompilator. Jeśli pracujesz nad projektem, który wymaga kilku plików kodu źródłowego (np. pliki nagłówkowe), wtedy jest uruchamiany kolejny program - linker. Linker służy do połączenia różnych plików i stworzenia jednej aplikacji lub biblioteki (library). Biblioteka jest zestawem procedur, który sam w sobie nie jest wykonywalny, ale może być używana przez inne programy. Kompilacja i łączenie plików są ze sobą bardzo ściśle powiązane, stąd są przez wielu traktowane jako jeden proces. Jedną rzecz warto sobie uświadomić - kompilacja jest jednokierunkowa: przekształcenie kodu źródłowego C w kod maszynowy jest bardzo proste, natomiast odwrotnie - nie. Dekompilatory co prawda istnieją, ale rzadko tworzą użyteczny kod C.

Najpopularniejszym wolnym kompilatorem jest prawdopodobnie GNU Compiler Collection, dostępny na stronie gcc.gnu.org.

Pewnie zaskoczy Cię to, że tak naprawdę "czysty" język C nie może zbyt wiele. Język C w grupie języków programowania wysokiego poziomu jest stosunkowo nisko. Dzięki temu kod napisany w języku C można dość łatwo przetłumaczyć na kod asemblera. Bardzo łatwo jest też łączyć ze sobą kod napisany w języku asemblera z kodem napisanym w C. Dla bardzo wielu ludzi przeszkodą jest także dość duża liczba i częsta dwuznaczność operatorów. Początkujący programista, czytający kod programu w C może odnieść bardzo nieprzyjemne wrażenie, które można opisać cytatem "ja nigdy tego nie opanuję". Wszystkie te elementy języka C, które wydają Ci się dziwne i nielogiczne w miarę, jak będziesz nabierał doświadczenia nagle okażą się całkiem przemyślanie dobrane i takie, a nie inne konstrukcje przypadną Ci do gustu. Dalsza lektura tego podręcznika oraz zaznajamianie się z funkcjami z różnych bibliotek ukażą Ci całą gamę możliwości, które daje język C doświadczonemu programiście.

Teraz omówimy podstawową strukturę programu napisanego w C. Jeśli miałeś styczność z językiem Pascal, to pewnie słyszałeś o nim, że jest to język programowania strukturalny. W C nie ma tak ścisłej struktury blokowej, mimo to jest bardzo ważne zrozumienie, co oznacza struktura blokowa. Blok jest grupą instrukcji, połączonych w ten sposób, że są traktowane jak jedna całość. W C, blok zawiera się pomiędzy nawiasami klamrowymi { }. Blok może także zawierać kolejne bloki.

Zawartość bloku. Generalnie, blok zawiera ciąg kolejno wykonywanych poleceń. Polecenia zawsze (z nielicznymi wyjątkami) kończą się średnikiem (;). W jednej linii może znajdować się wiele poleceń, choć dla zwiększenia czytelności kodu najczęściej pisze się pojedynczą instrukcję w każdej linii. Jest kilka rodzajów poleceń, np. instrukcje przypisania, warunkowe czy pętli. W dużej części tego podręcznika będziemy zajmować się właśnie instrukcjami.

Pomiędzy poleceniami są również odstępy - spacje, tabulacje oraz przejścia do następnej linii, przy czym dla kompilatora te trzy rodzaje odstępów mają takie samo znaczenie. Dla przykładu, poniższe trzy fragmenty kodu źródłowego, dla kompilatora są takie same:

printf("Hello world"); return 0;

printf("Hello world");
return 0;

printf("Hello world");



return 0;

W tej regule istnieje jednak jeden wyjątek. Dotyczy on stałych tekstowych. W powyższych przykładach stałą tekstową jest "Hello world". Gdy jednak rozbijemy ten napis, kompilator zasygnalizuje błąd:

printf("Hello
world");
return 0;

Należy tylko zapamiętać, że stałe tekstowe powinny zaczynać się i kończyć w tej samej linii (można ominąć to ograniczenie - więcej w rozdziale Napisy). Oprócz tego jednego przypadku dla kompilatora ma znaczenie samo istnienie odstępu, a nie jego wielkość czy rodzaj. Jednak stosowanie odstępów jest bardzo ważne, dla zwiększenia czytelności kodu - dzięki czemu możemy zaoszczędzić sporo czasu i nerwów, ponieważ znalezienie błędu (które się zdarzają każdemu) w nieczytelnym kodzie może być bardzo trudne.

Pojęcie to dotyczy zmiennych (które przechowują dane przetwarzane przez program). W każdym programie (oprócz tych najprostszych) są zarówno zmienne wykorzystywane przez cały czas działania programu oraz takie, które są używane przez pojedynczy blok programu (np. funkcję). Na przykład, w pewnym programie w pewnym momencie jest wykonywane skomplikowane obliczenie, które wymaga zadeklarowania wielu zmiennych do przechowywania pośrednich wyników. Ale przez większą część tego działania te zmienne są niepotrzebne i zajmują tylko miejsce w pamięci - najlepiej gdyby to miejsce zostało zarezerwowane tuż przed wykonaniem wspomnianych obliczeń, a zaraz po ich wykonaniu zwolnione. Dlatego w C istnieją zmienne globalne oraz lokalne. Zmienne globalne mogą być używane w każdym miejscu programu, natomiast lokalne - tylko w określonym bloku czy funkcji (oraz blokach w nim zawartych). Generalnie - zmienna zadeklarowana w danym bloku jest dostępna tylko wewnątrz niego.

Funkcje są ściśle związane ze strukturą blokową - funkcją jest po prostu blok instrukcji, który jest potem wywoływany w programie za pomocą pojedynczego polecenia. Zazwyczaj funkcja wykonuje pewne określone zadanie, np. we wspomnianym programie wykonującym pewne skomplikowane obliczenie.

Każda funkcja ma swoją nazwę, za pomocą której jest potem wywoływana w programie, oraz blok wykonywanych poleceń. Wiele funkcji pobiera pewne dane, czyli argumenty funkcji, wiele funkcji także zwraca pewną wartość po zakończeniu wykonywania. Dobrym nawykiem jest dzielenie dużego programu na zestaw mniejszych funkcji - dzięki temu będziesz mógł łatwiej odnaleźć błąd w programie.

Jeśli chcesz użyć jakiejś funkcji, to powinieneś wiedzieć:

• jakie zadanie wykonuje dana funkcja,
• jaki jest rodzaj wczytywanych argumentów i do czego są one potrzebne tej funkcji,
• jaki jest rodzaj zwróconych danych i co one oznaczają.

W programach w języku C jedna funkcja ma szczególne znaczenie - jest to main(). Funkcję tę, zwaną funkcją główną, musi zawierać każdy program. W niej zawiera się główny kod programu i przekazywane są do niej argumenty, z którymi wywoływany jest program (jako parametry argc i argv). Więcej o funkcji main() dowiesz się później w rozdziale Funkcje.

Język C, w przeciwieństwie do innych języków programowania (np. Fortranu czy Pascala), nie posiada absolutnie żadnych słów kluczowych, które odpowiedzialne by były za obsługę wejścia i wyjścia. Może się to wydawać dziwne - język, który sam w sobie nie posiada podstawowych funkcji, musi być językiem o ograniczonym zastosowaniu. Jednak brak podstawowych funkcji wejścia-wyjścia jest jedną z największych zalet tego języka. Jego składnia opracowana jest tak, by można było bardzo łatwo przełożyć ją na kod maszynowy. To właśnie dzięki temu programy napisane w języku C są takie szybkie. Pozostaje jednak pytanie - jak umożliwić programom komunikację z użytkownikiem?

W 1983 roku, kiedy zapoczątkowano prace nad standaryzacją C, zdecydowano, że powinien być zestaw instrukcji identycznych w każdej implementacji C. Nazwano je Biblioteką Standardową (czasem nazywaną "libc"). Zawiera ona podstawowe funkcje, które umożliwiają wykonywanie takich zadań jak wczytywanie i zwracanie danych, modyfikowanie zmiennych łańcuchowych, działania matematyczne, operacje na plikach i wiele innych, jednak nie zawiera żadnych funkcji, które mogą być zależne od systemu operacyjnego czy sprzętu, jak grafika, dźwięk czy obsługa sieci. W programie "Hello World" użyto funkcji z biblioteki standardowej - puts, która wyświetla na ekranie sformatowany tekst.

Komentarze - to tekst włączony do kodu źródłowego, który jest pomijany przez kompilator i służy jedynie dokumentacji. W języku C, komentarze zaczynają się od

/*

a kończą

*/

Dobre komentowanie ma duże znaczenie dla rozwijania oprogramowania, nie tylko dlatego, że inni będą kiedyś potrzebowali przeczytać napisany przez ciebie kod źródłowy, ale także możesz chcieć po dłuższym czasie powrócić do swojego programu, i możesz zapomnieć, do czego służy dany blok kodu, albo dlaczego akurat użyłeś tego polecenia, a nie innego. W chwili pisania programu, to może być dla ciebie oczywiste, ale po dłuższym czasie możesz mieć problemy ze zrozumieniem własnego kodu. Jednak nie należy też wstawiać zbyt dużo komentarzy, ponieważ wtedy kod może stać się jeszcze mniej czytelny - najlepiej komentować fragmenty, które nie są oczywiste dla programisty oraz te o szczególnym znaczeniu. Ale tego nauczysz się już w praktyce.

Dobry styl pisania kodu jest o tyle ważny, że powinien on być czytelny i zrozumiały; po to w końcu wymyślono języki programowania wysokiego poziomu (w tym C), aby kod było łatwo zrozumieć ;). I tak - należy stosować wcięcia dla odróżnienia bloków kolejnego poziomu (zawartych w innym bloku; podrzędnych), nawiasy klamrowe otwierające i zamykające blok powinny mieć takie same wcięcia, staraj się, aby nazwy funkcji i zmiennych kojarzyły się z zadaniem, jakie dana funkcja czy zmienna pełni w programie. W dalszej części podręcznika możesz napotkać więcej zaleceń dotyczących stylu pisania kodu. Staraj się stosować do tych zaleceń - dzięki temu kod pisanych przez ciebie programów będzie łatwiejszy do czytania i zrozumienia.

Porada Jeśli masz doświadczenia z językiem C++, w C nie powinno się stosować komentarzy zaczynających się od dwóch znaków slash: //komentarz Jest to niezgodne ze standardem ANSI C i niektóre kompilatory mogą nie skompilować kodu z komentarzami w stylu C++ (choć standard ISO C99 dopuszcza komentarze w stylu C++). Jeśli już koniecznie musisz stosować komentarze C++ pamiętaj, że nie wszystkie kompilatory obsługują je.

Innym zastosowaniem komentarzy jest chwilowe usuwanie fragmentów kodu. Jeśli część programu źle działa i chcemy ją chwilowo wyłączyć, albo fragment kodu jest nam już niepotrzebny, ale mamy wątpliwości, czy w przyszłości nie będziemy chcieli go użyć - umieszczamy go po prostu wewnątrz komentarza.

Podczas obejmowania chwilowo niepotrzebnego kodu w komentarz trzeba uważać na jedną subtelność. Otóż komentarze /* * /' w języku C nie mogą być zagnieżdżone. Trzeba na to uważać, gdy chcemy objąć komentarzem obszar w którym już istnieje komentarz (należy wtedy usunąć wewnętrzny komentarz). W nowszym standardzie C dopuszcza się, aby komentarz typu /* */ zawierał w sobie komentarz // i żeby komentarz typu "//" mógł być stosowany.

Jak już wcześniej było wspomniane, zmiennym i funkcjom powinno się nadawać nazwy, które odpowiadają ich znaczeniu. Zdecydowanie łatwiej jest czytać kod, gdy średnią liczb przechowuje zmienna srednia niż a, a znajdowaniem maksimum w ciągu liczb zajmuje się funkcja max albo znajdz_max niż nazwana f. Często nazwy funkcji to właśnie czasowniki.

Powstaje pytanie, w jakim języku należy pisać nazwy. Jeśli chcemy, by nasz kod mogły czytać osoby nieznające polskiego - warto użyć języka angielskiego. Jeśli nie - można bez problemu użyć polskiego. Bardzo istotne jest jednak, by nie mieszać języków. Jeśli zdecydowaliśmy się używać polskiego, używajmy go od początku do końca; przeplatanie ze sobą dwóch języków robi złe wrażenie.

Warto również zdecydować się na sposób zapisywania nazw składających się z więcej niż jednego słowa. Istnieje kilka możliwości, najważniejsze z nich:

1. oddzielanie podkreśleniem: int_to_str
2. "konwencja pascalowska", każde słowo dużą literą: IntToStr
3. "konwencja wielbłądzia", pierwsze słowo małą, kolejne dużą literą: intToStr

Ponownie, najlepiej stosować konsekwentnie jedną z konwencji i nie mieszać ze sobą kilku.

Czasem programista może zapomnieć, jakiego typu była dana zmienna. Wtedy musi znaleźć odpowiednią deklarację (co nie zawsze jest łatwe). Dlatego więc wymyślono sposób, by temu zaradzić. Pomyślano, by w nazwie zmiennej (bądź wskaźnika na zmienną) napisać, jakiego jest ona typu, np:

• a_liczba (liczba typu int)
• w_ll_dlugaLiczba (wskaźnik na zmienną typu long long)
• t5x5_ch_tabliczka (tablica 5x5 elementów typu char)
• func_i_silnia (funkcja zwracająca int)

Jest to bardzo wygodne przy bardzo zagmatwanych zmiennych:

• w_t4_w_t2x2_s_pomieszaniec (wskaźnik na tablicę czterech wskaźników na tablice dwuwymiarowe zmiennych typu short)

Lub gdy nie pamiętamy wymiarów tablicy:

• t4x5x6_f_powalonaKostkaRubika (od razu wiemy, że t4x5x6_f_powalonaKostkaRubika[5][4][6] jest niewłaściwe)

Taki zapis ma też swoje wady. Gdy zdecydujemy się zmienić typ zmiennej, zamiast po prostu przemienić w deklaracji int na long, musimy zmieniać nazwy w całym programie. Często takie nazwy są po prostu długie i nie chce nam się ich pisać (no cóż, programista też człowiek), więc wolimy wprowadzić pomieszaniec zamiast w_t4_w_t2x2_s_pomieszaniec. Najważniejsze to jednak trzymać się rozwiązania, które wybraliśmy na początku, bo mieszanie jest przerażające.

Nie cały napisany przez ciebie kod będzie przekształcany przez kompilator bezpośrednio na kod wykonywalny programu. W wielu przypadkach będziesz używać poleceń "skierowanych do kompilatora", tzw. dyrektyw kompilacyjnych. Na początku procesu kompilacji, specjalny podprogram, tzw. preprocesor, wyszukuje wszystkie dyrektywy kompilacyjne i wykonuje odpowiednie akcje - które polegają notabene na edycji kodu źródłowego (np. wstawieniu deklaracji funkcji, zamianie jednego ciągu znaków na inny). Właściwy kompilator, zamieniający kod C na kod wykonywalny, nie napotka już dyrektyw kompilacyjnych, ponieważ zostały one przez preprocesor usunięte, po wykonaniu odpowiednich akcji.

W C dyrektywy kompilacyjne zaczynają się od znaku hash (#). Przykładem najczęściej używanej dyrektywy, jest #include, która jest użyta nawet w tak prostym programie jak "Hello, World!". #include nakazuje preprocesorowi włączyć (ang. include) w tym miejscu zawartość podanego pliku, tzw. pliku nagłówkowego; najczęściej to będzie plik zawierający funkcje z którejś biblioteki standardowej (stdio.h - STandard Input-Output, rozszerzenie .h oznacza plik nagłówkowy C). Dzięki temu, zamiast wklejać do kodu swojego programu deklaracje kilkunastu, a nawet kilkudziesięciu funkcji, wystarczy wpisać jedną magiczną linijkę!

Identyfikatory, czyli nazwy zmiennych, stałych i funkcji mogą składać się z liter (bez polskich znaków), cyfr i znaku podkreślenia z tym, że nazwa taka nie może zaczynać się od cyfry. Nie można używać nazw zarezerwowanych (patrz: Składnia).

Przykłady błędnych nazw:

 2liczba      (nie można zaczynać nazwy od cyfry)
 moja funkcja (nie można używać spacji)
 $i           (nie można używać znaku $)
 if           (if to słowo kluczowe)

Aby kod był bardziej czytelny, przestrzegajmy poniższych (umownych) reguł:

• nazwy zmiennych piszemy małymi literami: i, file
• nazwy stałych (zadeklarowanych przy pomocy #define) piszemy wielkimi literami: SIZE
• nazwy funkcji piszemy małymi literami: print
• wyrazy w nazwach oddzielamy jedną z konwencji:
  • oddzielanie podkreśleniem: open_file
  • konwencja pascalowska: OpenFile
  • konwencja wielbłądzia: openFile

Procesor komputera stworzony jest tak, aby przetwarzał dane, znajdujące się w pamięci komputera. Z punktu widzenia programu napisanego w języku C (który jak wiadomo jest językiem niskiego poziomu) dane umieszczane są w postaci tzw. zmiennych, stałych i literałów. Zmienne ułatwiają programiście pisanie programu. Dzięki nim programista nie musi się przejmować gdzie w pamięci owe zmienne się znajdują, tzn. nie operuje fizycznymi adresami pamięci, jak np. 0x14613467, tylko prostą do zapamiętania nazwą zmiennej.

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

Deklaracja, definicja zmiennej^[3]

Typ zmiennej^[4]

• określa strukturę zmiennej i danych które będziemy mogli w niej przechowywać

Typy wg złożoności

• proste (podstawowe)
• złożone

Aby móc skorzystać ze zmiennej należy ją przed użyciem zadeklarować, to znaczy poinformować kompilator, jak zmienna będzie się nazywać i jaki typ ma mieć. Zmienne deklaruje się w sposób następujący:

typ nazwa_zmiennej;

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

int wiek;

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

int wiek = 17;

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

{
   int wiek = 17;
   printf("%d\n", wiek);
   int kopia_wieku; /* tu stary kompilator C zgłosi błąd - deklaracja występuje po instrukcji (printf). */
   kopia_wieku = wiek;
}

Według nowszych standardów (C99) możliwe jest deklarowanie zmiennej w dowolnym miejscu programu (podobnie jak w języku C++), ale wtedy musimy pamiętać, aby zadeklarować zmienną przed jej użyciem. To znaczy, że taki kod jest niepoprawny:

{
   printf ("Przeliczam wiek...\n");
   printf ("Mam %d lat\n", wiek);
   int wiek = 17; /* deklaracja po użyciu - kompilator nigdy tego nie dopuści */
}

Należy go zapisać tak:

{
   printf ("Przeliczam wiek...\n");
   int wiek = 17; /* deklaracja w środku bloku - dopuszczalna w C99 */
   printf ("Mam %d lat\n", wiek);
}

Uwaga! Język C nie inicjalizuje zmiennych lokalnych. Oznacza to, że w nowo zadeklarowanej zmiennej znajdują się śmieci - to, co wcześniej zawierał przydzielony zmiennej fragment pamięci. Aby uniknąć ciężkich do wykrycia błędów, dobrze jest inicjalizować (przypisywać wartość) wszystkie zmienne w momencie zadeklarowania.

• zasada spirali prawoskrętnej ( ang. The Clockwise/Spiral Rule)^[5]
• zasady wg Steve Friedl'a^[6]
• użyć programu cdecl: konwersja z c do języka angielskiego i w odwrotnym kierunku

Zasady nazywania zmiennych (ang. Rules for Constructing Variable Names in C Language) ^[7]

• zestaw dopuszczalnych znaków
• pierwszy znak : litera lub podkreślenie ( nie zalecane z uwagi na używanie ich w nazwach zmiennych systemowych)^[8]
• nie używamy słów kluczowych ( już są użyte ). Uwaga: po zmianie wielkości liter będą dopuszczalne
• wielkość liter odróżnia nazwy ( ang. case sensitive)
• długość nazwy
  • do pierwszych 8 znaków
  • do pierwszych 31 znaków
  • niektóre kompilatory/OS pozwalają na użycie do 247 znaków^[9]

Przykłady niedopuszczalnych nazw:^[10][11]

  1x  // zaczyna się od cyfry
  char // słowo zarezerwowane ( ang. reserved word ) 
  x+y //  znak specjalny
  addition of program // spacji używać nie wolno
  

Cel i zasady nadawania nazw:^[12]

• Wybierz słowo mające znaczenie (podaj kontekst): jednoznacznie i precyzyjnie opisywać koncept który nazywają^[13]
• Unikaj nazw ogólnych (takich jak tmp)
• nazwa zmiennej nie może być taka sama jak słowo kluczowe języka C oraz jak nazwa innej zmiennej, która została wcześniej zdefiniowana w programie^[14]
• Dołącz dodatkowe informacje do nazwy (użyj sufiksu lub prefiksu)
• Dołącz dodatkowe informacje do nazwy (użyj sufiksu lub prefiksu), zobacz notacja węgierska^[15]
• Nie rób zbyt długich ani zbyt krótkich imion
• Używaj spójnego formatowania

Zmienne mogą być dostępne dla wszystkich funkcji programu - nazywamy je wtedy zmiennymi globalnymi. Deklaruje się je przed wszystkimi funkcjami programu:

#include <stdio.h>

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

void func1 ()
{
 /* instrukcje */
 a=3;
 /* dalsze instrukcje */
}
 
int main ()
{
 b=3;
 a=2;
 return 0;
}

Specyfikacja języka C mówi, że zmienne globalne, jeśli programista nie przypisze im innej wartości podczas definiowania, są inicjalizowane wartością 0.

Zmienne, które funkcja deklaruje do "własnych potrzeb" nazywamy zmiennymi lokalnymi. Nasuwa się pytanie: "czy będzie błędem nazwanie tą samą nazwą zmiennej globalnej i lokalnej?". Otóż odpowiedź może być zaskakująca: nie. Natomiast w danej funkcji da się używać tylko jej zmiennej lokalnej. Tej konstrukcji należy, z wiadomych względów, unikać.

int a=1; /* zmienna globalna */ 

int main()
{
 int a=2;         /* to już zmienna lokalna */
 printf("%d", a); /* wypisze 2 */
}

Czas życia to czas od momentu przydzielenia dla zmiennej miejsca w pamięci (stworzenie obiektu) do momentu zwolnienia miejsca w pamięci (likwidacja obiektu).

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

main()
{
 int a = 10;
 {                            /* otwarcie lokalnego bloku */
   int b = 10;
   printf("%d %d", a, b);
 }                            /* zamknięcie lokalnego bloku, zmienna b jest usuwana */

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

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

Uwaga! Niektóre kompilatory (prawdopodobnie można tu zaliczyć Microsoft Visual C++ do wersji 2003) uznają powyższy kod za poprawny! W dodatku można ustawić w opcjach niektórych kompilatorów zachowanie w takiej sytuacji, włącznie z zachowaniami niezgodnymi ze standardem języka!

Możemy świadomie ograniczyć ważność zmiennej do kilku linijek programu (tak jak robiliśmy wyżej) tworząc blok. Nazwa zmiennej jest znana tylko w tym bloku.

{
  ...
}

Stała, różni się od zmiennej tylko tym, że nie można jej przypisać innej wartości w trakcie działania programu. Wartość stałej ustala się w kodzie programu i nigdy ona nie ulega zmianie.

W przeciwieństwie do języka C++, w C stała to cały czas zmienna, której kompilator pilnuje, by nie zmieniła się.

Stałą deklaruje się:

• z użyciem słowa kluczowego const
• dyrektywy preprocesora #define

Użycie stałej zapobiega używaniu magicznych liczb ( ang. Magic number or Unnamed numerical constants)

const typ nazwa_stałej=wartość;

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

const int WARTOSC_POCZATKOWA=5;
int i=WARTOSC_POCZATKOWA;
WARTOSC_POCZATKOWA=4;  /* tu kompilator zaprotestuje */
int j=WARTOSC_POCZATKOWA;

Przykład pokazuje dobry zwyczaj programistyczny, jakim jest zastępowanie umieszczonych na stałe w kodzie liczb stałymi. W ten sposób będziemy mieli większą kontrolę nad kodem - stałe umieszczone w jednym miejscu można łatwo modyfikować, zamiast szukać po całym kodzie liczb, które chcemy zmienić.

Nie mamy jednak pełnej gwarancji, że stała będzie miała tę samą wartość przez cały czas wykonania programu, możliwe jest bowiem dostanie się do wartości stałej (miejsca jej przechowywania w pamięci) pośrednio - za pomocą wskaźników. Można zatem dojść do wniosku, że słowo kluczowe const służy tylko do poinformowania kompilatora, aby ten nie zezwalał na jawną zmianę wartości stałej. Z drugiej strony, zgodnie ze standardem, próba modyfikacji wartości stałej ma niezdefiniowane działanie (tzw. undefined behaviour) i w związku z tym może się powieść lub nie, ale może też spowodować jakieś subtelne zmiany, które w efekcie spowodują, że program będzie źle działał.

Podobnie do zdefiniowania stałej możemy użyć dyrektywy preprocesora #define (opisanej w dalszej części podręcznika). Tak zdefiniowaną stałą nazywamy stałą symboliczną. W przeciwieństwie do stałej zadeklarowanej z użyciem słowa const stała zdefiniowana przy użyciu #define jest zastępowana daną wartością w każdym miejscu, gdzie występuje, dlatego też może być używana w miejscach, gdzie "normalna" stała nie mogłaby dobrze spełnić swej roli.

Literały^[16], czyli stałe dosłowne.

Zawsze w programie, w którym określasz wartość jawnie zamiast odnosić się do zmiennej lub innej formy danych, ta wartość jest określana jako literał.

Literały mogą przybierać formę zdefiniowaną przez ich typ :

• całkowity
• zmiennopozycyjny
• znakowy
• napisowy
• złożony^[17]

int ilosc = 23; // 23 to literał calkowity
double wysokosc = 88.2; // 88.2 to literał zmiennopozycyjny
char znak = 'c'; // 'c' jest literałem znakowym
string napis = "Napis"; // "Napis" to literał napisowy
int *p = (int []){2, 4, 6}; // literał złożony

Można użyć notacji szesnastkowej (szesnastkowej), aby bezpośrednio wstawić dane do zmiennej niezależnie od jej typu.

Każdy program w C operuje na zmiennych - wydzielonych w pamięci komputera obszarach, które mogą reprezentować obiekty nam znane, takie jak liczby, znaki, czy też bardziej złożone obiekty. Jednak dla komputera każdy obszar w pamięci jest taki sam - to ciąg zer i jedynek, w takiej postaci zupełnie nieprzydatny dla programisty i użytkownika. Podczas pisania programu musimy wskazać, w jaki sposób ten ciąg ma być interpretowany.

Typ zmiennej wskazuje właśnie sposób, w jaki pamięć, w której znajduje się zmienna będzie wykorzystywana. Określając go przekazuje się kompilatorowi informację, ile pamięci trzeba zarezerwować dla zmiennej, a także w jaki sposób wykonywać na niej operacje.

Każda zmienna musi mieć określony swój typ w miejscu deklaracji i tego typu nie może już zmienić. Lecz co jeśli mamy zmienną jednego typu, ale potrzebujemy w pewnym miejscu programu innego typu danych? W takim wypadku stosujemy konwersję (rzutowanie) jednej zmiennej na inną zmienną. Rzutowanie zostanie opisane później, w rozdziale Operatory.

W języku C wyróżniamy następujące typy zmiennych ( wg wielkości ) :

• 4 podstawowe :
  • char - jednobajtowe liczby całkowite, służy do przechowywania znaków;
  • int- typ całkowity, o długości domyślnej dla danej architektury komputera;
  • float - typ zmiennopozycyjny (zwany również zmiennoprzecinkowym), reprezentujący liczby rzeczywiste (4 bajty); Są dokładnie opisane w IEEE 754.
  • double - typ zmiennopozycyjny podwójnej precyzji (8 bajtów);
• dodatkowe :
  • typ logiczny : bool (tylko C99) (wymaga dołączenia stdbool.h) - typ logiczny
  • typy złożone

Wg lokalizacji definicji typy dzielimy na :

• wbudowane, które zna kompilator; są one w nim bezpośrednio "zaszyte"
• zdefiniowane przez użytkownika typy danych. Należy je kompilatorowi opisać. Więcej informacji znajduje się w rozdziale Typy złożone.

Wg zastosowania typy możemy podzielić na :

• liczbowe
• znakowe
  • char ( ang. single-byte character or byte), znak ( jednobajtowy)
  • wchar (ang. wide character) = znak wielobajtowy
  • łańcuchy, napis ( ang. string )
    • ASCII
    • Unicode

Rozmiar zmiennych można sprawdzić za pomocą prostego programu

W języku C nie jest możliwe przekazywanie typu jako argumentu

Pojęcia związane z typami:^[18]

• rodzaje typów
• grupy typów
• zgodność
• konwersje
• rozmiar

Ten typ przeznaczony jest do liczb całkowitych. Liczby te możemy zapisać na kilka sposobów:

• System dziesiętny

12 ; 13 ; 45 ; 35 itd

• System ósemkowy (oktalny)

010    czyli 8
016    czyli 8 + 6 = 14
018    BŁĄD

System ten operuje na cyfrach od 0 do 7. Tak wiec 8 jest niedozwolona. Jeżeli chcemy użyć takiego zapisu musimy zacząć liczbę od 0.

• System szesnastkowy (heksadecymalny)

0x10   czyli 1*16 + 0 = 16
0x12   czyli 1*16 + 2 = 18
0xff   czyli 15*16 + 15 = 255

W tym systemie możliwe cyfry to 0...9 i dodatkowo a, b, c, d, e, f, które oznaczają 10, 11, 12, 13, 14, 15. Aby użyć takiego systemu musimy poprzedzić liczbę ciągiem 0x. Wielkość znaków w takich literałach nie ma znaczenia.

Ponadto w niektórych kompilatorach przeznaczonych głównie do mikrokontrolerów spotyka się jeszcze użycie systemu binarnego. Zazwyczaj dodaje się przedrostek 0b przed liczbą (analogicznie do zapisu spotykanego w języku Python). W tym systemie możemy oczywiście używać tylko i wyłącznie cyfr 0 i 1. Tego typu rozszerzenie bardzo ułatwia programowanie niskopoziomowe układów. Należy jednak pamiętać, że jest to tylko i wyłącznie rozszerzenie.

W pliku inttypes.h są (od C99) zdefiniowane makra dla liczb całkowitych o stałej szerokości ( ang. Fixed width integer types ) ^[19]. Podstawowe typy:

• int8_t
• int16_t
• int32_t
• int64_t
• uintptr_t = typ liczby całkowitej bez znaku, który może pomieścić wskaźnik^[20]

Użycie typów o stałej szerokości zwiększa przenośność programów^[21]

Zobacz:

• Limity dla zmiennych całkowitych

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

• System dziesiętny

  3.14 ; 45.644 ; 23.54 ; 3.21 itd

• System "naukowy" - wykładniczy

  pek = p*10^k = p*pow(10.0, k) 

przykłady:

  6e2 czyli 6 * 102 czyli 600
  1.5e3 czyli 1.5 * 103 czyli 1500
  3.4e-3 czyli 3.4 * 10(-3) czyli 0.0034

Należy wziąć pod uwagę, że reprezentacja liczb rzeczywistych w komputerze jest niedoskonała i możemy otrzymywać wyniki o zauważalnej niedokładności.^[22]

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

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

  1.5f   (float)
  1.5    (double)

Można^[23] wyświetlić wewnętrzną reprezentację ( binarną i 16-ową) wartości specjalnych^[24] ( dla porównania kilka niespecjalnych):

0.5:
0 01111111110 0000000000000000000000000000000000000000000000000000
0 3FE 0

0.1:
0 01111111011 1001100110011001100110011001100110011001100110011010
0 3FB 999999999999A

0.0:
0 00000000000 0000000000000000000000000000000000000000000000000000
0 0 0

NaN:
1 11111111111 1000000000000000000000000000000000000000000000000000
1 7FF 8000000000000

+infinity:
0 11111111111 0000000000000000000000000000000000000000000000000000
0 7FF 0

2^-1074:
0 00000000000 0000000000000000000000000000000000000000000000000001
0 0 1

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

   'a' ; '7' ; '!' ; '$'

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

Warto zauważyć, że typ char to zwykły typ liczbowy i można go używać tak samo jak typu int (zazwyczaj ma jednak mniejszy zakres). Co więcej literały znakowe (np. 'a') są traktowane jako liczby i w języku C są typu int (w języku C++ są typu char).

Program^[25] drukuje znaki drukowalne ASCII:

// https://en.cppreference.com/w/c/language/ascii
// printtable ASCII
#include <stdio.h>
 
int main(void)
{
    puts("Printable ASCII:");
    for (int i = 32; i < 127; ++i) {
        putchar(i);
        putchar(i % 16 == 15 ? '\n' : ' ');
    }
}

Wynik:

Printable ASCII:
  ! " # $ % & ' ( ) * + , - . /
0 1 2 3 4 5 6 7 8 9 : ; < = > ?
@ A B C D E F G H I J K L M N O
P Q R S T U V W X Y Z [ \ ] ^ _
` a b c d e f g h i j k l m n o
p q r s t u v w x y z { | } ~

Wewnętrzna reprezentacja znaku:^[26]

  printf( "%c = %hhu\n", c, ( unsigned char )c );

Słowa kluczowego void można w określonych sytuacjach użyć tam, gdzie oczekiwana jest nazwa typu. void nie jest właściwym typem, bo nie można utworzyć zmiennej takiego typu; jest to "pusty" typ (ang. void znaczy "pusty"). Typ void przydaje się do zaznaczania, że funkcja nie zwraca żadnej wartości lub że nie przyjmuje żadnych parametrów (więcej o tym w rozdziale Funkcje). Można też tworzyć zmienne będące typu "wskaźnik na void"

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

Na początku zastanówmy się, jak komputer może przechować liczbę ujemną. Otóż w przypadku przechowywania liczb ujemnych musimy w zmiennej przechować jeszcze jej znak. Jak wiadomo, zmienna składa się z szeregu bitów. W przypadku użycia zmiennej pierwszy bit z lewej strony (nazywany także bitem najbardziej znaczącym) przechowuje znak liczby. Efektem tego jest spadek "pojemności" zmiennej, czyli zmniejszenie największej wartości, którą możemy przechować w zmiennej.

Signed oznacza liczbę ze znakiem, unsigned - bez znaku (nieujemną). Mogą być zastosowane do typów: char i int i łączone ze specyfikatorami short i long (gdy ma to sens).

Jeśli przy signed lub unsigned nie napiszemy, o jaki typ nam chodzi, kompilator przyjmie wartość domyślną czyli int.

Przykładowo dla zmiennej char(zajmującej 8 bitów zapisanej w formacie uzupełnień do dwóch) wygląda to tak:

signed char a;      /* zmienna a przyjmuje wartości od -128 do 127 */
unsigned char b;    /* zmienna b przyjmuje wartości od 0 do 255    */
unsigned short c;
unsigned long int d;

Jeżeli nie podamy żadnego ze specyfikatora wtedy liczba jest domyślnie przyjmowana jako signed (nie dotyczy to typu char, dla którego jest to zależne od kompilatora).

signed int i = 0;
// jest równoznaczne z:
int i = 0;

Liczby bez znaku pozwalają nam zapisać większe liczby przy tej samej wielkości zmiennej - ale trzeba uważać, by nie zejść z nimi poniżej zera - wtedy "przewijają" się na sam koniec zakresu, co może powodować trudne do wykrycia błędy w programach.

Typ size_t jest zdefiniowany w nagłówku stddef.h^[27][28] jako alias do liczby całkowitej bez znaku

typedef unsigned int size_t;

Użycie size_t może poprawić przenośność, wydajność i czytelność kodu.^[29]

Możemy to sprawdzić :^[30]

echo | gcc -E -xc -include 'stddef.h' - | grep size_t

przykładowy wynik :

typedef long unsigned int size_t;

Short i long są wskazówkami dla kompilatora, by zarezerwował dla danego typu mniej (odpowiednio — więcej) pamięci. Mogą być zastosowane do dwóch typów: int i double (tylko long), mając różne znaczenie.

Jeśli przy short lub long nie napiszemy, o jaki typ nam chodzi, kompilator przyjmie wartość domyślną czyli int.

Należy pamiętać, że to jedynie życzenie wobec kompilatora - w wielu kompilatorach typy int i long int mają ten sam rozmiar. Standard języka C nakłada jedynie na kompilatory następujące ograniczenia:

int - nie może być krótszy niż 16 bitów;

int - musi być dłuższy lub równy short a nie może być dłuższy niż long;

short int - nie może być krótszy niż 16 bitów;

long int - nie może być krótszy niż 32 bity;

Zazwyczaj typ int jest typem danych o długości odpowiadającej wielkości rejestrów procesora, czyli na procesorze szesnastobitowym ma 16 bitów, na trzydziestodwubitowym - 32 itd.^[31] Z tego powodu, jeśli to tylko możliwe, do reprezentacji liczb całkowitych preferowane jest użycie typu int bez żadnych specyfikatorów rozmiaru.

volatile znaczy ulotny. Oznacza to, że kompilator wyłączy dla takiej zmiennej optymalizacje typu zastąpienia przez stałą lub zawartość rejestru, za to wygeneruje kod, który będzie odwoływał się zawsze do komórek pamięci danego obiektu. Zapobiegnie to błędowi, gdy obiekt zostaje zmieniony przez część programu, która nie ma zauważalnego dla kompilatora związku z danym fragmentem kodu lub nawet przez zupełnie inny proces.

volatile float liczba1;
float liczba2;
{ 
 printf ("%f\n%f\n", liczba1, liczba2);
 /* instrukcje nie związane ze zmiennymi */ 
 printf ("%f\n%f", liczba1, liczba2);
}

Jeżeli zmienne liczba1 i liczba2 zmienią się niezauważalnie dla kompilatora to odczytując:

• liczba1 - nastąpi odwołanie do komórek pamięci. Kompilator pobierze nową wartość zmiennej.
• liczba2 - kompilator może wypisać poprzednią wartość, którą przechowywał w rejestrze.

Modyfikator volatile jest rzadko stosowany i przydaje się w wąskich zastosowaniach, jak współbieżność i współdzielenie zasobów oraz przerwania systemowe. Często jest stosowany przy tworzeniu programów na mikrokontrolery. Kompilatory często tak optymalizują kod, aby wszystkie operacje wykonywały się w rejestrach, przez co wartość zmiennej w pamięci może być przez dłuższy czas nieuaktualniana. Zastosowanie volatile zmusi kompilator do każdorazowego odwołania do pamięci w przypadku operowania na zmiennych.

Jeżeli utworzymy zmienną, której będziemy używać w swoim programie bardzo często, możemy wykorzystać modyfikator register. Kompilator może wtedy umieścić zmienną w rejestrze, do którego ma szybki dostęp, co przyśpieszy odwołania do tej zmiennej

register int liczba;

W nowoczesnych kompilatorach ten modyfikator praktycznie nie ma wpływu na program. Optymalizator sam decyduje czy i co należy umieścić w rejestrze. Nie mamy żadnej gwarancji, że zmienna tak zadeklarowana rzeczywiście się tam znajdzie, chociaż dostęp do niej może zostać przyspieszony w inny sposób. Raczej powinno się unikać tego typu konstrukcji w programie.

Pozwala na zdefiniowanie zmiennej statycznej. "Statyczność" polega na zachowaniu wartości pomiędzy kolejnymi definicjami tej samej zmiennej. Jest to przede wszystkim przydatne w funkcjach. Gdy zdefiniujemy zmienną w ciele funkcji, to zmienna ta będzie od nowa definiowana wraz z domyślną wartością (jeżeli taką podano). W wypadku zmiennej określonej jako statyczna, jej wartość się nie zmieni przy ponownym wywołaniu funkcji. Na przykład:

void dodaj(int liczba)
{
 int zmienna = 0;     /* bez static*/
 zmienna = zmienna + liczba;
 printf ("Wartosc zmiennej %d\n", zmienna);
}

Gdy wywołamy tę funkcję np. 3 razy w ten sposób:

 dodaj(3);
 dodaj(5);
 dodaj(4);

to ujrzymy na ekranie:

Wartosc zmiennej 3
Wartosc zmiennej 5
Wartosc zmiennej 4

jeżeli jednak deklarację zmiennej zmienimy na static int zmienna = 0, to wartość zmiennej zostanie zachowana i po ponownym wykonaniu funkcji powinnyśmy ujrzeć:

Wartosc zmiennej 3
Wartosc zmiennej 8
Wartosc zmiennej 12

Zupełnie co innego oznacza static zastosowane dla zmiennej globalnej. Jest ona wtedy widoczna tylko w jednym pliku. Zobacz też: rozdział Biblioteki.

Przez extern oznacza się zmienne globalne zadeklarowane w innych plikach - informujemy w ten sposób kompilator, żeby nie szukał jej w aktualnym pliku. Zobacz też: rozdział Biblioteki.

Zupełnym archaizmem jest modyfikator auto, który oznacza tyle, że zmienna jest lokalna. Ponieważ zmienna zadeklarowana w dowolnym bloku zawsze jest lokalna, modyfikator ten nie ma obecnie żadnego zastosowania praktycznego. auto jest spadkiem po wcześniejszych językach programowania, na których oparty jest C (np. B).

Konwersje typów zmiennych :^{[32][33] [34]}

• Rzutowanie
• funkcje ceil, floor, round,
• (int)

Operator przypisania ("="), jak sama nazwa wskazuje, przypisuje wartość prawego argumentu lewemu, np.:

int a = 5, b;
b = a;
printf("%d\n", b); /* wypisze 5 */

Operator ten ma łączność prawostronną tzn. obliczanie przypisań następuje z prawa na lewo i zwraca on przypisaną wartość, dzięki czemu może być użyty kaskadowo:

int a, b, c;
a = b = c = 3;
printf("%d %d %d\n", a, b, c);  /* wypisze "3 3 3" */

C umożliwia też skrócony zapis postaci a #= b;, gdzie # jest jednym z operatorów: +, -, *, /, %, &, |, ^, << lub >> (opisanych niżej). Ogólnie rzecz ujmując zapis a #= b; jest równoważny zapisowi a = a # (b);, np.:

int a = 1;
a += 5;     /* to samo, co a = a + 5;       */
a /= a + 2; /* to samo, co a = a / (a + 2); */
a %= 2;     /* to samo, co a = a % 2;       */
d >>= 2; // Przesuń d w prawo * ang. right shift) o 2 pozycje i przypisz z powrotem do d

Początkowo skrócona notacja miała następującą składnię: a =# b, co często prowadziło do niejasności, np. i =-1 (i = -1 czy też i = i-1?). Dlatego też zdecydowano się zmienić kolejność operatorów.

Zadaniem rzutowania jest konwersja danej jednego typu na daną innego typu. Konwersja może być niejawna (domyślna konwersja przyjęta przez kompilator) lub jawna (podana explicite przez programistę). Oto kilka przykładów konwersji niejawnej:

int i = 42.7;            /* konwersja z double do int */
float f = i;             /* konwersja z int do float */
double d = f;            /* konwersja z float do double */
unsigned u = i;          /* konwersja z int do unsigned int */
f = 4.2;                 /* konwersja z double do float */
i = d;                   /* konwersja z double do int */
char *str = "foo";       /* konwersja z const char* do char*  [1] */
const char *cstr = str;  /* konwersja z char* do const char* */
void *ptr = str;         /* konwersja z char* do void* */

Podczas konwersji zmiennych zawierających większe ilości danych do typów prostszych (np. double do int) musimy liczyć się z utratą informacji, jak to miało miejsce w pierwszej linijce - zmienna int nie może przechowywać części ułamkowej toteż została ona odcięta i w rezultacie zmiennej została przypisana wartość 42.

Zaskakująca może się wydać linijka oznaczona przez [1]. Niejawna konwersja z typu const char* do typu char* nie jest dopuszczana przez standard C. Jednak literały napisowe (które są typu const char*) stanowią tutaj wyjątek. Wynika on z faktu, że były one używane na długo przed wprowadzeniem słówka const do języka i brak wspomnianego wyjątku spowodowałby, że duża część kodu zostałaby nagle zakwalifikowana jako niepoprawny kod.

Do jawnego wymuszenia konwersji służy jednoargumentowy operator rzutowania, np.:

double d = 3.14;
int pi = (int)d;         /* 1 */
pi = (unsigned)pi >> 4;  /* 2 */

W pierwszym przypadku operator został użyty, by zwrócić uwagę na utratę precyzji. W drugim, dlatego że bez niego operator przesunięcia bitowego zachowuje się trochę inaczej.

Obie konwersje przedstawione powyżej są dopuszczane przez standard jako jawne konwersje (tj. konwersja z double do int oraz z int do unsigned int), jednak niektóre konwersje są błędne, np.:

const char *cstr = "foo";
char *str = cstr;

W takich sytuacjach można użyć operatora rzutowania by wymusić konwersję:

const char *cstr = "foo";
char *str = (char*)cstr;

Należy unikać jednak takich sytuacji i nigdy nie stosować rzutowania by uciszyć kompilator. Zanim użyjemy operatora rzutowania należy się zastanowić co tak naprawdę będzie on robił i czy nie ma innego sposobu wykonania danej operacji, który nie wymagałby podejmowania tak drastycznych kroków.

Uwaga! W arytmetyce komputerowej nie działa prawo łączności oraz rozdzielności. Wynika to z ograniczonego rozmiaru zmiennych, które przechowują wartości. Przykład dla zmiennych o długości 16 bitów (bez znaku). Maksymalna wartość, którą może przechowywać typ to: 2^16-1 = 65535. Zatem operacja typu 65530+10-20 zapisana jako (65530+10)-20 może zaowocować czymś zupełnie innym niż 65530+(10-20). W pierwszym przypadku zapewne dojdzie do tzw. przepełnienia — procesor nie będzie miał miejsca, aby zapisać dodatkowy bit. Zachowanie programu będzie w takim przypadku zależało od architektury procesora. Analogiczny przykład możemy podać dla rozdzielności mnożenia względem dodawania.

Język C definiuje następujące dwuargumentowe operatory arytmetyczne:

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

Zobacz również funkcję div

int a=7, b=2, c;
c = a % b;
printf ("%d\n",c); /* wypisze "1" */

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

float a = 7 / 2;
printf("%f\n", a);

wypisze (wbrew oczekiwaniu początkujących programistów) 3.0, a nie 3.5. Odnosi się to nie tylko do dzielenia, ale także mnożenia, np.:

float a = 1000 * 1000 * 1000 * 1000 * 1000 * 1000;
printf("%f\n", a);

prawdopodobnie da o wiele mniejszy wynik niż byśmy się spodziewali. Aby wymusić obliczenia rzeczywiste należy zmienić typ jednego z argumentów na liczbę rzeczywistą po prostu zmieniając literał lub korzystając z rzutowania, np.:

float a = 7.0 / 2; /* wcześniejszy zapis: float a = 7 / 2; */ 
float b = (float)1000 * 1000 * 1000 * 1000 * 1000 * 1000;
printf("%f\n", a);
printf("%f\n", b);

Dzielenie

• całkowite ( ang. integer division)^[35][36]
• zmiennoprzecinkowe ( ang. float division)

Zasady dzielenia liczb całkowitych i zmiennoprzecinkowych w C^[37]

• integer / integer = integer
• float / integer = float
• integer / float = float

Operatory dodawania i odejmowania są określone również, gdy jednym z argumentów jest wskaźnik, a drugim liczba całkowita. Ten drugi jest także określony, gdy oba argumenty są wskaźnikami. O takim użyciu tych operatorów dowiesz się więcej w dalszej części książki.

Aby skrócić zapis wprowadzono dodatkowe operatory: inkrementacji ("++") i dekrementacji ("--"), które dodatkowo mogą być pre- lub postfiksowe. W rezultacie mamy więc cztery operatory:

• pre-inkrementacja ("++i"),
• post-inkrementacja ("i++"),
• pre-dekrementacja ("--i") i
• post-dekrementacja ("i--").

Operatory inkrementacji zwiększa, a dekrementacji zmniejsza argument o jeden. Ponadto operatory pre- zwracają nową wartość argumentu, natomiast post- starą wartość argumentu.

 int a, b, c;
 a = 3;
 b = a--; /* po operacji b=3 a=2 */
 c = --b; /* po operacji b=2 c=2 */

Czasami (szczególnie w C++) użycie operatorów stawianych za argumentem jest nieco mniej efektywne (bo kompilator musi stworzyć nową zmienną by przechować wartość tymczasową).

Uwaga! Bardzo ważne jest, abyśmy poprawnie stosowali operatory dekrementacji i inkrementacji. Chodzi o to, aby w jednej instrukcji nie umieszczać kilku operatorów, które modyfikują ten sam obiekt (zmienną). Jeżeli taka sytuacja zaistnieje, to efekt działania instrukcji jest nieokreślony. Prostym przykładem mogą być następujące instrukcje: int a = 1; a = a++; a = ++a; a = a++ + ++a; printf("%d %d\n", ++a, ++a); printf("%d %d\n", a++, a++); Kompilator GCC potrafi ostrzegać przed takimi błędami - aby to czynił należy podać mu jako argument opcję -Wsequence-point lub -Wall.

Oprócz operacji znanych z lekcji matematyki w podstawówce, język C został wyposażony także w operatory bitowe^{[38][39][40][41]}, . Są to:

• negacja bitowa (NOT)("~"),
• koniunkcja bitowa (AND)("&"),
• alternatywa bitowa (OR)("|") i
• alternatywa rozłączna (XOR) ("^").

Uwaga! Operacje bitowe są zdefinowane tylko dla liczb całkowitych

Działają one na poszczególnych bitach przez co mogą być szybsze od innych operacji.

Działanie tych operatorów można zdefiniować za pomocą poniższych tabel prawdy ( matryc logicznych):

W pierwszej tabeli a i b oznaczają bity ( albo pole bitowe o długości 1) , a nie liczby typu całkowitego

 "~" | a     "&" | a | b     "|" | a | b     "^" | a | b
-----+---   -----+---+---   -----+---+---   -----+---+---
  0  | 1      0  | 0 | 0      0  | 0 | 0      0  | 0 | 0
  1  | 0      1  | 1 | 1      1  | 1 | 1      0  | 1 | 1
              0  | 0 | 1      1  | 0 | 1      1  | 0 | 1
              0  | 1 | 0      1  | 1 | 0      1  | 1 | 0

W drugiej tabeli a i b oznaczają 4 bitowe pole ( c nie ma typu 4 bitowego)

   a   | 0101  =  5
   b   | 0011  =  3
-------+------
  ~a   | 1010  = 10
  ~b   | 1100  = 12
 a & b | 0001  =  1
 a | b | 0111  =  7
 a ^ b | 0110  =  6

Lub bardziej opisowo:

• negacja bitowa daje w wyniku liczbę, która ma bity równe jeden tylko na tych pozycjach, na których argument miał bity równe zero;
• koniunkcja bitowa daje w wyniku liczbę, która ma bity równe jeden tylko na tych pozycjach, na których oba argumenty miały bity równe jeden (mnemonik: 1 gdy wszystkie 1);
• alternatywa bitowa daje w wyniku liczbę, która ma bity równe jeden na wszystkich tych pozycjach, na których jeden z argumentów miał bit równy jeden (mnemonik: 1 jeśli jest 1);
• alternatywa rozłączna daje w wyniku liczbę, która ma bity równe jeden tylko na tych pozycjach, na których tylko jeden z argumentów miał bit równy jeden (mnemonik: 1 gdy różne).

Przy okazji warto zauważyć, że a ^ b ^ b to po prostu a. Właściwość ta została wykorzystana w różnych algorytmach szyfrowania oraz funkcjach haszujących. Alternatywę wyłączną stosuje się np. do szyfrowania kodu wirusów polimorficznych.

Jak wpływa długość liczby binarnej na wynik negacji ?

	1 bit	4 bity	8 bitów
a	${\displaystyle 1_{2}=1_{10}}$	${\displaystyle {0001}_{2}=\ \ 1_{10}}$	${\displaystyle {00000001}_{2}=\ \ \ \ 1_{10}}$
~a	${\displaystyle 0_{2}=0_{10}}$	${\displaystyle {1110}_{2}={14}_{10}}$	${\displaystyle {11111110}_{2}=254_{10}}$

Przykładowy program działajacy na liczbie 8 bitowej ( unsigned char ):

// gcc b.c -Wall
// ./a.out
#include <stdio.h>

/*     
https://stackoverflow.com/questions/699968/display-the-binary-representation-of-a-number-in-c
Chris Lutz
*/
void PrintBitsOfUChar(unsigned char v) {
  int i; // for C89 compatability
  for(i = 7; i >= 0; i--) putchar('0' + ((v >> i) & 1));
}



void TestBitwiseNot (unsigned char a ){

	printf ("decimal number  a = %3u;\t ", a );
	printf ("it's binary expansion = ");
	PrintBitsOfUChar(a);
	printf("\n"); 
	printf ("decimal number ~a = %3u;\t ", (unsigned char) ~a );
	printf ("it's binary expansion = ");
	PrintBitsOfUChar((unsigned char) ~a);
	printf("\n\n"); 
	
}






int main ()
{
 //unsigned char a;
 //char buffer[8];
 
 printf("unsigned char	has size = 1 byte = 8 bits and range from 0 to 255\n\n");
 
 TestBitwiseNot(0);
 TestBitwiseNot(255);
 TestBitwiseNot(5);
 TestBitwiseNot(3);
    
 
 return 0;
}

Wynik

unsigned char	has size = 1 byte = 8 bits and range from 0 to 255

decimal number  a =   0;	 it's binary expansion = 00000000
decimal number ~a = 255;	 it's binary expansion = 11111111

decimal number  a = 255;	 it's binary expansion = 11111111
decimal number ~a =   0;	 it's binary expansion = 00000000

decimal number  a =   5;	 it's binary expansion = 00000101
decimal number ~a = 250;	 it's binary expansion = 11111010

decimal number  a =   3;	 it's binary expansion = 00000011
decimal number ~a = 252;	 it's binary expansion = 11111100

Dodatkowo, język C wyposażony jest w operatory przesunięcia bitowego w lewo ("<<") i prawo (">>"). Przesuwają one w danym kierunku bity lewego argumentu o liczbę pozycji podaną jako prawy argument.

  [variable]<<[numberOfPlaces]

Brzmi to może strasznie, ale wcale takie nie jest. Rozważmy operacje przesunięcia na liczbach 4-bitowych :

  a   | a<<1 | a<<2 | a>>1 | a>>2
------+------+------+------+------
 0001 | 0010 | 0100 | 0000 | 0000
 0011 | 0110 | 1100 | 0001 | 0000
 0101 | 1010 | 0100 | 0010 | 0001
 1000 | 0000 | 0000 | 0100 | 0010
 1111 | 1110 | 1100 | 0111 | 0011
 1001 | 0010 | 0100 | 0100 | 0010

Nie jest to zatem takie straszne na jakie wygląda.

Przesunięcie w lewą stronę oznacza przemieszczenie wszystkich bitów argumentu w lewo o określoną liczbę miejsc oraz wprowadzenie z prawej strony takiej samej ilości zer.

Przesunięcie w prawo oznacza przemieszczenie wszystkich bitów argumentu w prawo o określoną liczbę miejsc oraz powielenie najstarszego bitu na skrajnej lewej pozycji.^[42]:

#include <stdio.h>

int main ()
{
 int a = 6;
 printf ("6 << 2 = %d\n", a<<2);  /* wypisze 24 */
 printf ("6 >> 2 = %d\n", a>>2);  /* wypisze 1 */
 return 0;
}

Inny przykład

#include <stdio.h>

int main() {
    unsigned int d = 0b11010110; // Binary: 11010110, Decimal: 214
    int k = 2;

    printf("Before shift: %u\n", d);

    d >>= k; // Right shift d by 2 positions and assign back to d

    printf("After shift: %u\n", d);

    return 0;
}

W tym przykładzie początkowa wartość d wynosi 214 (w formacie binarnym: 11010110).

Po przesunięciu w prawo o 2 pozycje (k wynosi 2) wynikiem jest 00110101, czyli 53 w systemie dziesiętnym.

Zatem wynikiem będzie:

Before shift: 214
After shift: 53

Operatorów bitowych używamy do:

• operacji na zbiorach ^[43]
• szyfrowania: XOR Encryption^[44]
• kompresji danych ( najmniejszy typ liczbowy ma 1 bajt = 8 bitów )^[45]
• szybkich obliczeń ^[46][47]
  • kod Graya ^[48]
  • obliczania liczb losowych
• programowaniu systemów wbudowanych (ang. embedded system) ^[49]
• programowania grafiki
  • OpenGl: pola bitowe w arumentach funkcji
• sieciach komputerowych ( adres IP, Maska podsieci )
• (a << b) jest równoważne pomnożeniu a przez 2^b (2 podniesione do potęgi b)^[50]
• (a>>b)‘ jest równoznaczne z podzieleniem a przez 2^b

W języku C występują następujące operatory porównania:^[51]

• równe ("=="),
• różne ("!="),
• mniejsze ("<"),
• większe (">"),
• mniejsze lub równe ("<=") i
• większe lub równe (">=").

Wykonują one odpowiednie porównanie swoich argumentów i zwracają jedynkę jeżeli warunek jest spełniony lub zero jeżeli nie jest.

// http://blogs.msdn.com/b/nativeconcurrency/archive/2012/10/11/floating-point-arithmetic-intricacies-in-c-amp.aspx

#include <stdio.h>

int main()
{if (0.0f == -0.0f)
    printf("equal\n");
    else printf("not equal ");

    return 0;
}

Uwaga! Osoby, które poprzednio uczyły się innych języków programowania, często mają nawyk używania w instrukcjach logicznych zamiast operatora porównania "==", operatora przypisania "=". Ma to często zgubne efekty, gdyż przypisanie zwraca wartość przypisaną lewemu argumentowi.

Porównajmy ze sobą dwa warunki:

(a = 1)
(a == 1)

Pierwszy z nich zawsze będzie prawdziwy, niezależnie od wartości zmiennej a! Dzieje się tak, ponieważ zostaje wykonane przypisanie do a wartości 1 a następnie jako wartość jest zwracane to, co zostało przypisane - czyli jeden. Drugi natomiast będzie prawdziwy tylko, gdy a jest równe 1.

W celu uniknięcia takich błędów niektórzy programiści zamiast pisać a == 1 piszą 1 == a, dzięki czemu pomyłka spowoduje, że kompilator zgłosi błąd.

Warto zauważyć, że kompilator GCC potrafi w pewnych sytuacjach wychwycić taki błąd. Aby zaczął to robić należy podać mu argument -Wparentheses.

Innym błędem jest użycie zwykłych operatorów porównania do sprawdzania relacji pomiędzy liczbami rzeczywistymi. Ponieważ operacje zmiennoprzecinkowe wykonywane są z pewnym przybliżeniem rzadko kiedy dwie zmienne typu float czy double są sobie równe. Dla przykładu:

#include <stdio.h>

int main ()
{
 float a, b, c;
 a = 1e10;   /* tj. 10 do potęgi 10 */
 b = 1e-10;  /* tj. 10 do potęgi -10 */
 c = b;      /* c = b */
 c = c + a;  /* c = b + a          (teoretycznie) */
 c = c - a;  /* c = b + a - a = b  (teoretycznie) */
 printf("%d\n", c == b); /* wypisze 0 */
}

Obejściem jest porównywanie modułu różnicy liczb. Również i takie błędy kompilator GCC potrafi wykrywać - aby to robił należy podać mu argument -Wfloat-equal.

Analogicznie do części operatorów bitowych, w C definiuje się operatory logiczne, mianowicie:

• negację (zaprzeczenie): "!"
• koniunkcję ("i"): "&&"
• alternatywę ("lub"): "||"

Działają one bardzo podobnie do operatorów bitowych, jednak zamiast operować na poszczególnych bitach, biorą pod uwagę wartość logiczną argumentów.

W języku C mamy 3 możliwości korzystania z "prawdy" i "fałszu":^[52]

• poprzez wartość wyrażenie : fałsz to zero a prawdy to wszystkie inne wartości
• z użyciem dyrektywy preprocesora define : #define FALSE 0 ... #define TRUE !(FALSE)
• użyciem typu bool

Logiczny typ danych^[53] ( ang. Boolean data type ) składa się z dokładnie dwóch elementów: prawdy (ang. true, 1, +) i fałszu (ang. false, 0, -).

Typu bool możemy używać na 4 sposoby : ^[54]

• w C99 ( nie w C90 ^[55]) poprzez dodanie dyrektywy #include <stdbool.h>
• trzy sposoby z użyciem dyrektyw prepocesora :

typedef int bool;
#define true 1
#define false 0

typedef int bool;
enum { false, true };

typedef enum { false, true } bool;

W tym przypadku nie używamy specjalnego typu danych do operacji logicznych. Operatory logiczne można stosować do liczb (np. typu int), tak samo jak operatory bitowe albo arytmetyczne.

Wyrażenie ma wartość logiczną:

• 0, czyli jest "fałszywe" wtedy i tylko wtedy, gdy jest równe 0
• 1 czyli jest "prawdziwe", gdy jest różne od zera

Operatory logiczne w wyniku dają zawsze albo 0 albo 1.

Żeby w pełni uzmysłowić sobie, co to to oznacza, spójrzmy na wynik wykonania poniższych trzech linijek:

printf("koniunkcja: %d\n", 18 && 19);
printf("alternatywa: %d\n", 'a' || 'b');
printf("negacja: %d\n", !20);

koniunkcja: 1
alternatywa: 1
negacja: 0

Liczba 18 nie jest równa 0, więc ma wartość logiczną 1. Podobnie 19 ma wartość logiczną 1. Dlatego ich koniunkcja jest równa 1. Znaki 'a' i 'b' zostaną w wyrażeniu logicznym potraktowane jako liczby o wartości odpowiadającej kodowi ASCII znaku — czyli oba będą miały wartość logiczną 1. Liczba 20 również ma wartość logiczną 1 (bo nie jest zerem), dlatego jej negacja to 0 czyli fałsz.

Dalsze przykłady w dziale o instrukcjach sterujących.

Język C wykonuje skrócone obliczanie wyrażeń logicznych - to znaczy, oblicza wyrażenie tylko tak długo, jak nie wie, jaka będzie jego ostateczna wartość.^[56] To znaczy, idzie od lewej do prawej obliczając kolejne wyrażenia (dodatkowo na kolejność wpływ mają nawiasy) i gdy będzie miał na tyle informacji, by obliczyć wartość całości, nie liczy reszty. Może to wydawać się niejasne, ale przyjrzyjmy się wyrażeniom logicznym:

A && B
A || B

Jeśli A jest fałszywe, nie trzeba obliczać B w pierwszym wyrażeniu, bo koniunkcja fałszu i dowolnego wyrażenia zawsze da fałsz. Analogicznie, w drugim przykładzie, jeśli A jest prawdziwe, to całe wyrażenie jest prawdziwe i wartość B nie ma znaczenia.

Poza zwiększoną szybkością zysk z takiego rozwiązania polega na możliwości stosowania efektów ubocznych. Idea efektu ubocznego opiera się na tym, że w wyrażeniu można wywołać funkcje, które będą robiły poza zwracaniem wyniku inne rzeczy, oraz używać podstawień. Popatrzmy na poniższy przykład:

( (a > 0) || (a < 0) || (a = 1) )

Jeśli a będzie większe od 0 to obliczona zostanie tylko wartość wyrażenia (a > 0) - da ono prawdę, czyli reszta obliczeń nie będzie potrzebna. Jeśli a będzie mniejsze od zera, najpierw zostanie obliczone pierwsze podwyrażenie a następnie drugie, które da prawdę. Ciekawy będzie jednak przypadek, gdy a będzie równe zero - do a zostanie wtedy podstawiona jedynka i całość wyrażenia zwróci prawdę (bo 1 jest traktowane jak prawda).

Efekty uboczne pozwalają na różne szaleństwa i wykonywanie złożonych operacji w samych warunkach logicznych, jednak przesadne używanie tego typu konstrukcji powoduje, że kod staje się nieczytelny i jest uważane za zły styl programistyczny.

C posiada szczególny rodzaj operatora - to operator ?: zwany też operatorem wyrażenia warunkowego. Jest to jedyny operator w tym języku przyjmujący trzy argumenty.

a ? b : c

Jego działanie wygląda następująco: najpierw oceniana jest wartość logiczna wyrażenia a; jeśli jest ono prawdziwe, to zwracana jest wartość b, jeśli natomiast wyrażenie a jest nieprawdziwe, zwracana jest wartość c.

Praktyczne zastosowanie - znajdowanie większej z dwóch liczb:

a = (b>=c) ? b : c;     /* Jeśli b jest większe bądź równe c, to zwróć b. 
                           W przeciwnym wypadku zwróć c. */

lub zwracanie modułu liczby:

a = a < 0 ? -a : a;

Wartości wyrażeń są przy tym operatorze obliczane tylko jeżeli zachodzi taka potrzeba, np. w wyrażeniu 1 ? 1 : foo() funkcja foo() nie zostanie wywołana.

Operator przecinek jest dość dziwnym operatorem. Powoduje on obliczanie wartości wyrażeń od lewej do prawej po czym zwrócenie wartości ostatniego wyrażenia.^[57] W zasadzie, w normalnym kodzie programu ma on niewielkie zastosowanie, gdyż zamiast niego lepiej rozdzielać instrukcje zwykłymi średnikami. Ma on jednak zastosowanie w instrukcji sterującej for.

Operator sizeof zwraca rozmiar w bajtach (gdzie bajtem jest zmienna typu char) podanego typu lub typu podanego wyrażenia. Ma on dwa rodzaje: sizeof(typ) lub sizeof wyrażenie. Przykładowo:

#include <stdio.h>

int main()
{
 printf(" sizeof(short)=%lu\n sizeof(int)=%lu\n sizeof(long)=%lu\n", sizeof(short), sizeof(int), sizeof(long));
 return 0;
}

Operator ten jest często wykorzystywany przy dynamicznej alokacji pamięci, co zostanie opisane w rozdziale poświęconym wskaźnikom.

Pomimo, że w swej budowie operator sizeof bardzo przypomina funkcję, to jednak nią nie jest. Wynika to z trudności w implementacji takowej funkcji - jej specyfika musiałaby odnosić się bezpośrednio do kompilatora. Ponadto jej argumentem musiałyby być typy, a nie zmienne. W języku C nie jest możliwe przekazywanie typu jako argumentu. Ponadto często zdarza się, że rozmiar zmiennej musi być wiadomy jeszcze w czasie kompilacji - to ewidentnie wyklucza implementację sizeof() jako funkcji.

Wynik operatora sizeof jest typu size_t

Poza wyżej opisanymi operatorami istnieją jeszcze:

• operator "[]" opisany przy okazji opisywania tablic;
• jednoargumentowe operatory "*" i "&" opisane przy okazji opisywania wskaźników;
• operatory "." i "->" opisywane przy okazji opisywania struktur i unii;
• operator "()" będący operatorem wywołania funkcji,
• operator "()" grupujący wyrażenia (np. w celu zmiany kolejności obliczania)

Jak w matematyce, również i w języku C obowiązuje pewna ustalona kolejność działań. Aby móc ją określić należy ustalić dwa parametry danego operatora: jego priorytet oraz łączność. Przykładowo operator mnożenia ma wyższy priorytet niż operator dodawania i z tego powodu w wyrażeniu ${\displaystyle 2+2\cdot 2}$ najpierw wykonuje się mnożenie, a dopiero potem dodawanie.

Drugim parametrem jest łączność - określa ona od której strony wykonywane są działania w przypadku połączenia operatorów o tym samym priorytecie. Na przykład odejmowanie ma łączność lewostronną i ${\displaystyle 2-2-2\,}$ da w wyniku -2. Gdyby miało łączność prawostronną, wynikiem byłoby 2. Przykładem matematycznego operatora, który ma łączność prawostronną jest potęgowanie, np. ${\displaystyle 4^{3^{2}}}$ jest równe ${\displaystyle 4^{9}=262144}$ (łączność lewostronna dałaby wynik ${\displaystyle 64^{2}=4096}$).

W języku C występuje dużo poziomów operatorów. Poniżej przedstawiamy tabelkę ze wszystkimi operatorami poczynając od tych z najwyższym priorytetem (wykonywanych na początku).

Duża liczba poziomów pozwala czasami zaoszczędzić trochę milisekund w trakcie pisania programu i bajtów na dysku, gdyż często nawiasy nie są potrzebne, nie należy jednak z tym przesadzać, gdyż kod programu może stać się mylący nie tylko dla innych, ale po latach (czy nawet i dniach) również dla nas.

Warto także podkreślić, że operator koniunkcji ma niższy priorytet niż operator porównania^[58]. Oznacza to, że kod

if (flags & FL_MASK == FL_FOO)

zazwyczaj da rezultat inny od oczekiwanego. Najpierw bowiem wykona się porównanie wartości FL_MASK z wartością FL_FOO, a dopiero potem koniunkcja bitowa. W takich sytuacjach należy pamiętać o użyciu nawiasów:

if ((flags & FL_MASK) == FL_FOO)

Kompilator GCC potrafi wykrywać takie błędy i aby to robił należy podać mu argument -Wparentheses.

W przypadku większości operatorów (wyjątkami są tu &&, || i przecinek) nie da się określić, która wartość argumentu zostanie obliczona najpierw. W większości przypadków nie ma to większego znaczenia, lecz w przypadku wyrażeń, które mają efekty uboczne, wymuszenie konkretnej kolejności może być potrzebne. Weźmy dla przykładu program

#include <stdio.h>

int foo(int a) 
{
 printf("%d\n", a);
 return 0;
}
 
int main(void) 
{
 return foo(1) + foo(2);
}

Otóż nie wiemy czy najpierw zostanie wywołana funkcja foo z parametrem jeden, czy dwa. Jeżeli ma to znaczenie należy użyć zmiennych pomocniczych, zmieniając definicję funkcji main na:

int main(void) 
{
 int tmp = foo(1);
 return tmp + foo(2);
}

Teraz już na pewno najpierw zostanie wypisana jedynka, a potem dopiero dwójka. Sytuacja jeszcze bardziej się komplikuje, gdy używamy wyrażeń z efektami ubocznymi jako argumentów funkcji, np.:

#include <stdio.h>

int foo(int a) 
{
 printf("%d\n", a);
 return 0;
}
 
int bar(int a, int b, int c, int d) 
{
 return a + b + c + d;
}
 
int main(void) 
{
 return bar(foo(1), foo(2), foo(3), foo(4));
}

Teraz też nie wiemy, która z 24 permutacji liczb 1, 2, 3 i 4 zostanie wypisana i ponownie należy pomóc sobie zmiennymi tymczasowymi, jeżeli zależy nam na konkretnej kolejności:

int main(void) 
{
 int tmp1 = foo(1);
 int tmp2 = foo(2);
 int tmp3 = foo(3);
 return bar(tmp1, tmp2, tmp3, foo(4));
}

• złożone wyrażenia z wskaźnikami^[59]
  • cdecl : convert C gibberish to English

Reguła spiralna wg Davida Anderson^[60], która umożliwia każdemu programiście C przeanalizowanie dowolnej deklaracji C

• Zacznij od nieznanego elementu : opisz go
• poruszaj się spiralnie, zgodnie z ruchem wskazówek zegara
• spotykając kolejne elementy, zastąp je odpowiednim opisem
• Kontynuuj to w kierunku spiralnym/zgodnym z ruchem wskazówek zegara, aż wszystkie elementy zostaną opisane
• Zawsze najpierw rozwiązuj wszystko, co jest w nawiasach!

char *str[10]

Co to jest str ?

Zaczynamy od środka :

str jest to 

Poruszamy się spiralnie w kierunku zgodnym z ruchem wskazówek zegara, zaczynając od `str', a pierwszym znakiem, który widzimy, jest `[', co oznacza, że mamy tablicę, więc...

str to tablica zawierająca 10 elementów

Kontynuuj w kierunku spiralnym, i dochodzimy do "char *"

 str to tablica zawierająca 10 wskaźników na char
 

Odpowiedź z cdcl :

declare str as array 10 of pointer to char

                     +-------+
                     | +-+   |
                     | ^ |   |
                char *str[10];
                 ^   ^   |   |
                 |   +---+   |
                 +-----------+

Przykład 2

                     +--------------------+
                     | +---+              |
                     | |+-+|              |
                     | |^ ||              |
                char *(*fp)( int, float *);
                 ^   ^ ^  ||              |
                 |   | +--+|              |
                 |   +-----+              |
                 +------------------------+

Przykład 3

                      +-----------------------------+
                      |                  +---+      |
                      |  +---+           |+-+|      |
                      |  ^   |           |^ ||      |
                void (*signal(int, void (*fp)(int)))(int);
                 ^    ^      |      ^    ^  ||      |
                 |    +------+      |    +--+|      |
                 |                  +--------+      |
                 +----------------------------------+

• W języku C++ wprowadzony został dodatkowo inny sposób zapisu rzutowania, który pozwala na łatwiejsze znalezienie w kodzie miejsc, w których dokonujemy rzutowania. Więcej na stronie C++/Zmienne.

• Operatory
• Zaawansowane operacje matematyczne
• Bitwise_operations_in_C in english wikipedia

C jest językiem imperatywnym - oznacza to, że instrukcje wykonują się jedna po drugiej w takiej kolejności w jakiej są napisane. Aby móc zmienić kolejność wykonywania instrukcji potrzebne są instrukcje sterujące.

Na wstępie przypomnijmy jeszcze informację z rozdziału Operatory, że wyrażenie jest prawdziwe wtedy i tylko wtedy, gdy jest różne od zera, a fałszywe wtedy i tylko wtedy, gdy jest równe zeru.

Użycie instrukcji if wygląda tak:

 if (wyrażenie) {
   /* blok wykonany, jeśli wyrażenie jest prawdziwe */
 }
 /* dalsze instrukcje */

Istnieje także możliwość reakcji na nieprawdziwość wyrażenia - wtedy należy zastosować słowo kluczowe else:

 if (wyrażenie) {
   /* blok wykonany, jeśli wyrażenie jest prawdziwe */
 } else {
   /* blok wykonany, jeśli wyrażenie jest nieprawdziwe */
 }
 /* dalsze instrukcje */

Przypatrzmy się bardziej "życiowemu" programowi, który porównuje ze sobą dwie liczby:

 #include <stdio.h>
 
 int main ()
 {
   int a, b;
   a = 4;
   b = 6;
   if (a==b) {
     printf ("a jest równe b\n");
   } else {
     printf ("a nie jest równe b\n");
   }
   return 0;
 }

Stosowany jest też krótszy zapis warunków logicznych, korzystający z tego, jak C rozumie prawdę i fałsz, tzn.:

• liczba całkowita różna od zera oznacza prawdę
• liczba całkowita równa zero oznacza fałsz.

Jeśli zmienna a jest typu integer, zamiast:

 if (a != 0) b = 1/a;

można napisać:

  if (a) b = 1/a;

a zamiast

  if (a == 0) b = 0;

można napisać:

  if (!a)  b = 0;

Czasami zamiast pisać instrukcję if możemy użyć operatora wyrażenia warunkowego (patrz Operatory).

 if (a != 0)
   b = 1/a;
 else
   b = 0;

ma dokładnie taki sam efekt jak:

 b = (a !=0) ? 1/a : 0;

Zobacz też:

• Dangling else problem w wikipedi

Aby ograniczyć wielokrotne stosowanie instrukcji if możemy użyć switch. Jej użycie wygląda tak:

 switch (wyrażenie) {
   case wartość1: /* instrukcje, jeśli wyrażenie == wartość1 */
     break;
   case wartość2: /* instrukcje, jeśli wyrażenie == wartość2 */
     break;
   /* ... */
   default: /* instrukcje, jeśli żaden z wcześniejszych warunków nie został spełniony */
     break;
 }

Należy pamiętać o użyciu break po zakończeniu listy instrukcji następujących po case. Jeśli tego nie zrobimy, program przejdzie do wykonywania instrukcji z następnego case. Może mieć to fatalne skutki:

 #include <stdio.h>
 
 int main ()
 {
   int a, b;
   printf ("Podaj a: ");
   scanf ("%d", &a);
   printf ("Podaj b: ");
   scanf ("%d", &b);
   switch (b) {
     case  0: printf ("Nie można dzielić przez 0!\n"); /* tutaj zabrakło break! */
     default: printf ("a/b=%d\n", a/b);
   }
   return 0;
 }

A czasami może być celowym zabiegiem (tzw. "fall-through") - wówczas warto zaznaczyć to w komentarzu. Oto przykład:

 #include <stdio.h>
 
 int main ()
 {
   int a = 4;
   switch ((a%3)) {
     case  0:
       printf ("Liczba %d dzieli się przez 3\n", a);
       break;
     case -2:
     case -1:
     case  1:
     case  2:
       printf ("Liczba %d nie dzieli się przez 3\n", a);
       break;
   }
   return 0;
 }

Przeanalizujmy teraz działający przykład:

 #include <stdio.h>
 
 int main ()
 {
   unsigned int dzieci = 3, podatek=1000;
   switch (dzieci) {
      case  0: break; /* brak dzieci - czyli brak ulgi */ 
      case  1: /* ulga  2% */
        podatek = podatek - (podatek/100* 2); 
        break;
      case  2: /* ulga  5% */
        podatek = podatek - (podatek/100* 5);
        break;
      default: /* ulga 10% */
        podatek = podatek - (podatek/100*10);
        break; 
   }
   printf ("Do zapłaty: %d\n", podatek);
 }

Często zdarza się, że nasz program musi wielokrotnie powtarzać ten sam ciąg instrukcji. Aby nie przepisywać wiele razy tego samego kodu można skorzystać z tzw. pętli. Pętla wykonuje się dopóty, dopóki prawdziwy jest warunek.

 while (warunek) {
   /* instrukcje do wykonania w pętli */
 }
 /* dalsze instrukcje */

Całą zasadę pętli zrozumiemy lepiej na jakimś działającym przykładzie. Załóżmy, że mamy obliczyć kwadraty liczb od 1 do 10. Piszemy zatem program:

 #include <stdio.h>
 
 int main ()
 {
   int a = 1;
   while (a <= 10) { /* dopóki a nie przekracza 10 */
     printf ("%d\n", a*a); /* wypisz a*a na ekran*/
     ++a; /* zwiększamy a o jeden*/
   }
   return 0;
 }

Po analizie kodu mogą nasunąć się dwa pytania:

• Po co zwiększać wartość a o jeden? Otóż gdybyśmy nie dodali instrukcji zwiększającej a, to warunek zawsze byłby spełniony, a pętla "kręciłaby" się w nieskończoność.
• Dlaczego warunek to "a <= 10" a nie "a!=10"? Odpowiedź jest dość prosta. Pętla sprawdza warunek przed wykonaniem kolejnego "obrotu". Dlatego też gdyby warunek brzmiał "a!=10" to dla a=10 jest on nieprawdziwy i pętla nie wykonałaby ostatniej iteracji, przez co program generowałby kwadraty liczb od 1 do 9, a nie do 10.

Od instrukcji while czasami wygodniejsza jest instrukcja for. Umożliwia ona wpisanie ustawiania zmiennej, sprawdzania warunku i inkrementowania zmiennej w jednej linijce co często zwiększa czytelność kodu.

Instrukcję for stosuje się w następujący sposób:

 for (wyrażenie1; wyrażenie2; wyrażenie3) {
   /* instrukcje do wykonania w pętli */
 }
 /* dalsze instrukcje */

Jak widać, pętla for znacznie różni się od tego typu pętli, znanych w innych językach programowania.

Opiszemy więc, co oznaczają poszczególne wyrażenia:

• wyrażenie1 (ang. initializationStatement) - jest to instrukcja, która będzie wykonana przed pierwszym przebiegiem pętli. Zwykle jest to inicjalizacja zmiennej, która będzie służyła jako "licznik" przebiegów pętli.
• wyrażenie2 (ang. testExpression) - jest warunkiem trwania pętli. Pętla wykonuje się tak długo, jak prawdziwy jest ten warunek.
• wyrażenie3 (ang. updateStatement) - jest to instrukcja, która wykonywana będzie po każdym przejściu pętli ( także po ostatnim). Zamieszczone są tu instrukcje, które zwiększają licznik o odpowiednią wartość.

Jeżeli wewnątrz pętli nie ma żadnych instrukcji continue (opisanych niżej) to jest ona równoważna z:

 {
   wyrażenie1;
   while (wyrażenie2) {
     /* instrukcje do wykonania w pętli */
     wyrażenie3;
   }
 }
 /* dalsze instrukcje */

Ważną rzeczą jest tutaj to, żeby zrozumieć i zapamiętać jak tak naprawdę działa pętla for. Początkującym programistom nieznajomość tego faktu sprawia wiele problemów.

W pierwszej kolejności w pętli for wykonuje się wyrażenie1. Wykonuje się ono zawsze, nawet jeżeli warunek przebiegu pętli jest od samego początku fałszywy.

Po wykonaniu wyrażenie1 pętla for sprawdza warunek zawarty w wyrażenie2, jeżeli jest on prawdziwy ( inny niż zero), to wykonywana jest treść pętli for, czyli najczęściej to co znajduje się między klamrami, lub gdy ich nie ma, następna pojedyncza instrukcja. W szczególności musimy pamiętać, że sam średnik też jest instrukcją - instrukcją pustą.

Gdy już zostanie wykonana treść pętli for, następuje wykonanie wyrażenie3. Należy zapamiętać, że wyrażenie3 zostanie wykonane, nawet jeżeli był to już ostatni obieg pętli. Poniższe 4 przykłady pętli for w rezultacie dadzą ten sam wynik. Wypiszą na ekran liczby od 1 do 10.

 
 for(i=1; i<=10; ++i){
  printf("%d", i);
 }

 for(i=1; i<=10; ++i){
  printf("%d", i);
}

 for(i=1; i<=10; printf("%d", i++ ) );

 
 // 4 przykład 
 for(i=1; i<10; printf("i = %d", i++ ) ); 
 printf(" i = %d", i ); // wyrażenie3 i++ zostanie wykonane, nawet jeżeli był to już ostatni obieg pętli

Dwa pierwsze przykłady korzystają z własności struktury blokowej, kolejny przykład jest już bardziej wyrafinowany i korzysta z tego, że jako wyrażenie3 może zostać podane dowolne bardziej skomplikowane wyrażenie, zawierające w sobie inne podwyrażenia. A oto kolejny program, który najpierw wyświetla liczby w kolejności rosnącej, a następnie wraca.

 #include <stdio.h>
 int main()
 {
  int i;
  for(i=1; i<=5; ++i){   
    printf("%d", i);
    }  

  for( ; i>=1; --i){
    printf("%d", i);
    }
 
  return 0;
 }

Po analizie powyższego kodu, początkujący programista może stwierdzić, że pętla wypisze 123454321. Stanie się natomiast inaczej. Wynikiem działania powyższego programu będzie ciąg cyfr 12345654321. Pierwsza pętla wypisze cyfry "12345", lecz po ostatnim swoim obiegu pętla for (tak jak zwykle) zinkrementuje zmienną i. Gdy druga pętla przystąpi do pracy, zacznie ona odliczać począwszy od liczby i=6, a nie 5. By spowodować wyświetlanie liczb od 1 do 5 i z powrotem wystarczy gdzieś między ostatnim obiegiem pierwszej pętli for a pierwszym obiegiem drugiej pętli for zmniejszyć wartość zmiennej i o 1.

Niech podsumowaniem będzie jakiś działający fragment kodu, który może obliczać wartości kwadratów liczb od 1 do 10.

   
 #include <stdio.h>
 
 int main ()
 {
   int a;
   for (a=1; a<=10; ++a) {
     printf ("%d\n", a*a);
   }
   return 0;
 }

Porada W kodzie źródłowym spotyka się często inkrementację i++. Jest to zły zwyczaj, biorący się z wzorowania się na nazwie języka C++. Post-inkrementacja i++ powoduje, że tworzony jest obiekt tymczasowy, który jest zwracany jako wynik operacji (choć wynik ten nie jest nigdzie czytany). Jedno kopiowanie liczby do zmiennej tymczasowej nie jest drogie, ale w pętli "for" takie kopiowanie odbywa się po każdym przebiegu pętli. Dodatkowo, w C++ podobną konstrukcję stosuje się do obiektów - kopiowanie obiektu może być już czasochłonną czynnością. Dlatego w pętli "for" należy stosować wyłącznie ++i.

Pętle while i for mają jeden zasadniczy mankament - może się zdarzyć, że nie wykonają się ani razu. Aby mieć pewność, że nasza pętla będzie miała co najmniej jeden przebieg musimy zastosować pętlę do while. Wygląda ona następująco:

 do {
   /* instrukcje do wykonania w pętli */
 } while (warunek);
 /* dalsze instrukcje */

Zasadniczą różnicą pętli do while jest fakt, iż sprawdza ona warunek pod koniec swojego przebiegu. To właśnie ta cecha decyduje o tym, że pętla wykona się co najmniej raz. A teraz przykład działającego kodu, który tym razem będzie obliczał trzecią potęgę liczb od 1 do 10.

 #include <stdio.h>
 
 int main ()
 {
   int a = 1;
   do {
     printf ("%d\n", a*a*a);
     ++a;
   } while (a <= 10);
   return 0;
 }

Może się to wydać zaskakujące, ale również przy tej pętli zamiast bloku instrukcji można zastosować pojedynczą instrukcję, np.:

 #include <stdio.h>
 
 int main ()
 {
   int a = 1;
   do printf ("%d\n", a*a*a); while (++a <= 10);
   return 0;
 }

Instrukcja break pozwala na opuszczenie wykonywania pętli w dowolnym momencie. Przykład użycia:

 int a;
 for (a=1 ; a != 9 ; ++a) {
   if (a == 5) break;
   printf ("%d\n", a);
 }

Program wykona tylko 4 przebiegi pętli, gdyż przy 5 przebiegu instrukcja break spowoduje wyjście z pętli.

W przypadku pętli for nie trzeba podawać warunku. W takim przypadku kompilator przyjmie, że warunek jest stale spełniony. Oznacza to, że poniższe pętle są równoważne:

 for (;;) { /* ... */ }
 for (;1;) { /* ... */ }
 for (a;a;a) { /* ... */} /*gdzie a jest dowolną liczba rzeczywistą różną od 0*/
 while (1) { /* ... */ }
 do { /* ... */ } while (1);

Takie pętle nazywamy pętlami nieskończonymi, które przerwać może jedynie instrukcja break^[61](z racji tego, że warunek pętli zawsze jest prawdziwy) ^[62].

Wszystkie fragmenty kodu działają identycznie:

 int i = 0;
 for (;i!=5;++i) {
   /* kod ... */
 }

 int i = 0;
 for (;;++i) {
   if (i == 5) break;
 }

 int i = 0;
 for (;;) {
   if (i == 5) break;
   ++i;
 }

W przeciwieństwie do break, która przerywa wykonywanie pętli instrukcja continue powoduje przejście do następnej iteracji, o ile tylko warunek pętli jest spełniony. Przykład:

 int i;
 for (i = 0 ; i < 100 ; ++i) {
   printf ("Poczatek\n");
   if (i > 40) continue ;
   printf ("Koniec\n");
 }

Dla wartości i większej od 40 nie będzie wyświetlany komunikat "Koniec". Pętla wykona pełne 100 przejść.

Oto praktyczny przykład użycia tej instrukcji:

 #include <stdio.h>
 int main()
 {
   int i;
   for (i = 1 ; i <= 50 ; ++i) {
     if (i%4 == 0) continue ;
     printf ("%d, ", i);
   }
   return 0;
 }

Powyższy program generuje liczby z zakresu od 1 do 50, które nie są podzielne przez 4.

Istnieje także instrukcja, która dokonuje skoku do dowolnego miejsca programu, oznaczonego tzw. etykietą.

 etykieta:
 /* instrukcje */
 goto etykieta;

Uwaga!: kompilator GCC w wersji 4.0 i wyższych jest bardzo uczulony na etykiety zamieszczone przed nawiasem klamrowym, zamykającym blok instrukcji. Innymi słowy: niedopuszczalne jest umieszczanie etykiety zaraz przed klamrą, która kończy blok instrukcji, zawartych np. w pętli for. Można natomiast stosować etykietę przed klamrą kończącą daną funkcję.

Porada Instrukcja goto łamie sekwencję instrukcji i powoduje skok do dowolnie odległego miejsca w programie - co może mieć nieprzewidziane skutki. Zbyt częste używanie goto może prowadzić do trudnych do zlokalizowania błędów. Oprócz tego kompilatory mają kłopoty z optymalizacją kodu, w którym występują skoki. Z tego powodu zaleca się ograniczenie zastosowania tej instrukcji wyłącznie do opuszczania wielokrotnie zagnieżdżonych pętli.