Roman numeral 10000 CC DD.svg
Latinitas nondum censa

C (lingua programmandi)

E Vicipaedia
Salire ad: navigationem, quaerere

Vide etiam paginam fere homonymam: C

Linguam C comminiscit Dennis Ritchie (ad dextram), dum iuxta Kenneth Thompson (ad laevam) laborabat, systema Unix creandi causa

C est lingua programmandi, quam Societatis Bell Telephonicae ingenarius Dennis Ritchie anno 1972 excogitavit, ut systema administrativum Unix exponeretur.

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 fuit ad programmata describenda, quae antea in lingua machinali sola scribentur.

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

Salve munde[recensere | fontem recensere]

Hic textus monstrat programma mimimum, quod "Salve, munde!" in scrinium mittit.

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

Usus[recensere | fontem recensere]

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 a 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[recensere | fontem recensere]

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[recensere | fontem recensere]

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 quoque 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[recensere | fontem recensere]

Omne programma lingua C scriptum constat in serie declarationum et setentiarum. 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[recensere | fontem recensere]

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.
exitús-genus functionis-nomen (variabilis-initialis-genus variabilis-initialis-nomen)
{
declarationes
sententiae
...
return (exitús valorem);
}
  • Omne programma lingua C scriptum incepit declarando functionem principalem quae appellatur Main (sc. Latine Principalis), sic:
#include <stdio.h>
 
int main() {
  printf("Salve, munde!\n");
  return 0;
}
  • In lingua C, ceruchi {} multas sententias cingunt ut una tractentur. Exempli gratia in Salve, Munde, ceruchi cigunt 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[recensere | fontem recensere]

Variabiles in ligua 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 variabilies 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

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[recensere | fontem recensere]

  • Constans generis int: possunt scriberi 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[recensere | fontem recensere]

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

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[recensere | fontem recensere]

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:

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

*indicator-alphanumericus ='5';

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

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:

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,

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

nomina verbum et vector1 indicatoribus funguntur. Possumus igitur equivalenter scribere

indicator-alphanumericus = & verbum[0];

et

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[recensere | fontem recensere]

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

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 *, ., et ->.

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[recensere | fontem recensere]

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

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[recensere | fontem recensere]

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.

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[recensere | fontem recensere]

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 dicti valores: falsum est zerum, et verum est nonzerum.

Operatores[recensere | fontem recensere]

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 incylti 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:
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: *, &, ., -> : Operatores indicatorum partem fundamentalem agunt in quo modo lingua C reddit elementa ordinata. Vide explanatio indicatorum supra.

Genera sententiarum[recensere | fontem recensere]

  • If (sc. Latine "si") est dictum quod exsecutionem aliarum sententiarum efficit cum argumentum nonzerum est. Usitate argumentum nonzerum est cum condiciones quaedam satisfaciuntur.
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.
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
for (i = 0; i < 5; i++) {
    printf("i=%d <0 est!\n",i);
}
printf("i>0 est!\n");

idem agit ac

int i=0;
while (i<5) {
    printf("i=%d <0 est!\n",i);
    i=i+1;
}
printf("i>0 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.
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 fugitur ut longa catenta sententiarum if-else. Sententia exempli gratia actuatur sic:
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.

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 :.
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[recensere | fontem recensere]

In lingua C, programmatores libenter possunt definire et declarare suas proprias functiones et librarias functionum. 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<nomen-librariae> quae necessario ad caput programmatis scribendum est.

Librariae praeparatae[recensere | fontem recensere]

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[recensere | fontem recensere]

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

/*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[recensere | fontem recensere]

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

Vide etiam[recensere | fontem recensere]

Fontes[recensere | fontem recensere]

Nexus externi[recensere | fontem recensere]