**C programazio-lengoaia** maila baxuko programazio-lengoaia inperatibo estandarizatu bat da. 1969. urtean Ken Thompsonek eta hurrengo urtean Dennis Ritchiek garatu zuten UNIX sistema eragilearen sorkuntzan erabiltzeko. Ordudanik hainbat sistema eragiletara zabaldu da haren erabilera, eta egun gehien erabiltzen den lengoaietako bat da. **C** behe mailakoa da baina oso eraginkorra ere bai, eta horregatik da konputagailuen sistema-softwarea idazteko programazio-lengoaiarik erabiliena, eta aplikazio-softwarea idazteko ere erabiltzen da. Hasiberrientzat diseinatua ez izan arren, maiz erabiltzen da informatikako ikasketetan, bereziki hardwaretik eta sistema eragiletik gertu dauden zereginak irakasteko (oinarrizko softwarea, sistema eragile bera, sare-protokoloak, sareko gailuen programazioa...).

Historia
--------

#### Sorrera Bell Laborategietan (1969)

1969. urtean Dennis Ritchiek *Bell Telephone Laboratories inc* enpresan garatutakoa da **C programazio-lengoaiaren** lehen bertsioa. Murray Hillen, New Jerseyn, geroago AT&T Bell Laboratories-en eta beranduago Lucent Tecnologoes-en ere osatu zuen garapen hura. Lehenagotik existitzen ziren BCPL eta B programazio-lengoaien garapenaren ondorioa da, horiek ere Bell laborategietan garatuak izan ziren. Aurreko lengoaia horiek bezala, sistema eragileak eta konkretuki Unix sistema eraikitzeko sortu zuten, kode eraginkorra sor zezan, hori funtsezko betekizuna zelako sistemaren nukleoaren programaziorako.

#### Lehen deskribapen eta konpiladore publikoak (1978)

C lengoaiaren sortzaileak: Ken Thompson and Dennis Ritchie 1973an
'GNU Compiler Collection' logoa
1978. urtera arte Bell laborategietako barne erabilpenerako bakarrik baliatu zuten **C** lengoaia. Brian Kernighan eta Dennis Ritchiek "C programming language" lan ezagunarekin lengoaiaren deskribapena egin zuten arte. Informazio horrekin, eta orduan publikoki eskuragarri jarri zen konpiladorearekin, **C** berebiziko hedapena izan zuen munduan zehar.

#### ANSI C lengoaia estandarizatua (1989)

Dennis Ritchie 2011n Japan Prize jaso zuenean.
1989. urtean **ANSI** (American National Standardization Institute) erakundeak C lengoaiaren lehen estandarizazioa burutu zuen, eta honen ondorioz, lengoaia arautu horri **ANSI C** izena eman zitzaion. Hurrengo urtean (International Standardization Institute **ISO**) estandar bihurtu zen. Estandarizazioari esker, arau jakin horiek jarraituz egindako programek garraiagarriak dira sistema eragile ezberdinen artean, horrela, programa bat, ukitu gehigarririk gabe, berdin konpilatu eta ibiliko zen sistema guzti horietan. Horren aurretik **C**-ren inplementazio komertzial guztiak ez zetozen bat "K&RC"-aren definizio originalarekin. Horrek bateraezintasun-arazoak zekartzan eta hori ekiditeko, ANSI-ko X3J11 komiteak lan egin zuen **C** lengoaiaren definizioa arautzeko. 1980.eko hamarkadaren erdialdean onartu zen estandarra.

#### C++ lengoaia estandarizatua (1998)

**C**-tik abiatuta proiektu berriak sortu dira gero, ezagunena C++ lengoaia izanik. 1998. urtean ANSI eta ISO erakundeen talde bateratu batek C lengoaiaren hedapen hau normalizatu zuen, C++ lengoaiari bultzada handia emanez.

#### Euskal Herrian

Akademikoki lehenengo erreferentzia da Ander Basalduak C lengoaia erabili zuela 1983an UEUn programaziorako ikastaro batean. 1991an Iñaki Alegriak, ordurako Donostiako Informatika Fakultatean **C** erabiltzen zuen sistema eragileak irakasteko, Montse Maritxalarrekin lengoaia deskribatzen zuen artikulu bilduma bat argitaratu zuen Ehuyar aldizkarian. Geroago 1995an Iñaki Alegriak berak liburu bat argitaratu zuen. 1999an *Bilboko Ingeniaritza Eskolan Iñaki Goirizelaiak Programazioaren oinarriak* **C**-rekin irakasteko liburu bat argitaratu zuen.

Ezaugarri orokorrak
-------------------

**C** eta bere ondorengoak (C++ eta Java), milaka programatzaile eta garapen-zentrok xede orokorreko programazio-lengoaia gisa hartu izan dituzte. **C** hain ezaguna izatearen arrazoi nagusiak ondoko hauek dira:

* C programazio-lengoaia **egituratua** da; **goi-mailako lengoaien ezaugarriak** ditu, baina **malgua** ere bada behe-mailako ezaugarriak barneratzeko. Lengoaiak duen potentzia eta adierazkortasun handiak direla-eta kode eraginkorra sortzeko gai da, zehatza eta laburra ere izan daitekeena beste kode-iturri batzuekin alderatuta.
* **C**-k mihiztadura-lengoaian edo makina-lengoaian aurki ditzakegun maila baxuko ezaugarriak ditu. Hau dela-eta sistema informatikoen oinarrizko programazioan oso erabilgarria da (adb.: sistema eragileen eta sareetako funtzioak programatzeko).
* **C** lengoaia eta bere ondorengoak izan dira erabilienak sistema eragile ohikoenetan (UNIX, MS-DOS, eta WINDOWS esaterako). Baita Interneteko protokolo garrantzitsuenak programatzeko ere: IP, TCP, UDP...
* **C**-ren barneko liburutegian oinarrizko funtzio ugari dago, eta gainera erabiltzaileei uzten die liburutegi-funtzio berriak sortzen beren erabilpen propiorako.
* **C**–n idatziriko programetatik abiatuta, konpiladorearen bitartez, oso modu eraginkorrean exekutatzen diren objektu-programa txikiak sortu eta birmolda daitezke.
* Ordenagailu pertsonal gehienentzat, handi zein txikientzat, **C**–ren konpiladore komertzialak daude.
* **C** ez dago plataformen menpe: **C**-n idatziriko programak ordenagailu batetik beste batera oso erraz eraman daitezke. Honen arrazoia zera da: **C**–k liburutegiko funtzioen esku uzten ditu ordenagailuaren ezaugarri gehienak.
* **C** abiapuntua izan zen ondoren iritsiko zen objektuetara bideratutako paradigmaren garapenerako: C++ eta Javarenean adibidez.

C-ren gabeziak
--------------

Dena ez da abantaila **C**-n. Bere gabezi kritikatuenak hauek dira:

* Aplikazioen programazio modularrari euskarri gutxi ematen dio (C++ eta Javaren kasuetan kritika hau ezin da egin).
* Lengoaiak eskaintzen duen malgutasunak programatzaileari kodea era oso pertsonalean garatzen uzten dio. Adibidez, konpiladoreak egiaztapen gutxi egiten ditu, geroago exekuzio-erroreak agertuz, eta erakusleekin erraz erabil daiteke memorian ondorio kontrolagaitzekin. Guzti horren ondorioz C lengoaia ez da gomendatzen programazio diziplinaturako tresna gisa, zeren oso zaila izan baitaiteke beste pertsona batek idatzitako programa bat ulertzea.

Sintaxia
--------

Arau sintaktiko orokor hauek kontuan hartu behar dira programak idazterakkoan:

* Aldagaien mota erazagutu behar da erabili baino lehenago
* Agindu bat baino gehiago lerro berean jarri ahal izateko '*;*' sinboloa erabili behar da banatzaile gisa.
* Kontrol-egituretako ataletan (*then* atalean edo *else* atalean adibidez) agindu bakar bat edo agindu multzo bakar bat jarri behar da.
* Agindu baten tokian agindu multzo bat egikaritu nahi dugunean aginduak multzokatzeko giltzak erabiltzen dira (irekitzeko giltza '{' eta ixtekoa '}'). Giltzen arteko agindu-multzoa agindu bakar gisa hartuko da kontrol-egituretan.

* Kontrol-egituretako atalak ondo bereizteko tabulazioa ez da kontuan hartzen Python lengoaian bezala, beraz agindu-blokeak edo multzoak definitzeko giltzak erabiliko dira. Hala ere, irakurgarritasunari begira tabulazio egokia erabiltzea gomendatzen da, baina konpiladoreak ez du kontuan hartuko.
* Parentesien erabilera baldintzetan. *if* edo *while* kontrol-egituretan baldintzak derrigorrez parentesi artean idatzi behar dira.
* Iruzkinak. Programa barruko oharrak '*/\**' karaktere bikotearekin hasten dira eta '*\*/*' karaktere-bikotearekin bultzen dira. Konpiladoreak ez du ikusiko iruzkineko testua, programatzaileek soilik ikusiko dute eta programaren logika ulergarriagoa izan dadin txertatzen dira programan.

Ezaugarriak
-----------

**C lengoaian** eragiketa bat adierazteko eragile bat erabiltzen da. Aldagaiak edota konstanteak eragileekin konbinatuz espresioak sortzen dira, eta espresio batek edo batzuek, eragileen bidez konbinaturik, agindu bat osatzen dute.

### Datu motak

Datuen mota erazagutu behar da definizioan, eta nahi bada, balio bat esleitu eskuinean = sinboloa erabiliz. Esleipenak idazteko eredua hau da (balio esleituta):

```
mota aldag\_izena = balioa

```

##### Datu mota bakunak

C-k ondoko oinarrizko datu-motak ezagutzen ditu:

* Karaktereak (*char*). Komatxo sinpleak erabiltzen dira balioa ematean. Adibidez *'z'*
* Zenbaki osoak (*int*). Adibidez: *12* edo *-5.*
* Zenbaki errealak (*float* edo *double*). Adibidez: *3.14* edo *-0.5*.
* Baliorik gabekoak (void)

|  |  |  |
| --- | --- | --- |
| **Datu mota** | **ADIBIDEA** | **ESANAHIA** |
| char | 'A' | karakterea |
| int | 1024 | zenbaki osoa |
| float | 3.14 | zenbaki erreala; kontuz, puntu hamartarra (ez koma). *double* doitasuna handitzeko. |
| void |  | mota hutsa |

##### Datu mota egituratuak

Datu mota egituratu arruntenak bektoreak dira, hainbeste dimentsio onartzen direlarik. Karaktere-kateak edo *string*-ak karaktereen bektore gisa definitzen dira; baina konstante moduan zehazteko komatxo bikoitza erabiltzen da. Adibidez *"Kaixo mundua"*.

### Agindu motak

Oinarrizko aginduak esleipena (*aldag\_izena* = *balioa*) eta datu-idazketak (*printf*) dira.

Datuen irakurketa *scanf* funtzioa erabiliz egiten da teklatutik egiten denean, fitxategietarako, berriz, bestelako funtzioak daude liburutegi estandarrean.

Agindu bat baino gehiago lerro berean jarri ahal izateko *;* sinboloa erabili behar da. Ondoren azaltzen diren egituretan aginduak multzokatzeko giltzak erabiltzen dira (irekitzeko giltza '{' eta ixtekoa '}'). Giltzen arteko agindu-multzoa agindu bakar gisa hartuko da kontrol-egituretan.

### Kontrol-egiturak

#### Baldintzapeko egiturak

Baldintzazko egituren artean bi dira erabilienak eta **C lengoaiak** bi hauek dauzka: *baldin* egitura (*if*) eta *aukera* (*switch*).

##### *if* egitura

*if* baldintza-egituraren exekuzioa
*if* egiturak balio du agindu-multzo bat soilik kasu batzuetan egikaritzeko, baldintza bat betetzen denean, alegia. Kontrol-egitura hau programazio-lengoaia guztietan dago. Egituran bigarren adar gehigarri bat zehaztu daiteke *else* hitz erreserbatua zehaztuz.

Beste gainontzeko egituretan bezala, tabulazioa ez da kontuan hartzen, beraz blokeak edo multzoak definitzeko giltzak erabiliko dira. Tabulazioa egokia gomendatzen da irakurgarritasunari begira, baina konpiladoreak ez du kontuan hartuko.

  

Egituraren eredua hau da:

```
if (<baldintza>)
 <agindua>
else
 <agindua>

```

Konparatzeko eragileak erabiliz osatu ohi da baldintza.

Parentesi artean zehaztu behar den baldintza betetzen bada segidan duen agindua (edo multzoa giltzen artean jarrita badaude) egikarituko da. Baldintza bete ezean, *else* adarra baldin badago adar horri dagokion agindu-multzoa egikarituko da. Ez badago *else* adarrik, berriz, egitura honek ez du inolako eraginik izango.

Esan bezala hautazkoa da *else* adarra idaztea. Adibidez, ondoko programa-zatian agertzen den *if* egitura sinplea da:

```
if (n < 0):
 n = -n; // balio absolutua

```
Aldiz, honako zati honetan egitura osoa dugu:

```
// zenbaki handiena kalkulatzeko
int a,b,hand;
printf("sakatu bi zenbakietako bat: \n");
scanf("%d",&a);
printf("sakatu bigarren zenbakia: \n");
scanf("%d",&b);
if (a > b)
 hand = a;
else
 hand = b;
printf("handiena:", hand);

```

Ondoko ñabardura hauek hartu behar dira kontuan:

* Baldintzazko espresioan berdintasuna adierazteko == eragilea erabili behar da eta ez = eragilea (esleipenetan bakarrik erabiltzen da hori).
* != eragilea erabiltzen da balio desberdinak bereizteko.
* Baldintzazko espresioa *&&* (eta), *||* (edo) eta *!* (ez) eragileekin osaturiko baldintza konposatua izan daiteke.
* Aldagai bat jartzen bada, dagokion zenbakizko balioa ebaluatuko da: 0 ez diren gainontzeko balio guztiak *egiazko*tzat hartzen dira halakoetan.

##### *switch* egitura

*switch* egiturak adar anitzeko baldintzazko egitura bat definitzen du. Adar bat aukeratuko da ebaluatzen den aldagai edo espresioaren balioaren arabera.

Ondoko adibidean hiru adar daude: batuketa baten emaitza, kenketa batena edo errore-mezu bat inprimatzea:

```
..
printf ("sakatu + edo - :\n");
scanf ("%c", &c);
switch (c)
 {
 case '+': printf("%d\n", a+b);
 break;
 case '-': printf("%d\n", a-b);
 break;
 default: printf("gaizki sakatu duzu\n");
 break;
 }
...

```

Ondoko ñabardura hauek hartu behar dira kontuan:

* Blokea mugatzeko giltzak erabili behar dira
* Adarrak hasierako puntuak dira, ondoko adarrekin ez jarraitzeko *break* gako-hitza adierazi behar da
* *case* gakoak adar baten hasiera adierazten du
* *default* gakoak beste adarren adar osagarria definitzen du
* *:* karakterearen ondoan adar bakoitzari dagokion agindua jartzen da

#### Iterazio-egiturak

Egitura hauetan oso aberatsa da C; hiru motakoak baitauzka: *bitartean* (*while*), *errepika* (*do*/*while*) eta *aldatuz* (*for*).

##### *while* kontrol-egitura

*while* iterazio-egituraren exekuzioa.
Egitura errepikakor orokorrena da *while*. Honela erabiltzen da:

```
while (<jarraitzeko-baldintza>)
 <agindua>

```

*Jarraitzeko baldintza* ebaluatu ondoren, *egiazkoa* lortu bada (zero ez den edozein zenbaki, aldagai bat denean), egiturari dagokion agindua edo agindu-multzoa exekutatuko da, eta gero baldintzako espresioa berriro ebaluatzera itzuliko da, begizta osatuz. Espresioaren emaitza *faltsua* denean, *while* egitura osoaren exekuzioa bukatutzat emango da eta hurrengo sententziara pasatuko da egikaritzapena, *while* egiturako gorputza berriro exekutatu gabe.

  

Zenbaki baten faktoriala kalkulatzen duen ondoko programan *while* egitura bat ikus daiteke. Bertan, egitura errepikakorraren baldintza *i<=n* da, eta bloke bat osatzen duten bi sententziek osatzen dute gorputza. *while* egitura errepikakorra *if* egitura baten barruan dago, *else* adarrean hain zuzen. Ohartzekoa da giltzen erabilera nola dagoen eginda. Azken sententzia (*printf*) ez da errepikatuko inolaz ere, 2. mailan dagoelako.

```
// n faktoriala
...
if (n < 0)
 printf ("errorea: zenbakia < 0 \n");
else
 {
 fakt = 1;
 i = 2;
 while (i <= n)
 {
 fakt = fakt \* i;
 i++;
 }
 printf ("%d faktoriala = %ld \n", n, fakt);
 }
...

```
  

##### *do-while* kontrol-egitura

*do-while* iterazio egituraren exekuzioa.
Egitura errepikakor antzekoa da, baina agindua beti egikaritzen da behin gutxienez eta orduan aztertzen da iteratzen jarraitzeko baldintza ea betetzen den,. Honela erabiltzen da:

```
do
 <agindua>
while (<jarraitzeko-baldintza>)

```

  

##### *for* kontrol-egitura

*for* iterazio-egiruraren exekuzioa
Egitura errepikakor honekin posible da bektoreetan elementu bakoitzerako agindu bat/batzuk errepikatzea. Honelako egitura du:

```
for (<hasieraketa>;<jarraitzeko-baldintza>;<eguneratzea>)
 <agindua>

```

Gehienetan hasieraketan bektore baten indizeari hasierako balioa esleitzen zaio, eta eguneratzean balio hori batean inkrementatzen da. Adibidez, hurrengo programa-zatian bektore baten osagaien batura kalkulatzen da:

```
...
int i, bekt[N], batura;
...
batura=0;
for(i=0;i<N;i++)
 batura=batura+bekt[i];
printf("Batura: %d\n",batura);

```

##### *break* eta *continue aginduak*

*break* sententziak iterazioen bat-bateko amaiera eragiten du, begizta ondoko hurrengo blokera joanez. *continue* bidez iterazio zehatz bat saihets daiteke. Hala ere, beren erabilera ez da gomendatzen, programen egitura ilundu egiten dutelako.

Adibidez aurreko programan zenbaki positiboak bakarrik batu nahi badira, eta zero bat agertzean bukatu, kodea horrela idatz liteke

```
...
int i, bekt[N], batura;
...
batura=0;
for(i=0;i<N;i++)
 {
 if(bekt[i]==0)
 break;
 if(bekt[i]<0)
 continue;
 batura=batura+bekt[i];
 }
printf("Batura: %d\n",batura);

```

### Funtzioak eta makroak

**C lengoaiaz** *funtzioak* dira azpiprogramak definitzeko baliabide bakarra. Berdin definitzen dira programan balio bat itzultzeko erabiltzen diren azpiprogramak eta agindu moduan erabiltzen direnak (beste lengoaia batzuetan *prozedura* edo *azpierrutina* deituak), diferentzia bakarra da azken kasu horretan funtzioaren mota *void* izango dela.

Funtzioak balio bat itzuli behar badu balioa (edo balioa duen aldagaia) parentesi artean zehaztuko da *return* hitz erreserbatuaren ondoan. Funtzioaren sententzia-multzoa giltzen artean idatziko da, eta bertan beharrezko izan daitezkeen aldagai lokalen erazagupena barnera daiteke. Lehen lerroan funtzioaren mota, izena eta, parentesi artean, parametroak zehaztuko dira. Adibidez faktoriala kalkulatzeko ondoko funtzioa idatz dezakegu:

```
// Zenbaki baten faktoriala kalkulatu funtzio bat erabiliz
int faktorial (int n):
 int fakt = 1;
 int i = 2;
 while (i <= n)
 fakt = fakt \* i;
 i=i+1;
 return (fakt);

```
Funtzioa erabiltzeko kodea horrela izan liteke:

```
 ...
 em=faktorial(k);
 printf("Faktorialaren emaitza: %d\n", em);

```

Makroek funtzioek bezala kodea egituratzeko balio dute, baina erreferentzia egiten zaienean makroaren kodea kopiatu egiten da programak (parametroen egokitzapena barne), eta horrela konpilatutako kodea luzeagoa izango da baina azkarrago egikarituko da.

Programa adibideak
------------------

Kaixo mundua adibidea (C lengoaiaz):

```
# include <stdio.h>

int main(void)
{
 printf("kaixo, mundua\n");
 return 0;
}

```

Erabilera
---------

C programak konpilatzeko urratsak.
C lengoaia sistema eragile gehienetan erabiltzen da. **C** behe mailakoa da baina oso eraginkorra ere bai, eta horregatik da konputagailuen sistema-softwarea idazteko programazio-lengoaiarik erabiliena, eta gainera aplikazio-softwarea idazteko ere erabiltzen da. Hasiberrientzat diseinatua ez izan arren, maiz erabiltzen da informatikako ikasketetan, bereziki hardwaretik eta sistema eragiletik gertu dauden zereginak irakasteko (oinarrizko softwarea, sistema eragile bera, sare-protokoloak, sareko gailuen programazioa...).

### Erabilera-estatistikak

**C** sortu zenetik etengabe egon da gehien erabilitako lengoaien artean, TIOBE programazio-komunitatearen sailkapenean ikus daitekeenez. 2019ko abenduan bigarrena zen sailkapen horretan. Sailkapen horren lehen posizioan Java dago erabilera guztien % 17.25 portzentajearekin; esan bezala, bigarrena C lengoaia da % 16.08rekin; hirugarrena Python % 10.30rekin, eta laugarrena C++ % 6.19rekin.

Erreferentziak
--------------

1. ↑   «Introduction — Ring 1.10 documentation» *ring-lang.sourceforge.net* (Noiz kontsultatua: 2019-12-22).
2. ↑    AlegriaLoinaz, Iñaki; Garay Vitoria, Nestor.  (1995). *C programazio-lengoaia.*  ELHUYAR arg ISBN 978-84-87114-03-8. (Noiz kontsultatua: 2023-04-27).
3. ↑   Montse, Alegria Loinaz, Iñaki Maritxalar.  (1991-02-01). «C programazio-lengoaia (I)» *Elhuyar aldizkaria* (Noiz kontsultatua: 2023-04-27).
4. ↑   Kernighan, Brian W.; Ritchie, Dennis.  (1978). *The C programming language.*  Prentice-Hall ISBN 0-13-110163-3. PMC 3608698. (Noiz kontsultatua: 2019-12-22).
5. ↑    Basaldua Artinano, Ander; Larizgoitia Lezama, Karmelo; Sarasola Gabiola, Kepa.  (1983). *Programaziorako sarrera txikia: problema bilduma.*  (Noiz kontsultatua: 2019-12-22).
6. 1 2    Alegria Loinaz, Iñaki; Maritxalar Anglada, Montse.  (1991). «C programazio-lengoaia (III). Eragileak eta Espresioak - Zientzia.eus» *zientzia.eus* (Noiz kontsultatua: 2019-12-19).
7. 1 2   Alegria, Iñaki..  (1995). *C programazio-lengoaia.*  Elhuyar Kultur Elkartea ISBN 8487114032. PMC 431789020. (Noiz kontsultatua: 2019-10-18).
8. ↑   Goirizelaia Ordorika, Iñaki.  (1999). *Programazioaren oinarriak.*  Universidad del País Vasco, Servicio Editorial = Euskal Herriko Unibersitatea, Argitalpen Zerbitzua ISBN 84-8373-139-8. PMC 433034031. (Noiz kontsultatua: 2019-12-22).
9. ↑    Alegria Loinaz, Iñaki; Maritxalar Anglada, Montse.  (1991). «C programazio-lengoaia (IV). Kontrol-egiturak I - Zientzia.eus» *zientzia.eus* (Noiz kontsultatua: 2019-12-19).
10. ↑    Alegria Loinaz, Iñaki; Maritxalar Anglada, Montse.  (1991). «C programazio-lengoaia (V). Kontrol-egiturak II - Zientzia.eus» *zientzia.eus* (Noiz kontsultatua: 2019-12-20).
11. ↑    Alegria Loinaz, Iñaki; Maritxalar Anglada, Montse.  (1991). «C programazio-lengoaia (VI). Funtzioak eta Makroak - Zientzia.eus» *Zientzia.eus* (Noiz kontsultatua: 2019-12-20).
12. ↑   «TIOBE Index | TIOBE - The Software Quality Company» *www.tiobe.com* (Noiz kontsultatua: 2019-10-29).

Ikus, gainera
-------------

* Programazio
* Programazio-lengoaia
* Programazio-lengoaien arteko konparazioa
* C++
* C#
* BASIC
* Python (programazio-lengoaia)
* Visual C.NET
* Visual Basic.NET
* .NET Framework
* Visual Studio.NET
* ASP.NET
* ADO.NET
* CLR
* .NET Show
* .NET
* .NET oinarri klase liburutegia
* Programazio-paradigma
* Programazio-lengoaien teoria
* Programazio-lengoaia konpilatua

Kanpo estekak
-------------

|  |  |
| --- | --- |
|  | Wikimedia Commonsen badira fitxategi gehiago, gai hau dutenak: ***C (programazio lengoaia)*** Aldatu lotura Wikidatan |

* **(Ingelesez)** ISO C taldearen webgune ofiziala
	+ **(Ingelesez)** ISO/IEC 9899, C dokumentu ofizial eskuragarriak, 'C99 Rationale' esaterako.
	+ **(Ingelesez)**   *C99 with Technical corrigenda TC1, TC2, and TC3 included.* . (3.61 MB)
* **(Ingelesez)** comp.lang.c FAQ maiz egindako galderak
* **(Ingelesez)**A History of C, Dennis Ritchie

|  |  |
| --- | --- |
| Autoritate kontrola | 
* **Wikimedia proiektuak**
* Wd Datuak: Q15777
* Commonscat Multimedia: C (programming language) / Q15777

---

* **Identifikadoreak**
* BNF: 119665180 (data)
* GND: 4113195-2
* LCCN: sh85018532
* NKC: ph116955
* SUDOC: 027672441
* **Hiztegiak eta entziklopediak**
* Britannica: url

 |

* Wd Datuak: Q15777
* Commonscat Multimedia: C (programming language) / Q15777