note sulla sintassi C

static

il valore della variabile sopravvive all termine scope corrente(funzione)

puo essere applicabile a variabili e a funzioni:

static int i = 10;
static void print(void) { putc ('\n'); }

static implica che il dato è privato alla unit/scope corrente. se usato all'interno di una funzione, il valore rimane disponibile alle successive chiamate.

le variabili statiche sono inizializzate dal compilatore, quindi il valore iniziale è semplicemente hardcoded nel eseguibile, normalmente sarebbe valutato a runtime.

extern

indica di usare la variabile perchè la sua dichiarazione è fatta altrove.

indica che la reale allocazione di una variabile, o corpo di funzione, è definita altrove, normalmente un'altro modulo di codice sorgente.

extern int _fmode;
extern void Factorial(int n);

extern è dato di default per un prototipo di funzione.

struct

raggruppa variabili in un singolo record.

struct _person {
    char name[80],
    email[30];
    int age;
} Person;

le dichiarazioni successive usano struct _person a_persons[100];

'struct _person' si comporta come fosse un tipo del linguaggio. 'Person' è una variabile inizializzata di tipo 'struct _person'

con "." si accede al valore

strcpy (Person.name, "test str");

mentre se la variabile fosse un puntatore useresti "->"

allocare una struttura:

int *ptr = malloc( sizeof(struct Person) );
if ( ptr != NULL ) {
    free(ptr);
    ptr = NULL;
}

typedef

crea un nuovo tipo di dato.

typedef definizione identificatore;

typedef unsigned char byte;
typedef char str40[41];
typedef struct {float re, im;} complex;
typedef char* byteptr;
typedef int (*fncptr)(int);
 
//After these definition, you can declare
 
byte m, n;
str40 myStr;
complex z1, z2;
byteptr p;
fncptr myFunc;
 
// con lo stesso significato di:
unsigned char m, n;
char myStr[41];
struct {float re, im;} z1, z2;
char *p;
int (*myFunc)(int);

union

raggruppa variabili che condividono lo stesso spazio di memoria, quando è settata una, non sono settate le altre. una ottimizzazione della memoria il cui uso è da valutare attentamente.

la sintassi è molto simile a quella di una struttura:

union [union-type-name]
  {
    type variable-names;
    ...
  } [union-variables] ;
union short_or_long {
    short i;
    long l;
  } a_number;

The compiler will allocate enough storage in a number to accommodate the largest element in the union. Elements of a union are accessed in the same manner as a struct.

Unlike a struct, the variables 'a_number.i' and 'a_number.l' occupy the same location in memory. Thus, writing into one will overwrite the other.

const

per una maggiore chiarezza,alcuni valori possono essere marcati come costanti, con la parola chiave const. il compilatore rileverà un errore al tentativo di modifica. le costanti vanno inizializzate assieme alla dichiarazione.

l'ordine delle parole chiave non è obbligatorio per cui le dichiarazioni seguenti sono equivalenti evalide:

int const AI = 1;
const int AI = 1;

inline

quando il programma è copilato, la chiamata alla funzione sarà _sostituita_ dal codice che definisce quella funzione, similmente a un copy-paste del compilatore

GCC apporta delle estensioni al C standard

compilare con librerie

gcc code.c -L/usr/local/lib -I/usr/local/include -lreadline