**C++11**, (ent. *C++0x*), on ISO:n 12.8.2011 hyväksymä C++-ohjelmointikielen standardi ISO/IEC 14882:2011. Standardi korvasi aiemmat ISO/IEC 14882:1998 (C++98) ja ISO/IEC 14882:2003 (C++03) standardiversiot. 

Nimessä esiintyvä 11 tulee yleisen nimeämiskäytännön mukaisesti standardin julkaisuvuodesta. C++0x-tunnusta käytettiin työskentelyvaiheessa, koska valmistumisvuodesta ei ollut varmuutta, mutta sen uskottiin valmistuvan ennen vuotta 2010.

Standardin on korvannut C++14 standardi ISO/IEC 14882:2014, joka hyväksyttiin 18. elokuuta 2014.

C++11 lisäsi itse kieleen useita ominaisuuksia sekä laajentaa C++:n standardikirjastoa STL:a. Standardikirjaston laajennos käsittää suurimman osan aikaisemmasta C++ Technical Report 1:stä (TR1).

Muutokset edellisestä standardista
----------------------------------

Uusi standardi laajentaa varsinaista kieltä sekä sen standardikirjastoa.
Pääsuuntaviivat uutta versiota suunniteltaessa olivat: 

* Säilyttää stabiilius sekä yhteensopivuus C++98:n ja mahdollisuuksien mukaan C:n kanssa;
* Mahdollisuuksien mukaan lisätä uudet ominaisuudet standardikirjastoon itse kieleen lisäämisen sijasta;
* Tehdä muutoksia, jotka ohjaavat käyttäjää oikeaan toteutustekniikkaan ja -tyyliin;
* Tukea systeemien ja kirjastojen suunnittelua pelkän uusien ominaisuuksien esittelyn sijaan;
* Parantaa tyypityksen turvallisuutta tarjoamalla aiemmin turvattomille tekniikoille vaihtoehtoja;
* Parantaa suorituskykyä ja laitteistorajapinnan kanssa kommunikointia;
* Tarjota oikeita ratkaisuja reaalimaailman ongelmiin;
* Toteuttaa niin sanottua "zero-overhead"-periaatetta;
* Tehdä C++:sta helposti opiskeltava kieli ottamatta kuitenkaan pois ominaisuuksia, joita kokeneemmat ohjelmoijat tarvitsevat;

Aloittelijoiden huomioon ottaminen koettiin tärkeäksi, koska ohjelmoijista suurin osa tulee aina olemaan aloittelijoita, ja koska suurin osa heistä tuskin koskaan tulee perehtymään C++:aan syvällisemmin.

Tyyppiturvallinen nolla-osoitin
-------------------------------

Kieleen on lisätty tyyppiturvallinen `nullptr` määrittely.

Vanha `NULL` -makro usein käsitellään `int`-tyyppinä eikä osoittimena. Vanhempi tapa voi hämmentää ajonaikaista tyyppimekanismia kutsumaan väärää metodia.

Käyttöesimerkki:

```
int a = 0;
int \*p = nullptr;

p = &a;
(\*p) = 42;

```

Vakiolauseke
------------

Vakiolauseke (`constexpr`) määrittää, että lauseke on mahdollista arvioida käännösaikana.

Esimerkki:

```
const double pi = 3.14;
constexpr double pi\_mul(int n) { return n \* pi; }

```

Käyttö olettaa että parametrina annettavat arvot ovat käännösaikana tunnettuja literaaleja. C++14 laajentaa vakiolausekkeen määrittelyä.

Yhdenmukaistettu alustaminen
----------------------------

Olioiden alustamista on yhdenmukaistettu muutoksilla määrittelyyn.

Esimerkiksi kolmen alkion vektorin alustaminen arvoilla:

```
std::vector<float> v = {0.1, 0.2, 1.0};

```

Anonyyminen vektorin alustaminen ja välittäminen funktiolle:

```
myfunction( std::vector<float>{0.1, 0.2, 1.0} );

```

Lambda-lausekkeet
-----------------

Lambda-lausekkeet ovat paikallisia nimettömiä funktioita, joita voidaan määrittää funktion tai lausekkeen sisällä.

Rajatun alueen toistorakenne
----------------------------

Perinteisten C-kielen toistorakenteiden vaihtoehdoksi on lisätty automatisoitu vaihtoehto. Uudempi menetelmä vähentää tyypillisen koodin toistuvaa kirjoittamista.

Tietorakenteissa olevien arvojen käsittelyä voidaan yksinkertaistaa seuraavasti:

```
std::vector<int> v = {0, 1, 2, 3, 4, 5};
for (auto i : v)
{
 std::cout << i << std::endl;
}

```

Delegoiva konstruktori
----------------------

Delegoiva konstruktori vähentää ohjelmakoodin toistoa useiden konstruktorien yhteydessä.

```
class Testi
{
private:
 std::string m\_s;
 int m\_i;
public:
 Testi(std::string s, int i) : m\_s(s), m\_i(i) {}
 Testi(int i) : Testi("testi", i) {}
};

```

Atomiset operaatiot
-------------------

Standardi lisää standardikirjastoon atomisuuden toiminnot.

Esimerkki käyttötapauksesta:

```
std::atomic<long> almuuttuja;

almuuttuja = 0; // asettaa arvoon 0

// lisää muuttujaan arvon 42 ja palauttaa uuden arvon
long uusiarvo = almuuttuja.fetch\_add(42);

```

Ohjelmointikielen käyttämä tekninen toteutustapa voi riippua käytetystä suorittimesta.

Säikeistyksen tuki
------------------

Monisäikeistykselle on lisätty alustariippumatonta tukea määrittelyyn. Näin ollen ohjelmakoodin siirtäminen helpottuu vähemmillä muutoksilla.

Standardikirjastossa on `std::thread` säikeiden luomiseen ja käsittelyyn. Parametrina tälle annetaan funktio-objekti (osoite säikeen suorituksen alkupaikkaan).

Lisäksi `thread_local` avainsanalla voi määritellä säiekohtaisia muuttujia. 

Synkronointitukea on atomisien operaatioiden lisäksi käytettävissä luokilla `std::mutex` ja `std::lock_guard`.

Synkronointiin on myös aikarajoitettu `std::timed_mutex` sekä rekursion salliva `std::recursive_mutex` ja näiden yhdistelmä `std::recursive_timed_mutex`.

Tuple-tyyppi
------------

Tuple on template-pohjainen vaihtoehto C-kielen `struct`-tyypille.

```
typedef std::tuple <int, string, double> tTuple;
tTuple data(42, "heippa", 3.14);

```

Vastaava tietotyyppi on aiemmin esiintynyt esimerkiksi rinnakkaisohjelmointiin kehitetyssä Alef -kielessä.

Älyosoittimet
-------------

Standardikirjastoon on lisätty älyosoittimia eri tarkoituksiin:

* `std::weak_ptr`
* `std::shared_ptr` - viitelaskenta
* `std::unique_ptr`

Siirto-operaattorit
-------------------

Tyypillisen *copy-delete* menettelyn sijaan on mahdollista käyttää tehokkaampaa siirto-operaattoria (engl. *move*):

```
class MyContainer
{
// ...
MyContainer & operator=(MyContainer && other)
{
 if (this != &other) 
 {
 // ...
 }
 return \*this;
}

```

Menetelmä välttää nk. *deep-copy* toiminnon, joka voi olla raskas käytössä.

Katso myös
----------

* Technical Report 1 - Muistio C++11 versioon suunnitelluista lisäyksistä

Lähteet
-------

1. ↑  ISO/IEC 14882:2011 ISO. Viitattu 25.1.2017.
2. ↑  nullptr, the pointer literal *en.cppreference.com*. Viitattu 6.2.2017.
3. 1 2  A name for the null pointer: nullptr (revision 4) *open-std.org*. Viitattu 6.2.2017.
4. ↑  constexpr specifier *en.cppreference.com*. Viitattu 6.2.2017.
5. ↑  list initialization *en.cppreference.com*. Viitattu 6.2.2017.
6. ↑  Lambda expressions and closures for C++ (PDF) *open-std.org*.  26.2.2006. Viitattu 14.6.2023. (englanniksi)
7. ↑  Range-based for loop *en.cppreference.com*. Viitattu 6.2.2017.
8. ↑  Constructors and member initializer lists *en.cppreference.com*. Viitattu 6.2.2017.
9. ↑  Atomic operations library *en.cppreference.com*. Viitattu 9.2.2017.
10. ↑  C++ Atomic Types and Operations *open-std.org*. Viitattu 9.2.2017.
11. ↑  std::mutex *en.cppreference.com*. Viitattu 21.2.2017.
12. ↑  Thread support library *en.cppreference.com*. Viitattu 21.2.2017.
13. ↑  std::tuple *en.cppreference.com*. Viitattu 6.2.2017.
14. ↑  Winterbottom, Phil: Alef Language Reference Manual *doc.cat-v.org*. Viitattu 20.2.2017.
15. ↑  Kieras, David: Using C++11’s Smart Pointers *umich.edu*. Viitattu 6.2.2017.
16. ↑  std::shared\_ptr *en.cppreference.com*. Viitattu 6.2.2017.
17. ↑  Move assignment operator *en.cppreference.com*. Viitattu 6.2.2017.

Aiheesta muualla
----------------

* Viimeinen työskentelyluonnos (*working draft*) C++11 -standardiin:
* C++11 vinkkejä