C++

Standardidokumenttien saatavuus

Virallinen standardi on saatavissa ISO:lta korvausta vastaan, mutta viimeisin työskentelyluonnos on saatavilla internetistä ilmaiseksi. Virallisessa standardissa on korjattu kirjoitusvirheitä ja lisätty selvennyksiä.

Erot C:hen

Monet C:llä kirjoitetuista ohjelmista ovat myös kelvollista C++:aa. Eivät kuitenkaan kaikki, muun muassa C:n kehittymisen aikana luotujen uusien varattujen sanojen ja tarkemman tyyppitarkistuksen vuoksi.
C:stä poiketen C++ tukee useaa nimiavaruutta.

Standardikirjastot

C++ sisältää Standard Template Library (STL) standardikirjaston.
Standard Template Library sisältää yleisiä ohjelmoijien tarvitsemia säiliöitä (containers), algoritmeja, funktioita ja iteraattoreita. STL toteutus seuraa usein kääntäjän mukana, mutta myös riippumattomia toteutuksia on olemassa.
C++:n standardikirjasto sisältää STL:n lisäksi myös joukon C-kielen standardikirjastoa vastaavista toiminnoista yhteensopivuuden vuoksi.

Polymorfismi

C++ tukee yksinkertaista perintää, abstrakteja pure virtual luokkia, moniperintää sekä virtuaalista moniperintää.

Hello, World! -esimerkkiohjelma

#include <iostream>int main() {
    std::cout << "Hello, world!\n";}
Tämä on yleisesti käytetty esimerkkiohjelma C++-oppaissa. Se tulostaa näytölle tekstin ”Hello, world!” Kuten C:ssä, ohjelma alkaa komennoilla esikääntäjälle, tässä kirjaston liittämisellä #include-käskyllä. Lohkot rajataan aaltosuluilla {}, ja main-funktio suoritetaan aina ensimmäisenä. Ohjaamalla tekstin cout-olioon <<-operaattorilla teksti tulostuu stdout-virtaan (näytölle).
C++:n kielioppi on samantapaista kuin C:n ja Javan. Lauseet päättyvät puolipisteeseen ;, eikä välilyöntejä tai muuta tyhjää tilaa oteta huomioon. Lohkot ympäröidään aaltosulkeilla { }, kommentit aloitetaan /* -merkinnällä ja päätetään */ -merkinnällä. Yhden rivin kommentti merkitään kahdella vinoviivalla //. Kaikki standardikirjaston luokat, funktiot ja globaalit muuttujat ovat std-nimiavaruudessa.

Nimiavaruudet

C++ tukee useaa nimiavaruutta. 
C++17 lisäsi tuen sisäkkäisille nimiavaruuksille, joka mahdollistaa namespace A::B::C {} käytön aiemman namespace A { namespace B { namespace C {}}} sijaan.
Lisäksi kieli tukee nimiavaruuden aliasointia:
namespace foo {
    namespace bar {
         namespace baz {
             int qux = 42;
         }
    }}namespace fbz = foo::bar::baz;int main(){
    std::cout << fbz::qux << '\n';}
C++ tukee myös anonyymejä nimiavaruuksia.
Aaltosuluilla merkittävät lohkot luovat oman nimiavaruuden kaltaisen näkyvyysalueen (engl. scope):
std::string foo = "foo";{
    std::string foo = "foobar";} // sisempi foo tuhotaan tässästd::cout << foo << std::endl; // tulostaa ensimmäisen foo:n arvon

RTTI

Ajonaikainen tyyppitieto (engl. Run-time type information, RTTI) on ominaisuus, jolla välitetyn olion tyyppi voidaan tunnistaa ohjelman ajonaikana.
Tämä mahdollistaa mm. perityn olion tyypin mukaisen käsittelyn.
class Asiakas{public:
    virtual ~Asiakas() {}}class KantaAsiakas : public Asiakas { ... };void tyyppi(Asiakas *p){
     std::cout << typeid(*p).name() << std::endl;

     KantaAsiakas *k = dynamic_cast<KantaAsiakas*>(p);
     if (k != nullptr)
         k->bonus();}

Poikkeuskäsittely

C++ tukee poikkeuksia ja pinon (stack) siivoamista (kuten näkyvyydeltä eli scopesta poistuessa).
try{
     throw "vikatilanne"; // const char *}catch (std::exception &e){
    std::cout << "poikkeus: " << e.what() << std::endl;}catch (...){
    std::cout << "tuntematon poikkeus" << std::endl;}
Poikkeuskäsittelijä valitaan määrittelyjärjestyksessä ja tyypin mukaan.
Ellipsis (kolme pistettä) voi vastaanottaa tyypit, joille ei ole muuta käsittelijää.

Template-mallit

Template-mallit mahdollistavat geneerisen ohjelmoinnin, jossa samoja algoritmeja voidaan käyttää uusille tietotyypeille ilman uutta ohjelmointia.
RAII-esimerkin ohjelmakoodi voidaan muokata geneerisemmäksi käyttämällä template-määrittelyä.
template<typename T> class Vector 
{private:
    T *elem; 
    int sz;public:
    Vector(int s) : elem{new T[s]}, sz{s} // constructor
    {
        for (int i = 0; i != s; ++1) elem[i] = 0;
    }
    ~Vector() { delete [] elem; } // destructor

    T& operator[] (int i) { return elem[i]; }
    int size() const { return sz; }};void fct(int n) 
{
    Vector<double> v(n); // acquire and initialize
    // .. use v ..
    Vector<int> v2(n)
    // .. use v2 ..} // v2 and v destroyed