Нацрт C++0x од марта 2010.

C++0x (у изговору: си плас плас оу екс) је незванични назив новог стандарда програмског језика C++, који је још увек у развојној фази. Намена му је да замени постојећи стандард за C++, ISO/IEC 14882, који је објављен 1998. и ажуриран 2003. Ове претходнице су неформално познате као C++98 и C++03. Нови стандард обухвата неколико додатака у језгру језика и проширује стандардну библиотеку, обухватајући већи део библиотека C++ Technical Report 1 (TR1). Највероватније ће библиотека специјалних математичких функција бити изузетак. Пошто стандард још увек није завршен, овај чланак можда не осликава ажурно стање C++0x, већ нацрт овог међународног стандарда, N3092, који је објављен у марту 2010.

Очекује се да ће комплетирање и објављивање стандарда сачекати крај 2011. године.

Побољшања перформанси током извршавања програма

Наредне карактеристике језика су првенствено направљене да пруже могућност за побољшање рада неког програма. Ово се може тицати уштеде меморије и процесорског времена.

Rvalue референце и размена меморије међу објектима

Rvalue референце омогућавају ефикасно премештање садржаја комплексних структура из једне у другу. Нпр. у стандардном C++-у је могуће да једна функција (f2) оформи низ типа std::vector<T> и врати га функцији која ју је позвала (f1). У том случају ће низ направљен у f2 прво бити потпуно ископиран у одговарајући низ из f1, а потом уништен. Копирање и уништавање низа из f2 је сувишан посао, јер ако низ већ постоји у меморији током f2, нема потребе нити правити његову копију, нити њега брисати. Треба га само на неки начин назад проследити.

У досадашњем C++-у је било могуће да f1 направи свој низ, и достави га f2 на попуњавање. Од C++0x је такође могуће да се низ настао у f2 врати у f1 као Rvalue референца. У том случају ће повратни тип од f2 бити std::vector<T>&&. Да би овако враћена Rvalue референца била успешно прихваћена од објекта типа std::vector<T> из f1, тај тип мора имати дефинисан тзв. конструктор премештања (енгл. move constructor), који преузима све из објекта на кога је добио Rvalue референцу, и оставља га празним. Уколико овакав конструктор није написан, бива коришћен стари приступ копирања и брисања.

Из безбедносних разлога језик не дозвољава једноставно остављање rvalue референци на објекте којима је додељено име. Да би се добила rvalue референца на овакав објекат, треба користити шаблон функције std::move<T>().

Генерализоване константне вредности

У стандардном C++ није могуће да се функције, које враћају константну вредност, користе у изразима који морају бити недвосмислено константни још током компајлирања. Овакав израз је нпр. дужина статички дефинисаног низа или садржај енумерација. На пример:

const int DajPet() {return 5;}

int niz[DajPet() + 7]; // Требало би да направи статички низ са
                       // 12 елемената. Не ради у C++.

Ово није могуће у C++-у, јер се вредност коју функција DajPet() враћа не третира као константа, иако она то у ствари јесте. C++0x има нову кључну реч, constexpr, којом програмер може да назначи да нека функција враћа константну вредност:

constexpr int DajPet() {return 5;}

Након ове назнаке, могуће је функцију користити као било коју бројевну константу. Предност оваквог приступа је у томе што оваквим дефинисањем функције њена вредност бива одређивана и употребљавана током компајлирања програма, а не током његовог извршавања, што значи уштеду процесорског времена.

Алтернатива овоме у C++-у су константни изрази, дефинисани нпр. са:

#define DajPet 5

или

const int DajPet = 5;

Редефинисање POD-типова

У стандардном C++-у, структура (struct) мора да испуни бројна правила да би била сматрана за POD-тип (енгл. plain old data). Добар разлог за постојање што више оваквих типова је компатибилност са C-ом. Пошто је списак правила дефинисан у C++03 био превише рестриктиван, у C++0x се ова правила опуштају.

Сваки тип дефинисан као класа (class) или структура се сматра POD-типом ако је тривијална, написана према стандардном обрасцу (енгл. standard layout) и ако су све њене енкапсулиране чланице тривијалне.

Класа или структура је тривијална, ако:

1. Има тривијалан подразумевани конструктор (енгл. default constructor).
2. Има тривијалан копи-конструктор (енгл. copy constructor).
3. Има тривијалан оператор доделе (енгл. assignment operator).
4. Има тривијалан деструктор (енгл. destructor), који није виртуелан.

Класа или структура је написана према стандардном обрасцу, ако:

1. Садржи само нестатичке, елементе, који су такође написани према стандардном обрасцу.
2. Има иста права приступа (public, private, protected) свим нестатичким чланицама.
3. Нема виртуелних функција.
4. Нема виртуелних базних класа.
5. Све базне класе су јој такође написане према стандардном обрасцу
6. Нема базних класа истог типа, дефинисане као прве не-статичне чланице.
7. У целој хијерархији се може наћи само једна класа са нестатичним чланицама. Важи или-или:
   1. Нема базних класа са нестатичним чланицама
   2. Нема нестатичних података у крајње изведеним класама и има највише једну базну класу са нестатичним чланицама.

Побољшања времена компајлирања

У стандардном C++-у имплементација шаблона бива инстанцирана у свакој јединици програма у којој се користе, што повећава време компајлирања. C++0x омогућава да се имплементације шаблона означе као екстерне (речју extern), што означава да ту имплементација не треба инстанцирати у тој јединици, већ је потражити у другој и користити тамошњу инстанцу. Дакле, садашње инстанце шаблона:

template class std::vector<T>;

Би са овим изгледале овако:

extern template class std::vector<T>;

Побољшања употребљивости језика

Ова побољшања су првенствено направљена да би олакшала употребу језика тј. унапређују сигурност руковања типовима, умањују понављање кода, отежавају јављање грешака итд.

Спискови аргумената

Стандардни C++ од C-а позајмљује концепт спискова аргумената променљиве дужине (енгл. variable argument list, va_list). Имплементација овог је захтевала много више кода него нпр. у Јави, и није била примењива на типове који нису одговарали C++03 дефиницији POD-типова.

C++0x уводи нови концепт, код кога се ови спискови аргумената везују за шаблон std::initializer_list.

Нпр, уместо досадашње декларације функције са:

void UzmiNiz(int n, ...);

И извлачења пристиглих аргумената помоћу va_list, va_arg и va_end, C++0x користи:

void UzmiNiz(std::initializer_list<float> spisak);

При чему променљива spisak садржи подаке о броју променљивих, а позив функције изгледа овако:

UzmiNiz({1.2f, -3.45f, 5.2f});