C-szintaxis

Egész típusok

A C egész számtípusai különböző rögzített méretűek, és különböző számtartományokat képesek reprezentálni. A char típus pontosan egy bájtot foglal el (a legkisebb címezhető tárolóegység), ami jellemzően 8 bit széles. (Bár a char képviselheti a C bármely "alap" karakterét, a nemzetközi karakterkészletekhez szélesebb típusra lehet szükség.) A legtöbb egész típusnak van előjeles és előjel nélküli változata is, amelyeket az signed és unsigned kulcsszavak jelölnek. Az elõjeles egész típusok mindig a kettes komplemens reprezentációt használják, a C23(wd) óta (és a gyakorlatban korábban is; a régebbi C verziókban a C23 elõtt lehet, hogy az ábrázolás egyes komplemens(wd), vagy előjel-nagyság volt, de a gyakorlatban ez a modern hardvereken évtizedek óta nem volt így). Sok esetben több egyenértékű mód létezik a típus megjelölésére; például a signed short int és short szinonimák.

Egyes típusok ábrázolása tartalmazhat fel nem használt "padding" biteket, amelyek tárhelyet foglalnak el, de nem szerepelnek a szélességben. Az alábbi táblázat a szabványos egész típusok teljes listáját tartalmazza és minimális megengedett szélességüket (beleértve az előjelbiteket is).

A char típus különbözik mind a signed char, mind az unsigned char karakterektől, de garantáltan megegyezik az egyikükkel. A _Bool és long long típusok 1999 óta szabványosak, és előfordulhat, hogy a régebbi C fordítók nem támogatják őket. A _Bool típus általában az stdbool.h szabványos fejléc-fájl által meghatározott bool typedef néven keresztül érhető el, azonban a C23 óta a _Bool típust átnevezték boolra, a <stdbool.h> pedig elavult.

Általánosságban elmondható, hogy az adott platformon megvalósított adatszélességek és ábrázolási sémák a gép architektúrája alapján kerülnek kiválasztásra, figyelembe véve a más platformokhoz kifejlesztett forráskódok importálásának egyszerűségét. Az int típus szélessége különösen nagymértékben változik a C implementációk között; gyakran megfelel az adott platform legtermészetesebb szóméretének. A limits.h szabványos fejléc makrókat definiál a szabványos egész típusok minimális és maximális reprezentálható értékéhez bármely adott platformon megvalósítva.

A szabványos egész típusokon kívül létezhetnek más "bővített" (extended) egész típusok is, amelyek a szabványos fejlécekben lévő typedef meghatározásokhoz használhatók. A szélesség pontosabb meghatározásához a programozók használhatják és kell is használni a typedefeket a szabványos stdint.h fejlécből.

Az egész konstansok többféleképpen is megadhatók a forráskódban. A numerikus értékek megadhatók decimális (példa: 1022), oktális nulla (0) előtaggal (01776), vagy hexadecimális 0x (nulla x) előtaggal (0x3FE). Egy idézőjelben lévő karakter (például: 'R'), amelyet "karakter konstansnak" neveznek, az adott karakter értékét jelenti a végrehajtási karakterkészletben, int típussal. A karakterkonstansok kivételével az egész konstans típusát a megadott érték megjelenítéséhez szükséges szélesség határozza meg, de az mindig legalább olyan széles, mint az int. Ez felülírható egy explicit hossz- és/vagy előjel-módosító hozzáadásával; például a 12lu unsigned long típusú. Nincsenek negatív egész állandók, de gyakran ugyanaz a hatás érhető el, ha egy "-" unáris negációs operátort használunk.

Felsorolt típus

A felsorolt típus C-ben, amelyet az enum kulcsszó határoz meg, és gyakran csak "enum"-nak nevezik, egy olyan típus, amelyet úgy terveztek, hogy az értékeket nevesített konstansok sorozatán keresztül reprezentálja. A felsorolt konstansok mindegyike int típusú. Mindegyik enum-típus önmagában kompatibilis a char-ral vagy egy előjeles vagy előjel nélküli egész típussal, de minden megvalósítás meghatározza a saját szabályait a típus kiválasztásához.

Egyes fordítók figyelmeztetnek, ha egy felsorolt típusú objektumhoz olyan értéket rendelnek, amely nem tartozik az állandók közé. Azonban egy ilyen objektumhoz bármilyen érték hozzárendelhető a kompatibilis típusuk tartományában, és az enum-konstansok bárhol használhatók, ahol egész szám várható. Emiatt gyakran enum értékeket használnak az előfeldolgozó #define direktívák helyett a nevesített konstansok létrehozásához. Az ilyen konstansok használata általában biztonságosabb, mint a makrók, mivel egy adott azonosító névtérben találhatók.

A felsorolt típust az enum megadásával és az enum opcionális nevével (vagy címkéjével) deklarálják, ezt követi a kapcsos zárójelben lévő és vesszővel elválasztott egy vagy több állandó listája, valamint a változónevek opcionális listája. Egy adott felsorolt típusra történő későbbi hivatkozások az enum kulcsszót és az enum nevét használják. Alapértelmezés szerint a felsorolás első konstansához nulla érték rendelődik, és minden további érték eggyel nő az előző állandóhoz képest. A deklarációban szereplő konstansokhoz specifikus értékek is hozzárendelhetők, és minden további, konkrét érték nélküli konstans ettől a ponttól kezdve növelt értékeket kap. Vegyük például a következő deklarációt:

enum colors { RED, GREEN, BLUE = 5, YELLOW } paint_color;

avagy:

enum Color { 
    RED, 
    GREEN, 
    BLUE = 5, 
    YELLOW 
} paint_color;

Ez deklarálja az enum colors típusát; az int konstansok RED (amelynek értéke 0), GREEN (amelynek értéke eggyel nagyobb, mint a RED, 1), BLUE (amelynek értéke a megadott érték, 5) és YELLOW (amelynek értéke eggyel nagyobb, mint a BLUE, 6); és az enum colors paint_color változója. A konstansok az enum kontextusán kívül is használhatók (ahol bármely egész érték megengedett), és a konstansoktól eltérő értékeket is hozzá lehet rendelni a paint_color-hoz vagy bármely más enum colors típusú változóhoz.

A C++-tól eltérően a C enumok nem rendelkeznek hatókörrel, mivel a C nem használja a névtereket. A C-ben az enumok implicit módon numerikus típussá alakíthatók, ami típusbiztonságot nem biztosít.

typedef enum Color {
    RED,
    ORANGE,
    YELLOW,
    GREEN,
    BLUE,
    INDIGO,
    VIOLET
} Color;

Color c = RED; // in C
Color d = Color::RED; // in C++, but not in C

A C23 óta lehetőség van manuálisan megadni az enum mögöttes típusát, hasonlóan a C++-hoz.

enum CardSuit: char { 
    HEARTS, 
    CLUBS, 
    SPADES, 
    DIAMONDS
};

Lebegőpontos típusok

A lebegőpontos forma törtkomponensű számok ábrázolására szolgál. Ezek azonban nem reprezentálják pontosan a legtöbb racionális számot; ehelyett szoros közelítések. A valós értékeknek három szabványos típusa van, amelyeket specifikációik jelölnek (és a C23(wd) szabvány óta még három decimális típus): egyszeres pontosság (float), kettős pontosság (double) és dupla kiterjesztett pontosság(wd) (long double). Ezek mindegyike más-más formában képviselheti az értékeket, gyakran az IEEE lebegőpontos formátumok egyikét.

A lebegőpontos állandók decimális jelöléssel írhatók fel, pl. 1.23. A tizedes tudományos jelölés használható e vagy E hozzáadásával, majd egy decimális kitevővel, más néven E-jelöléssel, pl. 1.23e2 (amelynek értéke 1,23 × 10² = 123,0). Vagy egy tizedesvesszőre, vagy egy kitevőre van szükség (ellenkező esetben a szám egész konstansként értelmeződik). A hexadecimális lebegőpontos konstansok hasonló szabályokat követnek, azzal a különbséggel, hogy 0x előtaggal kell rendelkezniük, és p vagy P-t kell használni egy bináris kitevő megadására, pl. 0xAp-2 (amelynek értéke 2,5, mivel A_h × 2⁻² = 10 × 2⁻² = 10 ÷ 4). Mind a decimális, mind a hexadecimális lebegőpontos konstansok utótagja lehet f vagy F a float típusú konstans jelzésére, l (l betű) vagy L a long double típus jelzésére, vagy utótag nélkül hagyható double konstans esetén.

A float.h szabványos fejlécfájl határozza meg a megvalósítás float, double, és long double lebegőpontos típusainak minimális és maximális értékét. Más határértékeket is meghatároz, amelyek a lebegőpontos számok feldolgozása szempontjából relevánsak.

A C23(wd) három további decimális (a binárissal szemben) valós lebegőpontos típust vezet be: _Decimal32, _Decimal64 és _Decimal128.

MEGJEGYZÉS: A C nem ad meg radixot a float, double, és long double értékekhez. Egy implementáció kiválaszthatja a float, double, és long double ábrázolását úgy, hogy megegyezzen a decimális lebegőpontos típusokkal.

Ennek ellenére a radix történelmileg bináris volt (2-es alapú), ami azt jelenti, hogy az olyan számok, mint az 1/2 vagy 1/4 pontosak, de az 1/10, 1/100 vagy 1/3 már nem. A decimális lebegőpontos számok mindegyike pontos pozitív szám, például 1/10 és 1/100, de pl. az 1/3 mégsem. Egyetlen ismert megvalósítás sem választja a decimális radixot a bináris típusként ismert típusok esetében. Mivel a legtöbb számítógépen nincs is hardvere a decimális típusokhoz, és azok a kevesek, amelyek igen (pl. IBM nagyszámítógépek az IBM System z10(wd) óta), használhatják a kifejezetten decimális típusokat.

Tárolási osztály-specifikációk

Minden objektumnak van tárolási osztálya. Ez alapvetően a tárolási időtartamot határozza meg, amely lehet statikus (alapértelmezett a globális), automatikus (alapértelmezett lokális) vagy dinamikus (allokált).

¹Lefoglalás és felszabadítás a malloc() és free() könyvtári függvények használatával.

Az alapértelmezés szerint egy blokkon belül deklarált változók automatikus tárolással rendelkeznek, csakúgy, mint az auto vagy register tárolási osztály specifikációival kifejezetten deklarált változók. Az auto és a register specifikátorok csak függvényekben és függvényargumentum-deklarációkban használhatók; mint ilyen, az auto specifikáció mindig redundáns. Az összes blokkon kívül deklarált objektumok és a static tárolási osztály-meghatározóval kifejezetten deklarált objektumok statikus tárolási időtartammal rendelkeznek. A statikus változókat alapértelmezés szerint nullára inicializálja a fordító.

Az automatikus tárolással rendelkező objektumok abban a blokkban lokálisak, amelyben deklarálták őket, és a blokkból való kilépéskor megszűnnek. Ezenkívül a register tárolási osztályával deklarált objektumoknak a fordító magasabb prioritást adhat a regiszterekhez való hozzáféréshez; bár a fordító dönthet úgy, hogy valójában egyiket sem tárolja regiszterben. Az ilyen tárolási osztályú objektumok nem használhatók az (&) unáris operátor címével. A statikus tárolással rendelkező objektumok a program teljes időtartama alatt megmaradnak. Ily módon ugyanazt az objektumot egy függvény több híváson keresztül is elérheti. A hozzárendelt tárolási időtartamú objektumok kifejezetten malloc, free és kapcsolódó funkciókkal jönnek létre és semmisülnek meg.

Az extern tárolási osztály-meghatározó azt jelzi, hogy egy objektum tárolója máshol van meghatározva. Ha egy blokkon belül használják, akkor azt jelzi, hogy a tárolót a blokkon kívüli deklaráció határozta meg. Ha az összes blokkon kívül használjuk, akkor azt jelzi, hogy a tároló a fordítási egységen kívül lett meghatározva. Az extern tárolási osztály-meghatározó redundáns, ha függvénydeklarációban használják. Azt jelzi, hogy a deklarált függvény a fordítási egységen kívül lett meghatározva.

A C11-ben(wd) bevezetett _Thread_local (thread_local a C++-ban, és a C-ben C23(wd) óta, valamint a C korábbi verzióiban, ha a <threads.h> fejléc is benne van) tárolási osztály-specifikáció egy thread-local változó deklarálására szolgál. Kombinálható static vagy extern-nel a kapcsolat meghatározásához.

Vegye figyelembe, hogy a tárolási specifikációk csak a függvényekre és objektumokra vonatkoznak; egyéb dolgok, például a típus- és enum-deklarációk annak a fordítási egységnek a sajátja, amelyben megjelennek. A típusoknak viszont vannak minősítői (lásd alább).

A C23 óta a C nyelvben az auto használható típuskövetkeztetett változók deklarálására.

Típusminősítők

Bővebben: en:Type qualifier

(angolul)

A típusok minősíthetők adataik speciális tulajdonságainak jelzésére. A const típusminősítő azt jelzi, hogy az érték nem változik az inicializálás után. A const minősítésű érték módosításának kísérlete definiálatlan viselkedést eredményez, ezért egyes C fordítók rodata-ban(wd) vagy (beágyazott rendszerek esetén) csak olvasható memóriában (ROM) tárolják azokat. Hasonlóképpen, a constexpr a const egy "erősebb" formájának tekinthető, ahol az értéknek fordítási időben ismertnek kell lennie (így típusbiztosan helyettesítheti a makrókonstansokat). Egy constexpr függvénynek hasonlóképpen szintén ki kell tudnia értékelni fordítási időben. A volatile típusminősítő azt jelzi az optimalizáló fordítónak, hogy nem távolíthatja el a látszólag redundáns olvasásokat vagy írásokat, mivel az érték akkor is változhat, ha nem módosították semmilyen kifejezéssel vagy utasítással, vagy többszöri írásra lehet szükség, például memórialeképezett I/O esetén.

Hivatkozás

Amikor egy nem statikus mutatót deklarálnak, egy meghatározatlan érték van hozzá társítva. Az ilyen mutatóhoz társított címet hozzárendeléssel meg kell változtatni a használat előtt.

Az & operátor az utána következő adatobjektum címét adja meg. A következő példában a ptr operátorhoz az a címe lesz hozzárendelve:

int a = 0;
int *ptr = &a;

Ennek eléréséhez az "address-of" (unáris &) operátort használjuk.

Hivatkozás megszüntetése (dereferencia)

Egy változó neve előtti csillag (ha nem deklarációban vagy matematikai kifejezésben szerepel) dereferenciál egy mutatót, hogy hozzáférést biztosítson a mutató által mutatott értékhez. A következő példában a b egész változó az a egész változó értékére van beállítva, ami 10:

int a = 10;
int* p;
p = &a;
int b = *p;

Tömb definíció

A tömbök a C nyelvben azonos típusú egymást követő elemeket tárolnak. A következő kód egy 100 elemből álló tömböt deklarál, amelynek a neve a, és amelynek a típusa int:

int array[100];

Ha egy függvényen kívül (globálisan) deklaráljuk, a méretnek konstans értéknek kell lennie. Ha egy függvényben deklaráljuk, a tömb mérete lehet nem konstans kifejezés.

Az elemek száma elérhető sizeof(a) / sizeof(int) formában, de ha az értéket egy másik függvénynek adjuk át, az elemek száma nem érhető el a formális paraméterváltozón keresztül.

A legtöbb esetben a későbbi használat során az array változó említése a tömb első elemére mutató mutatóvá alakul. A sizeof operátor kivétel: a sizeof array a teljes tömb méretét adja (vagyis egy int méretének 100-szorosa, és a sizeof(array) / sizeof(int) értéke 100). Egy másik kivétel az & (address-of) operátor, amely például egy mutatót ad a teljes tömbre:

int (*ptr_to_array)[100] = &array;

Elemek elérése

A tömb elemei értékeinek az eléréséhez elsődleges eszköz a tömb index-operátora. Például az a[i] az a tömb i indexű elemét éri el. A tömb indexének számozása 0-val kezdődik (nulla alapú indexelés). A tömb utolsó elemének indexe tehát egyenlő a tömb elemeinek számával mínusz 1. Mivel a szabvány nem biztosítja a tömbindexelési határok ellenőrzését(wd), a tartományon kívüli index megadása nem definiált viselkedést eredményez.

Mivel a tömbök és a mutatók felcserélhetők, az egyes elemek címe mutatóaritmetikában kifejezhető. Az alábbi táblázat mindkét módszert bemutatja ugyanazon tömb meglévő esetére:

Mivel a tömbök és mutatók felcserélhetők, az egyes tömbelemek címei ekvivalens mutató aritmetikával fejezhetők ki. Az alábbi táblázat mindkét módszert szemlélteti ugyanazon meglévő tömb esetében:

array[0]

array[1]

array[2]

array[n - 1]

*array

*(array + 1)

*(array + 2)

*(array + n - 1)

Mivel az a[i] kifejezés szemantikailag ekvivalens a *(a + i)-vel, ami viszont egyenértékű a *(i + a)-val, a kifejezés i[a]-ként is felírható, bár ezt az alakot ritkán használják.

Változó hosszúságú tömbök

A C99 szabványosította a változó hosszúságú tömböt (variable-length array(wd)) a blokk hatókörében, amely egy futásidejű információk (nem állandó érték) által méretezett, de a blokk végéig rögzített méretű tömböt hozott létre. Az ilyen tömbváltozók a blokkba való belépéskor futásidejű integer érték alapján kerülnek kiosztásra, és a blokk végén feloldódnak. A C11-től kezdve ezt a szolgáltatást már nem kell megvalósítania a fordítónak.

int n = 20; // n can be any arbitrary value
int a[n];
a[3] = 10;

Dinamikus tömbök

A C standard könyvtár segítségével dinamikusan átméretezhető tömbök állíthatók elő. A malloc függvény egyszerű módszert biztosít a memória lefoglalására. Egy paraméterre van szükség: a lefoglalandó memória mennyiségére bájtokban. Sikeres kiosztás esetén a malloc egy általános (void) mutatóértéket ad vissza, amely a lefoglalt terület elejére mutat. A visszaadott mutatóértéket hozzárendeléssel implicit módon a megfelelő típusra konvertálja. Ha az elosztás nem fejezhető be, a malloc null mutatót(wd) ad vissza. A következő részlet tehát funkciójában hasonló a fenti kívánt deklarációhoz:

#include <stdlib.h> /* declares malloc */
...
int *a = malloc(n * sizeof *a);
a[3] = 10;

Az eredmény egy "pointer to int" változó (a), amely az n összefüggő int objektum közül az elsőre mutat; a tömb-mutató ekvivalenciája miatt ez használható a tényleges tömbnév helyett, amint az az utolsó sorban látható. Ennek a dinamikus allokációnak az az előnye, hogy a hozzá lefoglalt memória mennyisége a futási időben a ténylegesen szükségesre korlátozható, és ez szükség szerint módosítható (a szabványos realloc könyvtári függvény segítségével).

Ha a dinamikusan lefoglalt memóriára már nincs szükség, azt vissza kell adni a futásidejű rendszernek. Ez a free funkció meghívásával történik. Egyetlen paraméter szükséges: egy mutató a korábban lefoglalt memóriára. Ez az az érték, amelyet a malloc korábbi hívása adott vissza.

Biztonsági intézkedésként néhány programozó ezután NULL-ra állítja a mutatóváltozót:

free(a);
a = NULL;

Ez biztosítja, hogy a legtöbb rendszeren a mutató hivatkozásának megszüntetésére irányuló további kísérletek a program összeomlásához vezetnek. Ha ez nem történik meg, a változó lógó mutatóvá válik, ami utólagos használat során hibához vezethet. Ha azonban a mutató egy helyi változó, akkor a NULL értéke nem akadályozza meg, hogy a program a mutató más másolatait használja. A statikus analizátorok általában könnyen felismerik a helyi, utánhasználat nélküli hibákat. Ezért ez a megközelítés kevésbé hasznos a helyi mutatók esetében, és gyakrabban használják a hosszú élettartamú struktúrákban tárolt mutatók esetében. Általában azonban a mutatók NULL-ra állítása jó gyakorlat, mivel lehetővé teszi a programozó számára, hogy NULL-ellenőrizze a mutatókat a hivatkozás megszüntetése előtt, így segít megelőzni az összeomlásokat.

Ha felidézzük a tömbpéldát, dinamikus allokációval fix méretű tömböt is létrehozhatunk:

int (*a)[100] = malloc(sizeof *a);

...Ez egy pointer-to-tömböt eredményez.

A pointer-to-tömbhöz való hozzáférés kétféleképpen történhet:

(*a)[index];

index[*a];

Az iteráció kétféleképpen is elvégezhető:

for (int i = 0; i < 100; i++)
    (*a)[i];

for (int *i = a[0]; i < a[1]; i++)
    *i;

A második példa használatának az az előnye, hogy az első példa numerikus korlátja nem kötelező, ami azt jelenti, hogy a mutató-tömb bármilyen méretű lehet, és a második példa változtatás nélkül végrehajtható.

Többdimenziós tömbök

A nyelv támogatja a többdimenziós tömböket – sorok szerint tárolva, ami lényegében egy egydimenziós tömb, amelynek elemei tömbök. Tekintettel arra, hogy a ROWS és COLUMNS konstansok, a következő deklaráció egy ROWS hosszúságú kétdimenziós tömböt deklarál, amelynek minden eleme COLUMNS egész számokból álló tömb.

int array2d[ROWS][COLUMNS];

A következő példa egy egész elem elérésére:

array2d[4][3]

Ismét balról jobbra olvasva ez eléri az 5. sort, és a sorban a 4. elemet. A array2d[4] kifejezés egy tömb, amelyet ezután a [3]-mal indexelünk, hogy elérjük a negyedik egész számot.

array[0][0]

array[1][1]

array[i - 1][j - 1]

*(*(array + 0) + 0)

*(*(array + 1) + 1)

*(*(array + i - 1) + j - 1)

A több-dimenziós tömbök is hasonló módon deklarálhatók.

A többdimenziós tömböt nem szabad összetéveszteni a tömbökre mutató mutatók tömbjével (más néven iliffe-vektor vagy néha tömbök tömbje). Az előbbi mindig négyszögletes alakú (minden altömbnek azonos méretűnek kell lennie), és egy összefüggő memóriaterületet foglal el. Ez utóbbi egy egydimenziós mutatók tömbje, amelyek mindegyike egy altömb első elemére mutathat a memória különböző helyén, és az altömböknek nem kell azonos méretűnek lenniük. Ez utóbbit a malloc többféle használatával is létrehozhatjuk.

Karakterlánc literál

A C nyelvben a karakterlánc-literálokat idézőjelek (") veszik körül (pl. "Hello world!"), és a megadott char értékekből álló tömbbe vannak fordítva egy további null karakteres(wd) (0 értékű vezérlőkarakter) kóddal, amely a karakterlánc végét jelzi.

A karakterlánc-literálok nem tartalmazhatnak beágyazott újsorokat; ez a tiltás némileg leegyszerűsíti a nyelv elemzését. Ha újsort szeretne beilleszteni egy karakterláncba, a fordított perjel \n escape használható az alábbiak szerint.

A nyelv támogatja a karakterlánc literálok összefűzését – a szomszédos karakterlánc literálokat fordítási időben összekapcsoltként kezeli a rendszer. Ez lehetővé teszi a hosszú karakterláncok több sorra való felosztását, valamint azt is, hogy a preprocesszori makrókból származó karakterlánc literálokat fordítási időben hozzáfűzzünk a karakterláncokhoz. Például a forráskód:

printf(__FILE__ ": %d: Hello "
       "world\n");

a következővé válik, miután az előfeldolgozó kibontja a __FILE__ fájlt:

printf("helloworld.c" ": %d: Hello "
       "world\n");

ami egyenértékű a következővel:

printf("helloworld.c: %d: Hello world\n");

Számos szabványos függvénytári függvény létezik a karakterlánc-adatokkal való (nem feltétlenül állandó) műveletekhez, amelyek karaktertömbként (array of char) vannak megszervezve ezzel a null-végződésű formátummal; lásd alább.

A C karakterlánc-literális szintaxisa nagyon befolyásos volt, és számos más nyelvben is elterjedt, mint például a C++, az Objective-C, a Perl, a Python, a PHP, a Java, a JavaScript, a C# és a Ruby. Manapság szinte minden új nyelv C-stílusú karakterlánc-szintaxist alkalmaz vagy arra épít. Azok a nyelvek, amelyekből hiányzik ez a szintaxis, általában a C előttiek.

Karakter-konstansok

A karakterliterál, más néven karakterkonstans, aposztrófok között áll, pl. 'A', és int típusú. A karakterláncliterál és a karakterkonstans közötti különbség szemléltetésére vegyük figyelembe, hogy az "A" két karakter, az 'A' és '\0', mivel az 'A' egyetlen karaktert jelöl (ASCII-ben 65).

Egy karakterkonstans nem lehet üres (azaz a '' érvénytelen szintaxis). A többkarakteres konstansok (pl. 'xy') érvényesek, bár ritkán hasznosak – lehetővé teszik több karakter tárolását egy egész számban (pl. 4 ASCII karakter fér el egy 32 bites egész számban, 8 egy 64 bitesben). Mivel a karakterek int-be csomagolásának sorrendje nincs meghatározva (ezt a megvalósításra van bízva), a több karakteres konstansok hordozható használata nehézkes.

Mindazonáltal egy adott platformra és a fordító implementációjára korlátozott helyzetekben a többkarakteres konstansok felhasználásra kerülnek az aláírások megadásában. Egy gyakori használati eset az OSType(wd), ahol a klasszikus Mac OS fordítók és a velük járó big endianitás kombinációja azt jelenti, hogy az egész számban a bájtok a literálban definiált karakterek pontos sorrendjében jelennek meg. A népszerű "implementációk" definíciója valójában következetes: a GCC-ben, a Clangban és a Visual C++-ban(wd) az '1234' 0x31323334-et eredményez ASCII alatt.

A karakterlánc literálokhoz hasonlóan a karakterkonstansok is módosíthatók előtagokkal, például az L'A' típusa wchar_t, és az "A" karakterértékét jelöli a széles karakterkódolásban.

Backslash eszképek

Mivel bizonyos karakterek nem lehetnek közvetlenül részei egy literális karakterlánc-kifejezésnek, ehelyett egy visszaperjellel (\) kezdődő escape szekvencia(wd) azonosítja őket. Például a fordított perjelek (backslash) a "Ez a karakterlánc \"dupla idézőjeleket tartalmaz\" szövegben. jelzik (a fordítónak), hogy a belső idézőjelpár a karakterlánc tényleges része, nem pedig magának a karakterláncnak az alapértelmezett olvasása határolóként (végpontként).

A fordított perjelek különféle vezérlőkarakterek stb. bevitelére használhatók egy karakterláncban:

A C-szabvány nem határozza meg az egyéb backslash escape-kódok használatát, bár a fordítóprogram-gyártók gyakran további escape kódokat adnak meg nyelvi kiterjesztésként. Ezek egyike a \e escape szekvencia az 1B ASCII hexadecimális értékű escape karakterhez, amely nem került be a C szabványba, mivel más karakterkészletekben (például EBCDIC) hiányzik a reprezentáció. Elérhető GCC, Clang és tcc változatban.

Ne feledje, hogy a printf formátumú karakterláncok %%-ot használnak a literális % karakter megjelenítésére; a standard C-ben nincs \% escape szekvencia.

Széles karakter-láncok

Mivel a char típus 1 bájt széles, egyetlen char érték általában legfeljebb 255 különböző karakterkódot jelenthet, ami közel sem elegendő a világszerte használt összes karakterhez. A nemzetközi karakterek jobb támogatása érdekében az első C szabvány (C89) széles karaktereket(wd) (wchar_t kódolású) és széles karakterláncokat vezetett be, amelyek L"Hello world!"-ként íródnak.

A széles karakterek leggyakrabban 2 bájtosak (2 byte-os kódolás, például UTF-16) vagy 4 bájtosak (általában UTF-32), de a C szabvány nem határozza meg a wchar_t szélességét, így a választást a megvalósítóra bízza. A Microsoft Windows általában UTF-16-ot használ, így a fenti karakterlánc 26 bájt hosszú lenne egy Microsoft fordítónál; a Unix világ az UTF-32-t részesíti előnyben, így az olyan fordítók, mint a GCC, 52 bájtos karakterláncot generálnak. A 2 bájt széles wchar_t ugyanazt a korlátozást érinti, mint a char, mivel bizonyos karakterek (a BMP-n kívüliek) nem ábrázolhatók egyetlen wchar_t-ben; hanem helyettesítő párokkal (surrogate pair) kell ábrázolni.

Az eredeti C szabvány csak minimális függvényeket írt elő a széles karakterláncokkal való működéshez; 1995-ben a szabványt módosították, hogy sokkal kiterjedtebb támogatást tartalmazzon a char karakterláncokhoz. A releváns függvényeket többnyire char megfelelőikről nevezték el, "w" hozzáadásával vagy az "str" helyett "wcs"-vel; a <wchar.h>-ban vannak megadva, ahol a <wctype.h> széles karakteres osztályozási és leképezési funkciókat tartalmaz.

A nemzetközi karakterek támogatásának jelenleg általánosan ajánlott módszere az UTF-8, amely char tömbökben van tárolva, és UTF-8 szerkesztő használata esetén közvetlenül a forráskódba írható, mivel az UTF-8 közvetlen ASCII-kiterjesztés(wd).

Változó szélességű karakterláncok

A wchar_t általános alternatívája a változó szélességű kódolás(wd) használata, ahol a logikai karakter a karakterlánc több pozícióján is átnyúlhat. A változó szélességű karakterláncokat szó szerint literálokká lehet kódolni, azzal a kockázattal, hogy megzavarják a fordítót, vagy numerikus fordított perjelek használatával (pl. "\xc3\xa9" az "é" helyett UTF-8-ban). Az UTF-8 kódolást kifejezetten a szabványos könyvtári karakterlánc-funkciókkal való kompatibilitásra tervezték (Plan 9 alatt); a kódolás támogató jellemzői közé tartozik a beágyazott nullák hiánya, az alsorozatok érvényes értelmezése és a triviális újraszinkronizálás. Az ilyen tulajdonságokat nem tartalmazó kódolások valószínűleg nem kompatibilisek a szabványos könyvtári funkciókkal; ilyen esetekben gyakran használnak kódolás-tudatos karakterlánc-függvényeket.

Könyvtári függvények

Az állandó és változó karakterláncok a standard függvénykönyvtár(wd) használata nélkül is manipulálhatók. A könyvtár azonban számos hasznos funkciót(wd) tartalmaz a null-végződésű karakterláncok kezeléséhez.

Tagok elérése

Egy tagot pontjelöléssel lehet elérni. Például, ha a fenti tee deklarációja adott, az y tag tee.y formátumban érhető el.

Egy struktúrához általában mutatón keresztül lehet hozzáférni. Vegyük például a struct MyStruct* ptee = &tee struktúrát, amely egy ptee nevű mutatót definiál a tee struktúrára. A tee-nek az y tagja a ptee struktúrára való hivatkozás megszüntetésével és az eredmény bal oldali operandusként (*ptee).y formájában történő használatával érhető el. Mivel ez a művelet gyakori, a nyelv egy rövidített szintaxist(wd) biztosít egy tagok közvetlen mutatón keresztüli eléréséhez, -> (például ptee->y).

Értékadás

Bővebben: Értékadás

Egy tagnak értéket rendelni olyan, mint egy változónak értéket adni. Az egyetlen különbség az, hogy a szintaxis szerint a hozzárendelés balértéke(wd) (lvalue) a tag neve.

Egy struktúra egészében is hozzárendelhető egy másik, azonos típusú struktúrához, amelyet a copy metódus ad át függvényargumentumként vagy visszatérési értékként. Például a tee.x = 74 a 74 értéket rendeli hozzá a tee struktúra x nevű tagjához, és a ptee->x = 74 ugyanezt teszi a ptee esetében.

Egyéb műveletek

A struktúrákhoz támogatott műveletek a következők: inicializálás, másolás, cím lekérése és mező elérése. Megjegyzendő, hogy a nyelv nem támogatja két struktúra értékének összehasonlítását, kivéve az egyéni kódon keresztüli összehasonlítást az egyes mezők között.

Bitmezők

A nyelv egy speciális tagtípust, úgynevezett bitmezőt biztosít, amely egy egész szám, amelynek meghatározott a mérete bitben. Egy bitmezőt int, bool vagy _BitInt(N) típusú (signed/unsigned) tagként deklarálunk., plusz egy kettőspontból és bizonyos számú bitből álló utótagot adunk hozzá a tag neve után. Egyetlen bitmezőben lévő bitek teljes száma nem haladhatja meg az alaptípus bitjeinek teljes számát. A szokásos C szintaxisszabályokkal ellentétben, ha nincs explicit módon megadva, akkor implementációfüggő, hogy egy bitmező előjeles vagy előjel nélküli. Ezért a legjobb gyakorlat az előjeles (signed) vagy előjel nélküli (unsigned) megadása.

A névtelen mezők kitöltést(wd) jelölnek, és csak egy kettőspontból, majd egy bizonyos számú bitből állnak. A névtelen mezők nulla szélességének megadása az új szóhoz való igazítás kikényszerítésére szolgál. Mivel egy unió összes tagja ugyanazt a memóriát foglalja el, a nulla szélességű névtelen bitmezők semmit sem csinálnak az uniókban, azonban a nem nulla szélességű névtelen bitmezők megváltoztathatják az unió méretét, mivel bele kell férniük.

A bitmezők tagjai nem rendelkeznek címmel, ezért nem használhatók a cím (&) unáris operátorral. A sizeof operátor nem alkalmazható bitmezőkre.

A következő példa deklarál egy FlagStatus nevű struktúratípust és annak egy g nevű példányát. Az első mező, a flag, egy egybites jelző, amely csak 1 vagy 0 lehet. A második mező, a num, egy előjeles 4 bites mező; tartománya -7...7 vagy -8...7. Az utolsó mező 3 bitnyi kitöltést ad hozzá, hogy a struktúra 8 bitre kerekedjen.

struct FlagStatus {
    unsigned int flag : 1;
    signed int num : 4;
    signed int : 3;
} g;

Névterek

A C nyelvnek nincs natív támogatása a névterekhez, ellentétben a C++-val és a Javával. Emiatt a C szimbólumnevek névütközésekre hajlamosak. Azonban lehetséges anonim struktúrák használatával emulálni a névtereket.

Math.h:

#pragma once

const struct {
    double PI;
    double (*sin)(double);
} Math;

Math.c:

#include <math.h>

static double _sin(double arg) {
    return sin(arg);
}

const struct {
    double PI;
    double (*sin)(double);
} Math = { M_PI, _sin };

Main.c:

#include <stdio.h>
#include "Math.h"

int main() {
    printf("sin(0) = %d\n", Math.sin(0));
    printf("pi is %f\n", Math.PI);
}

Uniók

Az uniók többnyire olyanok, mint egy struktúrák, azzal a különbséggel, hogy a mezők átfedésben vannak a memóriában, lehetővé téve a különböző típusú értékek tárolását, bár nem egyszerre. Az uniók hasonlóak más nyelvek variánsrekordjaihoz. Minden mező ugyanarra a helyre hivatkozik a memóriában. Az uniók mérete megegyezik a legnagyobb komponenstípusának méretével plusz az esetleges kitöltés mértékével.

Egy uniót a union kulcsszóval deklarálunk. A következő deklarál egy MyUnion nevű uniót és annak egy n nevű példányát:

union MyUnion {
    int x;
    float y;
    char* z;
} n;

Skalár

Egy változó inicializálása a deklarálásával együtt egyenlőségjel hozzáfűzését, majd az adattípussal kompatibilis konstrukció létrehozását jelenti. A következő inicializál egy int típust:

int x = 12;

A nyelv nyelvtanából adódóan egy skaláris inicializáló tetszőleges számú kapcsos zárójelpár közé kerülhet. A legtöbb fordítóprogram figyelmeztetést ad, ha egynél több ilyen pár van. Az alábbiak legálisak, bár vitathatatlanul szokatlanok:

int y = { 23 };
int z = { { 34 } };

Inicializáló lista

A struktúrák, uniók és tömbök deklaráció után inicializálhatók egy inicializáló listával.

Mivel a nem párosított elemek 0-ra vannak állítva, egy üres lista az összes elemet 0-ra állítja. Például a következő az a tömb összes elemét és az s tömb összes mezőjét 0-ra állítja:

int a[10] = {};
struct MyStruct s = {};

Ha egy tömböt explicit méret nélkül deklarálunk, akkor a tömb hiányos típus. Az inicializálók száma határozza meg a tömb méretét és teszi teljessé a típust. Például:

int x[] = { 0, 1, 2 };

Alapértelmezés szerint egy inicializáló lista elemei a definiálásuk sorrendjében felelnek meg az elemeknek. Túl sok érték megadása hibát eredményez. A következő utasítás inicializálja a MyStruct struktúra egy pi nevű példányát:

struct MyStruct {
    int x;
    float y;
    char* z;
};

struct MyStruct pi = { 3, 3.1415, "Pi" };

Kijelölt inicializálók

A kijelölt inicializálók lehetővé teszik a tagok név szerinti inicializálását, tetszőleges sorrendben, anélkül, hogy explicit módon megadnánk az előző értékeket. A következő inicializálás funkcionálisan egyenértékű az előzővel:

struct MyStruct pi = { .z = "Pi", .x = 3, .y = 3.1415 };

Egy inicializálóban egy jelölő használata mozgatja az inicializáló "kurzort". Az alábbi példában, ha a MAX nagyobb, mint 10, akkor az a közepén néhány nulla értékű elem lesz; ha kisebb, mint 10, akkor az első öt inicializáló által megadott értékek közül néhányat a második öt felülír. Ha a MAX kisebb, mint 5, akkor fordítási hiba keletkezik:

int a[MAX] = { 1, 3, 5, 7, 9, [MAX - 5] = 8, 6, 4, 2, 0 };

A C89-ben egy uniót egyetlen értékkel inicializáltak, amelyet az első tagjára adtak. Vagyis a fent definiált MyUnion uniónak csak az x tagja lehetett inicializálva:

union MyUnion value = { 3 };

Egy kijelölt inicializáló használatával az inicializálandó tagnak nem kell az első tagnak lennie:

union MyUnion value = { .y = 3.1415 };

Az összetett jelölők használhatók explicit inicializálás biztosítására, amikor a dísztelen inicializáló listák félreérthetők lennének. Az alábbi példában a w struktúrák tömbjeként van deklarálva, ahol minden struktúra egy a tagból (3 int-ből álló tömb) és egy b tagból (egy int-ből) áll. Az inicializáló a w méretét 2-re állítja, és beállítja minden a első elemének értékeit:

struct { int a[3], b; } w[] = { [0].a = {1}, [1].a[0] = 2 };

Ez egyenértékű a következővel:

struct { int a[3], b; } w[] =
{
   { { 1, 0, 0 }, 0 },
   { { 2, 0, 0 }, 0 } 
};

Összetett literálok

Lehetőség van az inicializálási módszertan kölcsönzésére összetett struktúra és tömbliterálok generálásához:

// pointer created from array literal.
int* ptr = (int[]){ 10, 20, 30, 40 };

// pointer to array.
float (*foo)[3] = &(float[]){ 0.5f, 1.f, -0.5f };

struct MyStruct pi = (struct MyStruct){ 3, 3.1415, "Pi" };

Az összetett literálokat gyakran kijelölt inicializálókkal kombinálják, hogy a deklaráció olvashatóbb legyen:

pi = (struct MyStruct){ .z = "Pi", .x = 3, .y = 3.1415 };

Tömbátadás

A tömb típusú függvényparaméterek első pillantásra kivételnek tűnhetnek az érték-átadás szabálya alól, amint azt a következő program is mutatja, amely 123-at, és nem 1-et ír ki:

#include <stdio.h>

void setArray(int a[], int index) {
    array[index] = 123;
}

int main(void) {
    int a[1] = {1};
    setArray(a, 0);
    printf("a[0]=%d\n", a[0]);
    return 0;
}

Ennek a viselkedésnek azonban más oka is van. A tömbparamétert mutatóként kezeli a rendszer. A következő prototípus egyenértékű a fenti függvényprototípussal:

void setArray(int* a, int index);

Ugyanakkor a tömbök kifejezésekben való használatára vonatkozó szabályok azt eredményezik, hogy az a értékét az első elemre mutató mutatóként kezeli a rendszer. Így ez továbbra is érték szerinti átadást jelent, azzal a kikötéssel, hogy az érték által átadott tömb első elemének címe, nem pedig a tömb tartalma.

A C99 óta a programozó a static kulcsszó használatával megadhatja, hogy egy függvény egy adott méretű tömböt fogadjon el. A következő függvényben

void setArray(int array[static 4], int index)

az első paraméternek egy legalább 4 elem hosszú tömb első elemére mutató mutatónak kell lennie. Lehetőség van minősítők (const, volatile és restrict) használatára is a tömb konvertálandó mutatótípusához.