• Внутри структуры или класса можно описывать новые типы, как через typedef, так и через описание других структур или классов. Для доступа к таким типам вне структуры или класса, к имени типа добавляется имя структуры и два двоеточия:

Стандартная библиотека

Стандартная библиотека Си++ включает стандартную библиотеку Си с небольшими изменениями, которые делают её более подходящей для языка Си++. Другая большая часть библиотеки Си++ основана на Стандартной Библиотеке Шаблонов (STL). Она предоставляет такие важные инструменты, как контейнеры (например, векторы и списки) и итераторы (обобщённые указатели), предоставляющие доступ к этим контейнерам как к массивам. Кроме того, STL позволяет сходным образом работать и с другими типами контейнеров, например, ассоциативными списками, стеками, очередями.

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

Так же, как и в Си, возможности библиотек активизируются использованием директивы #include для включения стандартных файлов. Всего в стандарте Си++ определено 50 таких файлов.

STL до включения в стандарт Си++ была сторонней разработкой, в начале — фирмы HP, а затем SGI. Стандарт языка не называет её «STL», так как эта библиотека стала неотъемлемой частью языка, однако многие люди до сих пор используют это название, чтобы отличать её от остальной части стандартной библиотеки (потоки ввода/вывода (Iostream), подраздел Си и др.).

Проект под названием STLPort, основанный на SGI STL, осуществляет постоянное обновление STL, IОstream и строковых классов. Некоторые другие проекты также занимаются разработкой частных применений стандартной библиотеки для различных конструкторских задач. Каждый производитель компиляторов Си++ обязательно поставляет какую-либо реализацию этой библиотеки, так как она является очень важной частью стандарта и широко используется.

Объектно-ориентированные особенности языка

Си++ добавляет к Си объектно-ориентированные возможности. Он вводит классы, которые обеспечивают три самых важных свойства ООП: инкапсуляцию, наследование и полиморфизм.

Проблемы старого подхода

В языке C основным способом организации данных были структуры. Структура состоит из набора полей, которые никак не защищены. Если элементы структуры имеют переменную длину, их представляют в виде указателей. Выделение и освобождение памяти под эти указатели делаются вручную. Так, например, одномерный массив переменной длины в языке C с проверкой границ может представлятся таким образом:

struct Array { double* val; int len; };

void FreeArray(const struct Array*); void AllocArray(const struct Array*, int len); double Elem(const struct Array*, int i); void ChangeElem(const struct Array*, int i, double x);

Такая реализация опасна и неэффективна по многим причинам:

• Необходимо вызывать FreeArray и AllocArray. Программист может забыть вызвать одну из этих функций, или вызвать её слишком рано/поздно, или дважды, или с указателем на неправильный массив. Всё это приводит к труднообнаруживаемым ошибкам.
• Функции Elem и ChangeElem медленны.
• Нет никакого способа помешать программистам создавать и другие функции для работы со структурой Array. Эти функции могут делать с полями len и val всё что угодно.
• Нет никакого способа помешать программистам непосредственно менять поля len и val.
• Присваивание объектов типа struct Array приведёт к тому, что их поля val будут указывать на одну и ту же область памяти. Нет никакого способа ни запретить присваивание, ни изменить такое поведение.

Язык Си++ , используя ООП, устраняет все эти проблемы.

Инкапсуляция

Основным способом организации информации в Си++ являются классы. В отличие от типа структура (struct) языка Си, состоящей только из полей, класс (class) Си++ состоит из полей и функций-членов (member functions). Поля бывают публичными (public), защищёнными (protected) и собственными (приватными, private). В Си++ тип структура аналогичен типу класс, отличие в том, что по умолчанию поля и функции-члены у структуры публичные, а у класса - собственные.

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

Используя инкапсуляцию, автор класса может защитить свои данные от некорректного использования. Кроме того, она задумывалась для облегчения совместной разработки классов. Имелось ввиду, что при изменении способа хранения данных, если они объявлены как защищенные или собственные, не требуется соответствующих изменений в классах, которые используют измененный класс. Например, если в старой версии класса данные хранились в виде линейного списка, а в новой версии - в виде дерева, те классы, которые были написаны до изменения формата хранения данных, переписывать не потребуется, если данные были приватными или защищенными (в последнем случае - если использующие классы не были классами-наследниками), так как ни один из них этих классов не мог бы напрямую обращаться к данным, а только через стандартные функции, которые в новой версии должны уже корректно работать с новым форматом данных. Даже оператор доступа operator ^* может быть определён как такая стандартная функция.

Функции-члены, как и поля, могут быть публичными, защищёнными и собственными. Публичные функции может вызывать кто угодно, а защищённые и собственные - только функции-члены и друзья.

Используя инкапсуляцию, структуру Array из предыдущего раздела можно переписать следующим образом: class Array { public: void Alloc(int _len); void Free(); inline double Elem(int i); inline void ChangeElem(int i, double x); protected: int len; double* val; };

void Array::Alloc(int new_len) {if (len>0) Free(); val=new double^*;} void Array::Free() {delete ^* val; len=0;} inline void Array::Elem(int i) {assert(i>=0 && i^*;} inline void Array::ChangeElem(int i, double x) {assert(i>=0 && i^*=x;}

И далее

Array a; a.Alloc(10); a.ChangeElem(3, 2.78); double b = a.Elem(3); a.Free();

Здесь массив a имеет 4 публичных функции-члена и 2 защищённых поля. Описатель inline означает, что вместо вызова функции ее код подставляется в точку вызова, что решает проблему неэффективности.

Описание функций в теле класса

В теле класса можно указать только заголовок функции, а можно описать всю функцию. Во втором случае она считается встроенной (inline), например:

class Array { public: void Alloc(int _len) {if (len==0) Free(); len=_len; val=new double^*;}

и так далее.

Конструкторы и деструкторы

Однако в приведённом примере не решена важная проблема: функции Alloc и Free по-прежнему надо вызывать вручную. Другая проблема данного примера — опасность оператора присваивания.

Для решения этих проблем в язык были введены конструкторы и деструкторы. Конструктор вызывается каждый раз, когда создаётся объект данного типа; деструктор - при уничтожении. При преобразованиях типов, присваивании, передаче параметра тоже вызываются конструкторы и при необходимости деструкторы.

С конструкторами и деструктором класс выглядит так:

class Array { public: Array() : len(0), val(NULL); Array(int _len) : len(_len) {val = new double^*;} Array(const Array& a); ~Array() : Free(); inline double Elem(int i); inline void ChangeElem(int i, double x); protected: void Alloc(int _len); void Free(); int len; double* val; };

Array::Array(const Array& a) : len(a.len) { val = new double^*; for (int i=0; i= a.val[i; }

Здесь Array::Array - конструктор, а Array::~Array - деструктор. Конструктор копирования (copy constructor) Array::Array(const Array&) вызывается при присваивании. Теперь объект класса Array нельзя испортить: как бы мы его ни создавали, что бы мы ни делали, его значение будет хорошим, потому что конструктор вызывается автоматически. Все опасные операции с указателями спрятаны в защищённые функции.

Array a(5); // вызывается Array::Array(int) Array b; // вызывается Array::Array() Array c(a); // вызывается Array::Array(const Array&) Array d=a; // то же самое b=c; // происходит вызов оператора = // если он не определен (как в данном случае), то // вызывается Array::Array(const Array&)

Оператор new тоже вызывает конструкторы, а delete - деструкторы.

По умолчанию, каждый класс имеет конструктор без параметров и деструктор. Конструктор без параметров по умолчанию вызывает конструкторы всех элементов, а деструктор - их деструкторы. Другие конструкторы по умолчанию не определены.

Класс может иметь сколько угодно конструкторов (с разными наборами параметров), но только один деструктор (без параметров).

Другие возможности функций-членов

Функции-члены могут быть и операциями:

class Array { ... inline double &operator^* (int n);

И далее

Array a(10); ... double b = a^*;

Функции-члены (и только они) могут иметь описатель const class Array { ... inline double operator^* (int n) const; Такие функции не имеют права изменять поля класса. Если они пытаются это сделать, компилятор должен выдать сообщение об ошибке.

Наследование

Для создания классов с добавленной функциональностью вводят наследование. Класс-наследник имеет поля и функции-члены базового класса, но не имеет права обращаться к собственным (private) полям и функциям базового класса. В этом и заключается разница между собственными и защищёнными членами.

Класс-наследник может добавлять свои поля и функции или переопределять функции базового класса.

По умолчанию, конструктор наследника без параметров вызывает конструктор базового класса, а затем конструкторы добавленных элементов. Деструктор работает в обратном порядке. Другие конструкторы приходится определять каждый раз заново. К счастью, это можно сделать вызовом конструктора базового класса.

class ArrayWithAdd : public Array { ArrayWithAdd(int n) : Array(n) {} ArrayWithAdd() : Array() {} ArrayWithAdd(const Array& a) : Array(a) {} void Add(const Array& a); };

Наследник - это больше чем базовый класс, поэтому он может использоваться везде, где используется базовый класс, но не наоборот.

Наследование бывает публичным, защищённым и собственным. При публичном наследовании, публичные и защищённые члены базового класса сохраняют свой статус, а к собственным не могут обращаться даже функции-члены наследника. Защищённое наследование отличается тем, что при нём публичные члены базового класса являются защищёнными членами наследника. При собственном наследовании, ни к каким членам базового класса даже функции-члены наследника не имают права обращаться. Как правило, публичное наследование встречается значительно чаще других.

Класс может быть наследником нескольких классов. Это называется множественным наследованием. Такой класс обладает полями и функциями-членами всех его предков. Например, класс FlyingCat (ЛетающийКот) может быть наследником классов Cat (Кот) i FlyingAnimal (ЛетающееЖивотное) class Cat { ... void Purr(); ... }; class FlyingAnimal { ... void Fly(); ... }; class FlyingCat : public Cat, public FlyingAnimal { ... PurrAndFly() {Purr(); Fly();} ... };

Полиморфизм

Полиморфизмом называется переопределение наследником функций-членов базового класса, например class Figure { ... void Draw() const; ... };

class Square : public Figure { ... void Draw() const; ... };

class Circle : public Figure { ... void Draw() const; ... };

В этом примере, какая из функций будет вызвана - Circle::Draw(), Square::Draw() или Figure::Draw(), определяется во время компиляции. К примеру, если написать Figure* x = new Circle(0,0,5); x->Draw(); то будет вызвана Figure::Draw(), поскольку x - объект класса Figure. Такой полиморфизм называется статическим.

Но в C++ есть и динамический полиморфизм, когда вызываемая функция определяется во время выполнения. Для этого функции-члены должны быть виртуальными.

class Figure { ... virtual void Draw() const; ... };

class Square : public Figure { ... virtual void Draw() const; ... };

class Circle : public Figure { ... virtual void Draw() const; ... };

Figure* figures^*; figures^* = new Square(1,2,10); figures^* = new Circle(3,5,8); ... for (int i=0; i<10; i++) figures^* -> Draw();

В этом случае для каждого элемента будет вызвана Square::Draw() или Circle::Draw() в зависимости от вида фигуры.

Чисто виртуальной функцией называется функция-член, которая не определена в базовом классе, а только в наследниках: class Figure { ... virtual void Draw() const = 0; Вот это = 0 и значит, что функция чисто виртуальная.

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

Друзья

Функции-друзья — это функции, не являющиеся функциями-членами и тем не менее имеющие доступ к защищённым и собственным полям и функциям-членам класса. Они должны быть описаны в теле класса как friend. Например: class Matrix { ... friend Matrix Multiply(Matrix m1, Matrix m2); ... }; Matrix Multiply(Matrix m1, Matrix m2) { ... }

Здесь функция Multiply может обращаться к любым полям и функциям-членам класса Matrix.

Существуют также классы-друзья. Если класс A - друг класса B, то все его функции-члены могут обращаться к любым полям и функциям членам класса B. Например: class Matrix { ... friend class Vector; ... };

Однако в С++ не действует правило «друг моего друга — мой друг».

Будущее развитие

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

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

Тем не менее (по состоянию на время написания этой статьи) среди компиляторов Си++ всё ещё продолжается битва за полную реализацию стандарта Си++, особенно в области шаблонов — части языка, совсем недавно полностью разработанной комитетом стандартизации.

Одной из точек преткновения в этом вопросе является ключевое слово export, используемое также и для разделения объявления и определения шаблонов.

Первым компилятором, поддерживающим export в шаблонах, стал Comeau C++ в начале 2003 года (спустя пять лет после выхода стандарта). В 2004 году бета-версия компилятора Borland C++ Builder X также начала его поддержку.

Оба этих компилятора основаны на внешнем интерфейсе EDG. Другие компиляторы, такие как Microsoft Visual C++ или GCC, вообще этого не поддерживают. Эрб Саттер (Herb Sutter), секретарь комитета по стандартизации Си++, рекомендовал убрать export из будущих версий стандарта по причине серьёзных сложностей в полноценной реализации, однако впоследствии окончательным решением было решено его оставить.

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

История имени «Си++»

Это имя было изобретено Риком Маскитти (Rick Mascitti) и было впервые использовано в декабре 1983 года. Ранее, на этапе разработки, новый язык называли «Си с классами». Имя, получившееся в итоге, происходит от оператора Си «++» (увеличение значения переменной на единицу) и распространённому способу присвоения новых имён компьютерным программам, заключающимся в добавлении к имени символа «+» для обозначения улучшений (например «Википедия+»). Согласно Страуструпу: «это название указывает на эволюционную природу изменений Cи». Ранее выражение «С+» обозначало несвязанную программу.

Некоторые программисты на Си могут заметить, что если выполняются выражения x=3; y=x++; то в результате получится x=4 и y=3, потому, что x увеличивается только после присвоения его y. Однако, если второе выражение будет y=++x; то получится x=4 и y=4. Исходя из этого, можно сделать вывод, что более логично было бы назвать язык не Си++, а ++Си. Однако оба выражения c++ и ++c увеличивают c, а кроме того выражение c++ более распространено. Педанты также могут заметить, что введение языка Си++ не изменяет самого Си, поэтому самым точным именем было бы «С+1».

Си++ не включает в себя Си