C++

Az oldal jelenlegi verzióját még nem ellenőrizték tapasztalt közreműködők, és jelentősen eltérhet a 2022. július 31-én felülvizsgált verziótól ; az ellenőrzések 14 szerkesztést igényelnek .

C++

Szemantika	több paradigma : objektumorientált , általános , procedurális , metaprogramozás
Nyelvóra	objektum-orientált programozási nyelv , többparadigmás programozási nyelv , procedurális programozási nyelv , funkcionális programozási nyelv , általános programozási nyelv , programozási nyelv , szabad formátumú nyelv [d] és fordított programozási nyelv
A végrehajtás típusa	összeállított
Megjelent	1983
Szerző	Stroustrup, Bjorn
Fájlkiterjesztés _	.cc, .cpp, .cxx, .c, .c++, .h, .hpp, .hh, .hxxvagy.h++
Kiadás	C++20 ( 2020. december ) [1]
Típusrendszer	statikus
Főbb megvalósítások	GNU C++ , Microsoft Visual C++ , Intel C++ fordító , Open64 C++ fordító , Clang , Comeau C/C++ , Embarcadero C++ Builder , Watcom C++ fordító , Digital Mars C++, Oracle Solaris Studio C++ Ci+
Dialektusok	ISO/IEC 14882 C++
Befolyásolva	C , Simula , Algol 68 , Clu , ML és Ada
Weboldal	isocpp.org _
Médiafájlok a Wikimedia Commons oldalon

A C ++ (ejtsd: c-plus-plus [2] [3] ) egy lefordított , statikusan tipizált , általános célú programozási nyelv .

Támogatja az olyan programozási paradigmákat , mint a procedurális programozás , az objektum-orientált programozás , az általános programozás . A nyelv gazdag szabványkönyvtárral rendelkezik, amely általános konténereket és algoritmusokat , I/O-t, reguláris kifejezéseket, többszálú támogatást és egyebeket tartalmaz. A C++ egyesíti a magas és az alacsony szintű nyelvek jellemzőit [4] [5] . Elődjéhez - a C nyelvhez - képest a legnagyobb figyelmet az objektum-orientált és általános programozás támogatására fordítják [5] .

A C++- t széles körben használják szoftverfejlesztésre, mivel az egyik legnépszerűbb programozási nyelv [vélemények 1] [vélemények 2] . Alkalmazási körébe tartozik operációs rendszerek , különféle alkalmazásprogramok, eszközillesztő -programok, beágyazott rendszerekhez való alkalmazások, nagy teljesítményű szerverek és számítógépes játékok létrehozása. A C++ nyelvnek számos megvalósítása létezik, ingyenesen és kereskedelmileg is, valamint különféle platformokra. Például az x86 platformon ezek a GCC , Visual C++ , Intel C++ Compiler , Embarcadero (Borland) C++ Builder és mások. A C++ óriási hatással volt más programozási nyelvekre, különösen a Java -ra és a C# -ra .

A C++ szintaxis a C nyelvből öröklődik . Az egyik eredeti tervezési elv a C-vel való kompatibilitás fenntartása volt. A C++ azonban nem szigorúan a C szuperhalmaza; A C és C++ fordítók által egyformán jól lefordítható programok készlete meglehetősen nagy, de nem tartalmazza az összes lehetséges C programot .

Történelem

A fejlődés történelmi szakasza [6]	Év
BCPL nyelv	1966
A B nyelv (a Thompson eredeti fejlesztése UNIX alatt )	1969
C nyelv	1972
C osztályokkal	1980
C84	1984
Cfront (E kiadás)	1984
cfront (1.0-s kiadás)	1985
Többszörös/virtuális öröklődés	1988
Általános programozás ( sablonok )	1991
ANSI C++ / ISO-C++	1996
ISO/IEC 14882:1998	1998
ISO/IEC 14882:2003	2003
C++/CLI	2005
TR1	2005
C++11	2011
C++14	2014
C++17	2017
C++20	2020

Létrehozás

A nyelv az 1980-as évek elején keletkezett , amikor a Bell Labs alkalmazottja, Björn Stroustrup számos fejlesztést dolgozott ki a C nyelven saját igényei szerint [7] . Amikor Stroustrup az 1970 -es évek végén a Bell Labs-nál kezdett dolgozni a sorbanálláselmélet problémáin (a telefonhívások modellezésére alkalmazva), úgy találta, hogy az akkoriban létező modellezési nyelvek használatára tett kísérletek nem voltak hatékonyak, és a rendkívül hatékony gépi nyelvek használata. túl nehéz volt a korlátozott kifejezőképességük miatt. Például a Simula nyelv olyan tulajdonságokkal rendelkezik, amelyek nagy szoftverek fejlesztéséhez nagyon hasznosak lennének, de túl lassú, a BCPL nyelv pedig elég gyors, de túl közel áll az alacsony szintű nyelvekhez, és nem alkalmas nagy szoftverek fejlesztésére.

Felidézve a disszertáció tapasztalatait, Stroustrup úgy döntött, hogy a C nyelvet (a BCPL utódját) kiegészíti a Simula nyelvben elérhető képességekkel. A C nyelv, amely a UNIX rendszer alapnyelve, amelyen a Bell számítógépek futottak, gyors, funkciókban gazdag és hordozható. Stroustrup hozzáadta az osztályokkal és objektumokkal való munka képességét. Ennek eredményeként a gyakorlati modellezési feladatok elérhetőnek bizonyultak mind a fejlesztési idő (a Simula-szerű osztályok használata miatt), mind a számítási idő (a C sebessége miatt) tekintetében. A C első kiegészítései az osztályok ( beágyazással ), az osztályöröklés, a szigorú típusellenőrzés, a soron belüli függvények és az alapértelmezett argumentumok voltak . A nyelv korai verziói, amelyeket eredetileg "C with classes"-nek hívtak, az 1980-as évek óta elérhetők .

A C osztályokkal való fejlesztése közben Stroustrup megírta a cfront programot , egy olyan fordítót , amely a C forráskódot osztályokkal sima C forráskódra dolgozza át. Ez lehetővé tette számunkra, hogy egy új nyelven dolgozzunk, és a gyakorlatban is használhassuk a UNIX-ban már elérhető infrastruktúra felhasználásával. fejlesztés C. Egy új nyelv, a szerző számára váratlanul, nagy népszerűségre tett szert a kollégák körében, és hamarosan Stroustrup már nem tudta személyesen támogatni, több ezer kérdésre válaszolt.

1983 - ra új funkciókkal bővült a nyelv, mint például a virtuális függvények, a funkciók és operátorok túlterhelése, hivatkozások, konstansok, a szabad memóriakezelés felhasználói vezérlése, továbbfejlesztett típusellenőrzés és új megjegyzésstílus ( //). Az eredményül kapott nyelv már nem csak a klasszikus C kiterjesztett változata, és C-ről osztályokkal átnevezték "C++"-ra. Első kereskedelmi forgalomba hozatalára 1985 októberében került sor .

A hivatalos szabványosítás megkezdése előtt a nyelvet főleg a Stroustrup fejlesztette ki a programozói közösség kérésére. A szabványos nyelvi leírások funkcióját Stroustrup C ++ nyelvű nyomtatott munkái látták el (a nyelv leírása, kézikönyv stb.). Csak 1998 - ban ratifikálták a C++ nyelv nemzetközi szabványát: ISO/IEC 14882:1998 "Standard for the C++ Programming Language"; a szabvány technikai korrekcióinak 2003 -as elfogadását követően ennek a szabványnak a következő változata az ISO/IEC 14882:2003 [8] .

A nyelv fejlesztése és szabványosítása

1985- ben jelent meg a The C++ Programming Language első kiadása , amely a nyelv első leírását adta, ami a hivatalos szabvány hiánya miatt rendkívül fontos volt. 1989 - ben adták ki a C++ 2.0-s verzióját. Új funkciói közé tartozik a többszörös öröklődés, az absztrakt osztályok, a statikus tagfüggvények, az állandó függvények és a védett tagok. 1990 -ben jelent meg a "Commented Reference Guide to C++", amely később a szabvány alapja lett. A legutóbbi frissítések sablonokat, kivételeket, névtereket, új castokat és logikai típust tartalmaztak. Az Alexander Stepanov és Meng Li által kifejlesztett Standard Template Library-t (STL) választották az általános algoritmusok tárolásának és elérésének alapjául .

A C++ Standard Library is vele együtt fejlődött. A C++ szabványos könyvtárának első kiegészítése az I/O adatfolyam volt, amely lehetőséget biztosított a hagyományos C printfés scanf. Később a standard könyvtár legjelentősebb fejlesztése a Standard Template Library felvétele volt .

A nyelv hivatalos szabványosítása 1998 -ban kezdődött az ISO/IEC 14882:1998 (C++98 néven ismert) [9] nyelvi szabvány közzétételével , amelyet a C++ szabványügyi bizottság ( ISO / IEC JTC1/SC22/WG21 munkacsoport) dolgozott ki. ). A C++ szabvány nem írta le az objektumok elnevezési konvencióit, néhány kivételkezelési részletet és egyéb, a megvalósításhoz kapcsolódó jellemzőket, így a különböző fordítók által generált objektumkódok nem kompatibilisek. Harmadik felek azonban számos szabványt hoztak létre erre az adott architektúrára és operációs rendszerre .
2003 -ban megjelent a C++ ISO/IEC 14882:2003 szabvány, ahol a szabvány korábbi változatának feltárt hibáit, hiányosságait kijavították. 2005 -ben megjelent a Library Technical Report 1 (rövidítve TR1). Bár hivatalosan nem része a szabványnak, a jelentés leírja a szabványkönyvtár olyan kiterjesztéseit, amelyeket a szerzők szerint bele kell foglalni a szabvány következő verziójába. A TR1 támogatása szinte minden támogatott C++ fordítóban javul.
2009 óta dolgoznak a korábbi szabvány frissítésén. Az előzetes verzió a C++09 nevet kapta, a következő évben C++0x névre keresztelték. A szabvány 2011-ben jelent meg C++11 néven . Kiegészítéseket tartalmaz a nyelv magjához, valamint a szabványos könyvtár kiterjesztését, beleértve a TR1 nagy részét.
A szabvány következő verziója, a C++14 2014 augusztusában jelent meg. Többnyire pontosításokat és hibajavításokat tartalmaz az előző verzióból.
A 2017 decemberében megjelent C++17 szabvány szabványos algoritmusok párhuzamos változatait foglalta be a szabványos könyvtárba, és eltávolított néhány elavult és rendkívül ritkán használt elemet.
A szabvány legújabb stabil, aktuális verziója a C++20 . Többek között tartalmaz egy alapvető újítást - a modulok támogatását.
A C++23 szabványt jelenleg aktívan tárgyalja az ISO bizottság.

A C++ folyamatosan fejlődik, hogy megfeleljen a modern követelményeknek. A C ++ nyelvet fejlesztő és a C ++ szabványosítási bizottságnak javaslatokat küldő csoportok egyike a Boost , amely többek között a nyelv képességeinek fejlesztésével foglalkozik metaprogramozási funkciók hozzáadásával .

A C++ nyelvhez senki nem rendelkezik jogokkal, az ingyenes. Maga a nyelvi szabványdokumentum azonban (a tervezetek kivételével) nem elérhető szabadon [10] . A szabványosítási folyamat részeként az ISO többféle kiadványt készít. A műszaki jelentéseket és műszaki leírásokat különösen akkor teszik közzé, amikor "a jövő látható, de nincs azonnali lehetőség a nemzetközi szabvány közzétételére vonatkozó megállapodásra". 2011-ig három technikai jelentés jelent meg a C++-ról: TR 19768: 2007 (más néven C++ Technical Report 1) a főként a C++11-be integrált könyvtárbővítésekről, a TR 29124: 2010 a speciális matematikai függvényekről és a TR 24733: 2011. tizedes lebegőpontos aritmetika. Műszaki specifikáció DTS 18822:. A 2014-et (fájlrendszer szerint) 2015 elején hagyták jóvá, a többi specifikáció fejlesztés alatt áll, és jóváhagyásra vár [11] .

2016 márciusában Oroszországban létrehozták a WG21 C++ munkacsoportot . A csoport a C++ szabványra vonatkozó javaslatok összegyűjtése, a bizottság elé terjesztése és a Nemzetközi Szabványügyi Szervezet (ISO) közgyűlésein való megvédése céljából jött létre [12] .

A név története

Az eredményül kapott nyelvnév a C unary postfix increment++ operátorból származik (egy változó értékét eggyel növelve). A C+ nevet nem használtuk, mert ez egy szintaktikai hiba a C nyelvben, ráadásul a nevet egy másik nyelv vette fel. A nyelvet azért sem nevezték D-nek, mert " a C kiterjesztése, és nem próbálja meg megoldani a problémákat a C elemek eltávolításával " [7] .

A C++ filozófiája

A The Design and Evolution of C++ [13] című könyvében Bjorn Stroustrup leírja azokat az elveket, amelyeket a C++ tervezésekor követett. Ezek az alapelvek megmagyarázzák, hogy a C++ miért olyan, amilyen. Néhány közülük:

Szerezzen egy univerzális nyelvet statikus adattípusokkal, a C hatékonyságával és hordozhatóságával.
Közvetlenül és átfogóan támogat számos programozási stílust, beleértve az eljárási programozást , az adatabsztrakciót , az objektumorientált programozást és az általános programozást .
Adja meg a programozónak a választás szabadságát, még akkor is, ha ez lehetőséget ad a helytelen választásra.
A lehető legnagyobb mértékben tartsa fenn a C-vel való kompatibilitást, ezáltal lehetővé téve a programozásról a C-re való egyszerű váltást.
Kerülje a következetlenségeket a C és a C++ között: minden olyan konstrukciónak, amely mindkét nyelven érvényes, ugyanazt kell jelentenie mindegyikben, és ugyanazt a programviselkedést kell eredményeznie.
Kerülje a platformfüggő vagy nem univerzális funkciókat.
"Ne fizessen azért, amit nem használ" – Egyetlen nyelvi funkció sem okozhat teljesítménycsökkenést azoknál a programoknál, amelyek nem használják.
Nem igényel túl bonyolult programozási környezetet.

Nyelvi áttekintés

A C++ szabvány két fő részből áll: az alapnyelv leírásából és a szabványkönyvtár leírásából.

A nyelv eleinte a formális kereteken kívül, spontán módon, az előtte álló feladatoknak megfelelően fejlődött. A nyelv fejlődését a cfront keresztfordító fejlesztése kísérte . A nyelvi újítások a keresztfordító verziószámának változásában is megmutatkoztak. Ezek a keresztfordító verziószámok magára a nyelvre is kiterjedtek, de a C++ verziókról jelenleg nincs szó. Csak 1998-ban vált szabványossá a nyelv.

A C++ támogatja a C-stílusú megjegyzéseket ( /* комментарий */) és az egysoros megjegyzéseket ( // вся оставшаяся часть строки является комментарием), ahol //a megjegyzés kezdetét jelöli, és a legközelebbi következő újsor, amelyet nem előz meg karakter \(vagy annak megfelelője ??/), a megjegyzés befejezésének minősül. Ennek a megjegyzésnek az az előnye, hogy nem szükséges befejezni, vagyis a megjegyzés végét jelezni.
Funkcióspecifikátor inline. Az osztálytörzsben definiált függvény alapértelmezés szerint soron belüli. Ez a specifikátor egy tipp a fordító számára, és beágyazhatja a függvény törzsét a kódba, ahelyett, hogy közvetlenül hívná meg.
Selejtezők constés volatile. A C-től eltérően, ahol csak constolvasható hozzáférést jelöl, a C++-ban egy minősítővel rendelkező változót constkell inicializálni. volatileváltozódeklarációban használatos, és tájékoztatja a fordítót arról, hogy az adott változó értéke úgy változtatható meg, hogy a fordító nem tudja követni. A -val deklarált változók volatileesetében a fordító nem alkalmazhat olyan optimalizálást, amely megváltoztatja a változó helyét a memóriában (például úgy, hogy egy regiszterbe helyezi), vagy arra hagyatkozhat, hogy a változó értéke változatlan marad két hozzárendelés között. volatileSegít elkerülni a 2-es típusú memóriakorlátokat egy többmagos rendszerben .
Névterek ( namespace). Példa:

névtér Foo { const int x = 5 ; } const int y = Foo :: x ;

A névtelen névtér speciális eset. A benne leírt összes név csak az aktuális fordítási egységben érhető el, és helyi kötéssel rendelkezik. A névtér stdtartalmazza a szabványos C++ könyvtárakat.

newA , new[]és operátorok a memóriával való együttműködésben mutatkoznak deletebe delete[]. A C-ből származó malloc és free könyvtártól eltérően ezek az operátorok inicializálnak egy objektumot. Osztályok esetében ez egy konstruktorhívás, a POD típusoknál az inicializálás elhagyható ( new Pod;), vagy nulla értékkel inicializálható ( new Pod(); new Pod {};).

Típusok

A következő beépített típusok érhetők el C++ nyelven. A C++ típusok szinte azonosak a C adattípusokkal :

karakter: char, wchar_t( char16_tés char32_t, a C++11 szabványban );
előjeles egész számok: signed char, short int, int, long int(és long long, a C++11 szabványban );
előjel nélküli egész számok: unsigned char, unsigned short int, unsigned int, unsigned long int(és unsigned long long, a C++11 szabványban );
lebegőpontos : , , ; _floatdoublelong double
logikai boolérték: vagy true, vagy false.

Az összehasonlító operátorok visszatérési típusa bool. ifA , utáni zárójelben lévő kifejezések [14]while típusúvá alakulnak . bool

A nyelv bevezette a referenciák fogalmát, a C++11 szabványból pedig az rvalues - references és a forwarding references . (Lásd link (C++) )

A C++ objektumorientált funkciókat ad a C-hez. Olyan osztályokat mutat be, amelyek az OOP három legfontosabb tulajdonságát biztosítják : a beágyazást , az öröklődést és a polimorfizmust .

A C++ szabványban az osztály egy felhasználó által definiált típus, amelyet a vagy kulcsszavak egyikével deklarálnak class, structa unionstruktúra a struct, az unió pedig a union. A használt kulcsszótól függően magának az osztálynak bizonyos tulajdonságai is megváltoznak. Például a -val deklarált osztályban structa manuálisan hozzárendelt hozzáférés-módosítóval nem rendelkező tagok alapértelmezés szerint nyilvánosak, nem pedig privátak.

Az osztálydefiníció törzsében megadhatja a függvénydeklarációkat és azok definícióját is. Ez utóbbi esetben a függvény inline ( inline). A nem statikus tagfüggvények rendelkezhetnek constés minősítőkkel volatile, valamint referenciaminősítővel ( &vagy &&).

Öröklődés

A C++ támogatja a többszörös öröklődést . Az alaposztályok (ősosztályok) az osztálydeklaráció fejében vannak megadva, esetleg hozzáférési specifikációkkal. Az egyes osztályokból származó öröklődés lehet nyilvános, védett vagy privát:

Az alaposztály tagjainak hozzáférési/öröklési módja	magántag	védett tagja	közéleti tag
magánörökség	nem elérhető	magán	magán
védett-öröklés	nem elérhető	védett	védett
közörökség	nem elérhető	védett	nyilvános

Alapértelmezés szerint az alaposztály privátként öröklődik.

Az öröklődés eredményeként a gyermekosztály megkapja az ősosztályok összes mezőjét és azok összes metódusát; azt mondhatjuk, hogy a leszármazott osztály minden példánya tartalmazza az egyes ősosztályok egy-egy részpéldányát . Ha egy ősosztály többször öröklődik (ez akkor lehetséges, ha a létrehozandó osztály több alaposztályának őse), akkor a leszármazott osztály példányai ennek az ősosztálynak annyi alpéldányát tartalmazzák majd. Ennek elkerülésére, ha nem kívánatos, a C++ támogatja a virtuális öröklődés koncepcióját . Örökléskor az alaposztály virtuálissá nyilvánítható; az ősosztály minden virtuális előfordulására a leszármazott osztály öröklési fájában csak egy részpéldány jön létre a leszármazottban.

Polimorfizmus

A C++ támogatja a dinamikus polimorfizmust és a parametrikus polimorfizmust .

A paraméteres polimorfizmust a következők képviselik:

A függvények alapértelmezett argumentumai. Például egy függvény esetében a és void f(int x, int y=5, int z=10)a hívások egyenértékűek.f(1)f(1,5)f(1,5,10)
Funkciótúlterhelés : Az azonos nevű függvénynek eltérő számú és típusú argumentuma lehet. Például :voidPrint ( int x ) ; voidPrint ( dupla x ) ; void Nyomtatás ( int x , int y );

A kezelő túlterhelése a funkciótúlterhelés speciális esete .

sablon motor

A dinamikus polimorfizmust virtuális módszerekkel és öröklődési hierarchiával valósítják meg. A C++ nyelvben egy típus akkor polimorf, ha rendelkezik legalább egy virtuális metódussal. Példa a hierarchiára:

osztály ábra { nyilvános : virtuális üresség Draw () = 0 ; // tiszta virtuális metódus virtual ~ ábra (); // ha van legalább egy virtuális metódus, a destruktort virtuálissá kell tenni }; osztály Négyzet : közfigura _ { nyilvános : void Draw () felülbírálás ; }; osztály Kör : közfigura _ { nyilvános : void Draw () felülbírálás ; };

Itt a Figure osztály absztrakt (és még interfész osztály is ), mivel a Draw metódus nincs definiálva. Az osztályba tartozó objektumok nem hozhatók létre, de használhatók az ábra típusú hivatkozások vagy mutatók. A Draw metódus megvalósításának kiválasztása futási időben történik az objektum tényleges típusa alapján.

Encapsulation

A C++ nyelven a beágyazás az osztálytagok hozzáférési szintjének megadásával valósul meg: nyilvánosak (public, public), védettek ( protected) és privátak (privát, private). A C++-ban a struktúrák formálisan csak abban különböznek az osztályoktól, hogy alapértelmezés szerint egy struktúra esetében az osztálytagokhoz való hozzáférési szint és az öröklődés típusa nyilvános, míg egy osztály esetében privát.

Hozzáférés	magán	védett	nyilvános
Maga az osztály	Igen	Igen	Igen
Barátok	Igen	Igen	Igen
Örökösök	Nem	Igen	Igen
Kívülről	Nem	Nem	Igen

A hozzáférés ellenőrzése fordítási időben történik, a hozzáférhetetlen osztálytag elérésének megkísérlése fordítási hibát okoz.

Barátok

A barátfüggvények olyan függvények, amelyek nem tagfüggvények, és mégis hozzáférnek az osztály védett és privát tagjaihoz. Ezeket az osztály törzsében a következőképpen kell megadni friend. Például:

osztály Mátrix { barát Matrix Multiply ( Mátrix m1 , Mátrix m2 ); };

Itt a függvény Multiplyelérheti a . bármely mezőjét és tagfüggvényét Matrix.

Mind az egész osztály, mind az osztály egy tagfüggvénye barátnak nyilvánítható. A baráti kapcsolatok négy fontos korlátozása a C++ nyelven:

A barátságosság nem tranzitív. Ha A B barátjának, B pedig C barátjának nyilvánítja, akkor C nem lesz automatikusan A barátja. Ehhez A-nak kifejezetten barátnak kell nyilvánítania C-t.
A barátság nem kölcsönös. Ha az A osztály B osztály barátjának nyilvánítja, akkor nem válik automatikusan B barátjává. Ehhez explicit nyilatkozatnak kell lennie A barátságáról a B osztályban.
A barátság nem öröklődik. Ha A egy B osztályt barátnak nyilvánít, akkor B gyermekei nem lesznek automatikusan A barátok. Ehhez mindegyiküket kifejezetten A barátnak kell nyilvánítani.
A barátság nem terjed ki a leszármazottakra. Ha egy A osztály barátnak nyilvánítja B-t, akkor B nem lesz automatikusan A leszármazott osztályainak barátja, minden leszármazottnak szükség esetén B-t a saját barátjának kell nyilvánítania.

Általában ez a szabály a következőképpen fogalmazható meg: "A baráti kapcsolat csak azon osztályok (osztály és funkció) között létezik, amelyekre a kódban kifejezetten deklarálva van, és csak abban az irányban hat, amelyben deklarálják."

Különleges szolgáltatások

Egy alapértelmezett osztálynak hat speciális funkciója lehet: alapértelmezett konstruktor, másolás konstruktor, mozgatási konstruktor, destruktor, másolási hozzárendelés operátor, áthelyezési hozzárendelés operátor. Lehetőség van mindegyiket kifejezetten meghatározni (lásd a három szabályt ).

class Array { nyilvános : Tömb ( ) = alapértelmezett // a fordító létrehozza magának az Array alapértelmezett konstruktorát ( size_t _len ) : len ( _len ) { val = új dupla [ _len ]; } Array ( const Array & a ) = törlés ; // a konstruktor másolása kifejezetten eltávolítva Tömb ( Tömb && a ); // konstruktor áthelyezése ~ Array () { törlés [] val ; } Tömb & operátor = ( const Tömb & rhs ); // hozzárendelés operátor másolása Array & operator = ( Tömb && rhs ); // hozzárendelés áthelyezése operátor double & operator []( size_t i ) { return val [ i ]; } const double & operátor []( size_t i ) const { return val [ i ]; } védett : std :: méret_t len = 0 ; // mező inicializálása double * val { nullptr }; };

A konstruktort az objektum (a megfelelő típusú) inicializálására hívják, amikor létrehozzák, a destruktort pedig az objektum megsemmisítésére. Egy osztálynak több konstruktora is lehet, de egy destruktornak csak egy. A C++-ban a konstruktorokat nem lehet virtuálisnak nyilvánítani, de a destruktorokat igen, és általában minden polimorf típusra deklarálják, hogy biztosítsák a hivatkozott vagy mutató által elérhető objektumok megfelelő megsemmisítését, függetlenül attól, hogy milyen típusú a hivatkozás vagy mutató. Ha legalább az egyik alaposztály rendelkezik virtuális destruktorral, akkor a gyermekosztály destruktora automatikusan virtuálissá válik.

Sablonok

A sablonok lehetővé teszik olyan függvények és osztályok létrehozását, amelyek egy adott típussal vagy értékkel vannak paraméterezve. Például az előző osztály bármilyen adattípushoz megvalósíthat egy tömböt:

sablon < típusnévT > _ class Array { ... T és operátor []( size_t i ) { return val [ i ]; } védett : std :: size_t len { 0 }; // mező inicializálása T * val { nullptr }; };

Standard Library

Általános szerkezet

A C++ Standard Library olyan eszközöket tartalmaz, amelyeknek a nyelv bármely implementációja számára elérhetőnek kell lenniük, hogy a programozók kényelmesen használhassák a nyelvi funkciókat, és alapot biztosítsanak az alkalmazások széles körének és a speciális könyvtárak fejlesztéséhez. A C++ Standard Library tartalmazza a C Standard Library egy részét. A C++ szabvány tartalmaz egy normatív hivatkozást az 1990 C szabványra , és nem határozza meg önállóan azokat a szabványos könyvtári funkciókat, amelyeket a C Standard Library-ből kölcsönöztek.

#includeA C++ szabványos könyvtár képességeihez való hozzáférést a megfelelő szabványos fejlécfájlok programba foglalása biztosítja (a direktíván keresztül ). Összesen 79 ilyen fájl van meghatározva a C++11 szabványban. A szabványos könyvtári szolgáltatások az std névtér részeként vannak deklarálva. A fejlécfájlok, amelyek neve megegyezik a „cX” mintával, ahol X a C Standard Library fejlécfájl neve kiterjesztés nélkül (cstdlib, cstring, cstdio stb.), a C Standard Library azon részének megfelelő deklarációkat tartalmaznak. szabványos könyvtári függvények is megtalálhatók a névtérben std.

Összetétel

A szabványos könyvtár a következő részeket tartalmazza:

Nyelvi támogatás . Tartalmazza a programok működéséhez szükséges eszközöket, valamint információkat a megvalósítási funkciókról. Memóriafoglalás, RTTI , alapvető kivételek, numerikus adattípusok értékhatárai, alapvető környezeti interakciók, mint például a rendszeróra, UNIX jelkezelés, programlezárás.
szabványos konténerek . A szabványos könyvtár sablonokat tartalmaz a következő tárolókhoz: dinamikus tömb (vektor), statikus tömb (tömb), egy- és kétirányú listák (előre_lista, lista), verem (verem), deque (deque), asszociatív tömbök (térkép, többleképezés), halmazok (halmaz, multiset), prioritási sor (priority_queue).
Alapvető segédprogramok . Ez a szakasz tartalmazza a szabványos könyvtárban használt fő alapelemek leírását, a memóriaelosztókat, valamint a C-stílusú idő- és dátumtámogatást.
Iterátorok . Olyan iterátorsablonokat biztosítson, amelyek szabványos mechanizmust biztosítanak a szabványos könyvtárban az adatfeldolgozási algoritmusok kötegelt alkalmazásához a tárolóelemekre .
Algoritmusok . Sablonok a feldolgozási műveletek leírására, amelyek a szabványos könyvtár mechanizmusait használva bármely elemsorozatra alkalmazhatók, beleértve a tárolókban lévő elemeket is. Ebben a részben a C szabványkönyvtár bsearch() és qsort() függvényeinek leírása is megtalálható.
Húrok . C++ stílusú karakterlánc-sablonok. Ez a szakasz néhány könyvtárat is tartalmaz a C-stílusú karakterláncokkal és szimbólumokkal való munkához.
Bemenet-kimenet . Sablonok és segédosztályok általános I/O adatfolyamokhoz, karakterlánc I/O-hoz, manipulátorokhoz (C++ stílusú stream I/O formátumvezérlők).
Lokalizáció . A C++-stílusú és C-stílusú nemzetiségek és megjelenítési formátumok (dátumok, pénznemek stb.) támogatására használt definíciók.
Diagnosztika . Számos kivétel és állítás-ellenőrzési mechanizmus definíciója futási időben (assert). C-stílusú hibakezelés támogatása.
Számok . Definíciók komplex számokkal való munkához, matematikai vektorok, általános matematikai függvények támogatása, véletlenszám-generátor.

A konténereket, karakterláncokat, algoritmusokat, iterátorokat és alapvető segédprogramokat – a C könyvtárból kölcsönzött kölcsönzések kivételével – együttesen STL-nek (Standard Template Library – szabványos sablonkönyvtár) nevezzük. Kezdetben ez a könyvtár külön termék volt, és a rövidítését másképp fejtették meg, de aztán integrált elemként bekerült a C ++ standard könyvtárba. Az elnevezés azt a tényt tükrözi, hogy az általánosított programozási mechanizmusokat (C++ templates - template) általános célú eszközök (tárolók, karakterláncok, algoritmusok) megvalósítására használják. Stroustrup írásai részletezik a választás okait. A legfontosabbak a választott megoldás nagyobb univerzálissága (a sablonkonténerek az objektumkonténerekkel ellentétben könnyen használhatók nem objektumtípusokhoz, és nem igényelnek közös őst az elemtípusokhoz) és a műszaki hatékonysága (általában sablonkonténer) a műveletek nem igényelnek virtuális függvényhívásokat, és könnyen beágyazhatók (inline), ami végső soron teljesítménynövekedést ad).

A C++11 szabvánnyal kezdve a következő szolgáltatások kerültek hozzáadásra:

A <regex> könyvtár hozzáadásra került, amely általános keresési és helyettesítési mechanizmusokat valósít meg reguláris kifejezések használatával.
Hozzáadott támogatás a többszálú feldolgozáshoz.
Atomműveletek
asszociatív tömbök és halmazok rendezetlen változatai.
Intelligens mutatók, amelyek automatikusan felszabadítják a lefoglalt memóriát.

Megvalósítások

Az STL, mielőtt belekerült a C++ szabványba, harmadik fél fejlesztése volt, először a HP , majd az SGI fejlesztése . A nyelvi szabvány nem nevezi "STL"-nek, mivel ez a könyvtár a nyelv szerves részévé vált, azonban sokan még mindig ezt a nevet használják, hogy megkülönböztessék a szabványos könyvtár többi részétől (I/O-folyamok ( iostream ), C alszakasz) és mások) .

Az SGI STL-en alapuló STLport [15] nevű projekt naprakészen tartja az STL, IOstream és karakterlánc osztályokat. Számos más projekt is fejleszti a szabványos könyvtár magáncélú felhasználását.

Különbségek a C nyelvtől

Kompatibilitás C nyelvvel

A C-t egy új programozási nyelv létrehozásának alapjául magyarázza, hogy a C nyelv:

egy többcélú, tömör és viszonylag alacsony szintű nyelv;
alkalmas a legtöbb rendszerfeladatra;
mindenhol és mindenen előadták;
interfészek a UNIX programozási környezettel.

— B. Stroustrup. C++ programozási nyelv. 1.6. szakasz [16]

A C nyelv számos jól ismert hiányossága ellenére Stroustrup ezt választotta alapként, mert "a C-nek megvannak a maga problémái, de a nulláról tervezett nyelvnek megvannak ezek, és ismerjük a C problémáit." Ezenkívül ez lehetővé tette számunkra, hogy gyorsan megszerezzük a fordító prototípusát ( cfront ), amely csak a hozzáadott szintaktikai elemeket fordította le az eredeti C nyelvre.

Ahogy a C++ fejlődött, más, a C konstrukciók képességeit felülíró funkciókat is beépítettek, és többször is felmerült a nyelvi kompatibilitás megszüntetésének kérdése az elavult konstrukciók eltávolításával. A kompatibilitás azonban megmaradt a következő okok miatt:

az eredetileg C nyelven írt és közvetlenül C ++-ba portolt aktuális kód megőrzése;
a korábban C nyelvet tanult programozók átképzésének megszüntetése (csak új C++ eszközöket kell megtanulniuk);
a nyelvek összetévesztésének kiküszöbölése, amikor együtt használják őket ("ha két nyelvet együtt használnak, akkor a különbségek minimálisak vagy olyan nagyok, hogy a nyelveket ne lehessen összetéveszteni").

Új funkciók

Az új C++ funkciók közé tartoznak a kifejezések deklarációi, függvénytípus-konverziók, operátorok newés delete, type bool, hivatkozások, kiterjesztett állandóság, soron belüli függvények, alapértelmezett argumentumok, felülírások, névterek, osztályok (beleértve az összes osztályhoz kapcsolódó szolgáltatást, mint az öröklődés, tagfüggvények, virtuális függvények, absztrakt osztályok és konstruktorok ), operátorfelülírások, sablonok, operátor ::, kivételkezelés, dinamikus azonosítás stb. A C++ nyelv sok esetben szigorúbb a típusellenőrzést illetően is, mint a C.

A C++ bevezette a dupla perjel megjegyzéseket ( //), amelyek a C elődjében, a BCPL -ben voltak .

constA C++ egyes funkciói később átkerültek C-be, mint például a és kulcsszavak, a ciklusdeklarációk inlineés a forC++-stílusú megjegyzések ( //). A C későbbi megvalósításai olyan funkciókat is bevezettek, amelyek nem találhatók meg a C++-ban, például makrókat va_argés továbbfejlesztett tömbparaméter-kezelést.

A C++ nem tartalmazza a C-t

Míg a legtöbb C kód a C++-ra is érvényes, a C++ nem a C szuperkészlete, és nem is tartalmazza azt. Van olyan kód is, amely igaz a C-re, de nem igaz a C++-ra. Ez különbözteti meg az Objective C -től, amely egy másik C-javítás az OOP számára , amely csak a C szuperkészlete.

Vannak más különbségek is. Például a C++ nem engedi meg egy függvény meghívását main()programon belül, míg C-ben ez legális. Ezenkívül a C++ bizonyos szempontból szigorúbb; például nem teszi lehetővé a nem kapcsolódó mutatótípusok közötti implicit öntést, és nem engedélyezi a még nem deklarált függvényeket.

Ezenkívül a mindkét nyelvre érvényes kód eltérő eredményeket produkálhat attól függően, hogy melyik nyelv fordítójára van lefordítva. Például a legtöbb platformon a következő program "C" betűt ír ki, ha C fordító fordítja, és "C++" betűt, ha C++ fordító fordítja. Ennek az az oka, hogy a C karakterkonstansok (például 'a') típusúak int, a C++-ban viszont típusok char, és ezeknek a típusoknak a mérete általában eltérő.

#include <stdio.h> int main () { printf ( "%s \n " , ( sizeof ( 'a' ) == sizeof ( char )) ? "C++" : "C" ); return 0 ; }

C Elkerülendő eszközök

Ahogy Stroustrup megjegyzi: "Minél jobban ismeri a C-t, annál nehezebb lesz elkerülnie a C++ C-stílusú programozást, miközben elveszíti a C++ lehetséges előnyeit." Ebből a célból a következő ajánlásokat fogalmazza meg a C programozóknak, hogy teljes mértékben kihasználhassák a C++ előnyeit:

Ne használjon makrókat #define. Konstansok deklarálásához használja consta , konstanscsoportokat (felsorolásokat) - enum, a függvények közvetlen felvételéhez - inline, függvénycsaládok vagy típusok meghatározásához - template.
Ne használjon továbbított változódeklarációkat. Deklarálja a változókat abban a blokkban, ahol ténylegesen használják őket, mindig a deklarációt az inicializálással kombinálva.
Hagyja fel a malloc()[17] használatát az operátor javára new, a realloc()[18] helyett a típus javára vector. Biztonságosabb lesz a szabvány tizenegyedik verziójából elérhető intelligens mutatók, például shared_ptrés , használata.unique_ptr
Kerülje a gépeletlen mutatókat, a mutató aritmetikáját, az implicit castokat, az uniókat, kivéve esetleg az alacsony szintű kódban. Használjon "új" típusú konverziót, mivel azok pontosabban fejezik ki a programozó tényleges szándékait és biztonságosabbak.
Minimalizálja a C-stílusú karaktertömbök és karakterláncok használatát azáltal, hogy lecseréli őket STL-típusokra , stringilletve azokból. vectorÁltalánosságban elmondható, hogy ne próbálja meg saját implementációit létrehozni abból, ami már a szabványos könyvtárban található.

Továbbfejlesztés

A jelenlegi ISO/IEC 14882:2017 nyelvi szabvány 2017 decemberében jelent meg . Nem hivatalosan C++17 -nek nevezik . A szabvány következő, 2020-ra tervezett változatának nem hivatalos megnevezése C++20 .

A C++ fejlesztés általános irányai

A nyelv szerzője, Björn Stroustrup [19] [20] [21] szerint a nyelv további fejlődéséről és kilátásairól szólva a következőket különböztetjük meg:

A nyelv további fejlesztése alapvetően a szabványos könyvtár kiegészítésének útját fogja követni. Ezeknek a kiegészítőknek az egyik fő forrása a híres Boost könyvtár .
A nyelv magjának változtatásai nem csökkenthetik a C++ már elért hatékonyságát. Stroustrup szempontjából előnyösebb néhány nagyobb változtatást végrehajtani a magon, mint sok apró változtatást.
A C ++ fejlesztésének alapvető irányai a közeljövőben az általános programozási eszközök képességeinek bővítése, finomítása, a párhuzamos feldolgozási mechanizmusok szabványosítása, valamint a biztonságos programozási eszközök finomítása, mint például a különböző ellenőrzések és biztonságos. típuskonverziók, állapotellenőrzés stb.
Általánosságban elmondható, hogy a C++ többparadigmás nyelvként készült, amely magába szívja a különféle programozási módszereket és technológiákat, de azokat olyan platformon valósítja meg, amely magas műszaki hatékonyságot biztosít. Ezért a jövőben lehetséges, hogy funkcionális programozási eszközöket, automatikus szemétgyűjtést és egyéb, jelenleg hiányzó mechanizmusokat adnak hozzá a nyelvhez. De mindenesetre ez egy rendkívül hatékony lefordított nyelv meglévő platformján fog megtörténni.
Bár formálisan a C++ egyik alapelve továbbra is a C nyelvvel való kompatibilitás fenntartása, valójában ezeknek a nyelveknek a szabványosítási csoportjai nem hatnak egymásra, és az általuk végrehajtott változtatások nemcsak hogy nem korrelálnak, hanem gyakran alapvetően ellentmondanak is. egymást ideológiailag. Tehát azok az elemek, amelyeket az új C szabványok adnak a kernelhez, a C ++ szabvány szabványos könyvtárának elemei, és általában hiányoznak a kernelből, például dinamikus tömbök, rögzített határokkal rendelkező tömbök, párhuzamos feldolgozási lehetőségek. Stroustrup úgy véli, hogy e két nyelv fejlesztésének kombinálása nagy hasznot hozna, de politikai okokból aligha lehetséges. Így a C és a C++ gyakorlati kompatibilitása fokozatosan elveszik.

A C++11 szabvány: kiegészítések a nyelv magjához

Explicit módon meghatározott konstans függvények és kifejezések constexpr.
Általános inicializálás.
Konstruktorok és hozzárendelési operátorok átviteli szemantikával.
Típuskövetkeztetés.

A sablonokban való használatra, ahol nehéz egy adott változótípust megadni, két új mechanizmus került bevezetésre: a típusváltozók autoés a deklaráció decltype.

Tekintse át a gyűjteményt.

Számos modern nyelvet követően a C++ bevezette az űrlap "hurok gyűjtemény" felépítését for (type &x: array) {...}. Itt a ciklustörzs a gyűjtemény minden eleméhez lefut array, és xminden iterációban a gyűjtemény következő elemére fog hivatkozni. A gyűjtemény lehet C-tömb vagy bármilyen szabványos könyvtári tároló, amely iterátorokat beginés end.

Lambda kifejezések.

Hozzáadtuk a lambda kifejezések deklarálásának lehetőségét (az alkalmazás helyén definiált névtelen függvények), beleértve azokat is, amelyek külső változóktól függenek (lezárások). A lambda-kifejezések változókhoz rendelhetők, és ott használhatók, ahol a megfelelő típusú függvényre van szükség, például szabványos könyvtári algoritmusokban.

Változások a virtuális metódusok leírásában.

Egy opcionális módosító került hozzáadásra override, amely a szülőosztály virtuális metódusát helyettesítő metódus deklarációjában használatos. A helyettesítés leírása overrideellenőrzi a helyettesítendő metódus jelenlétét a szülőosztályban, és a metódus aláírásaiban való egyezést. A Java-hoz hasonlóan egy módosító is bekerült final, ami tiltja a vele jelölt metódus további cseréjét. Osztály deklarálható is - finalebben az esetben tilos belőle új osztályokat örökölni.

Változósablonok leírásának képessége hozzáadva .
Különféle szintaktikai kiegészítések.

A kulcsszó egy konstanshoz van definiálva - egy nullmutató: nullptr. Változások történtek a felsorolások és uniók szemantikájában és részben szintaxisában. Bekerült a típusbiztos felsorolások létrehozásának lehetősége, számos szerkezeti korlátozás megszűnt a szakszervezetekből. A fordítónak helyesen kell elemeznie a program szövegét több záró szögletes zárójellel egymás után (korábban a „ >>” szekvenciát egyértelműen bitenkénti jobbra eltolási műveletnek tekintették, ezért a beágyazott sablonkonstrukciók jelölésénél ez kötelező volt hogy a „nagyobb, mint” jelzéseket szóközzel vagy sortöréssel válassza el).

Programpéldák

1. példa

Ez egy példaprogram Hello, world! , amely a szabványos könyvtár használatával üzenetet nyomtat a konzolra , és kilép.

#include <iostream> névtér használata std ; int main () { cout << "Helló, világ!" << endl ; return 0 ; }

2. példa

A modern C++ lehetővé teszi az összetettebb problémák egyszerű megoldását. Ez a példa többek között a Standard Template Library ( STL ) tárolók használatát mutatja be.

#include <iostream> // az std::cout használatához #include <vektor> // dinamikus tömböt tartalmaz #include <térkép> // szótári adattípust tartalmaz #include <karakterlánc> int main () { // Importálja az "std" névtérben lévő összes deklarációt a globális névtérbe. névtér használata std ; // Karakterlánc-kulcsokkal és adatokkal rendelkező asszociatív tárolót karakterláncvektorként deklarálunk. térkép < string , vektor < string > > elemek ; // Adjon hozzá néhány embert ehhez az asszociációs tárolóhoz, és adjon nekik néhány elemet. tételek [ "Anya" ]. push_back ( "sál" ); tételek [ "Dmitrij" ]. push_back ( "jegyek" ); tételek [ "Anya" ]. push_back ( "kölyökkutya" ); // Végigpörgetés az összes objektumon a tárolóban for ( const auto & person : items ) { // személy két objektum párja: a person.first a neve, // a személy.második az elemeinek listája (karakterláncok vektora) cout << person . első << " hord " << személyt . második . méret () << "elemek" << endl ; } }

Ez a példa az összes nevet az std névtérből importálja az egyszerűség kedvéért. Valós programban ez nem ajánlott, mivel névütközéssel találkozhatunk. A nyelv lehetővé teszi egyedi objektumok importálását:

#include <vektor> int main () { std :: vektor használatával ; vektor < int > saját_vektor ; }

C++-ban (mint a C-ben), ha a program végrehajtása eléri a függvény végét main(), akkor ez egyenértékű a -val return 0;. Ez a függvényen kívül más függvényre nem igaz main().

Összehasonlítás alternatív nyelvekkel

Több olyan tanulmány is ismert, amelyben több programozási nyelv többé-kevésbé objektív összehasonlítására is kísérletet tettek, ezek közül az egyik a C ++. Különösen:

A tudományos cikkben: "Haskell vs. Ada vs. C++ vs. Awk vs. …” Paul Hudak és Mark Jones [22] számos imperatív és funkcionális nyelv tanulmányozásáról számol be egy katonai térinformatikai rendszer gyors prototípus-készítésének modellproblémájának megoldására.
Négy szerző "DSL implementációja metaocaml-ben, sablon haskellben és C++-ban" című tudományos cikkében [23] egy módszeres tanulmány a C++ és két funkcionális nyelv használatáról, mint a generatív programozási módszerrel végzett nyelvorientált programozás alapvető eszközeiről. kerül végrehajtásra .
Lutz Prehelt [24] hét nyelvet (C, C++, Java, Perl, Python, Rexx és Tcl) vett figyelembe egy egyszerű program megírásában, amely bizonyos szabályok szerint a telefonszámokat szavakká alakítja.
David Wheler cikkében: „Ada, C, C++ és Java vs. A Steelman [25] összehasonlítja az Ada, C++, C, Java nyelveket a „ Steelman ” dokumentummal - a beágyazott rendszerek katonai fejlesztésének nyelvi követelményeinek listájával, amelyet a Magas szintű Nyelvi Bizottság dolgozott ki. az Egyesült Államok Védelmi Minisztériuma 1978-ban. Bár ez a dokumentum nagyon elavult, és nem veszi figyelembe a modern nyelvek számos alapvető tulajdonságát, az összehasonlítás azt mutatja, hogy a C++ az iparban megkövetelt funkciókat tekintve nem különbözik annyira azoktól a nyelvektől, amelyek használhatók. igazi versenytársainak tekintette.
Matthew Forment és Michael Gillings [26] cikke egy tanulmányt [27 ] ír le hat nyelven – C++, C, C#, Java, Perl, Python – három, a bioinformatikában használt algoritmus implementációjáról: legközelebbi szomszéd módszer , globális szekvencia igazítás ( Needleman Algorithm - Wunsha ) és a BLAST eredmények elemzése .

C++ és Ada

Az Ada nyelv funkciókészletét és alkalmazási területeit tekintve közel áll a C++-hoz: egy Simula-szerű objektumorientált kiegészítéssel (ugyanaz az „Algol osztályokkal” modellel, mint a C++-ban), statikus gépeléssel, lefordított szerkezeti nyelv. , általános programozási eszközök, nagy és összetett szoftverrendszerek fejlesztésére. Ugyanakkor az ideológiában alapvetően különbözik: a C ++-tól eltérően az Ada komplex szoftvergyártók korábban gondosan kidolgozott feltételeire épült, fokozott megbízhatósági követelményekkel, ami nyomot hagyott a szoftver szintaxisában és szemantikájában. nyelv.

Kevés közvetlen összehasonlítás létezik az Ada és a C++ kódolás hatékonyságáról. A fent említett cikkben [22] a modellprobléma Adában való megoldása körülbelül 30%-kal kisebb méretű (soros) kódot eredményezett, mint a C++-ban. Maguk a nyelvek tulajdonságainak összehasonlítását számos forrás megadja, például Jim Rogers cikke az AdaHome-ról [28] több mint 50 pontot sorol fel e nyelvek tulajdonságai között, amelyek többsége az Ada javára szól. (több funkció, rugalmasabb viselkedés, kisebb a hibalehetőség). Bár az adai támogatók kijelentései közül sok ellentmondásos, és némelyik egyértelműen elavult, általánosságban levonható a következtetés:

Az Ada szintaxisa sokkal szigorúbb, mint a C++. A nyelv megköveteli a programozási fegyelem betartását, nem ösztönöz "programozási trükkökre", egyszerű, logikus és könnyen érthető, könnyen karbantartható kód írására ösztönöz.
A C++-tól eltérően az Ada rendkívül típusbiztos. A típusok kidolgozott rendszere – bevallásuk és felhasználásuk fegyelmére figyelemmel – lehetővé teszi az adatfelhasználás helyességének minél teljesebb statikus ellenőrzését, és védelmet nyújt a véletlen hibák ellen. Az automatikus típuskonverziók minimálisra csökkennek.
Az Adában a mutatók sokkal szigorúbban ellenőrzöttek, mint a C++-ban, és a címaritmetika csak egy külön rendszerkönyvtáron keresztül érhető el.
Az egyéni Ada modulok funkcionalitásukban hasonlóak a C++ sablonokhoz, de jobb vezérlést biztosítanak.
Az Ada beépített modularitást és szabványos, különálló fordítórendszert tartalmaz, míg a C++ szövegfájlok beépítését, valamint külső fordítási és összeállítási vezérlőket használ.
Az Ada beépített multitaskingja párhuzamos feladatokat és azok kommunikációs mechanizmusait (bejegyzések, randevú, operátor select) tartalmazza. A C++ nyelven mindez csak könyvtári szinten valósul meg.
Az Ada szigorúan szabványosított, aminek köszönhetően jobb hordozhatóságot biztosít.

Stephen Zeiger, a Rational Software Corporation munkatársa [29] cikkében azt állítják, hogy az Adában a fejlesztés általában 60%-kal olcsóbb, és 9-szer kevesebb hibával rendelkező kódot eredményez, mint a C-ben. Bár ezek az eredmények nem vihetők át közvetlenül a C++-ba, mégis érdekesek, mivel a C++ számos hiányossága a C-ből öröklődik.

C++ és Java

A Java nem tekinthető a C++ teljes helyettesítésének, biztonságos nyelvnek készült, alacsony belépési küszöb mellett nagy hordozhatóságú egyedi alkalmazások fejlesztéséhez [30] , és alapvetően alkalmatlan bizonyos C++-ban fejlesztett alkalmazásokhoz. A Java azonban hatókörén belül nagyon is igazi versenytársa a C++-nak. A Java előnyeit általában a következőképpen említik:

Biztonság: nem támogatja a mutatókat és a címszámítást, automatikus memóriakezelés szemétgyűjtéssel, beépített védelem a gyakori C++ programhibák ellen, mint például a puffer túlcsordulása vagy a tömb túlcsordulása.
Fejlett modulrendszer és külön fordítás, sokkal gyorsabb és kevésbé hibás, mint a C ++ előfeldolgozója és kézi összeszerelése.
Teljes szabványosítás és végrehajtás virtuális gépen, fejlett környezetben, beleértve a grafikus könyvtárakat, a felhasználói felületet, az adatbázisokhoz való hozzáférést és más tipikus feladatokat, ennek eredményeként - valódi többplatformos.
Beépített többszálú.
A Java objektum alrendszer, sokkal nagyobb mértékben, mint a C++, megfelel az OOP alapelvnek, „ minden egy objektum ”. Az interfészek lehetővé teszik a többszörös öröklődés előnyeinek többségét anélkül, hogy negatív hatásait okoznák.
A tükrözés sokkal fejlettebb, mint a C++-ban, és lehetővé teszi az objektumok szerkezetének tényleges meghatározását és megváltoztatását a program futása közben.

Ugyanakkor a szemétgyűjtő és a virtuális gép használata nehezen áthidalható korlátokat teremt. A Java programok általában lassabbak, lényegesen több memóriát igényelnek, és a virtuális gép elszigeteli a programot az operációs rendszertől, ami lehetetlenné teszi az alacsony szintű programozást.

Egy empirikus tanulmány [24] nem talált szignifikáns különbséget a C++ és a Java fejlesztési sebességében. A tanulmány [26] azt is kimutatta, hogy nem mindig helytálló az az elképzelés, hogy ezeken a nyelveken jelentős különbségek vannak a programok sebességében: három tesztből kettőben a Java és C++ alkalmazások sebessége bizonyult hasonló. Ugyanakkor a Java tömörebb - a kód mennyiségének különbsége körülbelül 10-15% volt.

C++ és C

Az eredeti C folyamatosan fejlődik, számos nagyszabású projektet fejlesztenek benne: ez az operációs rendszerek fejlesztésének fő nyelve, számos dinamikus játék játékmotorja és számos alkalmazási alkalmazás íródik bele. Számos szakértő úgy érvel, hogy a C helyettesítése C++-ra nem növeli a fejlesztés hatékonyságát, hanem a projekt szükségtelen bonyolításához, a megbízhatóság csökkenéséhez és a karbantartási költségek növekedéséhez vezet. Különösen:

Linus Torvalds szerint "a C++ olyan jelentős mennyiségű kód írását váltja ki, aminek nincs alapvető jelentősége a program funkcionalitása szempontjából" [vélemények 3] .
Az OOP-támogatás, a sablonok és az STL nem döntő előnye a C ++-nak, hiszen minden, amire használjuk, szintén C-eszközökkel valósul meg. Ezzel egyidejűleg megszűnik a kódfelfúvás, és bizonyos bonyodalmakat, amelyek ráadásul távolról sem szükségesek, nagyobb rugalmasság, könnyebb tesztelés és jobb teljesítménymutatók kompenzálják.
A memóriaelérés automatizálása C++ nyelven növeli a memóriaköltséget és lelassítja a programokat.
A C++ kivételek használata a RAII követésére kényszeríti, a végrehajtható fájlok növekedéséhez vezet, lelassítja a programokat. További nehézségek merülnek fel a párhuzamos és elosztott programokban. Lényeges, hogy a Google C++ kódolási szabványa kifejezetten tiltja a kivételek alkalmazását [31] .
A C++ kódot nehezebb megérteni és tesztelni, a hibakeresést pedig bonyolultabb osztályhierarchiák használata nehezíti meg viselkedéssel és sablonörökléssel. Ráadásul több hiba is előfordul a C++ programozási környezetekben, mind a fordítókban, mind a könyvtárakban.
A kód viselkedésének sok részletét nem határozza meg a C++ szabvány, ami rontja a hordozhatóságot és nehezen fellelhető hibákat okozhat.
C-ben lényegesen több programozó van, mint C++-ban.

Nincs meggyőző bizonyíték arra, hogy a C++ jobb lenne a C-nél sem a programozói termelékenység, sem a programtulajdonságok tekintetében. Bár vannak olyan tanulmányok [32] , amelyek szerint a C programozók a teljes fejlesztési idő körülbelül 30-40%-át (a hibakeresést leszámítva) a memóriakezelésre fordítják, a fejlesztők általános termelékenységét összehasonlítva [22] a C és a C++ közel áll egymáshoz.

Az alacsony szintű programozásban a C++ új funkcióinak nagy része nem alkalmazható a megnövekedett többletterhelés miatt: a virtuális funkciók dinamikus valós cím számítást (RVA) igényelnek, a sablonok kódfelfújáshoz és rossz optimalizálási képességekhez vezetnek, a futásidejű könyvtár (RTL) nagyon nagy, és ennek elutasítása megfosztja a C ++ legtöbb funkcióját (már csak a new/ műveletek elérhetetlensége miatt is delete). Ennek eredményeként a programozónak a C-től örökölt funkciókra kell korlátoznia magát, ami értelmetlenné teszi a C ++ használatát:

… az egyetlen módja annak, hogy jó, hatékony, alacsony szintű, hordozható C++-t kapjunk, ha korlátozzuk magunkat mindazokra a dolgokra, amelyek triviálisan elérhetők C-ben. És ha a projektet C-re korlátozzuk, az azt jelenti, hogy az emberek nem fogják kidobni, és sok olyan programozó lesz elérhető, akik valóban jól értik az alacsony szintű funkciókat, és nem hagyják el őket az idióta "objektummodell" miatt. ostobaság.
… amikor a hatékonyság a legfontosabb, a C++ "előnyei" óriási hiba lesz.

– Linus Torvalds , [33]

C++ és funkcionális és szkriptnyelvek

Egy kísérletben [22] a szkript- és funkcionális nyelvek, különösen a Haskell 2-3-szoros növekedést mutattak a programozási idő és a kódméret tekintetében a C++ programokhoz képest. Másrészt a C++ programok ugyanilyen gyorsabbnak bizonyultak. A szerzők elismerik, hogy adataik nem képeznek reprezentatív mintát, és tartózkodnak a kategorikus következtetések levonásától.

Egy másik kísérletben [34] a szigorú funkcionális nyelvek ( Standard ML , OCaml ) 10-szeres általános fejlődési gyorsulást mutattak (főleg a hibák korai felismerése miatt), megközelítőleg azonos teljesítménymutatókkal (sok fordító több módban is használt).

Lutz Prehelt [24] tanulmányában , mintegy 80 önkéntesek által írt megoldás feldolgozásának eredményei alapján, különösen a következő következtetésekre jutottak:

A Perl, Python, Rexx, Tcl kétszer gyorsabb fejlesztési sebességet biztosított, mint a C, C++ és Java, és az így kapott kód is fele olyan hosszú volt.
A szkriptnyelvű programok körülbelül kétszer annyi memóriát fogyasztottak, mint a C/C++

Kritika

A C++ kritikájáról általában

A kritikusok leggyakrabban nem ellenzik a C++-t egyetlen másik nyelvvel sem, hanem azzal érvelnek, hogy egyetlen nyelv használatának elutasítása, amelynek számos hibája van, a projekt olyan részfeladatokra bontása javára, amelyek különböző nyelveken megoldhatók, amelyek a legalkalmasabbak jelentősen kevésbé időigényessé teszik a fejlesztést, miközben javítják a programozás minőségi mutatóit [35] [36] . Ugyanezen okból kifogásolják a C-vel való kompatibilitás fenntartását: ha a feladat egy része alacsony szintű funkciókat igényel, akkor ésszerűbb ezt a részt külön alrendszerre választani és C-be írni.

A C ++ támogatói viszont azt állítják, hogy a nyelvközi interakció technikai és szervezési problémáinak kiküszöbölése több speciális nyelv helyett egy univerzális nyelv használatával fontosabb, mint az univerzális nyelv tökéletlenségéből eredő veszteségek, azaz a C ++ szolgáltatáskészlet széles skálája mentség az egyes funkciók hiányosságaira; beleértve a C-ből örökölt hátrányokat is a kompatibilitás előnyei indokolják (lásd fent ).

Így a C ++ ugyanazokat a tulajdonságait - hangerő, összetettség, eklektika és az alkalmazási célterület hiánya - a támogatók " fő előnynek ", a kritikusok pedig " a fő hátránynak " tekintik.

Az egyes elemek és fogalmak kritikája

Viselkedésszabályozás

A nyelv ideológiája összekeveri a „ viselkedés -szabályozást ” a „ hatékonyság -szabályozással ”: a „ nem fizet azért, amit nem használ ” elv azt sugallja, hogy a programozó számára a programvégrehajtás minden aspektusa feletti teljes ellenőrzést egy meglehetősen alacsony szint szükséges és elégséges feltétel a magas kódhatékonyság eléréséhez. Valójában ez egyetlen nagy programra sem igaz: az alacsony szintű optimalizálás rákényszerítése a programozóra, amit egy jó minőségű tartományspecifikus nyelvi fordító nyilvánvalóan hatékonyabban tud végrehajtani, csak a kód mennyiségének növekedéséhez vezet, a programozási munkaintenzitás növekedése, valamint a kód érthetőségének és tesztelhetőségének csökkenése. Így a „nem fizess azért, amit nem használnak” elve nem igazán biztosítja a kívánt hatékonysági előnyöket, hanem negatívan befolyásolja a minőséget.

Komponens és objektum-orientált programozás

Alan Kay szerint a C++-ban használt „ Algol osztályokkal” objektummodell a teljes terjedelem, a kód újrafelhasználása , az érthetőség, a módosíthatóság és a tesztelhetőség tekintetében gyengébb az Objective-C- ben használt „minden egy objektum” modellnél [37] . .

A C++ öröklődési modell összetett, nehezen megvalósítható, ugyanakkor összetett hierarchiák létrehozását váltja ki az osztályok közötti természetellenes kapcsolatokkal (például egymásba ágyazás helyett öröklődés). Az eredmény szorosan összekapcsolt osztályok létrehozása homályosan elkülönülő funkcionalitással. Például a [38] -ban van egy oktató és ajánló példa a "lista" osztály megvalósítására a "lista elem" osztály alosztályaként, amely viszont hozzáférési funkciókat tartalmaz más listaelemekhez. Ez a típuskapcsolat matematikailag abszurd, és szigorúbb nyelveken reprodukálhatatlan. Egyes könyvtárak ideológiája megkívánja az osztályhierarchiában felfelé és lefelé történő kézi típussorolást ( static_castés dynamic_cast), ami sérti a nyelv típusbiztonságát . A C++ oldatok magas viszkozitása miatt a projekt nagy részét újra kell fejleszteni minimális változtatásokkal a fejlesztési folyamat későbbi szakaszában. Az ilyen problémák szemléletes példája a [35] dokumentumban található.

Ahogy Ian Joyner [39] rámutat , a C++ tévesen egyenlővé teszi a beágyazást (vagyis az adatok objektumokba helyezését és a megvalósítás elválasztását az interfésztől) és az implementáció elrejtését. Ez megnehezíti az osztályadatokhoz való hozzáférést, és megköveteli, hogy interfészét szinte kizárólag hozzáférési függvényeken keresztül valósítsák meg (ami viszont növeli a kód mennyiségét és bonyolítja azt).

A típusegyeztetés a C++ nyelven az azonosítók szintjén van meghatározva, nem az aláírások szintjén. Ez lehetetlenné teszi az interfész illesztésen alapuló komponensek cseréjét, ezért a könyvtári szinten megvalósított új funkcionalitások rendszerbe foglalása a meglévő kód manuális módosítását igényli [40] . Ahogy Linus Torvalds [33] rámutat , a C++ nyelvben "a kód csak addig tűnik elvontnak, amíg nem kell megváltoztatni."

A C++ kritikáját az OOP szempontjából a [39] tartalmazza .

Metaprogramozás

A C++ generatív metaprogramozása sablon- és előfeldolgozó alapú , munkaigényes és korlátozott hatókörű. A C++ sablonrendszer valójában a primitív funkcionális programozási nyelv fordítási idejű változata. Ennek a nyelvnek szinte nincs átfedése magával a C ++-szal, ezért az absztrakciók összetettségének növekedési lehetősége korlátozott. A C++ sablonokat használó programok érthetősége és tesztelhetősége rendkívül rossz, a sablonok kibontása pedig maga is nem hatékony kódot generál, mivel a sablonnyelv nem ad lehetőséget az optimalizálásra (lásd még #Számítási hatékonyság fejezet ). Az így megvalósított beágyazott tartományspecifikus nyelvek továbbra is megkövetelik magának a C++-nak a ismeretét, ami nem ad teljes értékű munkamegosztást. Így a C++ képessége magának a C++-nak a képességeinek kiterjesztésére meglehetősen korlátozott [41] [42] .

Cross-platform

A hordozható C++ kód megírása nagy jártasságot és tapasztalatot igényel, és a "hanyag" C++ kód nagy valószínűséggel nem hordozható [43] . Linus Torvalds szerint a C-hez hasonló C++ hordozhatóság eléréséhez a programozónak a C-ből örökölt C++ jellemzőkre kell korlátoznia magát [33] . A szabvány számos „implementation-defined”-ként definiált elemet tartalmaz (például az osztálymetódusokra mutató pointerek mérete a különböző fordítóprogramokban 4-20 bájt között változik [44] ), ami rontja az ezeket használó programok hordozhatóságát.

A nyelvi szabványosítás direktíva , a hiányos visszafelé kompatibilitás és a szabvány különböző verzióinak követelményeinek inkonzisztenciája problémákhoz vezet a programok különböző fordítók, sőt ugyanazon fordítók verziói közötti áthelyezésében.

Lehetőségek hiánya

Reflexiós metaprogramozás Az introspekció a C++ nyelvben a fő típusrendszertől külön van megvalósítva, ami szinte használhatatlanná teszi. A legnagyobb, amit elérhetünk, a viselkedés paraméterezése egy korábban ismert opciókészleten. Ez megakadályozza a C++ használatát a mesterséges intelligencia megvalósításának legtöbb megközelítésében . Funkcionális programozás A funkcionális programozás kifejezett támogatása csak a C++0x szabványban van, korábban a hiányt a sablonnyelvet használó könyvtárak ( Loki , Boost ) pótolták, de minőségük jelentősen elmarad a funkcionális nyelvekbe épített megoldásoktól [magyarázatok 1] , valamint a C++ szolgáltatások (például az OOP) funkcionális nyelveken keresztül történő megvalósításának minősége. A C++-ban megvalósított FP képességek nem teszik lehetővé a funkcionális programozásban rejlő optimalizálási technikák alkalmazását , hanem a funkcionális könyvtárak meghívására és az egyedi módszerek megvalósítására korlátozódnak. Ennek alig van előnye a programtervezésben (lásd Curry-Howard levelezést ).

Redundáns és veszélyes lehetőségek

Beépített bypass

A nyelv olyan eszközöket tartalmaz, amelyek lehetővé teszik a programozó számára, hogy megsértse az adott esetben adott programozási fegyelmet. Például egy módosító constbeállítja egy objektum állapotváltoztathatatlanságának tulajdonságát, de a módosító kifejezetten arra lettmutable tervezve , hogy engedélyt kényszerítsen a const objektumon belüli állapot megváltoztatására, vagyis az állandósági kényszer megsértésére. Ezenkívül megengedett egy attribútum dinamikus eltávolítása egy állandó objektumból, L-értékké alakítva azt. Az ilyen tulajdonságok jelenléte a nyelvben értelmetlenné teszi a kód formális ellenőrzésére tett kísérleteket , és lehetetlen a korlátozások használata az optimalizáláshoz. const

Ellenőrizetlen makróhelyettesítés

A C makró helyettesítési lehetőségek ( #define) éppoly erősek, mint veszélyesek. A C++-ban megmaradnak annak ellenére, hogy minden olyan feladathoz, amelyre C-ben biztosították, a C++ szigorúbb és speciálisabb lehetőségeket biztosított - sablonok, funkció túlterhelés, soron belüli függvények, névterek, fejlettebb gépelés, alkalmazás kiterjesztése a const módosító. , stb. Sok potenciálisan veszélyes makró található a C-ből örökölt standard könyvtárakban [45] . A sablon metaprogramozást néha a makróhelyettesítés használatával is kombinálják, hogy ún. " szintaktikus cukor ".

Túlterhelési problémák

A funkció és az operátor túlterhelésének C++ elvei jelentős kódduplikációhoz vezetnek. Eredetileg az úgynevezett " szintaktikai cukor " bevezetésére szánták, az operátortúlterhelés a C++ nyelvben ösztönzi az elemi operátorok ellenőrizetlen viselkedését a különböző típusoknál. Ez drámaian növeli a hibák kockázatát, különösen azért, mert lehetetlen új szintaxist bevezetni és a meglévőt megváltoztatni (például új operátorokat létrehozni, prioritásokat vagy asszociativitást módosítani), bár a szabványos C ++ operátorok szintaxisa megfelelő a korántsem minden típusú szemantika, amelyet esetleg be kell vezetni a programba. Bizonyos problémákat okoz az operátorok könnyű túlterhelésének lehetősége , ami rendkívül alattomos és nehezen fellelhető hibákat generálhat. Ugyanakkor néhány intuitívan elvárt művelet (dinamikus objektumok tisztítása kivételek dobása esetén) nem kerül végrehajtásra a C++-ban, és a túlterhelt függvények és operátorok jelentős része implicit módon meghívásra kerül (típusöntés, osztályok ideiglenes példányainak létrehozása stb. .). Ennek eredményeként az eredetileg a programok világosabbá tételére, valamint a fejlesztés és karbantarthatóság javítására szolgáló eszközök a szükségtelenül bonyolult és megbízhatatlan kódok újabb forrásaivá válnak. newdelete

Számítási hatékonyság

Az eredményül kapott végrehajtható kód mennyisége

A C++ sablonok használata paraméteres polimorfizmus a forráskód szintjén, de lefordítva ad hoc polimorfizmusba (azaz függvénytúlterhelésbe) alakul, ami a gépi kód mennyiségének jelentős növekedéséhez vezet azokhoz a nyelvekhez képest, amelyek rendelkeznek igazi polimorf típusú rendszer (az ML leszármazottai ). A gépi kód méretének csökkentése érdekében megpróbálják automatikusan feldolgozni a forráskódot a sablonok letekercselési szakasza előtt [46] [47] . Egy másik megoldás lehet a sablonok exportálása, amelyet még 1998-ban szabványosítottak, de nem minden fordítónál érhető el, mivel nehezen kivitelezhető [48] [49] [vélemények 4] és C ++ sablonkönyvtárak importálása. jelentősen eltérő C++ szemantikával rendelkező nyelvekbe még mindig haszontalan lenne. A C++ támogatói vitatják a kódfelfúvódás mértékét, mint eltúlzott [50] , még azt a tényt is figyelmen kívül hagyva, hogy a C-ben a parametrikus polimorfizmus közvetlenül, azaz a függvénytestek megkettőzése nélkül történik. Ugyanakkor a C++ támogatói úgy vélik, hogy a C paraméteres polimorfizmusa veszélyes – vagyis veszélyesebb, mint a C-ből C++-ba való átmenet (a C++ ellenzői ennek az ellenkezőjével érvelnek – lásd fent).

Optimalizálási lehetőség

A gyenge típusú rendszer és a rengeteg mellékhatás miatt rendkívül nehézkessé válik a programok egyenértékű konvertálása, ezért számos optimalizáló algoritmus beágyazása a fordítóba, mint például a programok automatikus párhuzamosítása , a gyakori részkifejezések eltávolítása , λ-emelés, hívások eljárások folytatásos passzírozással , szuperfordítással stb. Ennek eredményeként a C++ programok tényleges hatékonyságát korlátozza a programozók készségei és az adott projektbe fektetett erőfeszítések, és a „hanyag” megvalósítás hatékonysága jelentősen gyengébb lehet, mint a „hanyag” ” implementációk magasabb szintű nyelveken, amit a nyelvek összehasonlító tesztjei is megerősítenek [34] . Ez jelentős akadályt jelent a C++ adatbányászati iparban való használata előtt .

Hatékony memóriakezelés

A hatékony memóriakezelés felelőssége a fejlesztő vállára esik, és a fejlesztő képességeitől függ. Az automatikus memóriakezeléshez C ++-ban az ún. "intelligens mutatók", a kézi memóriakezelés csökkenti maguknak a programozóknak a hatékonyságát (lásd a Hatékonyság című részt ) . A szemétgyűjtés számos implementációja , mint például a régiók statikus következtetése , nem alkalmazható C++ programokra (pontosabban ehhez egy új nyelvi tolmács implementálása szükséges a C++ nyelven felül, ami a legtöbb objektív tulajdonságában nagyon különbözik a C++-tól és az általános ideológiában) az AST -hez való közvetlen hozzáférés szükségessége miatt .

Hatékonyság

A teljesítménytényezők korrelációja a fejlesztési költségekkel, valamint a programozói közösségben művelt általános fegyelem és programozási kultúra fontos azon ügyfelek számára, akik projektjeik megvalósításához nyelvet választanak (és ennek megfelelően ezt a fejlesztői nyelvet részesítik előnyben), valamint azoknak, akik elkezdenek programozást tanulni, különösen azzal a szándékkal, hogy saját igényeinek megfelelően programozzanak.

Programozási minőség és kultúra

A C++ elve, hogy „ ne kényszerítsünk ki egy „jó programozási stílust ”, ellentétes a programozás ipari megközelítésével, melyben a szoftver minősége és a kód karbantartásának lehetősége játssza a vezető szerepet, nem csak a szerző. , és melyek azok a nyelvek, amelyek minimálisra csökkentik az emberi tényező hatását , vagyis csak „ jó” programozási stílust kényszerítenek ki , bár ezeknek a nyelveknek magasabb lehet a belépési küszöbük.

Egyes vélemények szerint a C++ használatának előnyben részesítése (alternatív nyelvválasztás lehetőségével) negatívan jellemzi a programozó szakmai tulajdonságait. Linus Torvalds azt mondja, hogy a jelöltek pozitív véleményét a C++-ról lemorzsolódási kritériumként használja [vélemények 3] :

A C++ egy borzasztó nyelv. Ami még borzasztóbbá teszi, az az a tény, hogy sok írástudatlan programozó használja... Őszintén szólva, még ha nincs is más ok a C kiválasztására, mint a C++ programozók távoltartása, ez önmagában is jó ok lenne a használatára. C.
…Arra a következtetésre jutottam, hogy szívesebben rúgnék ki mindenkit, aki szívesebben dolgozna C++-ban, mint C-ben, hogy ne tegye tönkre azt a projektet, amelyben részt veszek.

– Linus Torvalds , [33] Hibás javítás

A nyelv folyamatos fejlődése arra ösztönzi (és néha kényszeríti is) a programozókat, hogy újra és újra módosítsák a már hibakeresett kódot – ez nemcsak a fejlesztés költségeit növeli, hanem azzal a kockázattal is jár, hogy a hibakereső kódban új hibákat visznek be. Különösen, bár a visszafelé kompatibilitás a C-vel eredetileg a C++ egyik alapelve volt, 1999 óta a C megszűnt a C++ részhalmaza lenni, így a hibakereső C-kód már nem használható egy C++-projektben módosítás nélkül.

Bonyolultság önmagáért

A C++-t apologétái éppen azért határozzák meg "a legerősebbnek" , mert tele van veszélyes, egymásnak ellentmondó tulajdonságokkal. Eric Raymond szerint ez magát a nyelvet teszi a programozók személyes önmegerősítésének talajává, és a fejlesztési folyamatot öncélúvá változtatja:

A programozók gyakran rikító egyéniségek, akik büszkék arra, hogy képesek kezelni a bonyolultságokat és az absztrakciókat ügyesen. Gyakran versenyeznek egymással, és megpróbálják kitalálni, hogy ki tudja létrehozni a "legbonyolultabb és legszebb összetettséget". ... a riválisok úgy vélik, hogy fel kell venniük a versenyt mások „dekorációival”, sajátjuk hozzáadásával. Nemsokára a "masszív daganat" válik az iparág szabványává, és mindenki olyan nagy, bugos programokat futtat, amelyeket még az alkotóik sem tudnak kielégíteni.
…
… ez a megközelítés bajba kerülhet, ha a programozók egyszerű dolgokat bonyolult módon csinálnak, egyszerűen azért, mert ismerik ezeket a módszereket és tudják, hogyan kell használni őket.

– Eric Raymond , [51] Szabotázs

Megfigyeltek olyan eseteket, amikor a gondatlan programozók a C ++ erős kontextusfüggőségét és a makródefiníciók fordító általi nyomon követésének hiányát kihasználva lelassították a projekt fejlődését azzal, hogy egy-két pluszt írtak, fordítói szempontból helyesen. nézetből, kódsorokból, de bevezetnek egy nehezen észlelhető, spontán módon megnyilvánuló hibát az ő kárukra. Például:

#define if(a) if(rand())

#define ji

A bizonyítottan helyes nyelveken még fejlett makrólehetőségekkel sem lehet ilyen módon kárt okozni.

Megbízhatatlan termék

A mellékhatások ésszerűtlen sokasága, a nyelv futásidejű rendszerének ellenőrzésének hiányával és a gyenge típusú rendszerrel kombinálva a C++ programokat hajlamossá teszi előre nem látható végzetes összeomlásokra (a jól ismert összeomlások olyan üzenetekkel, mint "Hozzáférés megsértése", "Tiszta virtuális funkció hívás" vagy "A program illegális műveletet hajtott végre, és be lesz zárva"), amely kizárja a C ++ használatát, magas hibatűrési követelményekkel. Ezenkívül megnöveli magának a fejlesztési folyamatnak az időtartamát [34] .

Projektmenedzsment

A fent felsorolt tényezők a C++ projektmenedzsment komplexitását a szoftverfejlesztési ipar egyik legmagasabb fokává teszik.

James Coggins, a The C++ Report négyéves rovatvezetője kifejti:
A probléma az, hogy az OOP programozói vérfertőző alkalmazásokkal kísérleteztek, és az absztrakció alacsony szintjére törekedtek. Például olyan osztályokat építettek, mint a „linked list” a „felhasználói felület” vagy a „sugárzási nyaláb” vagy „végeselem-modell” helyett. Sajnos az erős típusellenőrzés, amely segít a C++ programozóknak elkerülni a hibákat, megnehezíti a nagy objektumok kicsikből való építését is.

- F. Brooks , A mitikus emberhónap

Befolyás és alternatívák

A C++ egyetlen közvetlen leszármazottja a D nyelv , amely a C++ átdolgozása a legnyilvánvalóbb problémáinak megoldására. A szerzők lemondtak a C-vel való kompatibilitásról, megtartották a C ++ szintaxisát és számos alapelvét, és olyan funkciókat vezettek be a nyelvbe, amelyek az új nyelvekre jellemzőek. A D-nek nincs előfeldolgozója, nincs fejlécfájlja, nincs többszörös öröklődése, de modulrendszere, interfészek, asszociatív tömbök, unicode támogatása karakterláncokban, szemétgyűjtés (a kézi memóriakezelés lehetőségének fenntartása mellett), beépített többszálú, típuskövetkeztetés , tiszta függvények és megváltoztathatatlan értékek explicit deklarációja. A D használata nagyon korlátozott, nem tekinthető a C ++ valódi versenytársának.

A C++ legrégebbi vetélytársa az alacsony szintű feladatokban az Objective-C , amely szintén a C objektummodellel való kombinálásának elvén épült , csak az objektummodellt örökli a Smalltalk . Az Objective-C-t, akárcsak leszármazottját a Swiftet , széles körben használják szoftverfejlesztésre MacOS és iOS rendszeren.

A C++ egyik első alternatívája az alkalmazásprogramozásban a Java nyelv volt . Gyakran tévesen a C++ közvetlen leszármazottjának tekintik; Valójában a Java szemantikája a Modula-2 nyelvből öröklődik , és a C++ alapvető szemantikája nem követhető nyomon a Java-ban. Tekintettel erre, és a nyelvek genealógiájára (a Modula-2 a Simula leszármazottja , akárcsak a C++, de nem C), a Java-t helyesebben a C++ " másodunokatestvérének " nevezik, nem pedig " örökösének ". Ugyanez mondható el a C# nyelvről is, bár a C++-hoz való affinitás százaléka valamivel magasabb, mint a Javaé.

A Java és a C# biztonságát és fejlesztési sebességét a C++ képességeivel kombinálni próbálták a Managed C++ dialektus (később C++/CLI ). A Microsoft elsősorban a meglévő C++ projektek Microsoft .NET platformra történő portolására fejlesztette ki. A CLR alatt futó programok a .NET-könyvtárak teljes tömbjét használhatják, de a C++-szolgáltatások használatára számos korlátozás vonatkozik, ami hatékonyan csökkenti a C++-t C#-ra. Ez a nyelvjárás nem kapott széles körű elismerést, és főként a tiszta C ++ nyelven írt könyvtárak összekapcsolására szolgál C # alkalmazásokkal.

A C nyelv fejlesztésének egy másik módja, ha nem objektum-orientált programozással, hanem aplikatív programozással kombináljuk , vagyis az alacsony szintű programok absztrakcióját, szigorát és modularitását javítjuk a kiszámítható viselkedés és a hivatkozási átlátszóság biztosításával . Az ilyen jellegű munkákra példák a BitC , a Cyclone és a Limbo nyelvek . Bár vannak sikeres kísérletek az FP használatára valós idejű problémákban C eszközökkel való integráció nélkül [52] [53] [54] , jelenleg (2013) az alacsony szintű fejlesztésben a C eszközök használata bizonyos mértékig. jobb arányban áll a munkaintenzitás és a hatékonyság között. A Python és a Lua fejlesztői sok erőfeszítést tettek a Python és a Lua fejlesztésére annak biztosítására, hogy ezeket a nyelveket használják a C++ programozók, így az FP-hez szorosan kapcsolódó nyelvek közül ezek a nyelvek a leggyakrabban megjegyezték, hogy a C++-szal együtt kell használni ugyanabban a projektben. A C++ és az FP közötti legjelentősebb érintkezési pontok a C++-ban kifejlesztett wxWidgets és Qt könyvtárak C++-specifikus ideológiájú kötései Lisp -hez , Haskell -hez és Python -hoz (a legtöbb esetben a funkcionális nyelvekhez való kötések a nyelven írt könyvtárakhoz készülnek C vagy más funkcionális nyelvek).

Egy másik nyelv, amelyet a C++ versenytársának tartanak, a Nemerle , amely a Hindley-Milner tipizálási modell és a Common Lisp makró részhalmazának a C#-val való kombinálására tett kísérlet eredménye [55] . Ugyanebben a szellemben a Microsoft F# -ja, az ML nyelvjárása .NET környezetre adaptálva.

A C/C++ ipari helyettesítésére tett kísérlet a Go programozási nyelv volt, amelyet a Google fejlesztett ki 2009-ben . A nyelv szerzői egyenesen rámutatnak arra, hogy létrehozásának indítéka a fejlesztési folyamat hiányosságai, amelyeket a C és C ++ nyelvek sajátosságai okoztak [56] . A Go egy kompakt, egyszerű imperatív nyelv C-szerű szintaxissal, előprocesszor nélkül, statikus gépeléssel, erős gépeléssel, csomagoló rendszerrel, automatikus memóriakezeléssel, néhány funkcionális funkcióval, gazdaságosan felépített OOP alrendszerrel, implementáció öröklődés támogatása nélkül, de interfésszel és kacsa gépeléssel , beépített többszálú korutin és csövek alapján (a-la Occam ). A nyelvet a C ++ alternatívájaként pozicionálják, vagyis elsősorban rendkívül összetett, rendkívül összetett számítástechnikai rendszerek csoportos fejlesztésének eszközeként, beleértve az elosztottakat is, szükség esetén lehetővé téve az alacsony szintű programozást.

Ugyanabban az ökológiai résben a C / C ++-szal a Rust, amelyet 2010-ben fejlesztettek ki és a Mozilla Corporation karbantartott , és a szemétgyűjtő használata nélküli biztonságos memóriakezelésre összpontosít . A Microsoft 2019-ben különösen azt a tervet jelentette be, hogy a C / C ++ részben Rust-ra cseréli [57] .

Lásd még

Jegyzetek

↑ ISO/IEC 14882:2020 Programozási nyelvek - C++ - 2020.
↑ Gubina G. G. Számítógép angol. I. rész Számítógépes angol. I. rész Oktatóanyag . - P. 385. Archivált : 2017. december 3. a Wayback Machine -nál
↑ Bjarne Stroustrup GYIK . Bjarne Stroustrup (2017. október 1.). - "A név C++ (ejtsd: "lásd plusz")". Hozzáférés dátuma: 2017. december 4. Az eredetiből archiválva : 2016. február 6.
↑ Schildt, 1998 .
↑ 1 2 Stroustrup, 1999 , 2.1. Mi az a C++?, p. 57.
↑ Stanley Lippman, Pure C++: Hello, C++/CLI Archiválva : 2011. június 6. a Wayback Machine -nél
↑ 1 2 Stroustrup, 1999 , 1.4. Történelmi megjegyzések, p. 46.
↑ C++-szabványok . Letöltve: 2010. november 14. Az eredetiből archiválva : 2010. november 20.. (határozatlan)
↑ Bjarne Stroustrup. C++ szószedet (nem elérhető hivatkozás) . Letöltve: 2007. június 8. Az eredetiből archiválva : 2011. május 1.. (határozatlan)
↑ Hol találom az aktuális C vagy C++ szabványos dokumentumokat? http://stackoverflow.com/questions/81656/where-do-i-find-the-current-c-or-c-standard-documents Archiválva : 2015. november 29. a Wayback Machine -nél
↑ Tekintse meg a listát a http://en.cppreference.com/w/cpp/experimental címen . Archiválva : 2015. november 18., a Wayback Machine Látogatott 2015. január 5-én.
↑ A Yandex munkacsoportot szervez a C++ nyelv szabványosítására . ICS Media. Letöltve: 2018. augusztus 29. Az eredetiből archiválva : 2018. augusztus 29. (Orosz)
↑ Stroustrup, The Design and Evolution of C++, 2007 .
↑ ISO/IEC 14882:1998, 6.4. szakasz, 4. szakasz: "Annak a feltételnek az értéke, amely inicializált deklaráció egy utasítástól eltérő switchutasításban, a deklarált változó értéke, amelyet implicit módon konvertálunk bool... Egy feltétel értéke azaz egy kifejezés a kifejezés értéke, implicit módon konvertálva boola switch; ha ez az átalakítás rosszul van kialakítva, akkor a program rosszul van kialakítva."
↑ STLport: Üdvözlünk! . Letöltve: 2007. július 26. Az eredetiből archiválva : 2018. június 7. (határozatlan)
↑ Stroustrup, 1999 , 1.6.
↑ std::vector - cppreference.com . Hozzáférés dátuma: 2015. november 28. Az eredetiből archiválva : 2015. november 27. (határozatlan)
↑ std::realloc - cppreference.com . Hozzáférés időpontja: 2015. november 28. Az eredetiből archiválva : 2015. december 4. (határozatlan)
↑ B. Stroustrup interjú a LinuxWorld.com oldallal . Letöltve: 2013. január 4. Az eredetiből archiválva : 2013. január 27.. (határozatlan)
↑ B. Stroustrup interjúja a System Administrator magazinnal . Hozzáférés időpontja: 2013. január 4. Az eredetiből archiválva : 2013. február 9.. (határozatlan)
↑ CNews: Exkluzív interjú a C++ programozási nyelv megalkotójával (hivatkozás nem elérhető) . Letöltve: 2019. november 1. Az eredetiből archiválva : 2015. március 17. (határozatlan)
↑ 1 2 3 4 Kísérlet a szoftverprototípusok termelékenységére. Paul Hudak, Mark P. Jones. Yale Egyetem Számítástechnikai Tanszék, New Haven, CT 06518. 1994. július 4.
↑ K. Czarnecki, J. O'Donnell, J. Striegnitz, W. Taha. DSL megvalósítás a metaocaml-ban, a haskell sablonban és a C++-ban . — University of Waterloo, University of Glasgow, Research Center Julich, Rice University, 2004. Archiválva az eredetiből 2022. április 7-én. .
Idézet: A C++ sablon metaprogramozása számos korláttól szenved, beleértve a fordítói korlátok miatti hordozhatósági problémákat (bár ez jelentősen javult az elmúlt néhány évben), a hibakeresési támogatás vagy az IO hiánya a sablon példányosítása során, hosszú fordítási idő, hosszú és érthetetlen hibák , a kód rossz olvashatósága és rossz hibajelentés.
↑ 1 2 3 Lutz Prechelt ( Universiät Karlsruhe ). C, C++, Java, Perl, Python, Rexx és Tcl empirikus összehasonlítása kereső/karakterlánc-feldolgozó programhoz ( pdf) Freie Universität Berlin (2000. március 14.). Letöltve: 2019. november 20. Az eredetiből archiválva : 2020. január 3.
↑ Ada, C, C++ és Java vs. The Steelman" David A. Wheeler 1997. július/augusztus (a hivatkozás nem elérhető) . Letöltve: 2019. március 23. Az eredetiből archiválva : 2019. március 23. (határozatlan)
↑ 1 2 "A bioinformatikában használt általános programozási nyelvek összehasonlítása" . Letöltve: 2021. szeptember 2. Az eredetiből archiválva : 2021. szeptember 2. (határozatlan)
↑ Programozási nyelvek összehasonlítása bioinformatikai algoritmusok megvalósításában - a kísérlet leírása. . Letöltve: 2021. szeptember 2. Az eredetiből archiválva : 2021. szeptember 2. (határozatlan)
↑ Az Ada és a C++ szolgáltatások összehasonlítása (en) . Letöltve: 2019. március 23. Az eredetiből archiválva : 2019. március 23. (határozatlan)
↑ Stephen Zeigler, C és Ada fejlesztési költségeinek összehasonlítása. Archiválva az eredetiből 2007. április 4-én.
↑ 1.2 A Java™ programozási nyelv tervezési céljai . A Java nyelvi környezet . Oracle (1999. január 1.) . Letöltve: 2013. január 14. Az eredetiből archiválva : 2013. január 23..
↑ Google C++ stílus útmutató. Kivételek. . Letöltve: 2019. március 31. Az eredetiből archiválva : 2019. március 16. (határozatlan)
↑ Boehm H. A konzervatív szemétgyűjtés előnyei és hátrányai . Archiválva az eredetiből 2013. július 24-én.
( Raymond, Eric hivatkozása . A Unix programozás művészete. - 2005. - 357. o. - 544 p. - ISBN 5-8459-0791-8 . )
↑ 1 2 3 4 Nyitott levelezés: gmane.comp.version-control.git, 2007. 09. 06. (hozzáférhetetlen hivatkozás) . Letöltve: 2013. augusztus 5. Az eredetiből archiválva : 2013. december 9.. (határozatlan)
↑ 1 2 3 Ray Tracer nyelvi összehasonlítás (a programozási nyelvek referenciaértéke - ffconsultancy.com/languages/ray_tracer/)
↑ 12 Martin Ward . Nyelvorientált programozás . - Computer Science Department, Science Labs, 1994. Az eredetiből archiválva : 2016. március 4..
↑ Hudak Pál. Moduláris tartományspecifikus nyelvek és eszközök. — A Yale Egyetem Számítástechnikai Tanszéke.
↑ Alan Kay definíciója az objektum-orientált programozásról (a hivatkozás nem elérhető) . Hozzáférés dátuma: 2013. augusztus 5. Az eredetiből archiválva : 2013. augusztus 24.. (határozatlan)
↑ Schildt, C++ elmélet és gyakorlat, 1996 , p. 64-67.
↑ 12 Ian Joyner . A C++ kritikája és a 90-es évek programozási és nyelvi trendjei – 3. kiadás . - szerzői jog és publikációk listája . Az eredetiből archiválva : 2013. november 25.
↑ Paulson, Lawrence C. ML for the Working Programmer, 2. kiadás. - Cambridge-i Egyetem: Cambridge University Press, 1996. - ISBN 0-521-57050-6 (keménykötés), 0-521-56543-X (puhakötés). , 271-285 körül
↑ Walid Taha. Domain-specifikus nyelvek . — A Rice Egyetem Számítástechnikai Tanszéke. Archiválva az eredetiből 2013. október 24-én.
↑ Lugovsky VS Domain-specifikus nyelvek hierarchiájának használata az összetett szoftverrendszerek tervezésében . - 2008. Archiválva : 2016. augusztus 10.
↑ Andrej Karpov. 20 buktatója a C++ kód 64 bites platformra történő portolásának . - RSDN Magazine #1-2007, 2007. Archiválva az eredetiből 2015. április 2-án.
↑ Don Clugston, CSG Solar Pty Ltd (Fordította: Denis Bulichenko). Tagfüggvénymutatók és a delegált leggyorsabb C++ megvalósítása . — RSDN Magazine #6-2004. Az eredetiből archiválva : 2013. október 19.
↑ Stroustrup, Programozás: C++ alapelvek és gyakorlat, 2001
↑ Dave Gottner. Sablonok kód nélkül Bloat . — Dr. Dobb's Journal , 1995. január. Az eredetiből archiválva : 2008. június 7..
↑ Adrian Stone. Kódfelfúvódás minimalizálása: Redundáns sablonpéldányosítás (lefelé irányuló kapcsolat) . Game Angst (2009. szeptember 22.). Hozzáférés dátuma: 2010. január 19. Az eredetiből archiválva : 2011. december 8. (határozatlan)
↑ Herb Sutter . C++ megfelelőségi összesítés . — Dr. Dobb's Journal , 2001. január. Az eredetiből archiválva : 2009. január 15.
↑ Vannak olyan fordítók, amelyek megvalósítják mindezt? (nem elérhető link) . comp.std.c++ gyakran ismételt kérdések / A C++ nyelv . Comeau Computing (2008. december 10.). Hozzáférés dátuma: 2010. január 19. Az eredetiből archiválva : 2009. április 30. (határozatlan)
↑ Scott Meyers . Kódfelfújás a sablonok miatt . comp.lang.c++.moderated . Usenet (2002. május 16.). Letöltve: 2010. január 19. (határozatlan)
↑ Eric Raymond . Programozás művészete Unix számára = The Art of Unix. - Williams, 2005. - ISBN 5-8459-0791-8 .
↑ Zhanyong Wan és Paul Hudak. Eseményvezérelt FRP // Számítástechnikai Tanszék, Yale Egyetem. Az eredetiből archiválva : 2011. augusztus 16.
↑ Walid Taha (angol) (a hivatkozás nem elérhető) . Rice Egyetem Mérnöki Iskola . Letöltve: 2019. november 20. Az eredetiből archiválva : 2013. augusztus 13..
↑ MLKit (lefelé irányuló kapcsolat) . Letöltve: 2013. július 30. Az eredetiből archiválva : 2013. szeptember 17.. (határozatlan)
↑ Chistyakov Vlad más néven VladD2. Szintaktikus cukor vagy C++ vs. Nemerle :) // RSDN Magazin 1-2006. - 2006.05.24. Az eredetiből archiválva : 2013. december 13.
↑ Ugrás a Google oldalára: Nyelvi tervezés a szoftverfejlesztés szolgálatában . talks.golang.org. Letöltve: 2017. szeptember 19. Az eredetiből archiválva : 2021. január 25. (határozatlan)
↑ Catalin Cimpanu. A Microsoft a Rust használatával fedezi fel . ZDNet (2019. június 17.). Letöltve: 2019. szeptember 26. Az eredetiből archiválva : 2019. október 15.

Vélemények

↑ Programozási nyelv népszerűsége (elérhetetlen link) (2009). Hozzáférés dátuma: 2009. január 16. Az eredetiből archiválva : 2009. január 16. (határozatlan)
↑ TIOBE Programozási Közösségi Index (hivatkozás nem érhető el) (2009). Letöltve: 2009. május 6 .. Archiválva az eredetiből: 2009. május 4.. (határozatlan)
↑ 1 2 Nyissa meg a gmane.comp.version-control.git levelezést, 2007. 09. 06. (hozzáférhetetlen hivatkozás) . Letöltve: 2013. augusztus 5. Az eredetiből archiválva : 2013. december 9.. (határozatlan)
↑ vanDooren. A nap C++ kulcsszava: export (nem elérhető link) . Blogs@MSMVPs (2008. szeptember 24.). „Az export kulcsszó kicsit olyan, mint a C++ Higgs-bozonja. Elméletileg létezik, a szabvány leírja, és még senki sem látta a vadonban. … 1 C++ fordítófelület létezik a világon, amely valójában támogatja ezt.” Hozzáférés dátuma: 2010. január 19. Az eredetiből archiválva : 2009. május 6. (határozatlan)

Magyarázatok

↑ Például Boost.Lambdalambda-függvényként forgalmazzák, de a C++ nem valósítja meg a Church lambda-számítását teljes egészében; a kombinátorok sablonnyelven keresztüli utánzása túl nehéz ahhoz, hogy elvárjuk a gyakorlati használatukat; a C-ből örökölt folytatások nem ideomatikusnak és veszélyesnek minősülnek, megvalósításuk a sablonnyelven keresztül lehetetlen; továbbá a λ-lifting használata a C++ optimalizálására nem lehetséges – tehát valójában ez Boost.Lambda csak egy névtelen függvény, nem pedig a lambda-számítás objektuma.

Irodalom

Bjorn Stroustrup . C++ programozási nyelv = A C++ programozási nyelv / Per. angolról. - 3. kiadás - Szentpétervár. ; M .: Nyevszkij dialektus - Binom , 1999. - 991 p. - 3000 példányban. — ISBN 5-7940-0031-7 (Nevszkij-dialektus), ISBN 5-7989-0127-0 (Binom), ISBN 0-201-88954-4 (angol).
Bjorn Stroustrup . C++ programozási nyelv. Special Edition = A C++ programozási nyelv. különleges kiadás. - M. : Binom-Press, 2007. - 1104 p. — ISBN 5-7989-0223-4 .
Bjorn Stroustrup . Programozás: Alapelvek és gyakorlat C++ használatával, átdolgozott kiadás = Programozás: Alapelvek és gyakorlat C++ használatával. — M .: Williams , 2011. — S. 1248. — ISBN 978-5-8459-1705-8 .
Bjorn Stroustrup . Design and Evolution of C++ = The Design and Evolution of C++. - Szentpétervár. : Péter, 2007. - 445 p. — ISBN 5-469-01217-4 .
Bjorn Stroustrup . C++ programozási nyelv. Rövid tanfolyam. - 2019. - 320 p. - ISBN 978-5-907144-12-5 .
Bjorn Stroustrup . Programozás: alapelvek és gyakorlat a C++ használatával. - 2016. - 1328 p. - ISBN 978-5-8459-1949-6 .

Siddhartha Rao. Tanítsd meg magad C++-ban napi egy órában, 7. kiadás (C++11) = Sams Teach Yourself C++ in One Hour a Day, 7. kiadás. - M. : "Williams" , 2013. - 688 p. — ISBN 978-5-8459-1825-3 .
Stephens D. R. C++. Receptek gyűjteménye. - KUDITS-PRESS, 2007. - 624 p. - ISBN 5-91136-030-6 .
István Prata. C++ programozási nyelv (C++11). Előadások és gyakorlatok = C++ Primer Plus, 6. kiadás (Developer's Library). - 6. kiadás — M .: Williams , 2012. — 1248 p. - ISBN 978-5-8459-1778-2 .
István Prata. Programozási nyelv C. Előadások és gyakorlatok. — M .: Williams , 2015. — 928 p. - ISBN 978-5-8459-1950-2 .
Ivor Horton. Visual C ++ 2010: teljes tanfolyam = Ivor Horton Beginning Visual C ++ 2010. - M . : Dialectics , 2010. - S. 1216. - ISBN 978-5-8459-1698-3 .
Herbert Schildt . The Complete Reference to C++ = C++: The Complete Reference. - 4. kiadás - M .: Williams , 2011. - S. 800. - ISBN 978-5-8459-0489-8 .
Herbert Schildt . A C++ elmélete és gyakorlata = Schildt's Expert C++. - Szentpétervár. : BHV - Szentpétervár, 1996. - ISBN 0-07-882209-2 , 5-7791-0029-2.
PJ Plauger. Programozási nyelv kitalálós játékok - Ha a C++ a válasz, mi a kérdés? // Dr. Dobb folyóirata . - 1993. október.
The Unix-Haters Handbook (határozatlan idejű) . - International Data Group , 1994.
Ian Joyner. A C++ és az 1990-es évek programozási és nyelvi trendjei kritikája – 3. kiadás // szerzői jog és publikációk listája . – 1996.
Scott Meyers. Hatékony Modern C++: 42 ajánlás a C++11 és C++14 használatához = Hatékony Modern C++: 42 konkrét módszer a C++11 és C++14 használatának javítására / Per. angolról. - Williams, 2016. - 304 p. - ISBN 978-5-8459-2000-3 .
Herbert Schildt . C++ The Complete Reference Third Edition. - Osborne McGraw-Hill, 1998. - ISBN 978-0-07-882476-0 .
Jeremy A. Hansen The Rook's Guide to C++ (A Creative Commons által engedélyezett tankönyv) .

Linkek

isocpp.org ( angol) - hivatalos C++ webhely

a szabványosítási bizottság 2009. évi munkaanyagai

Bjorn Stroustrup. CppCoreGuidelines A C++ Core Guidelines jól bevált irányelvek, szabályok és bevált gyakorlatok készlete a C++ nyelvű kódolással kapcsolatban.
Bjorn Stroustrup. A C++ 0x rövid áttekintése
comp.lang.c++. moderált
Yossi Kreinin. C++ FQA Lite . (határozatlan)
Linus Torvalds . Konvertálja a builin-mailinfo.c fájlt a The Better String Library (downlink) használatára . Gmane fórum (2007. szeptember 6.). Az eredetiből archiválva : 2013. december 9. (határozatlan)

Szótárak és enciklopédiák

Bibliográfiai katalógusokban
BNE : XX540250 BNF : 12139768z GND : 4193909-8 J9U : 987007539277905171 LCCN : sh87007505 NKC : ph116956 SUDOC : 029859778

Programozási nyelvek
Sztori Kronológia
Ada ALGOL szerelő APL ALAPVETŐ C C++ C# D Delphi COBOL Erlang F# Tovább Fortran megy Haskell Jáva JavaScript Julia Kotlin Selypít Lua MATLAB Célkitűzés-C OCaml Pascal Perl PL/SQL PHP Piton rubin Rozsda Scala UNIX Shell Csevej Gyors Visual Basic .NET Zig
Kategória Listák: kronologikus kategória szerint

ISO szabványok
Listák: ISO szabványok listája Az ISO romanizálások listája Az IEC szabványok listája Kategóriák: Kategória:ISO szabványok Kategória:OSI protokollok
1 -től 9999 -ig	egy 2 3 négy 5 6 7 9 16 31 -0 -egy -2 -3 - négy -5 -6 -7 -nyolc -9 -tíz -tizenegy -12 -13 128 216 217 226 228 233 259 269 296 302 306 428 639 -egy 646 668 690 732 764 796 843 898 1000 1004 1007 1073-1 1413 1538 1745 2014 2015 2022 2108 2145 2146 2281 2709 2711 2788 3029 3103 3166 -egy -2 -3 3297 3307 3602 3864 3901 3977 4031 4157 4217 5218 5775 5776 5964 6166 6344 6346 6425 6429 6438 6523 6709 7001 7002 7098 7185 7388 7498 7736 7810 7811 7812 7813 7816 8000 8217 8571 8583 8601 8632 8652 8691 8807 8820-5 8859 -egy -2 -3 - négy -5 -6 -7 -nyolc -9 -tíz -tizenegy -12 -13 -tizennégy -tizenöt -16 ) 8879 9000 9075 9126 9241 9362 9407 9506 9529 9564 9594 9660 9897 9945 9984 9985 9995
10 000 és 19999 között	10006 10118-3 10160 10161 10165 10179 10206 10303 10303-11 10303-21 10303-22 10303-238 10303-28 10383 10487 10585 10589 10646 10664 10746 10861 10957 10962 10967 11073 11170 11179 11404 11544 11783 11784 11785 11801 11898 11940 11941 11941 (TR) 11992 12006 12164 12182:1998 12207:1995 12207:2008 12234-2 13211 -egy -2 13216 13250 13399 13406-2 13407 13450 13485 13490 13567 13568 13584 13616 14000 14031 14396 14443 14496-10 14496-14 ISO 14575 14644 -egy -2 -3 - négy -5 -6 -7 -nyolc -9 14649 14651 14698 14698-2 14750 14882 14971 15022 15189 15288 15291 15292 15408 15444 15445 15438 15504 15511 15686 15693 15706 15706-2 15707 15897 15919 15924 15926 15926 WIP 15930 16023 16262 16750 17024 17025 17369 17799 17987 18000 18004 18014 18245 18629 18916 19005 19011 19092-1 19092-2 19114 19115 19439 19501:2005 19752 19757 19770 19775-1 19794-5
20000+	20000 20022 21000 21047 21500 21827:2002 22000 23008-2 23270 23360 24613 24707 25964-1 25178 26000 26300 26324 27000-es sorozat 27000 27001 27002 27003 27004 27005 27006 27007 27729 27799 29199-2 29500 31000 32000 38500 42010 50001 80000
Lásd még: Azon cikkek listája, amelyek címe "ISO"-val kezdődik

C++
C++98 C++03 C++11 C++14 C++17 C++20 C++23
Sajátosságok	Funkció túlterhelés Kezelői túlterhelés Sablonok virtuális öröklés Linkek Három szabály HÜVELY SFINAE
Néhány könyvtár	Szabványos könyvtár STL Boost POCO Qt
Fordítók	Borland C++ C++ Builder cfront Csengés GCC Intel C++ fordító Visual C++ nyissa meg a watcomot
befolyásolta	C# D Jáva Felügyelt C++ Rozsda Vala
C++ kategória