Просмотр кода страницы C++

{{чистить|дата=2025-06-17}}
{{другие значения|C}}
{{см. также|Си (язык программирования)}}
{{Язык программирования
| семантика = [[Мультипарадигменный язык программирования|мультипарадигменный]]: [[объектно-ориентированное программирование|объектно-ориентированное]], [[обобщённое программирование|обобщённое]], [[процедурное программирование|процедурное]], [[метапрограммирование]]
| система типов = [[статическая типизация|статическая]]
| реализации = [[GNU Compiler Collection|GNU C++]], [[Microsoft Visual C++]], [[Intel C++ compiler]], [[Open64|Open64 C++ Compiler]], [[Clang]], {{нп5|Comeau C/C++}}, [[C++ Builder|Embarcadero C++ Builder]], [[Open Watcom|Watcom C++ compiler]], [[Digital Mars]] C++, [[Oracle Solaris Studio]] C++ compiler, Turbo C++
| диалекты = ISO/IEC 14882 C++
| тип = [[Компилируемый язык программирования|компилируемый]]
}}
'''{{Ltn|C}}++''' (читается ''си-плюс-плюс''<ref>{{книга |автор=Губина Г. Г. |заглавие=Компьютерный английский. Ч. I. Computer English. Part I. Учебное пособие |ответственный= |ссылка=https://books.google.ru/books?id=RcrhAwAAQBAJ&pg=PA385 |место= |издательство= |год= |том= |страниц= |страницы=385 |isbn= |ref= |archive-date=2017-12-03 |archive-url=https://web.archive.org/web/20171203224644/https://books.google.ru/books?id=RcrhAwAAQBAJ&pg=PA385 }}</ref><ref>{{cite web|url=http://www.stroustrup.com/bs_faq.html#name|title=Bjarne Stroustrup's FAQ|quote=The name C++ (pronounced "see plus plus")|date=Ocober 1, 2017|publisher=Bjarne Stroustrup|lang=en|access-date=2017-12-04|archive-date=2016-02-06|archive-url=https://web.archive.org/web/20160206214150/http://www.stroustrup.com/bs_faq.html#name|url-status=live}}</ref>) — [[Компилируемый язык программирования|компилируемый]], [[Статическая типизация|статически типизированный]] [[язык программирования]] общего назначения.

Является [[Мультипарадигменный язык программирования|мультипарадигменным языком программирования]]: поддерживаются такие парадигмы, как [[процедурное программирование]], [[объектно-ориентированное программирование]], [[обобщённое программирование]], [[функциональное программирование]]. Язык имеет богатую стандартную библиотеку, которая включает в себя распространённые контейнеры и [[алгоритм]]ы, ввод-вывод, регулярные выражения, поддержку [[многопоточность|многопоточности]] и другие возможности. C++ сочетает свойства как [[Высокоуровневый язык программирования|высокоуровневых]], так и [[Низкоуровневый язык программирования|низкоуровневых языков]]{{sfn|Шилдт|1998}}{{sfn|Страуструп|1999|loc=2.1. Что такое C++?|с=57}}. В сравнении с его предшественником — языком [[Си (язык программирования)|C]] — наибольшее внимание уделено поддержке [[объектно-ориентированное программирование|объектно-ориентированного]] и [[обобщённое программирование|обобщённого программирования]]{{sfn|Страуструп|1999|loc=2.1. Что такое C++?|с=57}}, а также переменных.

C++ широко используется для разработки программного обеспечения, являясь одним из самых популярных языков программирования<ref group="мнения" name="langpop">{{Cite web |url=http://www.langpop.com/|title=Programming Language Popularity|date=2009|access-date=2009-01-16|archive-url=https://web.archive.org/web/20090116080326/http://www.langpop.com/ |archive-date=2009-01-16|url-status=dead}}</ref><ref group="мнения" name="tiobe">{{Cite web|url=http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html|title=TIOBE Programming Community Index|date=2009|access-date=2009-05-06|archive-url=https://web.archive.org/web/20090504181627/http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html|archive-date=2009-05-04|url-status=dead}}</ref>. Область его применения включает создание [[Операционная система|операционных систем]], разнообразных прикладных программ, [[драйвер]]ов устройств, приложений для встраиваемых систем, высокопроизводительных серверов, а также [[Компьютерная игра|компьютерных игр]]. Существует множество реализаций языка C++, как бесплатных, так и коммерческих и для различных платформ. Например, на платформе [[x86]] это [[GNU Compiler Collection|GCC]], [[Clang]], [[Visual C++]], [[Intel C++ Compiler]], [[Embarcadero C++ Builder|Embarcadero (Borland) C++ Builder]] и другие. C++ оказал огромное влияние на другие языки программирования, в первую очередь на [[Java]] и [[C Sharp|C#]].

Синтаксис C++ унаследован от языка [[Си (язык программирования)|Си]]. Изначально одним из принципов разработки было сохранение совместимости с Си. Тем не менее, C++ не является в строгом смысле надмножеством Си: множество программ, которые могут одинаково успешно транслироваться как [[компилятор]]ами Си, так и компиляторами C++, довольно велико, но не включает все возможные программы на Си.

== История ==
{| class="wikitable"
! Исторический этап развития<ref>Стэнли Липпман, [http://msdn.microsoft.com/en-us/magazine/cc163681.aspx Pure C++: Hello, C++/CLI] {{Wayback|url=http://msdn.microsoft.com/en-us/magazine/cc163681.aspx |date=20110606084459 }}{{ref|en}}</ref> !! Год
|-
| Язык [[BCPL]] || [[1966]]
|-
| Язык [[Би (язык программирования)|Би]] (оригинальная разработка [[Кен Томпсон|Томпсона]] под [[UNIX]]) || [[1969]]
|-
| Язык [[Си (язык программирования)|Си]] || [[1972]]
|-
| «Си с классами» || [[1980]]
|-
| C84 || [[1984]]
|-
| [[Cfront]] (выпуск E) || [[1984]]
|-
| Cfront (выпуск 1.0) || [[1985]]
|-
| Множественное/виртуальное наследование || [[1988]]
|-
| Обобщённое программирование ([[Шаблоны C++|шаблоны]]) || [[1991]]
|-
| ANSI C++ / ISO-C++ || [[1996]]
|-
| [[C++98]] (ISO/IEC 14882:1998) || [[1998]]
|-
| [[C++03]] (ISO/IEC 14882:2003) || [[2003]]
|-
| [[C++/CLI]] || [[2005]]
|-
| [[C++ Technical Report 1|TR1]] || [[2005]]
|-
| [[C++11]] || [[2011]]
|-
| [[C++14]] || [[2014]]
|-
| [[C++17]] || [[2017]]
|-
|[[C++20]] || [[2020]]
|-
|[[C++23]] || [[2023]]
|-
|[[C++26]]
|{{TBA}}
|}

=== Создание ===
[[Язык программирования|Язык]] возник в начале [[1980-е годы|1980-х годов]], когда сотрудник фирмы [[Bell Labs]] [[Страуструп, Бьёрн|Бьёрн Страуструп]] придумал ряд усовершенствований к языку [[Си (язык программирования)|Си]] под собственные нужды{{sfn|Страуструп|1999|loc=1.4. Исторические замечания|с=46}}. Когда в конце [[1970-е годы|1970-х годов]] Страуструп начал работать в Bell Labs над задачами теории очередей (в приложении к моделированию телефонных вызовов), он обнаружил, что попытки применения существовавших в то время языков моделирования оказались неэффективными, а применение высокоэффективных машинных языков слишком сложно из-за их ограниченной выразительности. Так, язык [[Симула]] имеет такие возможности, которые были бы очень полезны для разработки большого программного обеспечения, но работает слишком медленно, а язык [[BCPL]] достаточно быстр, но слишком близок к языкам низкого уровня и не подходит для разработки большого программного обеспечения.

Вспомнив опыт своей диссертации, Страуструп решил дополнить язык C (преемник BCPL) возможностями, имевшимися в языке Симула. Язык Си, будучи базовым языком системы [[Unix]], на которой работали компьютеры Bell, является быстрым, многофункциональным и переносимым. Страуструп добавил к нему возможность работы с классами и объектами. В результате практические задачи моделирования оказались доступными для решения как с точки зрения времени разработки (благодаря использованию cимулаподобных классов), так и с точки зрения времени вычислений (благодаря быстродействию C). В первую очередь в C были добавлены классы (с [[Инкапсуляция (программирование)|инкапсуляцией]]), наследование классов, строгая проверка типов, inline-функции и [[Аргумент по умолчанию|аргументы по умолчанию]]. Ранние версии языка, первоначально именовавшегося «C with classes» («Си с классами»), стали доступны с [[1980 год]]а.

Разрабатывая «Си с классами», Страуструп написал программу [[cfront]] — [[транслятор]], перерабатывающий исходный код своего языка в исходный код простого Си. Это позволило работать над новым языком и использовать его на практике, применяя уже имевшуюся в unix-инфраструктуру для разработки на Си. Новый язык неожиданно для автора приобрёл большую популярность среди коллег и вскоре Страуструп уже не мог лично поддерживать его, отвечая на тысячи вопросов.

К 1983 году в язык были добавлены новые возможности, такие как виртуальные функции, перегрузка функций и операторов, ссылки, константы, пользовательский контроль над управлением свободной памятью, улучшенная проверка типов и новый стиль комментариев (<code>//</code>). Получившийся язык уже перестал быть просто дополненной версией классического C и был переименован из ''C с классами'' в «C++». Его первый коммерческий выпуск состоялся в октябре [[1985 год]]а.

До начала официальной стандартизации язык развивался в основном силами Страуструпа в ответ на запросы программистского сообщества. Функцию стандартных описаний языка выполняли написанные Страуструпом печатные работы по C++ (описание языка, справочное руководство и так далее). Лишь в [[1998 год]]у был ратифицирован международный стандарт языка C++: ISO/IEC 14882:1998 «Standard for the C++ Programming Language»; после принятия технических исправлений к стандарту в [[2003 год]]у — следующая версия этого стандарта — ISO/IEC 14882:2003<ref>{{Cite web |url=http://www.open-std.org/jtc1/sc22/wg21/docs/standards |title=C++ — Standards |access-date=2010-11-14 |archive-date=2010-11-20 |archive-url=https://web.archive.org/web/20101120215619/http://www.open-std.org/jtc1/sc22/wg21/docs/standards |url-status=live }}</ref>.

=== Развитие и стандартизация языка ===
В [[1985 год]]у вышло первое издание «[[Язык программирования C++ (книга)|Языка программирования C++]]», обеспечивающее первое описание этого языка, что было чрезвычайно важно из-за отсутствия официального стандарта. В [[1989 год]]у состоялся выход C++ версии 2.0. Его новые возможности включали множественное наследование, абстрактные классы, статические функции-члены, функции-константы и защищённые члены. В [[1990 год]]у вышло «Комментированное справочное руководство по C++», положенное впоследствии в основу стандарта. Последние обновления включали шаблоны, исключения, пространства имён, новые способы приведения типов и булевский тип. В качестве основы для хранения и доступа к обобщённым алгоритмам была выбрана [[Стандартная библиотека шаблонов|Стандартная библиотека шаблонов (STL)]], разработанная [[Степанов, Александр Александрович (учёный)|Александром Степановым]] и {{Не переведено|Ли, Менг|Менг Ли|en|Meng Lee}}.

[[Стандартная библиотека C++]] также развивалась вместе с ним. Первым добавлением к стандартной библиотеке C++ стали потоки ввода-вывода, обеспечивающие средства для замены традиционных функций C <code>printf</code> и <code>scanf</code>. Позднее самым значительным развитием стандартной библиотеки стало включение в неё [[Стандартная библиотека шаблонов|Стандартной библиотеки шаблонов]].

* Официальная стандартизация языка началась в [[1998 год]]у, когда был опубликован стандарт языка ISO/IEC 14882:1998 (известный как C++98)<ref>{{Cite web
 | author  = Bjarne Stroustrup.
 | title  = C++ Glossary
 | url  = http://www.research.att.com/~bs/glossary.html
 | access-date  = 2007-06-08
 | archive-url  = https://web.archive.org/web/20110501150638/http://www2.research.att.com/~bs/glossary.html
 | archive-date  = 2011-05-01
 | url-status  = dead
 }}</ref>, разработанный комитетом по стандартизации C++ ([[International Organization for Standardization|ISO]]/[[International Electrotechnical Commission|IEC]] JTC1/SC22/WG21 working group). Стандарт C++ не описывал способов именования объектов, некоторых деталей обработки исключений и других возможностей, связанных с деталями реализации, что делает несовместимым объектный код, созданный различными компиляторами. Однако для этого третьими лицами создано множество стандартов для конкретных [[Архитектура компьютера|архитектур]] и [[операционная система|операционных систем]].
* В [[2003 год]]у опубликован стандарт C++ ISO/IEC 14882:2003, где исправлены выявленные ошибки и недочёты предыдущей версии стандарта. В [[2005 год]]у опубликован отчёт Library Technical Report 1 (кратко называемый TR1). Не являясь официально частью стандарта, отчёт описывает расширения стандартной библиотеки, которые, по мнению авторов, должны были быть включены в следующую версию стандарта. Степень поддержки TR1 улучшается почти во всех поддерживаемых компиляторах языка C++.
* С [[2009 год]]а велась работа по обновлению предыдущего стандарта. Предварительная версия называлась C++09, в следующем году её переименовали в C++0x. Стандарт был опубликован в 2011 году под названием [[C++11]]. В него включены дополнения в ядре языка и расширение стандартной библиотеки, в том числе большая часть TR1.
* Следующая версия стандарта, [[C++14]], вышла в августе 2014 года. Она содержит в основном уточнения и исправления ошибок предыдущей версии.
* Стандарт [[C++17]], опубликованный в декабре 2017 года, включил в стандартную библиотеку параллельные версии стандартных алгоритмов и удалил некоторые устаревшие и крайне редко используемые элементы.
* Последняя стабильная на текущий момент действующая версия стандарта — [[C++20]]. Помимо прочего, он содержит принципиальное новшество — поддержку модулей.
* Стандарт C++23 на данный момент активно обсуждается комитетом ISO.

C++ продолжает развиваться, чтобы отвечать современным требованиям. Одна из групп, разрабатывающих язык C++ и направляющих комитету по стандартизации C++ предложения по его улучшению — это [[Boost]], которая занимается, в том числе, совершенствованием возможностей языка путём добавления в него особенностей [[Метапрограммирование|метапрограммирования]].

Никто не обладает правами на язык C++, он является свободным. Однако сам документ стандарта языка (за исключением черновиков) не доступен бесплатно<ref>Where do I find the current C or C++ standard documents? http://stackoverflow.com/questions/81656/where-do-i-find-the-current-c-or-c-standard-documents {{Wayback|url=http://stackoverflow.com/questions/81656/where-do-i-find-the-current-c-or-c-standard-documents |date=20151129194611 }}</ref>. В рамках процесса стандартизации ISO выпускает несколько видов изданий. В частности, технические доклады и технические характеристики публикуются, когда «видно будущее, но нет немедленной возможности соглашения для публикации международного стандарта». До 2011 года было опубликовано три технических отчёта по C++: TR 19768: 2007 (также известный как C++, Технический отчёт 1) для расширений библиотеки в основном интегрирован в C++11, TR 29124: 2010 для специальных математических функций, и TR 24733: 2011 для десятичной арифметики с плавающей точкой. Техническая спецификация DTS 18822:. 2014 (по файловой системе) была утверждена в начале 2015 года, и остальные технические характеристики находятся в стадии разработки и ожидают одобрения<ref>See a list at http://en.cppreference.com/w/cpp/experimental {{Wayback|url=http://en.cppreference.com/w/cpp/experimental |date=20151118051831 }} Visited 5 January 2015.</ref>.

В марте 2016 года в России была создана рабочая группа [[РГ21 C++]]. Группа была организована для сбора предложений к стандарту C++, отправки их в комитет и защиты на общих собраниях Международной организации по стандартизации (ISO)<ref name="sozd">{{Cite web|url=http://www.iksmedia.ru/news/5298228-Yandeks-sozdaet-rabochuyu-gruppu.html|title=Яндекс организует рабочую группу по стандартизации языка C++|lang=ru|access-date=2018-08-29|publisher=ИКС Медиа|archive-date=2018-08-29|archive-url=https://web.archive.org/web/20180829212016/http://www.iksmedia.ru/news/5298228-Yandeks-sozdaet-rabochuyu-gruppu.html|url-status=live}}</ref>.

=== История названия ===
Имя языка, полученное в итоге, происходит от оператора унарного постфиксного ''[[инкремент]]а'' C <code>++</code> (увеличение значения переменной на единицу). Имя C+ не было использовано потому, что является синтаксической ошибкой в [[Си (язык программирования)|C]] и, кроме того, это имя было занято другим языком. Язык также не был назван D, поскольку ''«является расширением C и не пытается устранять проблемы путём удаления элементов C»''{{sfn|Страуструп|1999|loc=1.4. Исторические замечания|с=46}}.

=== Философия C++ ===
В книге «Дизайн и эволюция C++»{{sfn|Страуструп, Дизайн и эволюция C++|2007}} [[Бьёрн Страуструп]] описывает принципы, которых он придерживался при проектировании C++. Эти принципы объясняют, почему C++ именно такой, какой он есть. Некоторые из них:

* Получить универсальный язык со статическими типами данных, эффективностью и переносимостью языка C.
* Непосредственно и всесторонне поддерживать множество стилей программирования, в том числе [[процедурное программирование]], [[абстракция данных|абстракцию данных]], [[объектно-ориентированное программирование]] и [[обобщённое программирование]].
* Дать программисту свободу выбора, даже если это даст ему возможность выбирать неправильно.
* Максимально сохранить совместимость с C, тем самым делая возможным лёгкий переход от программирования на C.
* Избежать разночтений между C и C++: любая конструкция, допустимая в обоих языках, должна в каждом из них обозначать одно и то же и приводить к одному и тому же поведению программы.
* Избегать особенностей, которые зависят от платформы или не являются универсальными.
* «Не платить за то, что не используется» — никакое языковое средство не должно приводить к снижению производительности программ, не использующих его.
* Не требовать слишком усложнённой среды программирования

== Обзор языка ==
Стандарт C++ состоит из двух основных частей: описание ядра языка и описание стандартной библиотеки.

Первое время язык развивался вне формальных рамок, спонтанно, по мере встававших перед ним задач. Развитию языка сопутствовало развитие [[кросс-компилятор]]а [[cfront]]. Новшества в языке отражались в изменении номера версии кросс-компилятора. Эти номера версий кросс-компилятора распространялись и на сам язык, но применительно к настоящему времени речь о версиях языка C++ не ведут. Лишь в 1998 году язык стал стандартизированным.

* C++ поддерживает как комментарии в стиле C (<code>/* комментарий */</code>), так и однострочные (<code>// вся оставшаяся часть строки является комментарием</code>), где <code>//</code> обозначает начало комментария, а ближайший последующий символ новой строки, который не предварён символом <code>\</code> (либо эквивалентным ему обозначением <code>??/</code>), считается окончанием комментария. Плюс этого комментария в том, что его не обязательно заканчивать, то есть обозначать окончание комментария.
* Спецификатор <code>inline</code> для функций. Функция, определённая внутри тела класса, является inline по умолчанию. Данный спецификатор является подсказкой компилятору и может встроить тело функции в код вместо её непосредственного вызова.
* Квалификаторы <code>const</code> и <code>volatile</code>. В отличие от С, где <code>const</code> обозначает только доступ на чтение, в C++ переменная с квалификатором <code>const</code> должна быть инициализирована. <code>volatile</code> используется в описании переменных и информирует компилятор, что значение данной переменной может быть изменено способом, который компилятор не в состоянии отследить. Для переменных, объявленных <code>volatile</code>, компилятор не должен применять средства оптимизации, изменяющие положение переменной в памяти (например, помещающие её в регистр) или полагающиеся на неизменность значения переменной в промежутке между двумя присваиваниями ей значения.<!-- В многоядерной системе <code>volatile</code> помогает избегать [[Барьер памяти|барьеров памяти]] 2-го типа{{нет АИ|31|05|2013}}.-->
* [[Пространство имён (программирование)#C++|Пространства имён]] (<code>namespace</code>). Пример:
<source lang="cpp" line="1">
namespace foo {
    const int x = 5; // константа
    void t() {} // функция
    namespace bar { // пространство имён в пространстве имён
        float b = 2.2;
    }
}


int main() {
    const int y = foo::x;
    y; // 5
    foo::t(); // вызов функции из пространства имён "foo"
    foo::bar::b; // 2.2
    
    return 0;
}
</source>
Специальным случаем является безымянное пространство имён. Все имена, описанные в нём, доступны только в текущей единице трансляции и имеют локальное связывание. Пространство имён <code>std</code> содержит в себе стандартные библиотеки C++, пространство имён '''chrono''' содержит функции для работы с единицами времени из с chrono.
* Для работы с памятью введены операторы <code>new</code>, <code>new[]</code>, <code>delete</code> и <code>delete[]</code>. В отличие от библиотечных malloc и free, пришедших из C, данные операторы производят инициализации объекта. Для классов — это вызов конструктора, для [[Простая структура данных|POD]]-типов инициализацию можно либо не проводить(<code>new Pod;</code>) либо провести инициализацию нулевыми значениями (<code>new Pod(); new Pod {};</code>).

=== Типы ===
В C++ доступны следующие встроенные типы. Типы C++ практически полностью повторяют [[типы данных в C]]:
* символьные: <code>char</code>, <code>wchar_t</code>, <code>char16_t</code> и <code>char32_t</code>, в стандарте [[C++11]] и <code>char8_t</code> в стандарте [[C++20]]);
* целочисленные знаковые: <code>signed char</code>, <code>short int</code>, <code>int</code>, <code>long int</code> (и <code>long long</code>, в стандарте [[C++11]]);
* целочисленные беззнаковые: <code>unsigned char</code>, <code>unsigned short int</code>, <code>unsigned int</code>, <code>unsigned long int</code> (и <code>unsigned long long</code>, в стандарте [[C++11]]);
* с [[Число с плавающей запятой|плавающей точкой]]: <code>float</code>, <code>double</code>, <code>long double</code>;
* логический: <code>bool</code>, имеющий значения либо <code>true</code>, либо <code>false</code>.

Операции сравнения возвращают тип <code>bool</code>. Выражения в скобках после <code>if</code>, <code>while</code> [[Приведение типа#Неявное приведение|приводятся к типу]] <code>bool</code><ref>ISO/IEC 14882:1998, раздел 6.4, пункт 4: «The value of a ''condition'' that is an initialized declaration in a statement other than a <code>switch</code> statement is the value of the declared variable implicitly converted to <code>bool</code> … The value of a ''condition'' that is an expression is the value of the expression, implicitly converted to <code>bool</code> for statements other than <code>switch</code>; if that conversion is ill-formed, the program is ill-formed».</ref>.

Язык ввёл понятие ссылок, а со стандарта C++11 — ''rvalue''-ссылки и [[передаваемая ссылка|передаваемые ссылки]] ({{lang-en|forwarding reference}}; см. [[Ссылка (C++)]]).

C++ добавляет к C объектно-ориентированные возможности. Он вводит классы, которые обеспечивают три самых важных свойства [[объектно-ориентированное программирование|ООП]]: [[Инкапсуляция (программирование)|инкапсуляцию]], [[наследование (программирование)|наследование]] и [[полиморфизм (программирование)|полиморфизм]].

В стандарте C++ под классом (class) подразумевается пользовательский тип, объявленный с использованием одного из ключевых слов <code>class</code>, <code>struct</code> или <code>union</code>, под структурой (structure) подразумевается класс, определённый через ключевое слово <code>struct</code>, и под объединением (union) подразумевается класс, определённый через ключевое слово <code>union</code>. В зависимости от использованного ключевого слова меняются также и некоторые свойства самого класса. Например, в классе, объявленным через <code>struct</code>, члены без вручную прописанного модификатора доступа будут по умолчанию иметь публичный уровень доступа, а не приватный.

В теле определения класса можно указать как объявления функций, так и их определение. В последнем случае функция является встраиваемой (<code>inline</code>). Нестатические функции-члены могут иметь квалификаторы <code>const</code> и <code>volatile</code>, а также ссылочный квалификатор (<code>&</code> или <code>&&</code>).

=== [[Наследование (программирование)|Наследование]] ===
C++ поддерживает [[множественное наследование]]. Базовые классы (классы-предки) указываются в заголовке описания класса, возможно, со спецификаторами доступа. Наследование от каждого класса может быть публичным, защищённым или закрытым:
{| class="wikitable"
! Доступ члена базового класса/режим наследования !! private-член !! protected-член !! public-член
|-
| private-наследование || недоступен || private || private
|-
| protected-наследование || недоступен || protected || protected
|-
| public-наследование || недоступен || protected || public
|}
По умолчанию базовый класс наследуется как private.

В результате наследования класс-потомок получает все поля классов-предков и все их методы; можно сказать, что каждый экземпляр класса-потомка содержит ''подэкземпляр'' каждого из классов-предков. Если один класс-предок наследуется несколько раз (это возможно, если он является предком нескольких базовых классов создаваемого класса), то экземпляры класса-потомка будет включать столько же подэкземпляров данного класса-предка. Чтобы избежать такого эффекта, C++ поддерживает концепцию ''виртуального наследования''. При наследовании базовый класс может объявляться виртуальным; на все виртуальные вхождения класса-предка в дерево наследования класса-потомка в потомке создаётся только один подэкземпляр.

* Private-наследование — хранит все методы и свойства класса «родителя» в закрытом доступе извне и закрытом доступе для классов потомков.
* Public-наследование — хранит все методы и параметры класса «родителя» в открытом доступе извне.
* Protected-наследование — то же, что и private, но потомки имеют доступ к унаследованным методам и свойствам.
{{see also|Виртуальное наследование}}

=== Полиморфизм ===
C++ поддерживает [[динамический полиморфизм]] и [[параметрический полиморфизм]].

Параметрический полиморфизм представлен:
* Аргументами по умолчанию для функций. К примеру, для функции <code>void f(int x, int y=5, int z=10)</code>, вызовы <code>f(1)</code>, <code>f(1,5)</code> и <code>f(1,5,10)</code> эквивалентны.
* [[Перегрузка функций]]: функция с одним именем может иметь разное число и разные по типу аргументы. Например : <source lang="cpp" line="1">
void f(int x);
void f(double x);
void f(int x, int y);
</source>
:: Частным случаем перегрузки функций можно считать [[Перегрузка операторов#Перегрузка операторов в C++|перегрузку операторов]].
* Механизмом шаблонов

Динамический полиморфизм реализуется с помощью [[виртуальный метод|виртуальных методов]] и иерархии наследования. Полиморфным в C++ является тип, имеющий хотя бы один виртуальный метод. Пример иерархии:
<source lang="cpp" line="1">
class Figure {
public:
    virtual void draw() = 0; // чистый виртуальный метод
    virtual ~figure();       // при наличии хотя бы одного виртуального метода деструктор следует сделать виртуальным
};

class Square: public Figure {
public:
    void draw() override;
};

class Circle: public Figure {
public:
    void draw() override;
};
</source>
Здесь класс Figure является [[Абстрактный класс|абстрактным]] (и, даже, [[Интерфейс (объектно-ориентированное программирование)|интерфейсным]]), так как метод draw не определён. Объекты данного класса нельзя создать, зато можно использовать ссылки или указатели с типом Figure. Выбор реализации метода Draw будет производиться во время выполнения исходя из реального типа объекта.

=== [[Инкапсуляция (программирование)|Инкапсуляция]] ===
Инкапсуляция в C++ реализуется через указание уровня доступа к членам класса: они бывают публичными (открытыми, <code>public</code>), защищёнными (<code>protected</code>) и приватными (закрытыми, <code>private</code>). В C++ структуры формально отличаются от классов лишь тем, что по умолчанию уровень доступа к членам класса и тип наследования у структуры публичные, а у класса — приватные.
{| class="wikitable"
! Доступ !! private !! protected !! public
|-
| Сам класс || да || да || да
|-
| [[#Друзья|Друзья]] || да || да || да
|-
| Наследники || нет || да || да
|-
| Извне || нет || нет || да
|}
Проверка доступа происходит во время компиляции, попытка обращения к недоступному члену класса вызовет ошибку компиляции.

==== Друзья ====
<!-- на этот заголовок есть ссылка из текста статьи -->
''Функции-друзья'' — это функции, не являющиеся функциями-членами и тем не менее имеющие доступ к защищённым и закрытым членам класса. Они должны быть объявлены в теле класса как <code>friend</code>. Например:
<source lang="cpp" line="1">
class Matrix {
    friend Matrix multiply(Matrix m1, Matrix m2);
};
</source>
Здесь функция <code>multiply</code> может обращаться к любым полям и функциям-членам класса <code>Matrix</code>.

Дружественным может быть объявлен как весь класс, так и функция-член класса.
Четыре важных ограничения, накладываемых на отношения дружественности в C++:
* '''Дружественность не транзитивна.''' Если A объявляет другом B, а B, в свою очередь, объявляет другом C, то C не становится автоматически другом для A. Для этого A должен явно объявить C своим другом.
* '''Дружественность не взаимна.''' Если класс A объявляет другом класс B, то он не становится автоматически другом для B. Для этого должно существовать явное объявление дружественности A в классе B.
* '''Дружественность не наследуется.''' Если A объявляет класс B своим другом, то потомки B не становятся автоматически друзьями A. Для этого каждый из них должен быть объявлен другом A в явной форме.
* '''Дружественность не распространяется на потомков.''' Если класс A объявляет B другом, то B не становится автоматически другом для классов-потомков A. Каждый потомок, если это нужно, должен объявить B своим другом самостоятельно.
В общем виде это правило можно сформулировать следующим образом: ''«Отношение дружественности существует только между теми классами (классом и функцией), для которых оно явно объявлено в коде, и действует только в том направлении, в котором оно объявлено».''

=== Специальные функции ===
Класс по умолчанию может иметь шесть специальных функций: конструктор по умолчанию, конструктор копирования, конструктор перемещения, деструктор, оператор присваивания копированием, оператор присваивания перемещением. Также можно явно определить их все (см. [[Правило трёх (C++)|Правило трёх]]).
<source lang="cpp" line="1">
class Array {
protected:
	std::size_t len = 0; // инициализация поля
	double* val {nullptr};
public:
	Array() = default; // компилятор создаст конструктор по умолчанию сам
	explicit Array(size_t len):
		len{len}, val{new double[len]} {}
	Array(const Array& a) = delete;  // конструктор копирования явно удалён
	Array(Array&& a); // конструктор перемещения
	~Array() {
		delete[] val;
	}
	Array& operator=(const Array& rhs); // оператор присваивания копированием
	Array& operator=(Array&& rhs); // оператор присваивания перемещением

    [[nodiscard]]
	double& operator[](size_t i) noexcept {
		return val[i];
	}

    [[nodiscard]]
	const double& operator[](size_t i) const noexcept {
		return val[i];
	}
};
</source>
Конструктор вызывается для инициализации объекта (соответствующего типа) при его создании, а деструктор — для уничтожения объекта. Класс может иметь несколько конструкторов, но деструктор может иметь только один. Конструкторы в C++ не могут быть объявлены виртуальными, а деструкторы — могут, и обычно объявляются для всех полиморфных типов, чтобы гарантировать правильное уничтожение доступного по ссылке или указателю объекта независимо от того, какого типа ссылка или указатель. При наличии хотя бы у одного из базовых классов виртуального деструктора, деструктор класса потомка автоматически становится виртуальным.

=== Шаблоны ===
{{Main|Шаблоны C++}}
Шаблоны позволяют порождать функции и классы, параметризованные определённым типом или значением. Например, предыдущий класс мог бы реализовывать массив для любого типа данных:
<source lang="cpp" line="1">
template <typename T>
class Array {
protected:
	std::size_t len{0}; // инициализация поля
	T* val{nullptr};
public:
    // ...
    [[nodiscard]]
    T& operator[](size_t i) noexcept {
		return val[i];
	}
};
</source>

== Стандартная библиотека ==
{{main|Стандартная библиотека C++}}

=== Общая структура ===
Стандартная библиотека C++ включает в себя набор средств, которые должны быть доступны для любой реализации языка, чтобы обеспечить программистам удобное пользование языковыми средствами и создать базу для разработки как прикладных приложений самого широкого спектра, так и специализированных библиотек. Стандартная библиотека C++ состоит из нескольких ключевых компонентов:

* '''STL ([[Standard Template Library]])''': контейнеры (vector, list, map и др.), итераторы, алгоритмы (сортировка, поиск) и функциональные объекты.
* '''Ввод-вывод''': потоки (iostream, fstream, sstream) для работы с консолью, файлами и строками.
* '''Строки''': классы для работы с текстом (string, wstring).
* '''Утилиты''': умные указатели (unique_ptr, shared_ptr), пары и кортежи (pair, tuple), динамическое управление типами (type_info).
* '''Многопоточность''': поддержка потоков, мьютексов и атомарных операций (начиная с C++11).
* '''Локализация''': обработка региональных настроек.
* '''Диагностика''': механизмы исключений (try/catch, exception_ptr).
* '''Численные методы''': математические функции (cmath), генераторы случайных чисел.

Стандартная библиотека C++ включает в себя часть стандартной библиотеки Си. Стандарт C++ содержит нормативную ссылку на стандарт C от 1990 года и не определяет самостоятельно те функции стандартной библиотеки, которые заимствуются из стандартной библиотеки Си. Однако в C++ заголовочные файлы Си адаптированы: вместо <code><[[stdio.h]]></code> используется <code><[[cstdio]]></code>, а их содержимое размещается в пространстве имён <code>std</code>. Это позволяет избежать конфликтов имён и сохранить совместимость.

Доступ к возможностям стандартной библиотеки C++ обеспечивается с помощью включения в программу (посредством директивы <code>#include</code>) соответствующих стандартных заголовочных файлов. Всего в стандарте [[C++11]] определено 79 таких файлов. В более новых версиях языка ([[C++17]], [[C++20]]) их количество увеличивается за счёт добавления функциональности, такой как файловая система (<code><filesystem></code>), концепты (<code><concepts></code>) и корутины. Средства стандартной библиотеки объявляются как входящие в пространство имён <code>std</code>. При этом рекомендуется избегать директивы <code>[[using namespace std;]]</code> глобально, чтобы предотвратить неоднозначности.

С развитием стандартов ([[C++11]], [[C++14]], [[C++17]], [[C++20]]) библиотека расширяется, предлагая более безопасные и выразительные средства. Например, в [[C++11]] появились умные указатели для автоматического управления памятью, а в [[C++17]] — структуры для работы с файловой системой. Каждое обновление стремится упростить разработку, сохраняя обратную совместимость и эффективность.

=== Состав ===
Стандартная библиотека включает в себя следующие разделы:
* ''Поддержка языка''. Включает средства, которые необходимы для работы программ, а также сведения об особенностях реализации. Выделение памяти, [[RTTI]], базовые исключения, пределы значений для числовых типов данных, базовые средства взаимодействия со средой, такие как системные часы, обработка сигналов UNIX, завершение программы.
* ''Стандартные [[Контейнер (программирование)|контейнеры]]''. В стандартную библиотеку входят шаблоны для следующих контейнеров: динамический массив (vector), статический массив (array), одно- и двунаправленные списки (forward_list, list), стек (stack), дек (deque), ассоциативные массивы (map, multimap), множества (set, multiset), очередь с приоритетом (priority_queue).
* ''Основные утилиты''. В этот раздел входит описание основных базовых элементов, применяемых в стандартной библиотеке, [[аллокатор|распределителей памяти]] и поддержка времени и даты в стиле C.
* ''Итераторы''. Обеспечивают шаблоны [[Итератор (программирование)|итераторов]], с помощью которых в стандартной библиотеке реализуется стандартный механизм группового применения алгоритмов обработки данных к элементам контейнеров.
* ''Алгоритмы''. Шаблоны для описания операций обработки, которые с помощью механизмов стандартной библиотеки могут применяться к любой последовательности элементов, в том числе к элементам в контейнерах. Также в этот раздел входят описания функций bsearch() и qsort() из стандартной библиотеки C.
* ''Строки''. Шаблоны строк в стиле C++. Также в этот раздел попадает часть библиотек для работы со строками и символами в стиле Си.
* ''Ввод-вывод''. Шаблоны и вспомогательные классы для потоков ввода-вывода общего вида, строкового ввода-вывода, манипуляторы (средства управления форматом потокового ввода-вывода в стиле C++).
* ''Локализация''. Определения, используемые для поддержки национальных особенностей и форматов представления (дат, валют и так далее) в стиле C++ и в стиле Си.
* ''Диагностика''. Определения ряда исключений и механизмов проверки утверждений во время выполнения (assert). Поддержка обработки ошибок в стиле Си.
* ''Числа''. Определения для работы с комплексными числами, математическими векторами, поддержка общих математических функций, генератор случайных чисел.

Контейнеры, строки, алгоритмы, итераторы и основные утилиты, за исключением заимствований из библиотеки C, собирательно называются STL (Standard Template Library — стандартная шаблонная библиотека). Изначально эта библиотека была отдельным продуктом и её аббревиатура расшифровывалась иначе, но потом она вошла в стандартную библиотеку C++ в качестве неотъемлемого элемента. В названии отражено то, что для реализации средств общего вида (контейнеров, строк, алгоритмов) использованы механизмы обобщённого программирования (шаблоны C++ — template). В работах Страуструпа подробно описываются причины, по которым был сделан именно такой выбор. Основными из них являются бо́льшая универсальность выбранного решения (шаблонные контейнеры, в отличие от объектных, могут легко использоваться для не объектных типов и не требуют наличия общего предка у типов элементов) и его техническая эффективность (как правило, операции шаблонного контейнера не требуют вызовов виртуальных функций и могут легко встраиваться (inline), что в итоге даёт выигрыш в производительности).

Начиная со стандарта C++11 добавились следующие возможности:
* Добавлена библиотека &lt;regex&gt;, реализующая общепринятые механизмы поиска и подстановки с помощью регулярных выражений.
* Добавлена поддержка многопоточности.
* Атомарные операции
* unordered-варианты ассоциативных массивов и множеств.
* Умные указатели, обеспечивающие автоматическое освобождение выделенной памяти.

=== Реализации ===
STL до включения в стандарт C++ была сторонней разработкой, вначале — фирмы [[Hewlett-Packard|HP]], а затем — [[SGI]]. Стандарт языка не называет её «STL», так как эта библиотека стала неотъемлемой частью языка, однако многие люди до сих пор используют это название, чтобы отличать её от остальной части стандартной библиотеки (потоки ввода-вывода ([[iostream]]), подраздел C и другие).

Проект под названием STLport<ref>{{Cite web |url=http://www.stlport.org/ |title=STLport: Welcome! |access-date=2007-07-26 |archive-date=2018-06-07 |archive-url=https://web.archive.org/web/20180607183150/http://www.stlport.org/ |url-status=live }}</ref>, основанный на SGI STL, осуществляет постоянное обновление STL, IOstream и строковых классов. Некоторые другие проекты также занимаются разработкой частных применений стандартной библиотеки.

== Отличия от Си ==
[[Файл:CppCgenealogy.png|мини|справа|Генеалогия и взаимовлияние версий Си и C++ (по «Краткому курсу» Страуструпа)]]

=== Совместимость с Си ===
{{main|Несовместимость Си и C++}}
Выбор именно C в качестве базы для создания нового языка программирования объясняется тем, что язык C:
{{начало цитаты}}
# является многоцелевым, лаконичным и относительно низкоуровневым языком;
# подходит для решения большинства системных задач;
# исполняется везде и на всём;
# стыкуется со средой программирования UNIX.
{{конец цитаты|источник=Б. Страуструп. Язык программирования C++. Раздел 1.6{{sfn|Страуструп|1999|loc=1.6}}}}
Несмотря на ряд известных недостатков языка Си, Страуструп пошёл на его использование в качестве основы, так как «в Си есть свои проблемы, но их имел бы и разработанный с нуля язык, а проблемы C нам известны». Кроме того, это позволило быстро получить прототип компилятора ([[cfront]]), который лишь выполнял трансляцию добавленных синтаксических элементов в оригинальный язык Си.

По мере разработки C++ в него были включены другие средства, которые перекрывали возможности конструкций Си, в связи с чем неоднократно поднимался вопрос об отказе от совместимости языков путём удаления устаревших конструкций. Тем не менее, совместимость была сохранена из следующих соображений:
* сохранение действующего кода, написанного изначально на C и прямо перенесённого в C++;
* исключение необходимости переучивания программистов, ранее изучавших C (им требуется только изучить новые средства C++);
* исключение путаницы между языками при их совместном использовании («если два языка используются совместно, их различия должны быть или минимальными, или настолько большими, чтобы языки было невозможно перепутать»).

=== Новые возможности ===
{{Викиучебник|Си++#Основные отличия Си++ от Си|Основные отличия C++ от C}}
Новые возможности C++ включают объявления в виде выражений, преобразования типов в виде функций, операторы <code>new</code> и <code>delete</code>, тип <code>bool</code>, ссылки, расширенное понятие константности, подставляемые функции, аргументы по умолчанию, переопределения, пространства имён, классы (включая и все связанные с классами возможности, такие как наследование, функции-члены, виртуальные функции, абстрактные классы и [[Конструктор (объектно-ориентированное программирование)|конструкторы]]), переопределения операторов, шаблоны, оператор <code>::</code>, обработку исключений, динамическую идентификацию и многое другое. Язык C++ также во многих случаях строже относится к проверке типов, чем C.

В C++ появились комментарии в виде двойной косой черты (<code>//</code>), которые были в предшественнике C — языке [[BCPL]].

Некоторые особенности C++ позднее были перенесены в C, например, ключевые слова <code>const</code> и <code>inline</code>, объявления в циклах <code>for</code> и комментарии в стиле C++ (<code>//</code>). В более поздних реализациях C также были представлены возможности, которых нет в C++, например макросы <code>va_arg</code> и улучшенная работа с массивами-параметрами.

=== C++ не включает в себя C ===
Несмотря на то, что большая часть кода C будет справедлива и для C++, C++ не является надмножеством C и не включает его в себя. Существует и такой верный для C код, который неверен для C++. Это отличает его от [[Objective C]], ещё одного усовершенствования C для [[Объектно-ориентированное программирование|ООП]], как раз являющегося надмножеством C.

Существуют и другие различия. Например, C++ не разрешает вызывать функцию <code>main()</code> внутри программы, в то время как в C это действие правомерно. Кроме того, C++ более строг в некоторых вопросах; например, он не допускает неявное приведение типов между несвязанными типами указателей и не разрешает использовать функции, которые ещё не объявлены.

Более того, код, верный для обоих языков, может давать разные результаты в зависимости от того, компилятором какого языка он оттранслирован. Например, на большинстве платформ следующая программа печатает «С», если компилируется компилятором C, и «C++» — если компилятором C++. Так происходит из-за того, что символьные константы в C (например, <code>'a'</code>) имеют тип <code>int</code>, а в C++ — тип <code>char</code>, а размеры этих типов обычно различаются.
<source lang="cpp" line="1">
#include <stdio.h>

int main() {
    printf("%s\n", (sizeof('a') == sizeof(char)) ? "C++" : "C");
    return 0;
}
</source>

=== Средства C, которых рекомендуется избегать ===
По замечанию Страуструпа, «чем лучше вы знаете C, тем труднее вам будет избежать программирования на C++ в стиле C, теряя при этом потенциальные преимущества C++». В связи с этим он даёт следующий набор рекомендаций для программистов на C, чтобы в полной мере воспользоваться преимуществами C++:
* Не использовать макроопределения <code>#define</code>. Для объявления констант применять <code>const</code>, групп констант (перечислений) — <code>enum</code>, для прямого включения функций — <code>inline</code>, для определения семейств функций или типов — <code>template</code>.
* Не использовать предварительные объявления переменных. Объявлять переменные в блоке, где они реально используются, всегда совмещая объявление с инициализацией.
* Отказаться от использования <code>malloc()</code><ref>{{Cite web |url=http://en.cppreference.com/w/cpp/container/vector |title=std::vector — cppreference.com |access-date=2015-11-28 |archive-date=2015-11-27 |archive-url=https://web.archive.org/web/20151127093014/http://en.cppreference.com/w/cpp/container/vector |url-status=live }}</ref> в пользу оператора <code>new</code>, от <code>realloc()</code><ref>{{Cite web |url=http://en.cppreference.com/w/cpp/memory/c/realloc |title=std::realloc — cppreference.com |access-date=2015-11-28 |archive-date=2015-12-04 |archive-url=https://web.archive.org/web/20151204114524/http://en.cppreference.com/w/cpp/memory/c/realloc |url-status=live }}</ref> — в пользу типа <code>vector</code>. Более безопасным будет использование умных указателей, таких как <code>shared_ptr</code> и <code>unique_ptr</code>, доступных с одиннадцатой версии стандарта.
* Избегать бестиповых указателей, арифметики указателей, неявных приведений типов, объединений, за исключением, возможно, низкоуровневого кода. Использовать «новые» преобразования типов как более точно выражающие действительные намерения программиста и более безопасные.
* Свести к минимуму использование массивов символов и строк в стиле C, заменив их на типы <code>string</code> и <code>vector</code> из STL. Вообще не стремиться создавать собственные реализации того, что уже имеется в стандартной библиотеке.

== Дальнейшее развитие ==
Текущий стандарт языка ISO/IEC 14882:2020 был опубликован в декабре [[2020 год]]а. Неофициально его обозначают как [[C++20]]. Следующая версия стандарта, запланированная на 2024 год, имеет неофициальное обозначение [[C++23]].

=== Общие направления развития C++ ===
По мнению автора языка Бьёрна Страуструпа<ref>{{Cite web |url=http://www.codenet.ru/progr/cpp/straustrup.php |title=Интервью Б. Страуструпа LinuxWorld.com |access-date=2013-01-04 |archive-date=2013-01-27 |archive-url=https://web.archive.org/web/20130127131918/http://www.codenet.ru/progr/cpp/straustrup.php |url-status=live }}</ref><ref>{{Cite web |url=http://samag.ru/archive/article/1034 |title=Интервью Б. Страуструпа журналу «Системный администратор» |access-date=2013-01-04 |archive-date=2013-02-09 |archive-url=https://web.archive.org/web/20130209043902/http://samag.ru/archive/article/1034 |url-status=live }}</ref><ref>{{Cite web |url=http://www.cnews.ru/reviews/index.shtml?2010%2F09%2F29%2F410282 |title=CNews: Эксклюзивное интервью с создателем языка программирования C++ |access-date=2019-11-01 |archive-url=https://web.archive.org/web/20150317122705/http://www.cnews.ru/reviews/index.shtml?2010%2F09%2F29%2F410282 |archive-date=2015-03-17 |url-status=dead }}</ref>, говоря о дальнейшем развитии и перспективах языка, можно выделить следующее:
* В основном дальнейшее развитие языка будет идти по пути внесения дополнений в стандартную библиотеку. Одним из основных источников этих дополнений является известная библиотека [[Boost]].
* Изменения в ядре языка не должны приводить к снижению уже достигнутой эффективности C++. С точки зрения Страуструпа, предпочтительнее внесение в ядро нескольких серьёзных больших изменений, чем множества мелких правок.
* Базовыми направлениями развития C++ на ближайшее время является расширение возможностей и доработка средств обобщённого программирования, стандартизация механизмов параллельной обработки, а также доработка средств безопасного программирования, таких как различные проверки и безопасные преобразования типов, проверка условий и так далее.
* В целом C++ спроектирован и развивается как мультипарадигменный язык, впитывающий в себя различные методы и технологии программирования, но реализующий их на платформе, обеспечивающей высокую техническую эффективность. Поэтому в будущем не исключено добавление в язык средств функционального программирования, автоматической сборки мусора и других отсутствующих в нём сейчас механизмов. Но в любом случае это будет делаться на имеющейся платформе высокоэффективного компилируемого языка.
* Хотя формально одним из принципов C++ остаётся сохранение совместимости с языком C, фактически группы по стандартизации этих языков не взаимодействуют, а вносимые ими изменения не только не коррелируют, но и нередко принципиально противоречат друг другу идеологически. Так, элементы, которые новые стандарты C добавляют в ядро, в стандарте C++ являются элементами стандартной библиотеки и в ядре вообще отсутствуют, например, динамические массивы, массивы с фиксированными границами, средства параллельной обработки. Как считает Страуструп, объединение разработки этих двух языков принесло бы большую пользу, но оно вряд ли возможно по политическим соображениям. Так что практическая совместимость между C и C++ постепенно будет утрачиваться.

=== Стандарт C++11: дополнения в ядре языка ===
{{main|C++11}}
* Явно определяемые константные функции и выражения <code>constexpr</code>.
* Универсальная инициализация.
* Конструкторы и операторы присваивания с семантикой переноса.
* Вывод типов.
:: Для применения в шаблонах, там, где затруднительно указать конкретный тип переменной, введены два новых механизма: переменные типа <code>auto</code> и описание <code>decltype</code>.
* Цикл по коллекции.
:: Вслед за многими современными языками в C++ введена конструкция «цикл по коллекции» вида <code>for (type &x: array) {...}</code>. Здесь тело цикла выполняется для каждого элемента коллекции <code>array</code>, а <code>x</code> в каждой итерации будет ссылаться на очередной элемент коллекции. В качестве коллекции может выступать C-массив или любой контейнер стандартной библиотеки, для которого определены итераторы <code>begin</code> и <code>end</code>.
* Лямбда-выражения.
:: Добавлена возможность объявлять лямбда-выражения (безымянные функции, определяемые в точке применения), в том числе зависящие от внешних переменных (замыкания). Лямбда-выражения могут присваиваться переменным и использоваться везде, где требуется функция соответствующего типа, например, в алгоритмах стандартной библиотеки.
* Изменения в описании виртуальных методов.
:: Добавлен необязательный модификатор <code>override</code>, который употребляется в объявлении метода, замещающего виртуальный метод родительского класса. Описание замещения с <code>override</code> вызывает проверку на наличие в родительском классе замещаемого метода и на совпадение сигнатур методов.
:: Добавлен также модификатор <code>final</code>, как и в Java, запрещающий дальнейшее замещение помеченного им метода. Также <code>final</code> может быть объявлен класс — в таком случае от него запрещено наследовать новые классы.
* Добавлена возможность описания [[Вариативный шаблон|вариативных шаблонов]].
* Различные синтаксические дополнения.
:: Определено ключевое слово для константы — нулевого указателя: <code>nullptr</code>.
:: Внесены изменения в семантику и, частично, синтаксис перечислений и объединений. Добавлена возможность создавать типобезопасные перечисления, с объединений снят ряд ограничений на структуру.
:: От компилятора требуется правильный лексический разбор текста программы с несколькими закрывающимися угловыми скобками подряд (ранее последовательность «<code>>></code>» воспринималась однозначно как операция побитового сдвига вправо, поэтому в записи вложенных шаблонных конструкций требовалось обязательно разделять знаки «больше» пробелами или переводами строк).

== Примеры программ ==

=== Пример № 1 ===
Это пример программы [[Hello, world!]], которая выводит сообщение в [[Интерфейс командной строки|консоль]], используя стандартную библиотеку, и завершается. Используется стандарт [[C++23]].
<source lang="cpp" line="1">
import std;

int main() {
    std::println("Hello, world!");
    return 0;
}
</source>

В более старых стандартах данная программа выглядит так:

<source lang="cpp" line="1">
#include <iostream>

int main() {
    std::cout << "Hello, world!\n";
    return 0;
}
</source>

=== Пример № 2 ===
Современный C++ позволяет решать простым способом и более сложные задачи. Этот пример демонстрирует, кроме всего прочего, использование контейнеров стандартной библиотеки шаблонов ([[Стандартная библиотека шаблонов|STL]]).
<source lang="cpp" line="1">
import std;

int main() {
    // Объявляем ассоциативный контейнер со строковыми ключами и данными в виде массивов строк (`std::vector` реализует динамический массив).
    std::map<std::string, std::vector<std::string>> items;

    // Добавим в этот ассоциативный контейнер пару человек и дадим им несколько предметов.
    items["Anya"].push_back("scarf");
    items["Dmitry"].push_back("tickets");
    items["Anya"].push_back("puppy");

    // Переберём все объекты в контейнере.
    // Ключевое слово `auto` используется для вывода типов (type inference);
    // в данном случае, тип `person` выводится как `std::pair<std::string, std::vector<std::string>>`.
    for (const auto& person : items) {
        // person - это пара двух объектов:
        // person.first - это его имя,
        // person.second - это список его предметов (вектор строк)
        std::string& name = person.first;
        std::vector<std::string>& personItems = person.second;
        std::println("{} is carrying {} items", name, personItems.size());
    }
}
</source>

<code>std</code> — пространство имён, в котором находятся всё объекты и функции стандартной библиотеки C++. Директива <code>using</code> позволяет избавиться от необходимости указывать пространство имён при использовании стандартной библиотеки:

<source lang="cpp" line="1">
import std;

using namespace std;

int main() {
    vector<int> myVector;
}
</source>

Однако, так делать обычно не рекомендуется по причине того, что в стандартной библиотеке есть много функций, названия которых соответствуют тем, что могут использоваться программистом при объявлении переменных или пользовательских функций.

Также язык позволяет не указывать пространство имён для отдельных объектов из стандартной библиотеки:

<source lang="cpp" line="1">
import std;

int main() {
    using std::vector; // теперь `std::vector` доступен напрямую, без указания пространства имён (но для других объектов по прежнему нужно указывать пространство имён)
    vector<int> myVector;
}
</source>

В C++ (как и в C), если выполнение программы доходит до конца функции <code>main()</code>, то это эквивалентно <code>return 0;</code>. Это неверно для любой другой функции, кроме <code>main()</code>.

== Сравнение с альтернативными языками ==
Известно несколько исследований, в которых была сделана попытка более или менее объективно сравнить несколько языков программирования, одним из которых является C++. В частности:
* В научной статье «Haskell vs. Ada vs. C++ vs. Awk vs. …» Пауля Худака и Марка Джонса<ref name="haskell">An Experiment in Software Prototyping Productivity. Paul Hudak, Mark P. Jones. Yale University, Department of Computer Science, New Haven, CT 06518. July 4, 1994.</ref> даётся отчёт об исследовании ряда императивных и функциональных языков на решении модельной задачи быстрого прототипирования ГИС-системы военного назначения.
* В научной статье «DSL implementation in metaocaml, template haskell, and C++» четырёх авторов<ref>{{статья
|автор = K. Czarnecki, J. O’Donnell, J. Striegnitz, W. Taha
|заглавие = DSL implementation in metaocaml, template haskell, and C++
|издательство = University of Waterloo, University of Glasgow, Research Centre Julich, Rice University
|год = 2004
|ссылка = https://www.researchgate.net/publication/221025927_DSL_implementation_in_MetaOCaml_template_Haskell_and_C
|ref = Czarnecki, O’Donnell, Striegnitz, Taha
|издание =
|archive-date = 2022-04-07
|archive-url = https://web.archive.org/web/20220407022648/https://www.researchgate.net/publication/221025927_DSL_implementation_in_MetaOCaml_template_Haskell_and_C
}}.<br>Цитата: ''C++ Template Metaprogramming suffers from a number of limitations, including portability problems due to compiler limitations (although this has signiﬁcantly improved in the last few years), lack of debugging support or IO during template instantiation, long compilation times, long and incomprehensible errors, poor readability of the code, and poor error reporting.''</ref> проводится методичное исследование применения C++ и двух функциональных языков в роли базовых инструментов для [[языково-ориентированное программирование|языково-ориентированного программирования]] методом [[порождающее программирование|порождающего программирования]].
* В работе Лутца Прехельта<ref name="perhelt">{{cite web |url=http://page.mi.fu-berlin.de/prechelt/Biblio/jccpprt_computer2000.pdf |title=An empirical comparison of C, C++, Java, Perl, Python, Rexx, and Tcl for a search/string-processing program |author=Lutz Prechelt ([[Технологический институт Карлсруэ|Universität Karlsruhe]]) |lang=en |format=pdf |website=[[Свободный университет Берлина|Freie Universität Berlin]] |date=2000-03-14 |access-date=2019-11-20 |archive-date=2020-01-03 |archive-url=https://web.archive.org/web/20200103050915/http://page.mi.fu-berlin.de/prechelt/Biblio/jccpprt_computer2000.pdf |url-status=live }}</ref> рассмотрено семь языков (C, C++, Java, Perl, Python, Rexx и Tcl) в задаче написания простой программы преобразования телефонных номеров в слова по определённым правилам.
* В статье Дэвида Велера «Ada, C, C++, and Java vs. The Steelman»<ref name="steelman">{{Cite web |url=https://dwheeler.com/steelman/steeltab.htm |title=«Ada, C, C++, and Java vs. The Steelman» David A. Wheeler July/August 1997 |access-date=2019-03-23 |archive-date=2019-03-23 |archive-url=https://web.archive.org/web/20190323164511/https://dwheeler.com/steelman/steeltab.htm |url-status=dead }}</ref> приведено сопоставление языков Ада, C++, Си, Java с документом «[[Ада (язык программирования)#История|Steelman]]» — списком требований к языку для военных разработок встроенных систем, который был выработан комитетом по языку высокого уровня Министерства обороны США в 1978 году. Хотя этот документ сильно устарел и не учитывает многих существенных свойств современных языков, сравнение демонстрирует, что C++ по набору востребованных в отрасли возможностей не так уж сильно отличается от языков, которые можно считать его реальными конкурентами.
* Статья Мэтью Формента и Михаэля Гиллингса<ref name="bioinfartcl">{{Cite web|title=«A comparison of common programming languages used in bioinformatics»|url=https://bmcbioinformatics.biomedcentral.com/articles/10.1186/1471-2105-9-82|access-date=2021-09-02|archive-date=2021-09-02|archive-url=https://web.archive.org/web/20210902102443/https://bmcbioinformatics.biomedcentral.com/articles/10.1186/1471-2105-9-82|url-status=live}}</ref> описывает исследование<ref name="bioinfbench">{{Cite web |url=http://www.bioinformatics.org/benchmark/index.html |title=Сравнение языков программирования в реализации алгоритмов биоинформатики — описание эксперимента. |access-date=2021-09-02 |archive-date=2021-09-02 |archive-url=https://web.archive.org/web/20210902102446/http://www.bioinformatics.org/benchmark/index.html |url-status=live }}</ref> реализации на шести языках — C++, C, C#, Java, Perl, Python, — трёх специфичных алгоритмов, применяемых в биоинформатике: [[метод ближайших соседей (биоинформатика)|метод ближайших соседей]], глобальное [[выравнивание последовательностей]] ([[Алгоритм Нидлмана — Вунша]]) и [[парсинг]] результатов [[BLAST]].

=== C++ и Ада ===
[[Язык Ада]] близок к C++ по набору возможностей и по сферам применения: это компилируемый структурный язык с Симула-подобным объектно-ориентированным дополнением (та же модель «Алгол с классами», что и в C++), статической типизацией, средствами обобщённого программирования, предназначенный для разработки крупных и сложных программных систем. В то же время он принципиально отличается по идеологии: в отличие от C++, Ада строилась на основе предварительно тщательно проработанных условий производителей сложного ПО с повышенными требованиями к надёжности, что наложило отпечаток на синтаксис и семантику языка.

Прямых сравнений эффективности кодирования на Аде и C++ немного. В упомянутой выше статье<ref name="haskell"/> решение модельной задачи на Аде привело к получению кода примерно на 30 % меньшего по объёму (в строках), чем на C++. Сравнение свойств самих языков приводится во многих источниках, например, в статье Джима Роджерса на AdaHome<ref name="rogers">{{Cite web |url=http://www.adahome.com/articles/9703/ada_vs_cpp.html |title=Comparison of Ada and C++ Features (en) |access-date=2019-03-23 |archive-date=2019-03-23 |archive-url=https://web.archive.org/web/20190323164727/http://www.adahome.com/articles/9703/ada_vs_cpp.html |url-status=live }}</ref> содержится перечисление более 50 пунктов различий свойств этих языков, большая часть которых — в пользу Ады (больше возможностей, более гибкое поведение, меньше вероятность ошибок). Хотя многие утверждения сторонников Ады спорны, а часть из них явно устарела, в целом можно заключить:
* Синтаксис Ады гораздо строже, чем C++. Язык требует соблюдения дисциплины программирования, не поощряет «программистские трюки», стимулирует написание простого, логичного и легко понимаемого кода, удобного в сопровождении.
* В отличие от C++, Ада максимально типобезопасна. Развитая система типов позволяет, при соблюдении дисциплины их объявления и использования, максимально полно статически контролировать корректность использования данных и защищает от случайных ошибок. Автоматические преобразования типов сведены к минимуму.
* Указатели в Аде контролируются гораздо более строго, чем в C++, а адресная арифметика доступна только через отдельную системную библиотеку.
* Настраиваемые модули Ады по возможностям аналогичны шаблонам C++, но обеспечивают лучший контроль.
* Ада имеет встроенную в язык модульность и стандартизованную систему раздельной компиляции, тогда как C++ применяет включение текстовых файлов и внешние средства управления компиляцией и сборкой.
* Встроенная многозадачность Ады включает параллельные задачи и механизм их коммуникации (входы, рандеву, оператор <code>select</code>). В C++ всё это реализуется только на уровне библиотек.
* Ада строго стандартизована, за счёт чего обеспечивает лучшую переносимость.

В статье Стефена Цейгера из [[Rational Software Corporation]]<ref>[http://www.adaic.com/whyada/ada-vs-c/cada_art.html Stephen Zeigler, Comparing Development Costs of C and Ada.] {{webarchive|url=https://web.archive.org/web/20070404120024/http://www.adaic.com/whyada/ada-vs-c/cada_art.html |date=2007-04-04 }}</ref>, утверждается, что в целом разработка на Аде обходится на 60 % дешевле, и приводит к получению кода, имеющего в 9 раз меньше дефектов, чем на Си. Хотя эти результаты не могут быть прямо перенесены на C++, но всё же представляют интерес с учётом того, что многие недостатки C++ унаследованы от Си.

=== C++ и Java ===
Java не может считаться в полной мере заменой C++, она создана как безопасный язык с низким порогом вхождения для разработки прикладных пользовательских приложений с высокими показателями портируемости<ref>{{cite web |url=http://www.oracle.com/technetwork/java/intro-141325.html |title=1.2 Design Goals of the Java™ Programming Language |subtitle=The Java Language Environment |lang=en |publisher=Oracle |date=1999-01-01 |access-date=2013-01-14 |archive-date=2013-01-23 |archive-url=https://web.archive.org/web/20130123204103/http://www.oracle.com/technetwork/java/intro-141325.html |url-status=live }}</ref> и принципиально непригодна для некоторых типов приложений, которые разрабатываются на C++. Однако в пределах своей области Java составляет вполне реальную конкуренцию C++. В качестве преимуществ Java обычно называют:

* Безопасность: отсутствие поддержки указателей и адресной арифметики, автоматическое управление памятью со сборкой мусора, встроенные средства, защищающие от распространённых ошибок программ C++, таких как переполнение буфера или выход за границы массива.
* Наличие разработанной системы модулей и раздельной компиляции, значительно более быстрой и менее подверженной ошибкам, чем препроцессор и ручная сборка C++.
* Полная стандартизация и исполнение в виртуальной машине, развитое окружение, включающие библиотеки для графики, интерфейса пользователя, доступа к базам данных прочих типовых задач, как следствие — реальная многоплатформенность.
* Встроенная многопоточность.
* Объектная подсистема Java в значительно более высокой степени, чем C++, отвечает фундаментальному принципу ООП ''«всё — объект»''. Интерфейсы позволяют обеспечить большинство преимуществ множественного наследования, не вызывая его негативных эффектов.
* Рефлексия значительно более развита, чем в C++ и позволяет реально определять и изменять структуру объектов во время работы программы.

В то же время использование сборщика мусора и виртуальной машины создают труднопреодолимые ограничения. Программы на Java, как правило, медленнее, требуют значительно больше памяти, к тому же виртуальная машина изолирует программу от операционной системы, делая невозможным низкоуровневое программирование.

Эмпирическое исследование<ref name="perhelt"/> не обнаружило существенной разницы в скорости разработки на C++ и на Java. Исследование<ref name="bioinfartcl"/> также показало, что представление о существенной разнице в скорости программ на этих языках не всегда верно: в двух из трёх тестов скорость работы приложений на Java и C++ оказалась сравнима. В то же время Java лаконичнее — разница в объёме кода составила порядка 10-15 %.

=== C++ и C ===
Оригинальный Си продолжает развиваться, на нём разрабатываются многие масштабные проекты: он является основным языком разработки операционных систем, на нём написаны игровые движки многих динамических игр и большое число прикладных приложений. Ряд специалистов утверждает, что замена Си на C++ не повышает эффективности разработки, но приводит к ненужному усложнению проекта, снижению надёжности и увеличению затрат на сопровождение. В частности:

* По мнению Линуса Торвальдса, «C++ провоцирует на написание … значительного объёма кода, не имеющего принципиального значения с точки зрения функциональности программы»<ref name="torvalds" group="мнения" />.
* Поддержка ООП, шаблоны и STL не являются решающим преимуществом C++, так как всё, для чего они применяются, реализуемо и средствами Си. При этом устраняется раздувание кода, а некоторое усложнение, которое к тому же далеко не обязательно, компенсируется большей гибкостью, более простым тестированием, лучшими показателями производительности.
* Автоматизация доступа к памяти в C++ увеличивает затраты памяти и замедляет работу программ.
* Использование исключений C++ вынуждает следовать [[RAII]], приводит к росту исполняемых файлов, замедлению программ. Дополнительные трудности возникают в параллельных и распределённых программах.
* Код на C++ сложнее для понимания и тестирования, его отладка затрудняется использованием сложных иерархий классов с наследованием поведения и шаблонов. К тому же в средах программирования на C++ больше ошибок, как в компиляторах, так и в библиотеках.
* Многие детали поведения кода стандартом C++ не специфицированы, что ухудшает переносимость и может являться причиной трудно обнаруживаемых ошибок.
* Квалифицированных программистов на Си существенно больше, чем на C++.

Нет убедительных данных о преимуществе C++ перед Си ни по производительности программистов, ни по свойствам программ. Хотя есть исследования<ref>{{статья | заглавие = Advantages and Disadvantages of Conservative Garbage Collection | автор = Boehm H. | ссылка = http://www.hpl.hp.com/personal/Hans_Boehm/gc/issues.html | издание =  | archive-url = https://web.archive.org/web/20130724030259/http://www.hpl.hp.com/personal/Hans_Boehm/gc/issues.html | archive-date = 2013-07-24 }}<br> (ссылка из {{книга |автор = [[Реймонд, Эрик]]. |заглавие =Искусство программирования для Unix | год = 2005 |страницы = 357 | страниц = 544 | isbn = 5-8459-0791-8}})</ref>, утверждающие, что программисты на Си тратят около 30-40 % общего времени разработки (не считая отладки) на управление памятью, при сопоставлении общей производительности разработчиков<ref name="haskell"/> Си и C++ оказываются близки.

В низкоуровневом программировании значительная часть новых возможностей C++ оказывается неприменимой из-за увеличения накладных расходов: виртуальные функции требуют динамического вычисления реального адреса (RVA), шаблоны приводят к раздуванию кода и ухудшению возможностей оптимизации, [[библиотека времени исполнения]] (RTL) очень велика, а отказ от неё лишает большинства возможностей C++ (хотя бы из-за недоступности операций <code>new</code>/<code>delete</code>). В результате программисту придётся ограничиться функционалом, унаследованным от Си, что делает бессмысленным применение C++:

{{начало цитаты}}… единственный способ иметь хороший, эффективный, низкоуровневый и портируемый C++ сводится к тому, чтобы ограничиться всеми теми вещами, которые элементарно доступны в Си. А ограничение проекта рамками Си будет означать, что люди его не выкинут, и что будет доступно множество программистов, действительно хорошо понимающих низкоуровневые особенности и не отказывающихся от них из-за идиотской ерунды про «объектные модели».<br>… когда эффективность является первостепенным требованием, «преимущества» C++ будут огромной ошибкой.{{конец цитаты|источник=[[Торвальдс, Линус|Линус Торвальдс]],<ref name=autogenerated1 /> }}

=== C++ и функциональные и скриптовые языки ===
В одном эксперименте<ref name="haskell"/> скриптовые и функциональные языки, в частности, [[Haskell]], показали 2-3 кратный выигрыш во времени программирования и объёме кода по сравнению с программами на C++. С другой стороны, программы на C++ оказались во столько же раз быстрее. Авторы признают, что полученные ими данные не составляют репрезентативной выборки и воздерживаются от категоричных выводов.

В другом эксперименте<ref name="raytracer">'''Ray Tracer Language Comparison''' (бенчмарк языков программирования — ffconsultancy.com/languages/ray_tracer/)</ref> строгие функциональные языки ([[Standard ML]], [[OCaml]]) показали общее ускорение разработки в 10 раз (в основном за счёт раннего выявления ошибок) при примерно равных показателях быстродействия (использовалось множество компиляторов в нескольких режимах).

В исследовании Лутца Прехельта<ref name="perhelt"/> по результатам обработки около 80 решений, написанных добровольцами, получены, в частности, следующие выводы:
* Perl, Python, Rexx, Tcl обеспечили скорость разработки вдвое больше, чем C, C++ и Java, причём полученный код был также вдвое короче.
* Программы на скриптовых языках потребляли примерно вдвое больше памяти, чем C/C++.

== Критика ==
{{чистить|дата=2013-08-27}}

=== О критике C++ в целом ===
Чаще всего критики не противопоставляют C++ какой-либо другой конкретный язык, а утверждают, что отказ от использования единственного языка, имеющего многочисленные недостатки, в пользу декомпозиции проекта на подзадачи, решаемые на различных, наиболее подходящих для них, языках, делает разработку существенно менее трудоёмкой при одновременном повышении показателей [[Качество программного обеспечения|качества программирования]]<ref name="languageorient">{{статья | заглавие = [[Языково-ориентированное программирование|Language Oriented Programming]] | автор = Martin Ward | издательство = Computer Science Department, Science Labs | год = 1994 | ссылка = http://www.cse.dmu.ac.uk/~mward/martin/papers/middle-out-t.pdf | издание =  | archive-date = 2016-03-04 | archive-url = https://web.archive.org/web/20160304020956/http://www.cse.dmu.ac.uk/~mward/martin/papers/middle-out-t.pdf }}</ref><ref name="Hudak_DSL">{{статья | заглавие = Modular Domain Speciﬁc Languages and Tools | автор = Paul Hudak | издательство = Department of Computer Science, Yale University | ссылка = }}</ref>. По этой же причине критикуется сохранение совместимости с Си: если часть задачи требует низкоуровневых возможностей, разумнее выделить эту часть в отдельную подсистему и написать её на Си.

В свою очередь, сторонники C++ заявляют, что устранение технических и организационных проблем межъязыкового взаимодействия за счёт использования одного универсального языка вместо нескольких специализированных важнее, чем потери от несовершенства этого универсального языка, то есть сама широта набора возможностей C++ является оправданием недостатков каждой отдельной возможности; в том числе недостатки, унаследованные от Си, оправданы преимуществами совместимости (см. [[#Философия C++|выше]]).

Таким образом, одни и те же свойства C++ — объём, сложность, [[эклектичность]] и отсутствие конкретной целевой ниши применения — рассматривается сторонниками как ''«главное достоинство»'', а критиками — как ''«главный недостаток»''.

=== Критика отдельных элементов и концепций ===

==== Контроль за поведением ====
Идеология языка смешивает «контроль за ''поведением''» с «контролем за ''эффективностью''»: принцип ''«не платишь за то, что не используешь»''{{переход|Философия C++}} предполагает, что обеспечение полного контроля программиста за всеми аспектами исполнения программы на довольно низком уровне является необходимым и достаточным условием достижения высокой эффективности кода. В действительности для сколько-нибудь крупных программ это неверно: возложение на программиста низкоуровневой оптимизации, которую качественный компилятор [[Предметно-ориентированный язык программирования|предметно-ориентированного]] языка способен выполнить заведомо более эффективно, приводит лишь к росту объёма кода, повышению трудоёмкости программирования и снижению показателей понимаемости и тестируемости кода. Таким образом, принцип «не платить за то, что не используется» в действительности не даёт желаемых выгод в эффективности, но негативно сказывается на качестве.

==== Компонентное и объектно-ориентированное программирование ====
По мнению [[Кэй, Алан Кёртис|Алана Кэя]], объектная модель «[[Алгол]] с классами», использованная в C++, уступает модели «всё — объект»<ref name="alankay">{{cite web |url=http://c2.com/cgi/wiki?AlanKaysDefinitionOfObjectOriented|title=Alan Kay's Definition Of Object Oriented Programming|access-date=2013-08-05|url-status=dead |archive-url=https://web.archive.org/web/20130824235515/http://c2.com/cgi/wiki?AlanKaysDefinitionOfObjectOriented|archive-date=2013-08-24}}</ref>, используемой в [[Objective-C]], по общем объёму возможностей, показателям [[повторное использование кода|повторного использования кода]], понимаемости, модифицируемости и тестируемости.

Модель наследования C++ сложна, трудна в реализации и при этом провоцирует создание сложных иерархий с неестественными отношениями между классами (например, наследование вместо вложения). Результатом становится создание [[Зацепление (программирование)|сильно зацепленных]] классов с нечётко разделённым функционалом. Например, в {{sfn|Шилдт, Теория и практика C++|1996||с=64—67}} приводится учебно-рекомендательный пример реализации класса «список» как подкласса от класса «элемент списка», который, в свою очередь, содержит функции доступа к другим элементам списка. Такое отношение типов является абсурдом с точки зрения математики и невоспроизводимо на более строгих языках. Идеология некоторых библиотек требует ручного приведения типов вверх и вниз по иерархии классов (<code>static_cast</code> и <code>dynamic_cast</code>), что нарушает [[типобезопасность]] языка. Высокая [[Вязкость (программирование)|вязкость]] решений на C++ может требовать повторной разработки значительных частей проекта при необходимости внесения минимальных изменений на поздних стадиях разработки. Яркий пример подобных проблем можно найти в<ref name="languageorient"/>.

Как отмечает Ян Джойнер<ref name="Joyner" />, C++ ошибочно отождествляет инкапсуляцию (то есть помещение данных внутрь объектов и отделение реализации от интерфейса) и сокрытие реализации. Это усложняет доступ к данным класса и требует реализовывать его интерфейс практически исключительно через функции доступа (что, в свою очередь, увеличивает объём кода и усложняет его).

Совпадение типов в C++ определяется на уровне идентификаторов, а не сигнатур. Это делает невозможной подстановку компонентов, основанную на совпадении интерфейсов, из-за чего включение в систему новой функциональности, реализованной на уровне библиотек, требует ручной модификации уже имеющегося кода<ref name="Paulson">{{книга|автор = Paulson, Lawrence C.|заглавие = ML for the Working Programmer, 2nd edition
|издательство = Cambridge University Press|место = University of Cambridge|год = 1996|isbn = 0-521-57050-6 (hardback), 0-521-56543-X (paperback)}}, c.271-285</ref>. Как отмечает [[Торвальдс, Линус|Линус Торвальдс]]<ref name=autogenerated1 />, в C++ «код кажется абстрактным лишь до тех пор, пока не возникает необходимость его изменить».

Критика C++ с позиций ООП приведена в работе<ref name="Joyner">{{статья | заглавие = A Critique of C++ and Programming and Language Trends of the 1990s - 3rd Edition | автор = Ian Joyner | ссылка = http://www.quinn.echidna.id.au/quinn/C++-Critique-3ed.pdf | издательство = [http://www.emu.edu.tr/aelci/Courses/D-318/D-318-Files/cppcrit/index008.htm копирайт и список изданий] | издание =  | archive-date = 2013-11-25 | archive-url = https://web.archive.org/web/20131125045724/http://www.quinn.echidna.id.au/quinn/C++-Critique-3ed.pdf }}</ref>.

==== Метапрограммирование ====
Порождающее метапрограммирование C++ основано на шаблонах и [[препроцессор]]е, оно трудоёмко и ограничено по возможностям. Система шаблонов C++ фактически является вариантом примитивного [[Функциональный язык программирования|функционального языка программирования]], исполняемого на этапе компиляции. Этот язык почти не пересекается с самим C++, из-за чего потенциал роста сложности абстракций оказывается ограниченным. Программы, использующие шаблоны C++, имеют крайне низкие показатели понимаемости и тестируемости, а само разворачивание шаблонов порождает неэффективный код, так как язык шаблонов не предоставляет никаких средств для оптимизации (см. также раздел [[#Вычислительная эффективность]]). Встраиваемые предметно-специфичные языки, реализуемые таким образом, всё равно требуют знания самого C++, что не обеспечивает полноценного разделения труда. Таким образом, возможности C++ по расширению возможностей самого C++ весьма ограничены<ref>{{статья
| заглавие = Domain-Speciﬁc Languages
| автор = Walid Taha
| издательство = Department of Computer Science, Rice University
| ссылка = http://www.cs.rice.edu/~taha/publications/conference/icces08.pdf
| издание =
| archive-url = https://web.archive.org/web/20131024072658/http://www.cs.rice.edu/~taha/publications/conference/icces08.pdf
| archive-date = 2013-10-24
}}</ref><ref>{{статья
| заглавие = Using a hierarchy of Domain Speciﬁc Languages in complex software systems design
| автор = Lugovsky V.S.
| год = 2008
| ссылка = http://arxiv.org/abs/cs/0409016v1
| издание =
| archive-date = 2016-08-10
| archive-url = https://web.archive.org/web/20160810224158/http://arxiv.org/abs/cs/0409016v1
}}</ref>.

==== Кроссплатформенность ====
Для написания портируемого кода на C++ требуется огромное мастерство и опыт, и «небрежные» коды на C++ с высокой вероятностью могут оказаться непортируемыми<ref name="XXtraps64bit">{{статья |заглавие=20 ловушек переноса Си++ - кода на 64-битную платформу |автор=Андрей Карпов |издательство=RSDN Magazine #1-2007 |год=2007 |ссылка=http://www.rsdn.ru/?article%2Fcpp%2FXXtraps64bit.xml |издание= |archive-date=2015-04-02 |archive-url=https://web.archive.org/web/20150402114050/http://rsdn.ru/?article%2Fcpp%2FXXtraps64bit.xml }}</ref>. По мнению [[Торвальдс, Линус|Линуса Торвальдса]], для обеспечения на C++ портируемости, аналогичной Си, программист должен ограничиться возможностями C++, унаследованными от Си<ref name=autogenerated1>{{cite web|url=http://thread.gmane.org/gmane.comp.version-control.git/57643/focus=57918|title=Открытая переписка gmane.comp.version-control.git от 06.09.2007|archive-url=https://web.archive.org/web/20131209133259/http://thread.gmane.org/gmane.comp.version-control.git/57643/focus=57918 |archive-date=2013-12-09|access-date=2013-08-05|url-status=dead}}</ref>. Стандарт содержит множество элементов, определённых как «implementation-defined» (например, размер указателей на методы классов в различных компиляторах варьируется в диапазоне от 4 до 20 байт<ref>{{статья |заглавие=Указатели на функции-члены и реализация самых быстрых делегатов на C++ |автор=Don Clugston, CSG Solar Pty Ltd (Перевод: Денис Буличенко) |издательство=RSDN Magazine #6-2004 |ссылка=http://www.rsdn.ru/?article%2Fcpp%2FFastDelegate%2FFastDelegate.xml |издание= |archive-date=2013-10-19 |archive-url=https://web.archive.org/web/20131019045704/http://www.rsdn.ru/?article%2Fcpp%2FFastDelegate%2FFastDelegate.xml }}</ref>), что ухудшает портируемость программ с их использованием.

Директивный характер [[Стандартизация|стандартизации]] языка, неполная обратная совместимость и противоречивость требований разных версий стандарта приводят к проблемам в переносе программ между различными компиляторами и даже версиями одних и тех же компиляторов.

=== Отсутствие возможностей ===
<!-- Если в языке что-то отсутствует, то язык называется ограниченным по возможностям. В данном разделе перечисляются отсутствующие вещи. -->

; Рефлексивное метапрограммирование
: [[Отражение (программирование)|Интроспекция]] в C++ реализована отдельно от основной системы типов, что делает её практически бесполезной. Наибольшее, что можно получить — параметризацию поведения на заранее известном наборе вариантов. Это препятствует применению C++ в большинстве подходов к реализации [[Искусственный интеллект|искусственного интеллекта]].

; Функциональное программирование
: Явная поддержка функционального программирования присутствует только в стандарте [[C++0x]], ранее пробел устранялся библиотеками ([[Loki]], [[Boost]]), использующими язык шаблонов, но их качество значительно уступают решениям, встроенным в функциональные языки<ref group="пояснения">Например, <code>Boost.Lambda</code> позиционируется как лямбда-функция, однако C++ не воплощает [[лямбда-исчисление]] Чёрча целиком; имитация [[комбинатор]]ов посредством языка шаблонов слишком затруднена, чтобы ожидать их использование на практике; [[продолжение (программирование)|продолжения]], унаследованные от Си, считаются неидеоматичными и опасными, а их реализация посредством языка шаблонов невозможна; кроме того, применение {{iw|λ-подъём|λ-подъёма|en|lambda lifting}} для оптимизации C++ невозможно,— так что фактически <code>Boost.Lambda</code> — это просто анонимная функция, а не объект лямбда-исчисления.</ref>, как и качеству реализаций возможностей C++ (таких как ООП) посредством функциональных языков. Реализованные в C++ возможности ФП не дают возможности применения присущих функциональному программированию оптимизационных методик{{переход|Вычислительная эффективность}}, а ограничиваются вызовами функциональных библиотек и реализацией отдельных методов. Это практически не даёт преимуществ в проектировании программ (см. [[Соответствие Карри — Ховарда]]).

=== Избыточные и опасные возможности ===

==== Встроенные средства обхода ограничений ====
Язык содержит средства, позволяющие программисту нарушать заданную в конкретном случае дисциплину программирования. Например, модификатор <code>const</code> задаёт для объекта свойство неизменности состояния, но модификатор <code>mutable</code> предназначен ''именно для'' принудительного разрешения изменения состояния внутри константного объекта, то есть для нарушения ограничения константности. Более того, допускается динамически удалить атрибут <code>const</code> с константного объекта, превращая его в леводопустимый (L-value). Наличие в языке таких возможностей делает попытки [[Формальная верификация|формальной верификации]] кода бессмысленными, а использование ограничений для оптимизации невозможным.

==== Неконтролируемая макроподстановка ====
Средства макроподстановки Си (<code>#define</code>) являются сколь мощным, столь же опасным средством. Они сохранены в C++ несмотря на то, что для решения всех задач, для которых они были предусмотрены в Си, в C++ были предоставлены более строгие и специализированные средства — шаблоны, перегрузка функций, inline-функции, пространства имён, более развитая типизация, расширение применения модификатора const, и др. В унаследованных от Си стандартных библиотеках много потенциально опасных макросов<ref>Страуструп, Программирование: принципы и практика использования C++, 2001</ref>. Шаблонное метапрограммирование также порой совмещается с использованием макроподстановки для обеспечения так называемого [[Синтаксический сахар|синтаксического сахара]].

==== Проблемы перегрузки ====
Принятые в C++ принципы перегрузки функций и операторов приводят к значительному дублированию кода. [[Перегрузка операторов#Перегрузка операторов в C++|Перегрузка операторов]], исходно предназначенная для введения так называемого «[[Синтаксический сахар|синтаксического сахара]]», в C++ поощряет бесконтрольное изменение поведения элементарных операций для различных типов. Это резко повышает риск ошибок, тем более что вводить новый синтаксис и изменять существующий (например, создавать новые операторы или менять приоритеты или ассоциативность) нельзя, хотя синтаксис стандартных операторов C++ адекватен семантике далеко не всех типов, которые может потребоваться ввести в программу. Отдельные проблемы создаёт возможность лёгкой перегрузки операторов <code>new</code>/<code>delete</code>, способной породить крайне коварные и трудновыявляемые ошибки. При этом некоторые интуитивно ожидаемые операции (подчистка динамических объектов в случае генерации исключений) в C++ не выполняются, а значительная часть перегруженных функций и операторов вызывается неявно (приведение типов, создание временных экземпляров классов и др.). В результате средства, изначально предназначенные для того, чтобы сделать программы более ясными и повысить удобство разработки и сопровождения, превращаются в ещё один источник неоправданного усложнения и снижения надёжности кода.

=== Вычислительная эффективность ===

==== Результирующий объём исполнимого кода ====
Использование шаблонов C++ представляет собой [[Полиморфизм (программирование)#Параметрический полиморфизм|параметрический полиморфизм]] на уровне исходного кода, но при трансляции он превращается в [[Полиморфизм (программирование)#Ситуативный (ad hoc) полиморфизм|ситуативный (ad hoc) полиморфизм]] (то есть перегрузку функций), что приводит к существенному увеличению объёма машинного кода в сравнении с языками, имеющими истинно полиморфную систему типов (потомками [[ML]]). Для снижения размера машинного кода пытаются автоматически обрабатывать исходный код до этапа раскрутки шаблонов<ref>{{статья|автор=Dave Gottner.|заглавие=Templates Without Code Bloat|ссылка=http://www.ddj.com/cpp/184403053|издательство=[[Dr. Dobb's Journal]]|год=январь 1995|издание=|archive-date=2008-06-07|archive-url=https://web.archive.org/web/20080607062859/http://www.ddj.com/cpp/184403053}}</ref><ref>{{cite web|author=Adrian Stone.|title=Minimizing Code Bloat: Redundant Template Instantiation|url=http://gameangst.com/?p=246|publisher=Game Angst|date=2009-09-22|access-date=2010-01-19|archive-url=https://web.archive.org/web/20111208031943/http://gameangst.com/?p=246|archive-date=2011-12-08|url-status=dead}}</ref>. Другим решением могла бы быть стандартизованная ещё в 1998 году возможность экспорта шаблонов, но она доступна далеко не во всех компиляторах, так как её трудно реализовать<ref>{{статья|автор=[[Саттер, Герб|Herb Sutter]].|заглавие=C++ Conformance Roundup|ссылка=http://www.ddj.com/cpp/184401381|издательство=[[Dr. Dobb's Journal]]|год=январь 2001|издание=|archive-date=2009-01-15|archive-url=https://web.archive.org/web/20090115075141/http://www.ddj.com/cpp/184401381}}</ref><ref>{{cite web|url=http://www.comeaucomputing.com/csc/faq.html#C8|title=Are there any compilers that implement all of this?|work=comp.std.c++ frequently asked questions / The C++ language |date=2008-12-10|publisher={{нп1|Comeau Computing||en|Comeau Computing}}|access-date=2010-01-19|url-status=dead |archive-url=https://web.archive.org/web/20090430065535/http://www.comeaucomputing.com/csc/faq.html#C8|archive-date=2009-04-30}}</ref><ref group="мнения">{{cite web |author=vanDooren |url=http://msmvps.com/blogs/vandooren/archive/2008/09/24/c-keyword-of-the-day-export.aspx|title=C++ keyword of the day: export|publisher=Blogs@MSMVPs|date=2008-09-24|access-date=2010-01-19|quote=The export keyword is a bit like the Higgs boson of C++. Theoretically it exists, it is described by the standard, and noone has seen it in the wild. … There is 1 C++ compiler front-end in the world which actually supports it|archive-url=https://web.archive.org/web/20090506053736/http://msmvps.com/blogs/vandooren/archive/2008/09/24/c-keyword-of-the-day-export.aspx|archive-date=2009-05-06|url-status=dead}}</ref> и для импорта библиотек шаблонов C++ в языки с существенно отличной от C++ семантикой она всё равно была бы бесполезна. Сторонники C++ оспаривают масштабы раздувания кода как преувеличенные<ref>{{cite web|author=[[Майерс, Скотт|Scott Meyers]] |url=http://groups.google.com/group/comp.lang.c++.moderated/browse_thread/thread/2b00649a935997f5/5feec243078c5fd8|title=Code Bloat due to Templates |work=comp.lang.c++.moderated|publisher=[[Usenet]]|date=2002-05-16|access-date=2010-01-19}}</ref>, игнорируя даже тот факт, что в Си параметрический полиморфизм транслируется непосредственно, то есть без дублирования тел функций вообще. При этом сторонники C++ считают, что параметрический полиморфизм в Си опасен — то есть более опасен, чем переход от Си к C++ (противники C++ утверждают обратное — см. выше).

==== Потенциал оптимизации ====
Из-за слабой системы типов и изобилия [[побочный эффект (программирование)|побочных эффектов]] становится крайне затруднительным эквивалентное преобразование программ, а значит и встраивание в компилятор многих оптимизирующих алгоритмов, таких как автоматическое [[распараллеливание программ]], [[удаление общих подвыражений]], λ-подъём, вызовы процедур с передачей [[Продолжение (информатика)|продолжений]], [[суперкомпиляция]] и др. В результате реальная эффективность программ на C++ ограничивается имеющейся квалификацией программистов и вложенными в конкретный проект усилиями, и «небрежная» реализация может существенно уступать по эффективности «небрежным» реализациям на языках более высокого уровня, что подтверждается сравнительными испытаниями языков<ref name="raytracer" />. Это является существенным препятствием против применения C++ в индустрии [[data mining]].

==== Эффективное управление памятью ====
Обязанность по эффективному управлению памятью ложится на плечи разработчика и зависит от навыков разработчика. Для автоматического управления памятью в C++ традиционно используются так называемые «умные указатели», ручное же управление памятью снижает эффективность самих программистов{{переход|Результативность}}. Многочисленные реализации [[сборка мусора|сборки мусора]], таких, как статический [[Управление памятью на основе регионов|вывод регионов]], не применимы для C++-программ (точнее, это требует реализации поверх языка C++ интерпретатора нового языка, сильно отличающегося от C++ как большинством объективных свойств, так и общей идеологией) по причине необходимости прямого доступа к [[Абстрактное синтаксическое дерево|абстрактному синтаксическому дереву]].

=== Результативность ===
<!-- Этот раздел рассматривает язык извне, и потому править его могут только те, кто НЕ является программистом на C++ сам, а нанимает их. Заказчикам важнее статистика, нежели обещания. Это следует иметь в виду C++-программистам — не знающим ничего, кроме C++, и принимающим критику C++ на личный счёт — прежде, чем вносить правки -->

Соотнесение факторов результативности с затратами на разработку, а также общую культивируемую в сообществе программистов дисциплину и культуру программирования важно принимать во внимание заказчикам, выбирающим язык C++ (и, соответственно, предпочитающим этот язык разработчикам) для реализации задуманных ими проектов, а также людям, начинающим изучать программирование, особенно с намерением программировать для собственных нужд.{{Нет АИ|20|10|2025}}

==== Качество и культура программирования ====
Принцип C++ ''«не навязывать „хороший“ стиль программирования»'' противоречит промышленному подходу к программированию, в котором ведущую роль играют [[качество программного обеспечения]] и возможность сопровождения кода не только автором, и для которого предпочтительны языки, сводящие к минимуму влияние [[человеческий фактор|человеческого фактора]], то есть как раз ''«навязывающие „хороший“ стиль программирования»'', хотя такие языки и могут иметь более высокий порог вхождения.

Существует мнение, что предпочтение использования C++ (при возможности выбора альтернативных языков) отрицательно характеризует профессиональные качества программиста. В частности, [[Торвальдс, Линус|Линус Торвальдс]] говорит, что использует положительное мнение кандидатов о C++ в качестве критерия отсева<ref name="torvalds" group="мнения">{{cite web |url=http://thread.gmane.org/gmane.comp.version-control.git/57643/focus=57918|title=Открытая переписка gmane.comp.version-control.git от 06.09.2007|access-date=2013-08-05|url-status=dead |archive-url=https://web.archive.org/web/20131209133259/http://thread.gmane.org/gmane.comp.version-control.git/57643/focus=57918|archive-date=2013-12-09}}</ref>:
{{начало цитаты}}C++ — кошмарный язык. Его делает ещё более кошмарным тот факт, что множество недостаточно грамотных программистов используют его… Откровенно говоря, даже если нет '''никаких''' причин для выбора Си, кроме того чтобы держать C++-программистов подальше — то одно это уже будет достаточно веским основанием для использования Си.<br>…Я пришёл к выводу, что '''действительно''' предпочту выгнать любого, кто предпочтёт вести разработку проекта на C++, нежели на Си, чтобы этот человек не загубил проект, в который я вовлечён.{{конец цитаты|источник=[[Торвальдс, Линус|Линус Торвальдс]],<ref name=autogenerated1 /> }}

==== Исправление исправного ====
Непрерывная эволюция языка побуждает (а порой вынуждает) программистов раз за разом изменять уже отлаженный код — это не только удорожает разработку, но и несёт риск внедрения в отлаженный код новых ошибок. В частности, хотя изначально обратная совместимость с Си была одним из базовых принципов C++, с 1999 года Си перестал быть подмножеством C++, так что отлаженный код на Си уже не может использоваться в проекте на C++ без изменений.

==== Сложность ради сложности ====
C++ определяется его апологетами как «мощнейший» ''именно потому'', что он изобилует опасными взаимно-противоречивыми возможностями. По мнению [[Реймонд, Эрик|Эрика Реймонда]], это делает язык почвой для личного самоутверждения программистов, превращения процесса разработки в самоцель:
{{начало цитаты}}Программисты — это зачастую яркие люди, которые гордятся … своей способностью справляться со сложностями и ловко обращаться с абстракциями. Часто они состязаются друг с другом, пытаясь выяснить, кто может создать «самые замысловатые и красивые сложности». … соперники полагают, что должны соревноваться с чужими «украшательствами» путём добавления собственных. Довольно скоро «массивная опухоль» становится индустриальным стандартом, и все используют большие, переполненные ошибками программы, которые не способны удовлетворить даже их создателей.<br>…<br>… такой подход может обернуться неприятностями, если программисты реализуют простые вещи сложными способами, просто потому что им известны эти способы и они умеют ими пользоваться.{{конец цитаты|источник=[[Реймонд, Эрик|Эрик Реймонд]] в <ref>{{книга | заглавие = Искусство программирования для Unix | автор = [[Реймонд, Эрик|Эрик Реймонд]] | оригинал = The Art of Unix | издательство = Вильямс | год = 2005 | isbn = 5-8459-0791-8 }}</ref>}}

==== Саботаж ====
Отмечены случаи{{Нет АИ|20|10|2025}}, когда нерадивые программисты, пользуясь сильной контекстной зависимостью C++ и отсутствием возможности отслеживания макроопределений компилятором, тормозили разработку проекта, написав одну-две лишних, корректных с точки зрения компилятора, строки кода, но внедрив за их счёт труднообнаружимую спонтанно проявляющуюся ошибку. Например:

<source lang="cpp" line="1">#define if(a) if(rand())</source>
<source lang="cpp" line="1">#define j i</source>

В [[чистота языка программирования|языках с доказанной корректностью]], даже с развитыми макросредствами, нанести урон подобным образом невозможно.

==== Ненадёжность продукта ====
Неоправданное обилие побочных эффектов в сочетании с отсутствием контроля со стороны системы времени исполнения языка и слабой системой типов делает программы на C++ подверженными непредсказуемым фатальным сбоям (общеизвестные падения с сообщениями типа «Access violation», «Pure virtual function call» или «Программа выполнила недопустимую операцию и будет закрыта»), что исключает применение C++ при высоких требованиях к отказоустойчивости. Кроме того, это увеличивает длительность самого процесса разработки<ref name="raytracer" />.

==== Менеджмент проектов ====
Перечисленные выше факторы делают сложность менеджмента проектов на C++ одной из самых высоких в индустрии разработки ПО.
{{начало цитаты}}Джеймс Коггинс, в течение четырёх лет ведущий колонку в ''The C++ Report'', даёт такое объяснение:<br> — Проблема в том, что программисты, работающие в ООП, экспериментировали с кровосмесительными приложениями и были нацелены на низкий уровень абстракции. Например, они строили такие классы как «связанный список», вместо «интерфейс пользователя», или «луч радиации», или «модель из конечных элементов». К несчастью, строгая проверка типов, которая помогает программистам C++ избегать ошибок, одновременно затрудняет построение больших объектов из маленьких.{{конец цитаты|источник=[[Брукс, Фредерик|Ф. Брукс]], [[Мифический человеко-месяц]]}}

== Влияние и альтернативы ==
<!-- на этот заголовок в статье есть ссылки -->
[[Файл:C Cpp compare.png|thumb|right|Программа «[[Hello, world!]]» {{nobr|на C и C++.}}]]
Единственным прямым потомком C++ является [[D (язык программирования)|язык D]], задуманный как переработка C++ для устранения наиболее очевидных его проблем. Авторы отказались от совместимости с Си, сохранив синтаксис и многие базовые принципы C++ и введя в язык возможности, характерные для новых языков. В D нет препроцессора, заголовочных файлов, множественного наследования, но есть система модулей, интерфейсы, ассоциативные массивы, поддержка [[unicode]] в строках, [[сборка мусора]] (при сохранении возможности ручного управления памятью) встроенная многопоточность, [[вывод типов]], явное объявление чистых функций и неизменяемых значений. Использование D весьма ограничено, считать его реальным конкурентом C++ нельзя.

Старейшим конкурентом C++ в задачах низкого уровня является [[Objective-C]], также построенный по принципу объединения [[Си (язык программирования)|Си]] с объектной моделью, только объектная модель унаследована от [[Smalltalk]]. Objective-C, как и его потомок [[Swift (язык программирования)|Swift]], широко используется для разработки ПО под macOS и iOS.

Одной из первых альтернатив C++ в прикладном программировании стал язык [[Java (язык программирования)|Java]]. Его часто ошибочно считают прямым потомком C++; в действительности семантика Java унаследована от языка [[Модула-2]], и основы семантики C++ в Java не прослеживаются. Учитывая это, а также генеалогию языков (Модула-2 является потомком [[Симула|Симулы]], как и C++, но им не является Си), Java правильнее называть ''«троюродным племянником»'' C++, нежели ''«наследником»''. То же можно сказать о языке [[C Sharp|C#]], хоть процент родственности с C++ у него несколько выше, чем у Java.

Попыткой совмещения безопасности и скорости разработки, характерных для Java и C#, с возможностями C++ явился диалект [[Managed C++]] (впоследствии — [[C++/CLI]]). Он разработан Microsoft в основном для переноса существующих проектов на C++ под платформу Microsoft.NET. Программы выполняются под управлением [[Common Language Runtime|CLR]] и могут использовать весь массив библиотек .NET, но при этом накладывается ряд ограничений на использование возможностей C++, что фактически сводит C++ к C#. Данный диалект не получил широкого признания и используется в основном лишь для связывания библиотек, написанных на чистом C++, с C#-приложениями.

Альтернативный путь развития языка Си — совмещение его не с объектно-ориентированным, а с [[аппликативное программирование|аппликативным программированием]], то есть улучшение абстракции, строгости и модульности низкоуровневых программ посредством обеспечения [[чистота языка программирования|предсказуемости поведения]] и [[Ссылочная прозрачность|ссылочной прозрачности]]. Примерами работ в этом русле служат языки [[BitC]], [[Cyclone (язык программирования)|Cyclone]] и [[Limbo]]. Хотя есть и успешные попытки применения ФП в задачах реального времени без интеграции со средствами Си<ref>{{статья |заглавие=Event-Driven FRP |автор=Zhanyong Wan and Paul Hudak |издание=Department of Computer Science, Yale University |ссылка=http://www.cs.rice.edu/~taha/publications/conference/padl02.pdf |archive-url=https://web.archive.org/web/20110816234039/http://www.cs.rice.edu/~taha/publications/conference/padl02.pdf |archive-date=2011-08-16 }}</ref><ref>{{Cite web|url=http://www.cs.rice.edu/~taha/publications/|title=Walid Taha|lang=en|website=School of Engineering Rice University|date=|access-date=2019-11-20|url-status=dead|archive-url=https://www.webcitation.org/6IqLu1AP0?url=http://www.cs.rice.edu/~taha/publications/|archive-date=2013-08-13}}</ref><ref>{{Cite web|url=http://www.it-c.dk/research/mlkit/index.php/Main_Page |title=MLKit |archive-url=https://web.archive.org/web/20130917074849/http://www.it-c.dk/research/mlkit/index.php/Main_Page|archive-date=2013-09-17|url-status=dead|access-date=2013-07-30}}</ref>, всё же на данный момент (2013 г.) в низкоуровневой разработке применение в той или иной мере средств Си имеет лучшее соотношение трудоёмкости с результативностью. Много усилий было приложено разработчиками [[Python (язык программирования)|Python]] и [[Lua]] для обеспечения использования этих языков программистами на C++, так что из всех языков, достаточно тесно связанных с ФП, именно они чаще всего отмечаются в совместном использовании с C++ в одном проекте. Наиболее значимыми точками соприкосновения C++ с ФП можно считать привязки разработанных на C++ библиотек [[wxWidgets]] и [[Qt]] с характерной для C++ идеологией к языкам [[Lisp]], [[Haskell]] и [[Python (язык программирования)|Python]] (в большинстве случаев привязки к функциональным языкам делают для библиотек, написанных на Си или на других функциональных языках).

Ещё одним языком, рассматриваемым как конкурент C++, стал [[Nemerle]], являющийся результатом попытки совместить [[модель типизации Хиндли-Милнера]] и макроподмножество [[Common Lisp]] с языком C#<ref>{{статья
| заглавие = Синтаксический сахар или C++ vs. Nemerle :)
| автор = Чистяков Влад aka VladD2
| издание = RSDN Magazine #1-2006
| год = 24.05.2006
| ссылка = http://rsdn.ru/?article%2Fphilosophy%2FSyntacticSugar.xml
| archive-date = 2013-12-13
| archive-url = https://web.archive.org/web/20131213061243/http://rsdn.ru/?article%2Fphilosophy%2FSyntacticSugar.xml
}}</ref>. В том же русле находится созданный Microsoft язык [[F Sharp|F#]] — диалект [[ML]], адаптированный для среды .NET.

Попыткой создать промышленную замену Си и C++ стал разработанный в корпорации Google в 2009 году язык программирования [[Go]]. Авторы языка прямо указывают, что мотивом для его создания были недостатки процесса разработки, вызванные особенностями языков [[Си (язык программирования)|Си]] и C++<ref name="designGo">{{Cite web|url=https://talks.golang.org/2012/splash.article|title=Go at Google: Language Design in the Service of Software Engineering|publisher=talks.golang.org|access-date=2017-09-19|archive-date=2021-01-25|archive-url=https://web.archive.org/web/20210125205239/https://talks.golang.org/2012/splash.article|url-status=live}}</ref>. Go — компактный, несложный по структуре императивный язык с Си-подобным синтаксисом, без препроцессора, со статической типизацией, строгим контролем типов, системой пакетов, автоматическим управлением памятью, некоторыми функциональными чертами, экономно построенной ООП-подсистемой без поддержки наследования реализации, но с интерфейсами и [[Утиная типизация|утиной типизацией]], встроенной многопоточностью, основанной на сопрограммах и каналах (в духе [[Occam]]). Язык позиционируется как альтернатива C++, то есть, в первую очередь, средство групповой разработки высокоэффективных вычислительных систем большой сложности, в том числе распределённых, допускающее, при необходимости, низкоуровневое программирование.

В одной нише с Си и C++ находится разработанный в 2010 году и поддерживаемый корпорацией [[Mozilla Corporation|Mozilla]] язык [[Rust (язык программирования)|Rust]], ориентированный на безопасное [[управление памятью]] без использования [[Сборка мусора|сборщика мусора]]. В частности, о планах частичной замены Си и C++ на Rust объявила в 2019 компания [[Microsoft]]<ref>{{Cite web|url=https://www.zdnet.com/article/microsoft-to-explore-using-rust/|title=Microsoft to explore using Rust|author=Catalin Cimpanu|website=|date=2019-06-17|publisher=ZDNet|lang=en|access-date=2019-09-26|archive-date=2019-10-15|archive-url=https://web.archive.org/web/20191015014736/https://www.zdnet.com/article/microsoft-to-explore-using-rust/|url-status=live}}</ref>.

В 2022 году компания Google представила новый экспериментальный язык программирования [[Carbon (язык программирования)|Carbon]], созданный с целью стать преемником C++. В отличие от Rust, язык должен предоставлять двунаправленную совместимость с C++ и лучшую читаемость.

== Примечания ==
{{примечания}}
'''Мнения'''
{{примечания|group="мнения"}}
'''Пояснения'''
{{примечания|group="пояснения"}}

== Литература ==
* {{книга
|автор=[[Страуструп, Бьёрн|Бьёрн Страуструп]].
|заглавие=Язык программирования C++
|оригинал=The C++ Programming Language
|ответственный=Пер. с англ
|издание=3-е изд|место={{СПб}}; {{М}}
|издательство=[[Невский диалект]] — [[Бином (издательство)|Бином]]
|год=1999
|страниц=991
|isbn=5-7940-0031-7 (Невский диалект), ISBN 5-7989-0127-0 (Бином), ISBN 0-201-88954-4 (англ.)
|тираж=3000
|ref=Страуструп}}
* {{книга
|автор = [[Страуструп, Бьёрн|Бьёрн Страуструп]]
|заглавие = Язык программирования C++. Специальное издание
|оригинал = The C++ programming language. Special edition
|место = М.
|издательство = Бином-Пресс
|год = 2007
|страниц = 1104
|isbn = 5-7989-0223-4
}}
* {{книга
|автор = [[Страуструп, Бьёрн|Бьёрн Страуструп]]
|заглавие = Программирование: принципы и практика использования C++, исправленное издание
|оригинал = Programming: Principles and Practice Using C++
|страницы = 1248
|isbn = 978-5-8459-1705-8
|год = 2011
|место = М.
|издательство = [[Вильямс (издательство)|Вильямс]]
|ref= Страуструп, Программирование: принципы и практика использования C++
}}
* {{книга
|автор = [[Страуструп, Бьёрн|Бьёрн Страуструп]]
|заглавие = Дизайн и эволюция C++
|оригинал = The Design and Evolution of C++
|место = СПб.
|издательство = Питер
|год = 2007
|страниц = 445
|isbn = 5-469-01217-4
|ref= Страуструп, Дизайн и эволюция C++
}}
* {{книга
|автор = [[Страуструп, Бьёрн|Бьёрн Страуструп]]
|заглавие = Язык программирования C++. Краткий курс
|оригинал =
|место =
|издательство =
|год = 2019
|страниц = 320
|isbn = 978-5-907144-12-5
|ref=
}}
* {{книга
|автор = [[Страуструп, Бьёрн|Бьёрн Страуструп]]
|заглавие = Программирование: принципы и практика с использованием C++
|оригинал =
|место =
|издательство =
|год = 2016
|страниц = 1328
|isbn = 978-5-8459-1949-6
|ref=
}}

* {{книга
|заглавие = Освой самостоятельно C++ за 21 день, 7-е издание (C++11)
|оригинал = Sams Teach Yourself C++ in One Hour a Day, 7th Edition
|автор = Сиддхартха Рао
|страниц = 688
|isbn = 978-5-8459-1825-3
|год = 2013
|место =  М.
|издательство = [[Вильямс (издательство)|«Вильямс»]]
}}
* {{книга
|автор = Стефенс Д. Р.
|заглавие = C++. Сборник рецептов
|издательство = КУДИЦ-ПРЕСС
|год = 2007
|страниц = 624
|isbn = 5-91136-030-6
}}
* {{книга
|автор = Стивен Прата.
|заглавие = Язык программирования C++ (C++11). Лекции и упражнения |издание = 6-е изд
|оригинал = C++ Primer Plus, 6th Edition (Developer’s Library)
|страниц = 1248
|isbn = 978-5-8459-1778-2
|год = 2012
|место = М.
|издательство = [[Вильямс (издательство)|Вильямс]]
}}
* {{книга
|автор = Стивен Прата.
|заглавие = Язык программирования С. Лекции и упражнения
|оригинал =
|страниц = 928
|isbn = 978-5-8459-1950-2
|год = 2015
|место = М.
|издательство = [[Вильямс (издательство)|Вильямс]]
}}
* {{книга
|автор = Айвор Хортон.
|заглавие = Visual C++ 2010: полный курс
|оригинал = Ivor Horton’s Beginning Visual C++ 2010
|страницы = 1216
|isbn = 978-5-8459-1698-3
|год = 2010
|место = М.
|издательство = [[Диалектика (издательство)|Диалектика]]
}}
* {{книга
|автор = [[Шилдт, Герберт|Герберт Шилдт]].
|заглавие = Полный справочник по C++ |издание = 4-е изд
|оригинал = C++: The Complete Reference
|страницы = 800
|isbn = 978-5-8459-0489-8
|год = 2011
|место = М.
|издательство = [[Вильямс (издательство)|Вильямс]]
|ref = Шилдт
}}
* {{книга
|автор = [[Шилдт, Герберт|Герберт Шилдт]]
|заглавие = Теория и практика C++
|оригинал = Shildt's Expert C++
|издательство = BHV — Санкт-Петербург
|место = {{СПб}}
|год = 1996
|isbn = 0-07-882209-2, 5-7791-0029-2
|ref = Шилдт, Теория и практика C++
}}
* {{статья
| заглавие = Programming Language Guessing Games - If C++ is the Answer, what’s the question?
| автор = P.J. Plauger. <!-- Соавтор книги "B. Kernighan and P.J. Plauger. The Elements of Programming Style" (McGraw-Hill, 1988) ISBN 0070342075. -->
| издание = [[Dr. Dobb's Journal]]
| год = Октябрь, 1993
| ссылка =
| ref = Plauger
}}
* {{книга
|заглавие=The Unix-Haters Handbook
|ссылка=http://web.mit.edu/~simsong/www/ugh.pdf
|издательство=[[International Data Group]]
|ref=Unix-Haters
|язык=
|год=1994
}}
* {{статья
| заглавие =A Critique of C++ and Programming and Language Trends of the 1990s - 3rd Edition
| автор = Ian Joyner.
| ссылка = http://www.quinn.echidna.id.au/quinn/C++-Critique-3ed.pdf
| издание = [http://www.emu.edu.tr/aelci/Courses/D-318/D-318-Files/cppcrit/index008.htm копирайт и список изданий]
| год = 1996
| ref = Joyner
}}
* {{книга
|автор=Скотт Мейерс
|заглавие=Эффективный и современный C++: 42 рекомендации по использованию C++11 и C++14
|оригинал=Effective Modern C++: 42 Specific Ways to Improve Your Use of C++11 and C++14
|ответственный=Пер. с англ
|издательство=Вильямс
|год=2016
|страниц=304
|isbn=978-5-8459-2000-3
}}
* {{книга
| заглавие = C++ The Complete Reference Third Edition
| ссылка = https://archive.org/details/ccompletereferen00schi_1
| автор = [[Шилдт, Герберт|Herbert Schildt]].
| издательство = Osborne McGraw-Hill
| год = 1998
| isbn = 978-0-07-882476-0
|ref = Шилдт
}}
* [https://rooksguide.org Jeremy A. Hansen. The Rook’s Guide to C++ (A Creative Commons-Licensed Textbook)].

== Ссылки ==
{{Навигация
 | Тема         = C++
 | Викитека     = ISO/IE 14882:2011}}
* {{Официальный сайт}}
** [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/ рабочие материалы комитета по стандартизации за 2009-й год]
* Бьёрн Страуструп. [https://github.com/isocpp/ CppCoreGuidelines]{{ref|en}} The C++ Core Guidelines are a set of tried-and-true guidelines, rules, and best practices about coding in C++
* Бьёрн Страуструп. [http://www.artima.com/cppsource/cpp0x.html Краткий обзор C++0x]{{ref|en}}
* [http://groups.google.com/group/comp.lang.c++.moderated/topics comp.lang.c++.moderated]{{ref|en}}
* {{cite web
| title = C++ FQA Lite
| author = Yossi Kreinin.
| url = http://yosefk.com/c++fqa/index.html
| access-date  =
| archive-url  =
| archive-date =
| ref = C++ FQA
}}
* {{cite web
| author = [[Торвальдс, Линус|Линус Торвальдс]].
| title = Convert builin-mailinfo.c to use The Better String Library
| publisher = [http://thread.gmane.org Gmane forum]
| url = http://thread.gmane.org/gmane.comp.version-control.git/57643/focus=57918
| date = 2007-09-06
| access-date =
| archive-url = https://web.archive.org/web/20131209133259/http://thread.gmane.org/gmane.comp.version-control.git/57643/focus=57918
| archive-date = 2013-12-09
| ref = Torvalds - Convert builin-mailinfo.c
| url-status = dead
}}

{{внешние ссылки}}
{{Стандарты ISO}}
{{Язык программирования C++}}

[[Категория:C++| ]]
[[Категория:Языки программирования с ручным управлением памятью]]
[[Категория:Высокоуровневые языки программирования]]
[[Категория:Низкоуровневые языки программирования]]