C Language
initialisatie

Initialisatie van variabelen in C

Bij gebrek aan expliciete initialisatie worden externe en static variabelen gegarandeerd op nul geïnitialiseerd; automatische variabelen (inclusief register ) hebben onbepaalde ¹ (dwz afval) beginwaarden.

Scalaire variabelen kunnen worden geïnitialiseerd wanneer ze worden gedefinieerd door de naam te volgen met een is-gelijk-teken en een uitdrukking:

int x = 1;
char squota = '\'';
long day = 1000L * 60L * 60L * 24L; /* milliseconds/day */

Voor externe en static variabelen moet de initialisatie een constante expressie ^{2 zijn} ; de initialisatie wordt eenmaal gedaan, conceptueel voordat het programma wordt uitgevoerd.

Voor automatische en register is de initialisatie niet beperkt tot een constante: het kan elke uitdrukking zijn die eerder gedefinieerde waarden bevat, zelfs functieaanroepen.

Zie bijvoorbeeld het codefragment hieronder

int binsearch(int x, int v[], int n)
{
   int low = 0;
   int high = n - 1;
   int mid;
   ...
}

in plaats van

   int low, high, mid;

   low = 0;
   high = n - 1;

De initialisatie van automatische variabelen is eigenlijk gewoon steno voor toewijzingsopdrachten. Welke vorm de voorkeur heeft, is grotendeels een kwestie van smaak. Over het algemeen gebruiken we expliciete opdrachten, omdat initializers in verklaringen moeilijker te zien zijn en verder weg van het gebruikspunt. Aan de andere kant moeten variabelen alleen worden gedeclareerd wanneer ze waar mogelijk worden gebruikt.

Een array initialiseren:

Een array kan worden geïnitialiseerd door de verklaring te volgen met een lijst met initialisatie tussen accolades en gescheiden door komma's.

Om bijvoorbeeld een array-dagen te initialiseren met het aantal dagen in elke maand:

int days_of_month[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }

(Merk op dat januari in deze structuur wordt gecodeerd als maand nul.)

Wanneer de grootte van de array wordt weggelaten, berekent de compiler de lengte door de initializers te tellen, waarvan er in dit geval 12 zijn.

Als er minder initializers voor een array zijn dan de opgegeven grootte, zijn de andere nul voor alle typen variabelen.

Het is een fout om te veel initializers te hebben. Er is geen standaardmanier om herhaling van een initialisatie te specificeren - maar GCC heeft een extensie om dit te doen.

Tekenreeksen initialiseren:

Tekenreeksen zijn een speciaal geval van initialisatie; een string kan worden gebruikt in plaats van de accolades en komma's:

char chr_array[] = "hello";

is een afkorting voor de langere maar equivalent:

char chr_array[] = { 'h', 'e', 'l', 'l', 'o', '\0' };

In dit geval is de arraygrootte zes (vijf tekens plus de afsluitende '\0' ).

¹ Wat gebeurt er met een aangegeven, niet-geïnitialiseerde variabele in C? Heeft het een waarde?

² Merk op dat een constante uitdrukking wordt gedefinieerd als iets dat kan worden geëvalueerd tijdens het compileren. Dus, int global_var = f(); is ongeldig. Een andere veel voorkomende misvatting is het beschouwen van een const gekwalificeerde variabele als een constante uitdrukking . In C betekent const "alleen-lezen", niet "compileer tijdconstante". Dus globale definities zoals const int SIZE = 10; int global_arr[SIZE]; en const int SIZE = 10; int global_var = SIZE; zijn niet legaal in C.

Structuren en structuren van structuren initialiseren

Structuren en arrays van structuren kunnen worden geïnitialiseerd door een reeks waarden tussen accolades, één waarde per lid van de structuur.

struct Date
{
    int year;
    int month;
    int day;
};

struct Date us_independence_day = { 1776, 7, 4 };

struct Date uk_battles[] =
{
    { 1066, 10, 14 },    // Battle of Hastings
    { 1815,  6, 18 },    // Battle of Waterloo
    { 1805, 10, 21 },    // Battle of Trafalgar
};

Merk op dat de initialisatie van de array zonder de interne accolades zou kunnen worden geschreven en in het verleden (voor bijvoorbeeld 1990) vaak zonder deze zou zijn geschreven:

struct Date uk_battles[] =
{
    1066, 10, 14,    // Battle of Hastings
    1815,  6, 18,    // Battle of Waterloo
    1805, 10, 21,    // Battle of Trafalgar
};

Hoewel dit werkt, is het niet een goede moderne stijl - je moet niet proberen deze notatie in nieuwe code te gebruiken en de compilerwaarschuwingen corrigeren die het meestal oplevert.

Zie ook aangewezen initializers .

Gebruik van aangewezen initializers

int array[] = { [4] = 29, [5] = 31, [17] = 101, [18] = 103, [19] = 107, [20] = 109 };

struct Date
{
    int year;
    int month;
    int day;
};

struct Date us_independence_day = { .day = 4, .month = 7, .year = 1776 };

struct discriminated_union
{
    enum { DU_INT, DU_DOUBLE } discriminant;
    union
    {
        int     du_int;
        double  du_double;
    } du;
};

struct discriminated_union du1 = { .discriminant = DU_INT, .du = { .du_int = 1 } };
struct discriminated_union du2 = { .discriminant = DU_DOUBLE, .du = { .du_double = 3.14159 } };

struct discriminated_union
{
    enum { DU_INT, DU_DOUBLE } discriminant;
    union
    {
        int     du_int;
        double  du_double;
    };
};

struct discriminated_union du1 = { .discriminant = DU_INT, .du_int = 1 };
struct discriminated_union du2 = { .discriminant = DU_DOUBLE, .du_double = 3.14159 };

typedef struct Date Date;  // See earlier in this example

struct date_range
{
    Date    dr_from;
    Date    dr_to;
    char    dr_what[80];
};

struct date_range ranges[] =
{
    [3] = { .dr_from = { .year = 1066, .month = 10, .day = 14 },
            .dr_to   = { .year = 1066, .month = 12, .day = 25 },
            .dr_what = "Battle of Hastings to Coronation of William the Conqueror",
          },
    [2] = { .dr_from = { .month = 7, .day =  4, .year = 1776 },
            .dr_to   = { .month = 5, .day = 14, .year = 1787 },
            .dr_what = "US Declaration of Independence to Constitutional Convention",
          }
 };

int array[] = { [3 ... 7] = 29, 19 = 107 };