C (lingua programmationis)

[thumb|Linguam C comminiscit [Dennis Ritchie (ad dextram), dum iuxta Kenneth Thompson (ad laevam) laborabat, systema Unix creandi causa]]
**C** est lingua programmandi quam Dennis Ritchie, ingeniarius Societatis Bell Telephonicae, ad Unix systema administrativum exponendum anno 1972  excogitavit.  

C iussa et instructiones in structuris segmentatis adhibet, talem grammaticam et memoriam gradu infimo adhibendo, eo consilio, ut programmatata simpliciter compilentur, sine interpretatione. C utilis ad programmata describenda erat, quae antea in lingua machinali sola scripta essent.  

Quia programmata in systemata varia facile lingua C transferuntur, principalis linguae C usus in programmandis systematis administrativis, compilatris interpretatrisque linguarum aliarum consistit. C quidem evolutionem multarum programmandi linguarum influit, praesertim linguae C++, quae primitus commenta est ut lingua C extendatur.

## "Salve, munde!"
Hic textus monstrat programma minimum, quod "Salve, munde!" in monitorium mittit.

```c
#include 

int main() {
  printf("Salve, munde!\n");
  return 0;
}
```

## Usus 
C perutilis est ad programmata describenda, quae antea in lingua machinali sola scribeantur. Cum quidem programmator programma C circumscribit, possumus expectare compilatrum programma vertere in compendiosas sententias linguae machinalis. Et cum programma aliquid inexpectatum agit, programmator quoque potest scire id esse ob erratum suum nec ob compilatri interpretationem.

Quamquam facultates infimi gradus praebet, lingua C commenta est ad programmationem independentem machina citandam. Programmata quidem in systemata varia facile lingua C transferuntur. Et principalis linguae C usus consistit in programmandis systematis administrativis scribendis, compilatris interpretatrisque linguarum aliarum.

## Doctrina
Quamquam ubique lingua C invenitur, hodie haud ad linguas programmandi docendum adhibetur. Nonnulli enim linguam vituperant quia compilatra programma C convertunt in linguam machinalem semper cum hoc agi potest. Programmatorem numquam compilatra minantur: Certus es agere velle hanc rem? Re vera vis hoc...? Ergo lingua sinit programmatorem facile creare programmata bona et mala. Et hoc multas difficultates dat tironibus dum linguam discunt.

## Natura
C iussa et instructiones in structuris segmentatis adhibet, talem grammaticam et memoriam gradu infimo adhibendo, eo consilio, ut programmata simpliciter compilentur, sine multa interpretatione. Lingua quidem conspicua est quia paucos modos speciales quo res agantur in programmatores imponit. Quamobrem interdum programmatores appellant C "linguam machinalem altí gradús". 

Sicut plurimae linguae iuxta traditionem ALGOL, C sinit programmare structuris, iterationibus, conspectibusque lexici variabilibus. Eius autem generum staticorum systema defendit, ne operationes non desideratae agantur. In lingua C, omnia iussa efficienda in functionibus habentur. Parametra semper functionibus traduntur per valores, nec per referentias. Ut referentiae ipsae tradantur, valorem indicatorum traduntur. Variabilis genus *struct* sinit datorum distinctorum generum elementa combinare ut coniunctim adhibeantur. Linguae C scriptura spatia lineasque inter nomina ignorat; semicolones (puncta et commas) adhibendo ad sententias desinendas.  

C etiam has res praebet speciales:
* functiones, quae *non-nidabiles* (Anglice *non-nestable*) dicuntur, quae definiri non possunt intra alias functiones, dum variabiles ita definiri possunt et intra functiones et in dictorum segmentis
* typographiam aliquanto debilem; e.g., characteres sicut numeri integri adhiberi possunt
* accessum ad computatri memoriam infimo gradu, qui efficiatur convertendo locos ad indicatores varium generum
* functionum indicatores, quae sinunt clausuras rudimentarias et polymorphismos actuatos modo cum programma currat 
* ordinationis indicationem, sicut notionem secundariam, definitam iuxta arithmeticam indicatorum
* praeprocessorium dicatum ad definitionem macronum, fasciculos includenos, et complilationes condicionales efficiendas.
* functionalitates complexas, sicut innitum/exitum, series characterum contractio, et functiones mathematicas, cohaerenter delegatas ad algoritmos librarios
* circa triginta nomina reservata
* syntaxim ab ALGOL divergentem secutum exemplum lingae B, e.g. adhibens
** ceruchos { ... } loco begin ... end linguae ALGOL
** signum aequalitatis ad valores assignandos (transcribendo) instar linguae Fortran
** duo signa aequalitatis ad aequalitatem probandam (confer cum *.EQ.* in Fortran aut cum signo aequalitatis linguae BASIC)
** && et || loco *and* et *or* in ALGOL, quae ab operatoribus bit & and | (quibus lingua B usa est in ambobus significationibus) distinguenda sunt, numquam evaluare operandum ad dextram signi, si proventus solo cum operando ad laevum computari possit (evaluatio circuitus brevis)
** magnum numerum operatorum compositorum, sicut +=, ++, etc.

## Syntaxis
Omne programma lingua C scriptum constat in serie declarationum et sententiarum. Declarantur functiones et variabiles. Variabiles, constantes, operatores et functiones componunt sententiae ad res utiles faciendas. Lingua novem genera sententiarum, et quinque genera variabilium definit, inter genera conversiones et implicitas et explicitas sinens. Indicatores, qui locos memoriae indicant, partes maximi momenti in modo quo ordinationes numerorum et characterum redduntur, magnamque potestatem ad computatrum regendum programmatoribus dant. Omnia dicta in lingua habent valores numericos. Ergo *x=3* habet valorem tria, etc. Operatores arithmeticos et booleanos habet usitatos, sed cave: '=' est operator arithmeticus quamquam '==' est operator booleanus. Ergo, si primum "int x=1;" declaretur, x==1 aequat unum et x==2 aequat zerum; sed x=1 aequat 1 et x=2 aequat 2 !

## Declarationes 
Declaratio statuit genus, nomen et valorem initialem variabilis vel functionis, et desinit in ;. Omnes functiones et variabiles necessario declaratur ad initium programmatis, vel initium functionis vel initium copiae sententiarum secretae ab ceruchis {}. 
* "int x=1;" est declaratio variabilis *x*, generis numeri integri, ubi valor 1 assignatur in *x*.
* "int scribe (char rem);" est declaratio functionis nomine *scribe* quae reddit numerum generis numeri integri (*int*) et accepit argumentum generis characteris (*char*) nomine *rem*.

```c
exitús-genus functionis-nomen (variabilis-initialis-genus variabilis-initialis-nomen)
{
declarationes
sententiae
...
return (exitús valorem);
}
```

* Omne programma lingua C scriptum incipit declarando functionem principalem quae appellatur *main* (sc. Latine *Principalis*), sic:

```c
#include 

int main() {
  printf("Salve, munde!\n");
  return 0;
}
```

* In lingua C, ceruchi {} multas sententias cingunt ut una tractentur. Exempli gratia in *Salve, Munde*, ceruchi cingunt duas sententias quae functionem *main* componunt.

* Functio quaedam actuata, cum desinit, exitús valorem reddit qui datur in sententia *Return (valorem);* (sc. Latine "Redde (valorem)"). In exemplo, *Main* reddit valorem 0. Cum function *Main* declaratur generis *int*, valor redditus tunc debet esse generis *int*. Vel si argumentum ad Return *int* non est, programma valorem in genus *int* convertit. E.g. "return (0.02);" effecit ut *main* conclusus reddat 0.

### Genera variabilium 
Variabiles in lingua C sunt omnes quantitates quas sententiae possunt mutare. Genera variabilium sunt:
* *char*: character, cui sunt 8 bit, sufficientes ad characteres ASCII reddendas
* *int*: numerus integer, cui sunt 16 aut plura bit  
* *long int*: numerus integer, cui sunt 32 aut plura bit
* *float*: numerus puncto fluctuante, cui sunt 32 aut plura bit
* *double*: numerus puncto fluctuante maior, cui sunt 64 aut plura bit

Omnes variabiles oportet declarare ad initium functionis aut ad initium segmenti sententiarum ab {} conclusi, scribendo aut

 Variabilis-genus Variabilis-nomen; 
aut 
 Variabilis-genus Variabilis-nomen = Constans; 
ubi *Constans* valorem initialem variabilis indicat. Exempli gratia, declarationes habemus validas

```c
int vicipaedia = 1;
char caesar = 'C';
long int probatio = 0x17c;
```

Ullum nomen alphanumericum adhiberi potest ad variabilem nominandum, praeter illa nomina servata ad nominanda genera variabilium et dicta syntactica sicut *if* et *for*. Litterae maiusculae ab minusculis distinguuntur, ut ita nomina *var*, *Var*, et *vAr* tres variabiles secretas nominentur.

### Genera constantium 
* Constans generis *int*: possunt scribi forma decimali, octali, vel sedecimali sic: numerus decimalis 15 = octalis (adde 0 ad initium) 017 = sedecimalis (add 0x ad initium) 0xf
* Constans generis *long int*: adde L vel l ad initium numeri: decimalis L15 = octalis L017 = sedecimalis L0xf  
* Constans generis *float/double*: omnes numeri cum puncto '.' fractionem decimalem indicante vel cum 'e' potestatem decimalem indicante habentur esse generis *double* et *decimalis*: 123.3, .012, 1.23e10
* Contans generis *char*: 'a', '0', 'B', ... Etiam habentur characteres speciales: '\n' = nova linea, '\b' =retroite,  = virgulae, = virgula simplex, '\\' = linea dextrorsum inclinata
* Constans generis versús, qui in lingua C idem est ac series constantium  generis *char*: "malum", "Caesar", etc...

### Ordinationes: series, matrices, et aliae 
In linguis programmandi, ordinatio vel arretum dicitur modus quo elementa in seriem ordinentur. Elementa ordinata possunt esse numeri, characteres, functiones, vel aliae res. Ordinationes in lingua C declaramus scribendo:
 elementorum-genus ordinationis-nomen [elementorum-numerus] = Constans;
Numero elementorum omisso, compilatrum effecit ut elementorum numerus aequet elementorum numerum constantis quo valores ordinati fingantur. Exempli gratia, ordinationum declarationes habemus validas

```c
char verbum [] = "Caesar";
int vector1 [5] = {0,1,2,3,4};
double vector2 [2] = {.1234, 34e15};
double Matrix [2][3] ={{0.1,2,4},{-0.2,0.1,3}};
double vector3 [4];
```

Primo in exemplo numero elementorum omisso, quia "Caesar" sex litteras habuit, numerus elementorum variabilis nomine "verbum" erit sex. In ultima declaratione, valor initialis *vector* non assignatur; nunc autem necessario elementorum numerus datur.

Quoddam elementum vocatur elementi numerum vocando. Habentur igitur, iuxta definitiones supra:
 verbum [0] = 'C', verbum [1] = 'a', verbum [2] = 'e'
 vector1 [0] = 0, vector [2] = 2
 Matrix [0][0] = 0.1,  Matrix [0][1] = 2,  Matrix [1][2] = 3,

### Indicatores 
Indicator in re informatica est res qua locus memoriae computatri in programmate indicetur. In lingua C, indicatores fundamentales partes habent in quo modo series et ordinationes redduntur. 

In lingua C, indicatores ad variabiles generum *char* et *int* declarantur:

```c
char *indicator-alphanumericus;
int *indicator-numericus;
```

Post generis-nomen in declarationibus, operator * indicatori praepositus significat "indicator qui locum indicat variabilis huius generis". Extra declarationes autem, operator * indicatori praepositus significat "*valorem* in loco quem indicator indicat". Quapropter extra declarationes sententia 

```c
*indicator-alphanumericus ='5';
```

efficit ut *char* '5' imponatur in locum indicatum. Si autem

```c
char *indicator-alphanumericus ='5'; /* pravum!! */
char *indicator-alphanumericus ="5"; /* rectum, quia exceptio habetur cum de serie characterum tractatur. */
```

scribatur, hoc pravum est quia '5' non est locus memoriae computatri. Quamquam nec "5" est locus memoriae, C autem sinit nos scribere *char *p="5";* quid equivalens est *char p[]="5";*. 

Operator & est operatoris * inversus: variabilis nomini praepositus locum memoriae eius dat. Hoc operatore possumus initialem indicatoris locum fingere:

```c
char littera = 'C';
int numerus = 4;
char *indicator-alphanumericus = &littera;
int *indicator-numericus = &numerus;
```

In lingua C, omne ordinationis nomen indicatoris nomen iam in se continet: cum ordinatio declaratur,

```c
char verbum []="Caesar";
int vector1 [5] = {0,1,2,3,4};
```

nomina *verbum* et *vector1* indicatoribus funguntur. Possumus igitur equivalenter scribere

```c
indicator-alphanumericus = & verbum[0];
```

et

```c
indicator-alphanumericus = verbum;
```

Dictum "& verbum [0]" initium memoriae serei nomnis "verbum []" indicat, et "verbum" per se idem ac "& verbum [0]" dat.

In lingua C, *vector1 [j]* idem dicit ac **(vector1 + j)*. Et, cum *Matrix [m][n]* declaretur, *Matrix [i][j] = *(Matrix +(n-1)*i +j)*

### Structurae 
C quoque sinit ordinationes variabilium multorum generum definire, appellatas *structuras*, adhibendo dictum *struct*. Ecce exemplum 

```c
struct persona {
    int aetas;
    char nomen[];
};		/* declaratio	*/
struct {
    int aetas;
    char nomen[];
} ignota;

struct persona ignota;
```

Supra structura quaedam declaratur, quae variabiles *aetas* et *nomen* complectitur. Prima declaratio sola structuram nomine *persona* declarat sine variabile declarando. In secunda, structura non est nominata, sed variabilis nomine *ignota* declaratur. Tertia declaratio requirit ut definitio iam extet generis nomine *persona* quo variabilis *ignota* declaratur. 

Exemplum quod infra sequitur monstrat modos tres quo valores ad elementa structurae assignantur, adhibendo variabilis nomen, indicatorem, et operatores 
```c
*
```
, 
```c
.
```
, et 
```c
->
```
.

```c
struct persona { int aetas; char nomen[]; };		/* declaratio */

int main(void) {
    struct persona gaius, quintus, *indicator;
    indicator = &quintus;
    gaius.aetas = 40;
    gaius.nomen = "Caesar";
    (*indicator).aetas = 30;
    indicator->nomen = "Cicero";

    functio-quaedam(indicator);
    return 0;
}
```

### Mutatio generis 
In C, rei genus automatice convertitur, cum quantitates inter variabiles traducuntur. Talis appellatur *conversio implicita*. Exempli gratia, observentur conversiones: 

```c
int i;
double d=13.45;

i=d; 
printf("postquam sententia i=d functa est, habemus i=%f; d=%f",i, d);

d=i;
printf("postquam d=i functa est, habemus d=%f",d);
```

Nonnulli autem programmatores malunt conversiones explicitas. In lingua C, conversio explicita functa est scribendo nomen generis in parenthesi ante variabilem sic: "*d = (double) i*". Ambo modi convertendi validi sunt.

### *Genus void*
Interdum sunt functiones quae nihil reddunt. Hae functiones in lingua C dicuntur generis *void*. Genus *void* etiam utile est, ut indicatores generales definiantur. Ergo, cum "*double d; int i; void * p;*" declarentur, indicator *p* potest utrumque variabilem indicare: et *d* et *i* (*p=&d* aut *p=&i* potest). Cum autem de indicatore generis *void* tractetur, necesse est semper dare genus variabilis indicati antequam valorem eius adhiberi potest.

```c
int i;
double d=13.45;
double * pd = &d;
void * p;

p=pd;
printf("postquam p=pd producit * ((double *) p) =%f",* ((double *) p));

p=&i;
printf("postquam p=&i producit * ((int *) p) =%f",* ((int *) p));
```

## Sententiae 
In lingua C sententia dicitur omnia alia dicta ab ; conclusa, quae variabiles, operatores, constantes, et functiones combinant ad computationes utiles faciendas. Lingua C sola novem genera setentiarum ostendit. 

Omne dictum in lingua C valorem habet. Exempli gratia dictum "x=2" habet valorem 2. Quapropter dictum *x=y=2* est validum, valorem 2 simul imponens in variabiles *x* et *y*. 

Lingua etiam non fortiter distinguit condiciones logicas ab dictis valorum: falsum est zerum, et verum est nonzerum.

### Operatores 
Lingua C operatores arithmeticos habet usitatos. 

* Operatores arithmetici simplices: +, -, *, /, =, % : Operator % est operator moduli residui, ubi e.g. 5%2=1, et 6%2=0. 
* Operatores augendi et minuendi: ++, --: Operatores inclyti linguae C sunt ++ et --. i++ idem ac i=i+1 agit, sed solum postquam i evaluatur in dicto ubi sedet. ++i idem ac i=i+1 agit, sed postea i evaluatur in dicto ubi sedet. Ergo, ecce programma quod "x=y=0;y=x++;" primum exercens "x=1, y=0" producit; et postea "y=++x" exercens "x=2, y=2" producit:

```c
int x, y;
x = y = 0;
y = x++;
printf("y=x++ primum dat x=%d, y=%d; ", x, y);
y = ++x;
printf("postquam y=++x faciens tunc dat x=%d, y=%d", x, y);
```

* Operatores complexi: =+, =-, =/, =*: "x=+5" idem dicit ac "x=x+5";et "x=*5" idem dicit ac "x=x*5"
* Operatores booleani: , ==, <>, !, &&, ||: Operatores booleanos usitatos habet, sed cave: '=' est operator arithmeticus quamquam '==' est operator booleanus. Ergo, si primum "int x=1;" declaretur, x==1 aequat unum et x==2 aequat zerum; sed x=1 aequat 1 et x=2 aequat 2 ! In lingua || = 'aut' et && = 'et'.
* Operatores indicatorum: 
```c
*
```
, 
```c
&
```
, 
```c
.
```
, 
```c
->
```
 : Operatores indicatorum partem fundamentalem agunt in quo modo lingua C reddit elementa ordinata. Vide explanatio indicatorum supra.

### Genera sententiarum 
* *If* (sc. Latine "si") est dictum quod exsecutionem aliarum sententiarum efficit cum argumentum nonzerum est. Usitate argumentum nonzerum est cum condiciones quaedam satisfaciuntur.

```c
if (condicio == VERA) {
    printf("Condicio est vera!\n");
} else {
    printf("Condicio est falsa!\n");
}
```

* *While* et *do* (sc. L. "dum" et "age") sunt dicta quae sententias efficiunt dum argumentum suum nonzerum manet. *While* condicionem probat ad initium, *do* ad finem cuiusque iterationis. 

```c
char FALSA = 'n';
char condicio ='i';

while (condicio != FALSA) {
    printf("Condicio est vera! Iterumne probanda est (ita/non)? \n");
    condicio = getchar();
}
printf("Condicio nunc est falsa!\n");

do {
    printf("Condicio est vera! Iterumne probanda est (ita/non)? \n");
    condicio = getchar();
} while (condicio != FALSA);
printf("Condicio nunc est falsa!\n");
```

* *For* est instar dicti *while*, sed indicem quandam declaratam augit in quaque iteratione. *For* hanc rem perficit brevi. Exempli gratia

```c
for (i = 0; i 0 est!\n");
```

idem agit ac

```c
int i=0;
while (i0 est!\n");
```

* *Break* et *Continue* sunt iussa quibus exsecutio aliae sententiarum interpelletur. *Break* (sc. Latine "Rumpe") exsecutionem catenae sententiarum currentis rumpit, praesentem structuram vel omnes iterationes sententiae regentis desinens. *Continue* (sc. L. "Excede") autem, exsecutionem continuo sequentem rumpens, praesentem structuram vel interactionem servat, effecitque ut proxima interactionem sequatur.

```c
char RUMPE = 'r';
char EXCEDE ='e';

while (1) {
    printf("Si vis Excedere imprime 'e'. Si non imprime alteram litteram.\n");

    if (getchar()==EXCEDE) continue;

    printf("Usor non imprimit Excede 'e'. Rumpe? Si vis rumpere, imprime 'r'. \n");

    if (getchar()==RUMPE) break;

    printf("Usor imprimuit nec e 'excede' nec r 'rumpe'. Ergo nova iteratio habetur.\n");
}

printf("Usor imprimuit 'Rumpe' (r). Ergo exsecutio desinit!\n");
```

* *Switch* (sc. L. "permuta") est sententia quae idem valet ut longa catena sententiarum *if*-*else* ex quibus omnibus prima vera perfertur aut ultima (default :). Sententia exempli gratia actuatur sic:

```c
char c;
int x,y,z;
x=y=z=0;
c=getchar();
switch (c){
    case 'a':
        x=1;
    case 'b':
        y=1;
    default :
        z=1;
}

printf("First switch: x=%d, y=%d, z=%d", x,y,z);
```

In exemplo, ab initio *x=y=z=0*. Si *c=* 'a', exsecutio salit ad ''case 'a':*, postquam omnia quae sequuntur facta sunt:*x=1*, *y=1*, et *z=1*. Si *c='' 'b', exsecutio salit ad ''case 'b':*, postquam omnia quae sequuntur facta sunt: *x=0*, *y=1*, *z=1''. Si c nec 'a' nec 'b' aequat, exsecutio salit ad *case default:*, postquam omnia quae sequuntur facta sunt: *x=0*, *y=0*, *z=1*. 

Usitatissime, dicta *break* adduntur post casus qui tunc logice dividuntur. Cum *Break* primum attigatur, exsecutio sententiae *switch* desinit.

```c
x=y=z=0;

switch (c){
    case 'a':
    case 'b':
        x=1;
        break;   
    case 'c':
        y=1;
        break;   
    default :
        z=1;
}
printf("Second switch: x=%d, y=%d, z=%d", x,y,z);
```

In exemplo, cum *c =* 'a' aut *c=* 'b', *x=1*, *y=0*, et *z=0*. Cum *c =* 'c', *x=0*, *y=1*, et *z=0*. Cum *c* nec 'a', nec 'b' nec 'c' aequat, *x=0*, *y=0*, et *z=1*.

* *Goto* (sc. L. "adí") efficit exsecutionem salire ad quoddam programmatis punctum quod programmator statuit per tesseram alicubi locatam desinentem in :. 

```c
int x=0;

Antea:

printf("Hic!! x=%d",x);
x=x+1;

if (x>4) break;

goto Antea;
```

In exemplo, *goto* efficit ut programma quinque iterationes agat, quid simile est sententiae *do*. In linguis programmandi, *goto* est instar clausularum *quod* quae in loco clausularum accusativi+infinitivi adhibentur: programmatores cave, ne deutatur!

* *Return* (sc. Latine "Redde") est sententia qua functio desinens valorem reddit. Syntax est "Return (valorem);".

## Functiones 
In lingua C, programmatores suas proprias functiones et librarias functionum definire et declarare libenter possunt. Functiones definendae sunt eodem modo functionis *Main*, quae iam descripta est supra. Declaratio functionum necessario ad caput programmatis scribitur iuxta iussa ad praeprocessorium quae in lingua C habentur incipere in symbolo #.
 
Lingua per se caret modo quo memoria dynamice allocetur (hoc est, dum programa currit), quo data inputetur et exponatur, et quo aliae res agantur. Lingua autem definit quasdam librarias functionum, quibus hae res agantur. Functionum librariae in programma includuntur per iussum #include quae necessario ad caput programmatis scribendum est. 

### Librariae praeparatae 
Lingua C praebet viginti quattuor librarias functionum varium generum: assert.h, complex.h, ctype.h, errno.h, fenv.h, float.h, inttypes.h, iso646.h, limits.h, locale.h, math.h, setjmp.h, signal.h, stdarg.h, stdbool.h, stddef.h, stdint.h, stdio.h, stdlib.h, string.h, tgmath.h, time.h, wchar.h, wctype.h

Inter utilissimae librariae sunt:
* *stdlib.h*: praebet functiones quibus memoria regantur, series characterum in numeros generis *double* convertantur, iussa directe ad systema edantur, inquisationes varium generum actuentur, absolutus numeri valor aestimetur, et numeri integri commode dividantur.
* *stdio.h* praebet functiones quibus data inputenur et exponantur computatro
* *math.h* praebet functiones mathematicas sicut cos, sin, atan, exp, log, log10... 
* *string.h* praebet multas functiones quibus series characterum adaptentur
* *time.h* praebet functiones quibus tempus et hora aestimantur

### Memoria 
Functiones quibus memoria computatri regantur lingua C praebet in libraria *stdlib.h*. 

```c
/*Alloca spatium memoriae magnitudinis variabilium decem generis *int*. */
int *ptr = malloc(10 * sizeof (int));

if (ptr == NULL) {
    /* Systema memoriam allocare non potest */
} else {
    /* Systema potuit memmoriam allocare. Nunc age aliquid.  */
    free(ptr); /* Cum iam egimus quid volumus, nunc memoriam librare oportet. */
}
```

Inter utilissimas functiones quae in exemplo supra monstratur sunt:
* *Sizeof*: dictum *sizeof(variabilis)* (sc. L. "magnitudo") dat magnitudinem variabilis in octetis (byte), quam requirunt functiones memoriae sicut malloc.
* *Malloc*: sententia *int * p = malloc (10);* allocat decem octetos memoriae et assignat indicatorem *p* ad locum variabilis generis *int*.
* *Free*: sententia *free (p);* liberat memoriam quem *p* indicat.
* *Calloc*: quasi idem ac malloc agit sed syntax aliquanto discrepat et valorem cuiusque loci in zerum ponit. Sententia *int *ptr = calloc(10,sizeof (int));* allocat spatium memoriae *10*sizeof(int)* et zerum imponit in hos decem locos.
* *Realloc*: sententia *int *ptr = realloc(p, 20*sizeof(int))* mutat ad *20*sizeof(int)* magnitudinem loci memoriae quem *ptr* indicat, conservans indicatorem ipsum.

### Initus et exitus 
Functiones quibus data inputentur et exponantur, dum programma currit, lingua C praebet in libraria *stdio.h*. Inter utillissimas functiones sunt:
* Quibus characteres singuli inputantur et exponantur:
** *getchar*, *getc*
** *putchar*, *putc* 
* Quibus characterum series inputantur et exponantur:
** *gets*, *puts*
* Quibus characteres et numeri inputantur et exponantur secundum modum datum:
** *scanf*, *printf*
* Quibus characteres et numeri inputantur et exponantur fasciculis secundum modum datum:
** *fopen*, *fclose*
** *fread*, *fgetc*, *fgets*
** *fwrite*, *gputc*, *fputs*

*Perl
*C++
*C--
*GCC
*Unix
*UnxUtils

## Bibliographia
*Kernighan, Brian, et Dennis Ritchie. *The C Programming Language*. Qui etiam appellatur K&R — Liber Primus de C.
** 1a, Prentice Hall 1978; ISBN 0-13-110163-3. Pre-ANSI C.
** 2a, Prentice Hall 1988; ISBN 0-13-110362-8. ANSI C.
* ISO/IEC 9899. Documenta officialia de C99, corrigenda technica et rationemc omplectens. Ab anno 2007, versio linguae C ad diem est ISO/IEC 9899:TC3.
*Harbison, Samuel P., et Guy L. Steele. *C: A Reference Manual*. Liber excellens qui sicut enchiridion definitivum fungitur vel pro eis quid compilatra de C elaborant. Liber grammaticam BNF linguae C continet.
** 5s, Prentice Hall 2002; ISBN 013089592X.
*Jones, Derek M. *The New C Standard: A Cultural and Economic Commentary.* Addison-Wesley. ISBN 0-201-70917-1. Enchiridion interretiale.
*Sedgewick, Robert. *Algorithms in C.* Addison-Wesley. ISBN 0-201-31452-5 (Part 1–4) et ISBN 0-201-31663-3 (Part 5).
*Press, William H., Saul A. Teukolsky, William T. Vetterling, et Brian P. Flannery. *Numerical Recipes in C (The Art of Scientific Computing).* ISBN 0521431085.

## Nexus externi 
* Exemplar Hodiernus (C99 Technicis corrigendis TC1, TC2, and TC3 conclusis)
* Draft ANSI C Standard (ANSI X3J11/88-090), Third Public Review (May 13, 1988)
* ISO C Working Group (situs interretialis officialis)
* *The Development of the C Language*, auctore Dennis M. Ritchie
* comp.lang.c Quaestiones Saepe Rogatae
* *The C Book*, auctoribus M.Banahan, D.Brady, et M.Doran, (Addison-Wesley, 2nd ed.) — Liber pro discipulis tironibus intermediis, non iam in librum impressus qui licet ab interreti depromere.
* *The New C Standard: An economic and cultural commentary* — Liber non iam vulgatus de "analysi descriptiva Exemplaris Internationalis linguae C."
* A New C Compiler symbola a Ken Thompson scripta.

Categoria:Linguae programmationis
!