**C++** 1979an Bjarne Stroustrup-ek diseinatutako programazio-lengoaia bat da. Objektuen manipulazioa ahalbidetzen duten mekanismoak C programazio-lengoaiara zabaltzea izan zen haren sorkuntzaren asmoa. Zentzu horretan, objektuetara bideratutako lengoaien ikuspegitik, C++ lengoaia hibridoa da.

Ondoren, programazio generikoaren erraztasunak gehitu ziren, eta horiek programazio egituratuaren paradigmei eta objektuetara bideratutako programazioari gehitu zitzaizkien. Horregatik esan ohi da C++ programazio-lengoaia multiparadigma bat dela.

Gaur egun, ISO C++ izeneko estandar bat dago, eta horri atxiki zaizkio konpiladore modernoenen fabrikatzaile gehienak. Badira interprete batzuk ere, ROOT kasu.

Historia
--------

Bjarne Stroustrup, C++ lengoaiaren sortzailea
1979an, Bjarne Stroustrup informatikari daniarra C++ lengoaiaren aurretikoa den "*C with Classes*" proiektuarekin lanean hasi zen. Programazio-lengoaia berri bat sortzeko motibazioa Stroustrup-i bere doktore-tesian programazioan izandako esperientziatik sortu zitzaion. Stroustrup ohartu zen Simulak bazituela tamaina handiko softwarea garatzeko oso baliagarriak ziren ezaugarriak, baina lengoaia motelegia zela erabilera praktikorako; BCPL, aldiz, azkarra zen baina oso behe-mailakoa tamaina handiko softwarea garatzeko egokia izateko. Stroustrup AT&T Bell Labs-en lanean hasi zenean, Unixen kernela aztertzen aritu zen, konputazio banatuari dagokionez. Bere doktorego esperientzia gogoratuz, Stroustrupek C lengoaia hobetzea proposatu zuen Simularen antzeko ezaugarriekin. C aukeratu zen, erabilera orokorrekoa, azkarra, eramangarria eta oso erabilia zelako. C eta Simula programazio-lengoaien eragina izateaz gain, beste hainbat lengoaiak ere izan zuten eragina lengoaia berrian, ALGOL 68, Ada, CLU eta ML barne.

Hasiera batean, C-ren Cpre konpiladoreari hainbat ezaugarri gehitu zitzaizkion Stroustrup-en *"C with Classes"* lengoaiarako: klaseak, klase eratorriak, datu-moten erabilera zurruna, i*nline expansion* eta argumentu lehenetsien erabilera, besteak beste.

1982an hasi zen Stroustrup "*C with Classes*"-en ondorengo izango zen programazio-lengoaia garatzen, eta hasiera batean beste izen batzuk erabili bazituen ere, azkenean "C++" izena jarri zion ( `++` ikurra inkrementu- edo gehikuntza-eragilea da C programazio-lengoaian). Ezaugarri berriak gehitu zizkion: funtzio birtualak, erreferentziak, konstanteak, datu-moten kontrol hobetua, iruzkinak lerro bakarrean egiteko bi barra ( `//`) erabiltzea BCPL lengoaian bezala, etab. Gainera, C++ -erako konpiladore independente berri bat garatu zuen: Cfront.

1985ean C++ programazio-lengoaiaren (*The C++ Programming Language*) lehen edizioa argitaratu zen. Garai hartan oraindik estandar ofizialik ez zegoenez, bertsio hura lengoaiarako erreferentzia bihurtu zen. Lehen inplementazio komertziala urte bereko urrian argitaratu zen.

2018an Stroustrupek *Charles Stark Draper Prize* saria jaso zuen "C++ programazio-lengoaia kontzeptualizatu eta garatzeagatik".

2019an programazio-lengoaia zabalduenen artean laugarren postuan dago C++, Javaren, Cren eta Pythonen atzetik.

  

### Etimologia

Stroustrupen arabera, "C++ izenak C-ren aldaketen izaera ebolutiboa adierazten du". Izen hori Rick Mascitti-k eman zion 1983an eta orduan hasi zen erabiltzen lehen aldiz. C programazio-lengoaian erabiltzen den `++` inkrementu- edo gehikuntza-eragiletik dator (aldagai baten balioaren inkrementua). Gainera, "+" ikurrarekin lengoaia areagotu edo hobetu dela adierazi nahi izan zen.

C++ lengoaiaren garapenak iraun zuen bitartean, *"new C"* (C berria) eta *"C with Classes"* (C klaseekin) izenak ere erabili ziren hura izendatzeko.

### Estandarizazioa

| **Urtea** | **C++ Estandarra** | **Izen informala** |
| **1998** | ISO/IEC 14882:1998 | C++98 |
| **2003** | ISO/IEC 14882:2003 | C++03 |
| **2011** | ISO/IEC 14882:2011 | C++11, C++0x |
| **2014** | ISO/IEC 14882:2014 | C++14, C++1y |
| **2017** | ISO/IEC 14882:2017 | C++17, C++1z |
| **2020** | Oraindik zehazteko | C++20, C++2a |

JTC1/SC22/WG21 izenez ezagutzen den ISO lantaldeak estandarizatzen du C++. Orain arte, C++ estandarraren bost berrikuspen argitaratu ditu.

1998an sortu zuen lehen C++ estandarra ISO lantaldeak. Modu informalean C++98 izenez ezagutzen da lehen estandar hori (*ISO/IEC 14882:1998*).

2003an argitaratu zuten C++ estandarraren bertsio berria (*ISO/IEC 14882:2003*) , C++98 bertsioan identifikatutako arazoak konpontzen zituena.

Estandarraren hurrengo berrikuspen nagusia *"C++0x"* izenez izendatua izan zen modu informalean, baina 2011ra arte ez zen argitaratua izan. *C++11 bertsioak* lengoaian bertan eta liburutegi estandarrean gehikuntza asko jaso zituen.

2014ean C++14 (edo informalki *C++1y*) argitaratu zen. Funtsean aurreko *C++11* estandarraren hedapen txiki bat zen; akatsen zuzenketak eta hobekuntza txikiak jaso zituen.

2017an beste berrikuspen nagusi bat argitaratu zen, C++17 (edo informalki *C++1z*).

Gaur egun, hurrengo berrikuspena izango den C++20rekin ari da lanean ISO lantaldea.

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

Atal honetan laburbiltzen dira C++ programazio-lengoaiaren oinarrizko ezaugarri batzuk: datu-motak, kontrol-egiturak, funtzioak idazteko modua, etab..

### Sarrera/Irteera funtzioak

C++ lengoaian badago aukera C lengoaiako `printf` eta `scanf` funtzioak erabiltzeko, baina horiez gain, beste bi funtzio daude: `cin` datuen sarrerako funtzioa eta `cout` irteerarako funtzioa. Adibidez:

```
cin >> balio; // Horrela balio aldagaiari datu bat ematen zaio.
cout << "Horrela balio aldagaiaren edukia bistaratzen da" << balio << "\n";

```

### Identifikatzaileak

Datu-mota ezberdinak prozesatu ahal izateko, izenak jarri behar zaizkie. Horretarako, identifikatzaileak daude, aldagaiei eta funtzioei izenak emateko. Identifikatzaileak definitzeko, karaktere alfabetikoak (A-tik Z-ra, maiuskulak zein minuskulak), zenbakiak (0-9) eta **`_`** karaktere berezia erabil daitezke. Konpilatzerakoan, identifikatzailearen lehen 31 karaktereak irakurriko dira eta hasierakoa derrigorrez karaktere alfabetikoa edo `_` izan behar du.

### Datu-motak

#### Zenbaki osoak

Zenbaki osoetarako, `int` datu-mota erabiltzen da. Zeinurik gabeko zenbakiak gordetzeko memoriako bi byte erabiltzen dira. Hitz gakoa `unsigned int` da eta 0 / 65535 tartean daude. Zeinudun zenbaki laburrak gordetzeko bi byte behar dira, `short int` erabiltzen da eta -32.768 / 32767 tartean daude. Azkenik, zeinudun zenbaki luzeak daude, lau byte behar dituztenak, `long int` hitz gakoa dutenak eta -2.147.438.648 / 2.147.483.647 tartean daudenak. Adibidez:

```
int aldagaia = 680;

```

#### Zenbaki errealak

Zenbaki errealek koma higikorrezko formatua erabiltzen dute.

`float` motakoek 7 hamartar dituzte, 4 byte behar dituzte eta horietatik 8 dira berretzailea adierazteko eta 24 mantisarako.

`double` motakoek 15 hamartar dituzte eta 8 byte behar dituzte.

`long double` motakoak ere definitu daitezke eta 10 byte behar dituzte.

Adibidez:

```
float aldagaia = 6.63e-23;

```

#### Karaktereak

Datu-mota honek 0-255 tarteko zeinurik gabeko zenbaki oso bat definitzen du, byte batean gordetzen da eta gehienetan ASCII kodea erabiltzen da zenbakiak karaktere bihurtzeko. `char` bidez deklaratzen dira. Adibidez:

```
char aldagaia = 'X';

```

#### Konstanteak

Konstanteak definitzeko, `const` datu-mota erabiltzen da. Derrigorrezkoa da hasieratzea eta bere balioa aldatzen ahaleginduz gero, konpiladoreak errorea emango du. Adibide bat:

```
const double PI = 3.1415926;

```

#### Array

Array motako aldagaiak askotan erabiltzen dira, aldagai hauek datu-mota asko gordetzeko balio dute eta matrize kontzeptuarekin erlazio handia dute.

##### Deklarazioa

Array motako aldagaiak definitzeko osagaien datu-mota, array-aren izena eta osagaien kopurua finkatu behar da, horretarako `[]` erabiltzen da eta zenbateko tamaina duen kortxeteen artean zehazten da. Array-ak edozein aldagai-motakoak izan daitezke. Deklarazio adibidea:

```
int aldagaiak[5]; // "aldagaiak" izeneko Array horretan int motako 5 elementu daude

```
Aldagai mota hauetan zenbaki guztiak identifikatu ahal izateko *indize* izeneko zenbaki bat erabiltzen da, derrigorrez zenbaki osoa izan behar duena. Kontuan izan behar duguna da, lehenengo indizearen balioa 0 dela.

0 indizea | 1 indizea | 2 indizea | 3 indizea | 4 indizea| aldagai 1 | aldagai 2 | aldagai 3 | aldagai 4 | aldagai 5 |
| --- | --- | --- | --- | --- |

Adierazpen grafiakoan adierazten den moduan, aldagaiak 5 elementu izan arren array-aren indize handiena 4 da, 0 indizetik hasten baita.

##### Hasieraketa

Array-ak hasieratzeko garaian beste aldagaiekin egiten den bezala, bere barneko elementu bakoitzari balio zehatz bat ezartzeko aukera ematen du. Horretarako, balioak `,` bitartez banandu behar dira elkarrengandik eta balio guzti horiek kortxete (`[]`) tartean sartu behar dira.

```
int aldagaiak[5] = {7,5,6,15,20};

```

##### Dimentsio anitzeko arrayak

Array motako aldagaiak dimentsio anitzekoak izan daitezke. Dimentsio anitzeko arrayak, azken finean, matrizeak dira. Bi dimentsiokoak direnak 2D-ko matrizeak osatzen dituzte eta hiru dimentsiokoak berriz 3D-ko matrizeak. Bi dimentsioko arrayen deklarazio egitura, dimentsio bakarrekoenaren antzekoa da, baina ez berdina.

Bi dimentsiokoak:

```
int aldagaiak [1 dimentsioa][2 dimentsioa];

```
Hiru dimentsiokoak:

```
int aldagaiak [1 dimentsioa][2 dimentsio][3 dimentsio];

```

### Kontrol-egiturak

#### Baldintzapeko egiturak

C++ lengoaiak bi baldintzapeko egitura eskaintzen ditu: `if` eta `switch`.

##### IF egitura

Egitura edo sententzia hau edozein lengoaiatan dago eta C++ lengoaian ezaugarri orokorrak mantentzen ditu, hau da, espresio logiko bat ebaluatzen da eta emaitza egiazkoa bada, espresioa exekutatzen da.

Bi sintaxi aukera posible daude:

```
if(baldin-espresioa) espresioa;

```
eta

```
if(baldin-espresioa)
{
 espresioa;
}

```
Egitura hauetan, baldintza egiazkoa denean espresioa exekutatuko da, baina gezurra denean ez da ezer gertatuko. `if else` egiturak aukera ematen du baldintza gezurra denean beste espresio batzuk exekutatzeko:

```
if(baldin-espresioa)
{
 espresioa1;
}
else
{
 espresioa2;
}

```

##### SWITCH egitura

Baldintzazko egitura honen bidez, aukera desberdin batzuen artean bat hartzen da eta horri dagokiona exekutatzen da. Aukera bakoitza `case` hitz-gakoaz hasten da. Hona hemen egitura:

```
switch(aukera-aldagaia)
{
 case 'balio1': espresioak;
 break;
 case 'balio2': espresioak;
 break;
 case 'balioN': espresioak;
 break;
}

```
`switch` hitz-gakoaren atzetik datorren aldagaia derrigorrez osoa (`int`) edo karakterea (`char`) izan behar da. `break` sententzia `switch` sententziatik irteteko erabiltzen da.

#### Iterazio-egiturak

C++ lengoaiak hiru iterazio-egitura eskaintzen ditu: `for`, `while` eta `do while`.

##### FOR egitura

Ezaguna bada aldez aurretik espresio bat zenbat bider exekutatu behar den edo eta baldintza baten balioaren arabera errepikatu behar bada, `for` egitura erabili ohi da. Ondorengoa da egitura:

```
for(hasierako-espresioa; baldintzazko-espresioa; eguneraketa-espresioa)
{
 espresioa;
}

```

##### WHILE egitura

Egitura errepikakor ohikoenetakoa da. Kontrol-egituraren barnean idazten dugun baldintza egiazkoa den bitartean, gorputzaren espresioak errepikatzen dira. Ondorengoa da egitura:

```
while(baldin-espresioa)
{
 espresioak;
}

```

##### DO WHILE egitura

`while` egituran, gorputzeko espresioak bakarrik exekutatzen dira baldintzako espresioa egiazkoa bada. `do while` egituran espresioa gutxienez behin burutuko da, baldintzazko espresioa begiztaren irteeran dagoelako. Ondorengoa da egitura:

```
do{
 espresioak;
}
while(baldin-espresioa);

```

### Funtzioak

Funtzioak programetan ataza konkretu bat egiteko erabiltzen dira. Normalki, programa nagusiak funtzioz osatuta daude eta bata bestearen atzetik deitzen dira programaren helburua lortzeko. Funtzioen helburuak gauzatzeko, normalki behar duten informazioa parametroen bidez ematen zaie. C++ lengoaiak funtzioei parametroak emateko era desberdinak ditu. Ondoren, adibide banaren bidez ikus daitezke funtzioei parametroak pasatzeko hiru modu.

#### Balioa pasatzea

```
void funtzioa(int param) //Funtzioaren prototipoa
void main(void)
{
 int balioa = 98;
 funtzioa(balioa); //Funtzioaren deia
}
void funtzioa(int param) //Funtzioaren definizioa
{
 printf("%d\n", param);
 param = 67;
}

```

#### Helbidea pasatzea

```
void elkartrukatu(int \*x\_ptr, int \*y\_ptr);
void main(void)
{
 int x = 4;
 int y = 12;
 printf("Elkartrukatu baino lehenago: x = %d, y = %d\n", x, y);
 elkartrukatu(&x, &y);
 printf("Elkartrukatu eta gero: x = %d, y = %d\n", x, y);
}
void elkartrukatu(int \*x\_ptr, int \*y\_ptr)
{
 int laguntza;
 
 laguntza = \*x\_ptr;
 \*x\_ptr = \*y\_ptr;
 \*y\_ptr = laguntza;
}

```

#### Erreferentzia pasatzea

```
void elkartrukatu(int &x, int &y);
void main(void)
{
 int x = 4;
 int y = 12;
 printf("Elkartrukatu baino lehenago: x = %d, y = %d\n", x, y);
 elkartrukatu(x, y);
 printf("Elkartrukatu eta gero: x = %d, y = %d\n", x, y);
}
void elkartrukatu(int &x, int &y)
{
 int laguntza;
 
 laguntza = x;
 x = y;
 y = laguntza;
}

```
Kontuan hartu behar da, parametro moduan arrayak pasatzeko erabili beharreko metodoa *helbidea* *pasatzea* dela.

### Erabilera

C++ lengoaia enpresa handi gehienek erabili ohi dute, baina haren erabilera batez ere grafikoen aplikazioetan nabarmentzen da, objektuei orientatuta baitago: mahaigaineko inguruneetarako, nabigatzaileetarako eta multimedia aplikazioetarako, batik bat.

Sistema eragileei dagokienez, Microsoft Windows, Chome OS eta Apple MacOS dira aipagarrienak. Mundu grafikoan ere oso erabilia da, hala nola, Gnome eta KDE. *Office* paketeen inguruan, Microsoft Office eta LibreOffice aipa ditzakegu. Kopiladore/interpretatzaileen oinarrian ere aurki daiteke C++ lengoaia, esate baterako, Microsoft Visual C++/Basic eta gcc(GNU Compiler Collection).

### Sintaxia

C++ lengoaian, beste hainbat lengoaietan bezala, `//` erabiltzen da iruzkinak egiteko. Azpimarratu beharra dago, bi barra hauetatik eskuinetara idatzitako dena konpiladoreak ez duela kontuan hartuko. Beraz, nahi dena idatz daiteke. Baina metodo hori lerro bakarreko iruzkinak egiteko bakarrik erabil daiteke. Hainbat lerrotako iruzkinetarako, `/*`-rekin hasi eta `*/` -rekin amaitu behar da. Hona hemen adibide bat:

```
// Hau lerro bakarreko iruzkina da

/\* Hau hainbat
lerrotako
iruzkina da\*/

```
C++ lengoaian, gainerako programazio-lengoaia gehienetan bezala, `;` sinboloa erabiltzen da agindu bati amaiera emateko lerroaren amaieran. Adibidez:

```
cout<<"kaixo";

```
Ildo beretik jarraituz, *Sartu* teklaren baliokidea programazio-lengoaia honetan `\n` da. Hau da, testu edo aldagai bat pantailaratu ondoren hurrengo lerrorako jauzi bat txertatu nahi izanez gero, nahiko da aldagaiaren edo testuaren segidan inongo hutsunerik gabe `\n` jartzea.

#### Espresio eta eragile aritmetiko-logikoak

C++ lengoaian, aldagai bati balio bat esleitzeko (emateko) `=` erabiltzen da. Adibidez:

```
i = 5;

```
Eragile aritmetikoei dagokionez, batuketarako `+` erabiltzen da, kenketarako `-` , biderketarako `*` , eta zatiketarako `/`. Modulu eragilea kasu honetan `%` da. Adibidez:

```
x = 6\*2+5/7-2

```
Eragile logiko erabilienak hauek dira: `&&` (AND), `||` (OR) eta `!` (NOT) dira. Horiez gain, badaude erlazio-eragileak: `<`, `>`, `==`, `<=`, `>=` eta `!=`.

Eragile horiez gain, nabarmentzekoak dira inkrementu (`++`) eta dekrementu (`--`) eragileak.

### Adibideak

*Kaixo mundua* adibidea C++ programazio-lengoaian:

```
#include <iostream>
using namespace std;
 
int main(){
 
 cout<< "Kaixo mundua! ";
 
 return 0;
 
}

```

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

1. ↑   **(Ingelesez)** Stroustrup, Bjarne.  (1997). *The C++ Programming Language.*  in: *Third*. ISBN 0201889544..
2. ↑   Stroustrup, Bjarne..  (1986). *The C++ programming language.*  Addison-Wesley ISBN 020112078X. PMC 12551884. (Noiz kontsultatua: 2019-10-21).
3. ↑   «Charles Stark Draper Prize for Engineering» *NAE Website* (Noiz kontsultatua: 2019-10-21).
4. ↑   **(Ingelesez)** 14:00-17:00. «ISO/IEC 14882:1998» *ISO* (Noiz kontsultatua: 2019-11-02).
5. ↑   **(Ingelesez)** 14:00-17:00. «ISO/IEC 14882:2003» *ISO* (Noiz kontsultatua: 2019-11-02).
6. ↑   **(Ingelesez)** 14:00-17:00. «ISO/IEC 14882:2011» *ISO* (Noiz kontsultatua: 2019-11-02).
7. ↑   **(Ingelesez)** 14:00-17:00. «ISO/IEC 14882:2014» *ISO* (Noiz kontsultatua: 2019-11-02).
8. ↑   **(Ingelesez)** 14:00-17:00. «ISO/IEC 14882:2017» *ISO* (Noiz kontsultatua: 2019-11-02).
9. ↑   Goirizelaia Ordorika, Iñaki..  (D.L. 2000). *Programazioaren oinarriak.*  Euskal Herriko Unibertsitatea = Universidad del País Vasco ISBN 84-7585-673-X. PMC 434128460. (Noiz kontsultatua: 2019-11-24).
10. ↑   «The Programming Languages Beacon» *www.mentofacturing.com* (Noiz kontsultatua: 2019-11-28).

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

* Programazio-lengoaia
* C
* C#
* BASIC
* Visual C.NET
* Visual Basic.NET
* .NET Framework
* Visual Studio.NET
* ASP.NET
* ADO.NET
* CLR
* .NET Show
* .NET
* .NET oinarri klase liburutegia

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

|  |  |
| --- | --- |
| Autoritate kontrola | 
* **Wikimedia proiektuak**
* Wd Datuak: Q2407
* Commonscat Multimedia: C++

---

* **Identifikadoreak**
* BNE: XX540250
* BNF: 12139768z (data)
* GND: 4193909-8
* LCCN: sh87007505
* NKC: ph116956
* SUDOC: 029859778
* **Hiztegiak eta entziklopediak**
* Britannica: url

 |

* Wd Datuak: Q2407
* Commonscat Multimedia: C++