C-programmering

C-programmering

Historia|Miljö|...TBD...

C är ett av de mest använda programspråken, och också ett av de mest långlivade. Det utvecklades av främst Dennis Ritchie parallellt med operativsystemet Unix under tiden 1969–1973, så att allt större delar av detta operativsystem kom att skrivas i C. Även om C har kommit att användas för programmering av användarapplikationer, så är den primära användningen fortfarande systemorienterad programmering. C lämpar sig för att skriva operativsystem, snabba serverapplikationer i klient-serversystem, drivrutiner till hårdvara, demoner/services i operativsystemet, interpreterande programspråk, databassystem och dylika program som behöver köra stabilt och snabbt.

C lämpar sig inte bra för att skriva textkonverteringsskript, Unicode-baserad textbehandling, och dylika applikationer där ANSI-C-standarden är definierad på ett sätt som tvingar C:s exekvering in i ett operativsystemberoende som gör att programmen inte fungerar om systemoperatören inte satt upp datamiljön för all världens språk. Med väl planerat val av bibliotek som inte ingår i standarden kan dessa problem kringgås utan alltför stort besvär.

Denna wikibok har nybörjare som primär målgrupp, inriktat på dem som verkligen vill bli produktiva programmerare. Det kommer att vara uppbyggt för att stödja dessa programmerare långt framåt, bland annat genom att inkludera material som gör att delar av det kommer att kunna användas som ett komplett uppslagsverk med avseende på ISO-standarderna, inklusive C99 och eventuellt C11.

Här ligger just nu en kopia av en tidigare version av Wikipedia-artikeln om C.

Kapitel

Syntax och uppbyggnad

C är skiftlägeskänsligt, det vill säga det skiljer på versaler och gemener i nyckelord och namn. Av praxis används versaler sällan utom i preprocessordirektiv och konstanter.

Satser och block

Varje sats i C är ett kommando som avslutas med ett semikolon, ;. I de flesta fall kan en sats bytas ut mot ett block av kod. Block skrivs inom klammerparenteser, { ... }.

Satser och block behöver inte vara på separata rader. Flera satser kan stå på samma rad och en sats kan vara utspridd över flera rader. Whitespace, det vill säga radbrytningar, tabulatorer och mellanslag, behandlas i de flesta fall lika och behövs bara mellan nyckelord och namn. Denna frihet ger möjligheten till olika kodformateringsstilar, varav en av de mest kända är den som Kernighan och Ritchie använde i The C Programming Language, den så kallade K&R-stilen.

Det främsta undantaget från whitespace-friheten är preprocessordirektiven, som måste stå först på raden och avslutas med en radbrytning eller en kommentar.

/* Preprocessordirektiv måste stå först på en egen rad. */
#include <stdio.h>

/* En deklaration utspridd över flera rader. */
int main(
    int argc,
    char **argv)
{
    /* Flera satser på samma rad. */
    int a = 4; a = a * 4; return a;
}

Programflöde

C har flera sorters villkorliga satser och slingor som styr vilken kod som exekveras.

Villkorliga satser

Det främsta sättet att göra villkorliga satser på är med if. if följs av ett logiskt uttryck inom parentes, och sedan en sats eller ett block som exekveras om och endast om det logiska uttrycket är sant. Detta kan valfritt följas av else och en sats eller ett block som exekveras om och endast om det logiska uttrycket är falskt.

if(a > 5)
    puts("a är större än 5.");
else
{
    puts("a är inte större än 5.");
    if(a < 5)
        puts("a är till och med mindre än 5.");
}

Som komplement till if i situationer där en och samma variabel jämförs med flera värden finns switch-satsen. Den tar ett uttryck inom parentes och jämför resultatet med en lista av utfall. Utfallen skrivs med case före och ett kolon efter, och fungerar ungefär som radetiketter. Kodexekveringen fortsätter från respektive rad. Till skillnad från switch-satser i en del andra språk stannar exekveringen inte när nästa case börjar. Vill man lämna switch-satsen använder man break (eller, om man vill avbryta hela funktionen, return). Om ingen matchande case finns fortsätter exekveringen från default om det finns, annars hoppas satsen över.

I exemplet nedan testas variabeln a. Om a är lika med 1 fortsätter programmet från case 1. Om a är lika med 2 fortsätter programmet från case 2. Eftersom case 1 inte avslutas med break kommer exekveringen att fortsätta in i case 2 så att båda utskrifterna görs.

switch(a)
{
case 1:
    puts("a är lika med 1.");
case 2:
    puts("a är lika med 1 eller 2.");
    break;
case 3:
case 4:
case 5:
    puts("a är lika med 3, 4 eller 5.");
    break;
default:
    puts("a:s värde var inte med i listan.");
}

Slingor

C har tre olika sorters slingor: for, while och do while.

for används vanligen för att iterera genom ett antal element, till exempel en lista, med hjälp av en räknare. for följs av en parentes med tre semikolonseparerade satser:

En sats eller en variabeldefinition som körs före slingan; typiskt tilldelas här en räknare sitt startvärde.
Ett villkor för om slingan upprepas eller inte.
En sats som körs sist i slingan; typiskt räknas räknaren upp här.

Sedan följer ett kodblock (eller en sats) som utgör själva slingan.

När en for-slinga exekveras utförs först den första satsen. Om en variabel definieras i den första satsen sträcker sig dess definitionsområde endast till slingan, den kan inte användas efteråt. Sedan görs en test av villkoret; om det är falskt så avslutas slingan, annars exekveras kodblocket. När kodblocket har exekverats kommer den sista satsen från for-satsen. Sedan hoppar programmet tillbaka till villkoret och fortsätter därifrån.

/* Skriver ut n och kvadraten av n för n = 1 till 25. */
for(int n = 1; n <= 25; n++)
{
    printf("%d %d\n", n, n*n);
}

Alla tre delar i for-satsen är valfria och kan lämnas tomma. Villkoret räknas som alltid sant om det utlämnas.

while är en enklare slinga än for. Den följs av en parentes med endast ett villkor.

/* Upprepa slingan så länge som getchar() inte returnerar bokstaven 'a'. */
printf("Tryck på a för att fortsätta.");
while(getchar() != 'a')
{
    printf("Fel! Tryck på a.");
}
printf("Rätt!");

do while fungerar precis som while, förutom att villkoret inte testas före första exekveringen. do while-slingan är därför garanterad att exekveras åtminstone en gång.

/* Upprepa slingan så länge som getchar() inte returnerar bokstaven 'a'. */
do
{
    printf("Tryck på a för att fortsätta.");
}
while(getchar() != 'a');
printf("Rätt!");

En slinga kan avbrytas i förtid med nyckelordet break. Exekveringen fortsätter då direkt efter slingan. Om programmet nästlar flera nivåer av slingor är det den närmaste som avbryts. Det går också att hoppa över resten av koden och fortsätta till nästa varv i slingan med nyckelordet continue. I for-slingor exekveras inkrementeringen, och i samtliga slingor testas villkoret.

Ovillkorliga hopp

C tillhandahåller goto, men det används i praktiken mycket sparsamt. Med goto kan man hoppa till en valfri plats i koden. Denna plats identifieras med ett namn, en radetikett, och avslutas med ett kolon.

int a = 5;
goto hopp;
a = 7; /* Den här raden exekveras aldrig. */
hopp:
printf("%d\n", a); /* Skriver alltid ut "5". */

Andra ovillkorliga hopp är continue, som hoppar till nästa iteration av en slinga; break, som hoppar ur en slinga eller switch-sats; och return, som hoppar ur en funktion.

Funktioner

En funktion definieras i C med först en returtyp, sedan namnet på funktionen, och sist en kommaseparerad lista av parametrar inom parentes. Sedan följer ett kodblock med funktionens kod. Om funktionen har en returtyp (det vill säga inte void) avslutas den med nyckelordet return och returvärdet. return måste inte ligga sist i funktionen, utan kan användas till exempel i villkorliga satser för att avsluta en funktion innan den har nått slutet.

/* En funktion som returnerar summan av två heltal. */
int summa(int a, int b)
{
    return a + b;
}

Typdeklarationen av en funktions parametrar kan utelämnas ur funktionsdeklarationen och i stället skrivas före kodblocket. Före C99 var det tillåtet att helt utelämna typdeklarationen – sådana parametrar antogs då vara av typen int. Dessa skrivsätt är inte vanliga eller rekommenderade.

/* En funktion som returnerar summan av två heltal. */
int summa(a, b)
    int a, b; /* Denna rad är inte nödvändig i C-versioner före C99. */
{
    return a + b;
}

Om en funktion ska anropas från ett ställe där den inte redan är definierad, till exempel tidigare i samma källkodsfil, i en annan källkodsfil eller förkompilerad i ett programbibliotek, så måste den först deklareras utan sitt kodblock så att kompilatorn känner till funktionens parametrar och returtyp. Denna deklaration sker vanligen i en headerfil som kan inkluderas från alla källkodsfiler som vill använda funktionen.

int summa(int a, int b);

En funktion som inte returnerar ett värde (ibland kallad för subrutin) ges den symboliska returtypen void. Om funktionen inte har några parametrar lämnas parentesen antingen tom eller med void.

Funktionen summa kan anropas med parametrar och dess returvärde kan fångas upp på följande sätt:

int x = summa(8, 13);

main
[redigera]

Varje C-program måste innehålla en funktion som heter main. Det är i main som programmet startar, programmets entry point. Funktionen tar två parametrar. De innehåller de argument som har skickats till programmet: argc (argument count) är ett heltal som säger hur många argument som har skickats med, och argv (argument vector) är en lista av strängar med argumenten. Den första strängen i listan är alltid namnet på programmet självt, vanligen inklusive sökvägen. Funktionen returnerar ett heltal som typiskt fungerar som resultat eller felmeddelande till det anropande programmet.

/* Den normala deklarationen av main. */
int main(int argc, char **argc);

/* I K&R C utelämnas vanligen parametrarna. */
int main();

/* Vissa kompilatorer tillåter att main inte returnerar något. */
void main(int argc, char **argc);

Kommentarer
[redigera]

Kommentarer är fritext som en utvecklare kan lägga till källkoden, till exempel för att beskriva vad koden gör. Kommentarer påverkar inte programmet som sådant. En vanliga användning av kommentarer är också att maskera kod så att den inte kompileras med i programmet, vanligen i debugsyfte. Detta kallas ofta för bortkommentering av källkod. Kommentarer rensas bort internt av kompilatorn innan källkoden kompileras.
Kommentarer inleds med /* och avslutas med */. Detta kallas ibland för blockkommentarer för att skilja dem från radkommentarer, då de kan användas för att skriva kommentarer över flera rader.
Många C-kompilatorer erbjuder radkommentarer. Dessa startar med // och avlutas vid radbrytning. Denna typ av kommentarer fanns i BCPL men togs inte med i B och heller inte i Ritchies ursprungliga version av C eller i ANSI C. C++ tog däremot upp bruket, och i och med att många kompilatorer fungerar för både C och C++ spred sig bruket till C. Radkommentarer standardiserades i C99.

/* En blockkommentar som
   sträcker sig över flera
   rader. */

int j; // En radkommentar kan beskriva vad koden i början av raden gör.

Preprocessordirektiv
[redigera]

Ett preprocessordirektiv är en instruktion till kompilatorn som modifierar källkoden innan den kompileras. Preprocessordirektiv inleds i C med #, som måste stå först på raden, och avslutas vid radbrytning. De vanligaste direktiven är #include, som vanligen används för att hämta funktionsdefinitioner och andra definitioner, och #define, som används för att skapa makron.



Direktiv

Beskrivning


#define, #undef

Definierar ett makro.


#error

Genererar ett felmeddelande vid kompileringen.


#if, #else, #elif, #endif, #ifdef, #ifndef

Villkorliga block baserade på tester


#include

Inkluderar andra källkodsfiler, vanligen headerfiler.


#pragma

Kompilatorspecifika direktiv.

Variabler och datatyper
[redigera]

C har ett antal enkla datatyper. Storlekarna på dem är avsiktligt vagt definierade. Därför kan det vara svårt att porta källkod från ett system till ett annat, till exempel från ett 16-bitarssystem till ett 32-bitarssystem.
För att definiera en variabel i C skriver man först datatypen och sedan variabelnamnet och avslutar med semikolon. Flera variabler av samma typ kan definieras på samma gång. De separeras då av kommatecken.

/* Definiera två variabler i och j av typen int. */
int i, j;

Tilldelning av variabler görs med ett likamedtecken. Jämförelser görs med dubbla likamedtecken.

/* Om i är lika med 6 så tilldelas j värdet 1. */
if(i == 6)
    j = 1;

Heltal
[redigera]

C har två grundläggande heltalsdatatyper:

char, som representerar teckendata. Storleken på en char är 1 byte, det vill säga den minsta adresserbara dataenheten som är minst 8 bit stor. Alla andra datatypers storlekar är multipler av char.
int, som vanligen är samma storlek som datorns ordtyp, typiskt 16 (garanterad minsta storlek), 32 eller 64 bitar.

De två heltalstyperna kan modifieras för att vara med eller utan tecken för att tillåta både positiva och negativa tal:

signed (med tecken)
unsigned (utan tecken)

signed innebär att en bit avsätts för att skilja mellan negativa och positiva tal, oftast (men inte nödvändigtvis) i tvåkomplementsform. Om ingen av dessa två anges så impliceras signed för int-typen. För char varierar implementationen mellan olika kompilatorer.
Storleken på datatypen int kan modifieras:

short eller short int, minst 16 bitar
long eller long int, minst 32, ofta 64 bitar
long long eller long long int, minst 64 bitar (sedan C99)

Logiska/booleska värden
[redigera]

I C fanns ursprungligen ingen strikt boolesk typ, vars enda värden skulle vara sant och falskt. I stället används heltal av typen int, där värdet noll representerar falskt och ett (eller icke-noll) representerar sant. Alla logiska operationer returnerar int, och alla villkorliga satser tolkar noll som falskt och alla andra värden som sant.

/* Det logiska uttrycket "13 < 6" är falskt, så x får värdet 0. */
int x = 13 < 6;

/* 7 är icke-noll. Det tolkas därför som sant och satsen exekveras alltid. */
if(7)
{ ... }

I C99 introducerades typen _Bool, med aliaset bool definierad i headerfilen bool.h, som en boolesk typ som kan anta värdena noll och ett för falskt respektive sant. Logiska operatorer är dock fortsatt av typen int.

Flyttal
[redigera]

Det finns tre flyttalstyper:

float
double
long double (sedan C89, men med bra stöd först i C99)

Standarden specificerar inte vad det ska vara för format på flyttalen. I de flesta implementationer är float och double baserade på IEEE 754:s standarder för enkel (32 bitar) och dubbel (64 bitar) precision. Den största flyttalstypen, long double, har sämre stöd i standardbiblioteken, och dess implementation varierar mer mellan olika plattformar, från 64 till 128 bitar. Standarden garanterar inte att det är någon skillnad alls mellan de tre typerna, bara att double är minst lika stor som float, och att long double är minst lika stor som double.
I standardbiblioteken användes ursprungligen endast double; float behandlades som en minnessparande typ som konverteras till double vid funktionsanrop. I C99 infördes varianter av standardbibliotekens funktioner för float och long double, till exempel sinusfunktionen double sin(double) med varianterna float sinf(float) och long double sinl(long double).

Komplexa tal
[redigera]

I C99 definierades en utökning för variabler som är komplexa tal. Dessa definieras med nyckelordet _Complex plus en flyttalstyp. Vanligen används complex, som är ett alias för _Complex men som bara finns tillgängligt om man inkluderar headerfilen complex.h. I samma headerfil finns konstanten I definierad som den imaginära enheten.
De vanliga flyttalstyperna räknas som reella tal. För rent imaginära tal kan man använda _Imaginary på samma sätt som _Complex, med ett motsvarande alias imaginary.

complex double z1, z2, z3;

z1 = 5 + 2*I; /* 5 + 2i */
z2 = 1 - I;   /* 1 - i */

z3 = z1 * z2; /* 7 - 3i */

Listor och matriser
[redigera]

En lista (engelska: array) definieras genom att till variabelnamnet lägga hakparenteser mellan vilka man skriver listans längd. Längden kan utelämnas om man i definitionen sätter värden på listan. För att läsa eller ändra ett värde i en lista skriver man indexet inom hakparenteser efter variabelnamnet. Det första elementet i en lista har alltid index 0.

int a[5]; /* En array med 5 element. */
int b[] = {12, -4, 7, 112}; /* En array med fyra element */

a[4] = b[2]; /* Det sista elementet i a tilldelas värdet av det tredje i b, det vill säga talet 7. */

Rent syntaktiskt kan listan och indexet byta plats.^[1] Detta används dock sällan i praktiken eftersom det försvårar läsbarheten.

/* x och y tilldelas samma värde: det fjärde elementet i a. */
int x = a[3];
int y = 3[a];

En matris är en lista med två dimensioner, eller en lista av listor. På samma sätt kan man bygga matriser av ännu högre dimensioner.

int m[5][12]; /* En matris med 5×12 element. */
int q[10][10][10][10]; /* En fyrdimensionell matris med 10×10×10×10 element. */

Förutom vid definitionstillfället kan listor inte tilldelas i sin helhet, bara elementvis.

int a[5], b[5];
a = b; /* Inte möjligt. */

Pekare
[redigera]

Pekare är en speciell datatyp som hänvisar till en adress i minnet där det egentliga datat finns. Pekarvariabler definieras med en datatyp och en asterisk framför pekarnamnet:

/* Definiera en variabel av typen int, och en pekare till typen int. */
int i, *p;

En pekare kan tilldelas adressen till en annan variabel av motsvarande datatyp genom att man sätter ett et-tecken framför variabln:

/* Gör så att p pekar på i. */
p = &i;

För att hämta eller manipulera värdet på den minnesadress som en pekare pekar på skriver man en asterisk framför pekaren:

/* Ändra värdet som p pekar på, det vill säga värdet av i. */
*p = 17;

En pekare kallas för en nullpekare när den pekar på minnesadressen 0. Detta räknas i princip alltid som att pekare är oinitierad och inte ännu bör användas. Att försöka att läsa från eller skriva till adress 0 leder i många moderna system till undantag eller att programmet kraschar.
Pekare kan användas som listor. Indexet multipliceras med datatypens storlek och adderas till minnesadressen innan värdet hämtas. På samma sätt fungerar listor som pekare till det första elementet i listan. En pekare kan tilldelas värdet av en lista; de pekar då samma minne och kan användas på samma sätt.

int *p, l[10];

p = l; /* p och l pekar på samma minne. */
p[2] = 7; /* Tilldelar l[2] värdet 7. */

En pekare kan adderas med ett heltal. Det ger en pekare som pekar på ett annat element i en lista. Att lägga på 1 innebär nästa element, och så vidare. Pekare kan inte adderas till varandra, men man kan ta differensen mellan dem för att få veta avståndet i antal element mellan dem.

int *p, l[10];

p = l + 5; /* p pekar på det femte elementet i l, dvs &l[5]. */
p[-3] = 9; /* Tilldelar l[2] värdet 9. */
*(p+2) = l-p; /* Tilldelar l[7] värdet 5; */

C har friare möjligheter till pekarhantering än många andra programspråk. Det beror på att C utvecklades för programmering av operativsystem med den lågnivåkod det kan innebära. Exempel på detta är att man kan få en pekare till en variabel, stega pekare, följa pekare via index, och omvandla mellan olika pekartyper.

char *p, s = "text";
int len = 0;
for(p = s; *p != '\0'; p++) /* p pekar på s. Stega p tills ett nolltecken hittas. */
{
    len++; /* len kommer att ange längden på strängen */
}

Strängar
[redigera]

Det finns ingen särskilt strängtyp i C, utan en sträng är detsamma som en lista av char-värden. Strängar avslutas med ett NULL-tecken, alltså en char med heltalsvärdet 0. När man reserverar minnesutrymme för en sträng måste man räkna med NULL-tecknet. Statiska strängar skrivs inom dubbla citattecken; NULL-tecknet är då implicit med.
Det finns inget i strängen som säger hur lång den är, eller hur mycket minne som den kan använda.

char c[] = "Hej!"; /* En sträng – eller en array med fem element (fyra skrivtecken plus implicit NULL) */

Eftersom strängar är listor eller pekare går de inte att jämföra som andra variabler. I stället används särskilda funktioner i C:s standardbibliotek string.h för sådana jämförelser:

char a[] = "Hello", b[] = "World";
/* Funktionen strcmp returnerar 0 om strängarna är lika. */
if(strcmp(a, b) == 0)
    puts("a och b är lika.");
else
    puts("a och b är olika.");

void
[redigera]

void är egentligen ingen datatyp, utan en symbol för när det inte finns någon datatyp. Den används i tre sammanhang:

För att definiera att en funktion inte har en returtyp.
För att definiera att en funktion inte tar några parametrar.
För att definiera eller typkonvertera pekare som typen void *, som kan peka på vilken annan typ som helst.

Sammansatta datatyper
[redigera]

C har stöd för användardefinierade, sammansatta typer, så kallade strukturer, genom nyckelordet struct. Sammansatta typer består av en eller flera medlemmar som kan vara av olika typer.

/* Definiera strukturen "kartplats" och en variabel "mariehamn". */
struct kartplats
{
    double longitud, latitud;
    char namn[50];
} mariehamn;

/* Tilldela värden till variabelns medlemmar. */
mariehamn.latitud = 60.10;
mariehamn.longitud = 19.93;
mariehamn.namn = "Mariehamn";

Unioner
[redigera]

En särskilt sorts sammansatta typer är unioner. I unioner pekar alla medlemmar på samma minnesutrymme. Unionens storlek är storleken på den största medlemmen. Det betyder rent praktiskt att man inte kan använda flera medlemmar samtidigt, eftersom de pekar på data som kan betyda helt olika saker beroende på vilken datatyp som förväntas.

/* Definiera unionen "volym" och en variabel "x". */
union volym
{
    int steg;
    double decibel;
} x;

/* Tilldela värde till en medlem. */
x.steg = 11;
/* Att läsa en annan medlems värde nu ger ett odefinierat resultat,
   som kan skilja sig mellan plattformar och kompilatorer. */
printf("%f\n", x.decibel);

Operatorer
[redigera]

Aritmetiska operatorer
[redigera]

Resultatet av de aritmetiska operatorerna är värdet på operationen. Till exempel är resultatet av b = c lika med det nya värdet på b. Det värdet kan i sin tur tilldelas en annan variabel: a = b = c. Då tilldelas b värdet av c, och a tilldelas värdet av b = c, det vill säga också c. Undantaget är de unära operatorerna för inkrementering och dekrementering, som finns i två former: ett prefix som returnerar det nya värdet och ett suffix som returnerar det gamla.



Operator

Syntax

Resultat (värde)


Tilldelning

a = b

Värdet på a efter tilldelningen. Detta kan användas för att sätta flera variabler till samma värde: a = b = c = 7;


Addition

a + b

Summan av a och b.


Subtraktion

a - b

Differensen mellan a och b.


Unärt plus

+a

Värdet på a. Om a är en mindre datatyp så konverteras den till signed int.


Unärt minus (negation)

-a

Värdet på a med motsatt tecken. Om a är en mindre datatyp så konverteras den till signed int.


Multiplikation

a * b

Produkten av a och b.


Division

a / b

Kvoten av a och b. Vid heltalsdivision är resultatet ett heltal.


Modulo (rest vid division)

a % b

Resten vid heltalsdivision av a med b. Fungerar endast på heltal.


Inkrement (prefix)

++a

a tilldelas värdet av a+1, och det nya värdet returneras.


Inkrement (suffix)

a++

a tilldelas värdet av a+1, och det gamla värdet returneras.


Dekrement (prefix)

--a

a tilldelas värdet av a-1, och det nya värdet returneras.


Dekrement (suffix)

a--

a tilldelas värdet av a-1, och det gamla värdet returneras.

Jämförelseoperatorer
[redigera]

Jämförelseoperatorer används för att jämföra två variabler eller uttryck med varandra. Resultatet av en jämförelse är ett heltal av typen int med värdet noll för falskt och ett för sant.



Operator

Syntax


Lika med

a == b


Ej lika med

a != b


Större än

a > b


Mindre än

a < b


Större än eller lika med

a >= b


Mindre än eller lika med

a <= b

Logiska operatorer
[redigera]

Logiska operatorer används på logiska (boolska) uttryck. Efter som C före C99 saknade en boolesk typ används heltal för att representera dessa värden: 0 betyder falskt och icke-0 sant. Resultatet av de logiska operatorerna är alltid 0 för falskt och 1 för sant.



Operator

Syntax


Negation (ICKE)

!a


Konjunktion (OCH)

a && b


Inklusiv disjunktion (ELLER)

a || b

Bitoperatorer
[redigera]

Bitoperatorer används på heltal för att utföra operationer på binärrepresentationen av tal.



Operator

Syntax


Bitvis negation (ICKE)

~a


Bitvis konjunktion (OCH)

a & b


Bitvis inklusiv disjunktion (ELLER)

a | b


Bitvis exklusiv disjunktion (XOR)

a ^ b


Bitvis skiftning, vänster

a << b


Bitvis skiftning, höger

a >> b

Operatorer för sammansatt aritmetik och tilldelning
[redigera]

Redan i B fanns möjligheten att utföra en operation på en variabel och tilldela variabeln resultatet med en förenklad syntax. Fördelen är tydligast när vänsterledet är ett komplicerat uttryck, till exempel en listelement med ett aritmetiskt uttryck som index. Resultatet av uttrycket är detsamma som vid en vanlig tilldelning.

/* Följande uttryck är ekvivalenta */
a = a * b;
a *= b;



Operator

Syntax


Addition och tilldelning

a += b


Subtraktion och tilldelning

a -= b


Multiplikation och tilldelning

a *= b


Division och tilldelning

a /= b


Modulo och tilldelning

a %= b


Bitvis konjunktion och tilldelning

a &= b


Bitvis inklusiv disjunktion och tilldelning

a |= b


Bitvis exklusiv disjunktion och tilldelning

a ^= b


Bitvis vänsterskiftning och tilldelning

a <<= b


Bitvis högerskiftning och tilldelning

a >>= b

Objekt-, pekar- och listoperatorer
[redigera]



Operator

Syntax

Resultat


Listindex

a[b]
b[a]

Element nummer b från en lista a, eller elementet på minnesposition a + b * s, där a är en pekare och s är storleken på datatypen som a pekar på. a och b kan byta plats i uttrycket.^[1]


Avreferering

*a

Elementet som a pekar på; detsamma som a[0].


Referering

&a

En pekare till a.


Medlem (i objekt)

a.b

Medlemmen b i a, där a är ett objekt av en strukturerad typ (struct eller union).


Medlem (i pekare)

a->b

Medlemmen b i a, där a är en pekare till ett objekt av en strukturerad typ.

Övriga operatorer
[redigera]



Operator

Syntax

Resultat


Funktionsanrop

a(a1, a2)

Resultatet från funktionen a.


Komma

a, b

b.


Villkorlig beräkning

a ? b : c

b om a är sant (icke-noll), annars c.


Datatypstorlek

sizeof a
sizeof(typ)

Storleken på objektet a eller datatypen typ i byte (multipler av char). Storleken är av heltalstypen size_t och inkluderar det eventuella utfyllnadsutrymme som kan krävas av systemet för att kunna adressera objekten.


Datajustering

_Alignof(a)
_Alignof(typ)

Datajusteringen (data alignment) för objektet a eller datatypen typ i byte (multipler av char). Storleken är av heltalstypen size_t. (Sedan C11.)


Typkonvertering

(typ) a

Värdet av a efter typkonvertering.

Reserverade nyckelord
[redigera]

C är ett av de språk med lägst antal nyckelord (även kallat reserverade ord): 32 stycken i C89, 37 i C99 och 44 i C11. Nyckelord kan inte användas som namn på variabler, funktioner eller användardefinierade typer.
När namnen på de varibeltyper som introducerades i C99 och C11 skulle bestämmas togs hänsyn till att de kan krocka med användardefinierade typer och variabelnamn i källkod som är skrivna för äldre versioner av standarden. Därför har de fått namn som avviker från mönstret, till exempel _Complex. Genom att inkludera särskilda C99- eller C11-specifika header-filer fås tillgång till makron med mer typiska namn, till exempel complex.
Många kompilatorer har utöver dessa nyckelord en mindre grupp egna ord för olika kompilatorspecifika funktioner. Ett av de vanligaste är asm, som används för att skriva assemblerkod direkt i C-koden.



Nyckelord

Standard

Beskrivning


_Alignas

C11

Sätter datajusteringen (data alignment) hos ett objekt eller en typ.


_Alignof

C11

Ger datajusteringen hos ett objekt eller en typ.


_Atomic

C11

Används för att skapa variabler som kan användas till atomiska, trådsäkra operationer.


auto



Skrivs före en variabel. Anger att kompilatorn får välja hur variabeln lagras. Jämför register.


_Bool

C99

En boolesk datatyp. Används oftast genom makrot bool.


break



Avbryter en do-, for-, switch- eller while-sats.


case



Anger alternativ i switch-satser.


char



En heltalstyp.


_Complex

C99

En komplex datatyp. Används oftast genom makrot complex.


const



Anger att en variabels värde inte kan ändras under körning.


continue



Hoppar till slutet av en do-, for- eller while-sats.


default



Det alternativ i en switch-sats som väljs när inget av de andra alternativen valdes.


do



En slinga vars villkor kommer efter första blocket, så att det är garanterat att exekveras minst en gång.


double



En datatyp för flyttal.


else



Startar alternativgrenen i if-satser.


enum



Definierar uppräkningstyper.


extern



Tillåter att en funktions kod eller variabels lagring finns i en annan modul är den nuvarande.


float



En datatyp för flyttal.


for



En slinga som vanligen används för att stega igenom listor eller liknande.


_Generic

C11

Används för att bygga typgeneriska makron.


goto



Sats för att flytta exekveringen till en annan del av koden (se goto).


if



Villkorlig sats.


_Imaginary

C99

En imaginär datatyp. Används oftast genom makrot imaginary.


inline

C99

Används för att göra koden snabbare genom att eliminera funktionsanrop för små funktioner.


int



En heltalstyp.


long



En heltalstyp (även long long).


_Noreturn

C11

Specificerar att en funktion inte kommer att returnera.


register



Skrivs före en variabel. Anger att kompilatorn om möjligt bör hålla denna variabel i ett processorregister. Jämför auto.


restrict

C99

Används i funktionsdeklarationer för att tillåta kompilatorn att optimera koden som hanterar pekare genom att säga att två pekare inte får peka på samma minnesadress.


return



Avslutar en funktion. Om funktionen returnerar ett värde så måste return följas av ett sådant.


short



En heltalstyp.


signed



Säger att en heltalstyp ska tillåta negativa värden.


sizeof



Ger storleken i bytes av en datatyp.


static



Deklarerar att en lokal variabel i en funktion ska behålla sitt värde mellan anrop.


_Static_assert

C11

Utför tester under kompileringen.


struct



En strukturerad datatyp.


switch



En sats med flera villkor och flera alternativa exekveringsvägar.


_Thread_local

C11

Specificerar att en variabel är lokal för en tråd.


typedef



Typdefinitioner, ett sätt att förkorta och förtydliga namn på datatyper.


union



En strukturerad datatyp där flera variabler delar på samma minnesutrymme.


unsigned



Säger att en heltalstyp bara ska tillåta positiva värden.


void



Säger att en funktion inte returnerar något värde eller inte tar några parametrar, eller att en pekare kan peka på vilken datatyp som helst.


volatile



Skrivs före en variabel. Anger att kompilatorn inte får spara variabeln i ett register, eftersom dess värde kan ändras när som helst, till exempel av andra trådar.


while



En slinga vars villkor kommer först, så att villkoret garanterat har testats före första exekveringen. Används även för villkoret i do-satser.

Programbibliotek och headerfiler
[redigera]

C har standardiserat ett relativt litet programbibliotek med funktioner för främst in- och utdata, sträng- och minneshantering, samt matematiska funktioner. För att komma åt dem måste de dels länkas in under kompileringen, dels göras tillgängliga genom inkludering av så kallade headerfiler. En headerfil är en källkodsfil med filändelsen .h, som innehåller definitioner av program, datastrukturer, makron och variabler som är externa, det vill säga inte är deklarerade i samma källkodsfil som det program eller de funktioner som använder dem.
Ett exempel är standardfunktionen printf som används för att formatera utskrifter till skärmen. Den är definierad i stdio.h. Själva funktionen finns vanligen i ett förkompilerat programbibliotek som länkas in under kompileringen av ett program. Ett program som vill använda printf måste inkludera stdio.h innan den anropar funktionen, vanligen alldeles i början av källkoden:

#include <stdio.h>

Genom att bara inkludera de headerfiler som behövs och bara länka in de programbibliotek som behövs kan storleken på ett C-program hållas nere.
De flesta kompilatorer tillhandahåller ett antal programbibliotek utöver de som är standard. Många av dem är mer eller mindre plattformsberoende, till exempel grafiska verktyg och bibliotek för trådning, något som helt saknas i standardbiblioteken.

Lista över headerfiler
[redigera]

C89 innehåller 15 headerfiler för standardbiblioteket.^[2] I tillägg Normative Addendum 1 (NA1) tillkom tre headerfiler.^[3] I C99 utökades antalet till 24,^[4] och i C11 till 29.^[5]



Headerfil

Standard

Beskrivning


assert.h



Innehåller makrot assert som används vid debugging.


complex.h

C99

Innehåller funktioner och makron för komplexa tal.


ctype.h



Innehåller funktioner för att klassificera och konvertera tecken.


errno.h



Innehåller makron för att testa felkoder från standardbiblioteket.


fenv.h

C99

Innehåller makron och funktioner för att kontrollera flyttalsmiljön.


float.h



Innehåller konstanter som definierar flyttalsmiljön.


inttypes.h

C99

Innehåller funktioner för konvertering mellan heltalstyper.


iso646.h

NA1

Innehåller definitioner för programmering i ISO 646-teckenuppsättningar.


limits.h



Innehåller konstanter som definierar heltalsmiljön.


locale.h



Innehåller funktioner och konstanter för lokalisering; se locale.


math.h



Innehåller matematiska funktioner och konstanter.


setjmp.h



Innehåller makrona setjmp och longjmp, som används för hopp mellan funktioner.


signal.h



Innehåller funktioner och definitioner för att hantera vissa meddelanden i miljön.


stdalign.h

C11

Innehåller makron för att specificera och testa datajustering (data alignment) i strukturer.


stdarg.h



Innehåller funktioner för att hantera ett variabelt antal parametrar till en funktion.


stdatomic.h

C11

Innehåller defintioner och funktioner för atomiska operationer på data som är delad mellan trådar.


stdbool.h

C99

Innehåller makron för den booleska datatypen.


stdint.h

C99

Innehåller definitioner av olika heltalstyper.


stddef.h



Innehåller ett antal standarddefinitioner.


stdio.h



Innehåller standardfunktionerna för läsning och skrivning av data.


stdlib.h



Innehåller ett antal standardfunktioner för bland annat minnesallokering.


stdnoreturn.h

C11

Innehåller ett makro för att definiera funktioner som inte returnerar alls.


string.h



Innehåller funktioner för stränghantering.


tgmath.h

C99

Innehåller datatypgeneriska matematiska funiktioner.


threads.h

C11

Innehåller funktioner och definitioner för trådning.


time.h



Innehåller funktioner för konvertering mellan tids- och datumformat.


uchar.h

C11

Innehåller typer och funktioner för att hantera Unicode-tecken.


wchar.h

NA1

Innehåller funktioner för hantering av multibyteteckenkodade strängar.


wctype.h

NA1

Innehåller funktioner för att klassificera och konvertera Unicode-tecken.

Programexempel
[redigera]

"Hello, World!" i C:

 #include <stdio.h>
 
 int main(void)
 {
     printf("Hello, world!\n");
     return 0;
 }

Noter
[redigera]


↑ ^1,0 ^1,1 Kernigan and Richie 2nd edition^{[sida behövs]}

↑  ISO/IEC 9899:1990. ISO. 1990 

↑  ISO/IEC 9899:1990/Amd 1:1995. ISO. 1995 

↑  ISO/IEC 9899:1999. ISO. 1999 

↑  ISO/IEC 9899:2011. ISO. 2011

Externa länkar
[redigera]

Mike Banahans The C Book, bok för avancerade tekniker som redan har programmeringskunskaper

[k&r2e-1] 1,0 ^1,1 Kernigan and Richie 2nd edition^{[sida behövs]}

[c90-2] ISO/IEC 9899:1990. ISO. 1990

[c95-3] ISO/IEC 9899:1990/Amd 1:1995. ISO. 1995

[c99-4] ISO/IEC 9899:1999. ISO. 1999

[c11-5] ISO/IEC 9899:2011. ISO. 2011

[1]

[2]

[3]

[4]

[5]

Operator	Syntax	Resultat (värde)
Tilldelning	`a = b`	Värdet på `a` efter tilldelningen. Detta kan användas för att sätta flera variabler till samma värde: `a = b = c = 7;`
Addition	`a + b`	Summan av `a` och `b`.
Subtraktion	`a - b`	Differensen mellan `a` och `b`.
Unärt plus	`+a`	Värdet på `a`. Om `a` är en mindre datatyp så konverteras den till `signed int`.
Unärt minus (negation)	`-a`	Värdet på `a` med motsatt tecken. Om `a` är en mindre datatyp så konverteras den till `signed int`.
Multiplikation	`a * b`	Produkten av `a` och `b`.
Division	`a / b`	Kvoten av `a` och `b`. Vid heltalsdivision är resultatet ett heltal.
Modulo (rest vid division)	`a % b`	Resten vid heltalsdivision av `a` med `b`. Fungerar endast på heltal.
Inkrement (prefix)	`++a`	`a` tilldelas värdet av `a+1`, och det nya värdet returneras.
Inkrement (suffix)	`a++`	`a` tilldelas värdet av `a+1`, och det gamla värdet returneras.
Dekrement (prefix)	`--a`	`a` tilldelas värdet av `a-1`, och det nya värdet returneras.
Dekrement (suffix)	`a--`	`a` tilldelas värdet av `a-1`, och det gamla värdet returneras.