Навчальні дисципліни

SQL [1]
Мова структурованих запитів

Філософія [1]
Особлива форма пізнання світу, що вивчає найбільш загальні суттєві характеристики і фундаментальні принципи реальності і пізнання, буття людини, відносин людини і світу[

Недавно додані

Деякі поняття
→ Детально

Мова структурованих запитів
→ Детально

Найпопулярніші теми

[7036 переглядів]
Мова структурованих запитів → Детально

[3310 переглядів]
Деякі поняття → Детально

[138 переглядів]
Лечебная грязь Шаболатского лимана → Детально

[66 переглядів]
Работа водитель такси → Детально

Оновлюються 2 матеріали

Особливості С++
В цьому розділі описуються можливості, безпосередньо не пов'язані з об'єктно-орієнтованим програмуванням (ООП). Багато які з них, проте, особливо важливі у поєднанні з ООП.

Ключове слово inline означає, що функція є хорошим кандидатом на оптимізацію, при якій в місцях звернення до функції компілятор вставить тіло цієї функції, а не код виклику. Приклад: inline double Sqr(double x) {return x*x;}
Замість функцій malloc і free, введені нові оператори new і delete. Якщо T — довільний тип, то
new T виділяє пам'ять, достатню для розміщення одного об'єкта типу Т; після завершення виклику оператора, компілятор здійснює ініціалізацію об'єкта (викликаючи його конструктор, якщо такий був визначний) і повертає вказівник типу Т*.
new T[n] виділяє пам'ять, достатню для розміщення n об'єктів типу Т; після завершення виклику оператора, компілятор здійснює ініціалізацію кожного з n об'єктів і повертає вказівник типу Т*.
delete p — звільняє пам'ять, на яку посилається вказівник p, виділену для нього раніше операцією new T. Деініціалізація об'єкта (викликаючи деструктора) забезпечується компілятором ще до виклику оператора delete.
delete [] p — звільняє область пам'яті, виділену для цього масиву раніше операцією new T[n]. Деініціалізація кожного елементу масиву забезпечується компілятором ще до виклику оператора.

Як видно, однією з принципових відмінностей операторів new та delete від своїх попередників, malloc і free, є обов'язковість ініціалізації об'єктів, пам'ять під які було призначено. Іншою відмінністю є те, що загальна реалізація (тобто визначена за умовчанням) оператора new не повертає нулеву вартість вказівника в випадку помилки призначення пам'яті (наприклад з причини її браку). Натомість, new кидає виняток (наприклад, std::bad_alloc в ситуації браку пам'яті). Так само як і для free, якщо вартістю аргументу оператора delete є 0, ані звільнення пам'яті, ані деініціація не відбувається (при тому, подібна ситуація не вважається помилковою).

Функції можуть приймати аргументи за посиланням. Наприклад, функція void f(int& x) {x=3;} присвоює своєму аргументу значення 3. Функції також можуть повертати результат за посиланням, і посилання можуть бути поза всяким зв'язком з функціями. Наприклад, {double&b=a[3]; b=sin(b);} еквівалентно а[3]=sin(а[3]);. Посилання певною мірою схожі з вказівниками, з такими особливостями: при описі посилання ініціалізувалися вказівкою на існуюче значення даного типу; посилання довічно указує на одну і ту ж адресу; при зверненні до посилання операція читання пам'яті за адресою посилання проводиться автоматично. На відміну від вказівників, посилання не може бути константним саме по собі, однак може посилатися на константний об'єкт. Наприклад, int const & const ref = a[3]; на відміну від int const * const ref = &a[3]; — є некоректним, з точки зору С++, виразом; в свою чергу, і int const & ref = a[3];, і int const * ref = &a[3]; — є цілком прийнятними.
Можуть бути декілька функцій з одним і тим же ім'ям, але різними типами або кількістю аргументів (перевантаження функцій; при цьому тип значення, що повертається, на перевантаження не впливає). Наприклад, цілком можна писати:

void Print(int x);
void Print(double x);
void Print(int x, int y);

Один або декілька останніх аргументів функції можуть задаватися за умовчанням. Наприклад, якщо функція описана як void f(int x, int y=5, int z=10), виклики f(1), f(1,5) і f(1,5,10) еквівалентні.
При описі функцій відсутність аргументів в дужках означає, на відміну від Сі, що аргументів немає, а не те, що вони невідомі. Якщо аргументи невідомі, треба користуватися багатокрапкою, наприклад int printf(const char* fmt …). Тип першого аргументу повинен бути заданий.
Можна описувати оператори над новими типами. Наприклад, так:

struct Date {int day, month, year;};
void operator ++(struct Date& date);

Оператори нічим не відрізняються від (інших) функцій. Не можна описувати оператори над зумовленими типами (скажімо, перевизначати множення чисел); не можна вигадувати нові операції, яких немає в Сі++ (скажімо **); арність (кількість параметрів) і пріоритет операцій зберігається (скажімо, у виразі a+b*c спочатку виконуватиметься множення, а потім складання, до яких би типів не належали а, b і с.) Можна перевизначити оператор [] (з одним параметром) і () (з будь-яким числом параметрів).

Додані простори імен namespace. Наприклад, якщо написати

namespace Foo {
const int x=5;
typedef int** T;
void f(y) {return y*x};
double g(T);
...
}

то поза фігурними дужками ми повинні звертатися до T, x, f, g як Foo::T, Foo::x, Foo::f, Foo::g. Якщо ми в якійсь одиниці трансляції (файл основного коду, наприклад myFile.cpp, та всі заголовкові файли що він включає) хочемо звертатися до них безпосередньо, ми можемо написати

using namespace Foo;

Або ж

using Foo::T;

Також можна створити синонім на вже існуючий простір імен (наприклад, аби уникнути постійно повторювати довгу назву простору)

namespace MyVeryOwnNameSpace {
typedef std::vector< std::string > StringTable;
}
namespace My = MyVeryOwnNameSpace;

Простори імен потрібні, щоб не виникало колізій між пакетами, що мають однакові імена глобальних змінних, функцій і типів. Спеціальним випадком є безіменний простір імен

namespace {
...
}

Всі імена, описані в ньому, доступні в поточній одиниці трансляції і більше ніде, неначебто ми до кожного опису приписали static.

Доданий новий тип bool, що має значення true і false. Операції порівняння повертають тип bool. Вирази в дужках після if, while приводяться до типу bool.
// означає, що вся частина рядка, що залишилася, є коментарем.
Додані шаблони (template). Наприклад, template<class T> T Min(T x, T у) {return x<y?x:y;} визначає функцію Min для будь-яких типів. Шаблони можуть задавати не тільки функції, але і типи. Наприклад, template<class T> struct Array{int len; T* val;}; визначає масив значень будь-якого типу, після чого ми можемо писати Array<float> x;
Введена стандартна бібліотека шаблонів (STL, англ. Standard Template Library), що визначає шаблони і функції для векторів (одновимірних масивів довільної довжини), множин, асоціативних масивів (map), списків, символьних рядків, потоків введення-виводу і інші шаблони і функції.
Якщо описана структура, клас (про класи див. нижче), об'єднання (union) або перерахування (enum), її ім'я є ім'ям типу, наприклад:

struct Time{int hh,mm,ss;};
Time t1, t2;

Усередині структури або класу можна описувати нові типи, як через typedef, так і через опис інших структур або класів. Для доступу до таких типів поза структурою або класу, до імені типу додається ім'я структури і дві двокрапки:

struct S {typedef int** T; T x;}; S::T у;

Об'єктно-орієнтовані особливості мови

Сі++ додає до Сі об'єктно-орієнтовані можливості. Він вводить класи, які забезпечують три найважливіші властивості ООП: інкапсуляцію, успадкування і поліморфізм.
Проблеми старого підходу

В мові 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 new_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(); len=new_len; val=new double[new_len];}
void Array::Free() {delete [] val; len=0;}
inline double Array::Elem(int i)
{assert(i>=0 && i<len ); return val;}
inline void Array::ChangeElem(int i, double x)
{assert(i>=0 && i<len); val=x;}

І далі

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

Тут масив а має 4 публічних функції-члена і 2 захищених поля. Описувач inline означає, що замість виклику функції її код підставляється в точку виклику, що вирішує проблему неефективності.
Опис функцій в тілі класу

В тілі класу можна вказати тільки заголовок функції, а можна описати всю функцію. У другому випадку вона вважається вбудованою (inline), наприклад:

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

і так далі.
Конструктори і деструктори

Проте в наведеному прикладі не вирішена важлива проблема: функції Alloc і Free як і раніше треба викликати вручну. Інша проблема даного прикладу — небезпека оператора присвоєння. Для вирішення цих проблем в мову були введені конструктори і деструктори. Конструктор викликається щоразу, коли створюється об'єкт даного типу; деструктор — при знищенні. При перетвореннях типів, присвоєнні, передачі параметра теж викликаються конструктори і при необхідності деструктори.

З конструкторами і деструкторами клас виглядає так:

class Array {
public:
Array() : len(0), val(NULL) {}
Array(int _len) : len(_len) {val = new double[_len];}
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[len];
for (int i=0; i<len; i++)
val = a.val;
}

Тут 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; // відбувається виклик оператора =
// якщо він не визначений (як в даному випадку), то викликається оператор присвоєння за умовчанням, який
// здійснює побітове копіювання для базових типів і виклик оператора присвоєння для користувача
// як правило, конструктор копій і оператор присвоєння перевизначаються попарно

Оператор new теж викликає конструктори, а delete — деструктори.

За умовчанням, кожен клас має конструктор без параметрів і деструктор. Конструктор без параметрів за умовчанням викликає конструктори всіх елементів, а деструктор — їхні деструктори. Інші конструктори за умовчанням не визначені.

Клас може мати скільки завгодно конструкторів (з різними наборами параметрів), але тільки один деструктор (без параметрів).
Інші можливості функцій-членів

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

class Array {
…
inline double &operator[] (int n);

І далі

Array a(10);
…
double b = a[5];

Функції-члени (і лише вони) можуть мати описувач const

class Array {
…
inline double operator[] (int n) const;

Такі функції не мають права змінювати поля класу (окрім полів, визначених як mutable). Якщо вони намагаються це зробити, компілятор повинен видати повідомлення про помилку.
Успадкування

Для створення класів з доданою функціональністю вводять успадкування. Клас-нащадок має поля і функції-члени базового класу, але не має права звертатися до приватних (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 і 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[10];
figures[0] = new Square(1, 2, 10);
figures[1] = 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;
...
};

Проте в С++ не діє правило «друг мого друга — мій друг».

За стандартом C++03 вкладений клас не має прав доступу до закритих членів охоплюючого класу і не може бути оголошений його другом (це виходить з визначення терміну друг як нечлена класу). Проте, багато розповсюджених компіляторів порушують обидва ці правила (може, зважаючи на сукупну дивність цих правил).
Переваги та недоліки
Переваги мови C++

Швидкодія. Швидкість роботи програм на С++ практично не поступається програмам на С, хоча програмісти отримали в свої руки нові можливості і нові засоби.
Масштабованість. На мові C++ розробляють програми для найрізноманітніших платформ і систем.
Можливість роботи на низькому рівні з пам'яттю, адресами, портами. (Що, при необережному використанні, може легко перетворитися на недолік.)
Можливість створення узагальнених алгоритмів для різних типів даних, їхня спеціалізація, і обчислення на етапі компіляції, з використанням шаблонів.
Підтримуються різні стилі та технології програмування, включаючи традиційне директивне програмування, ООП, узагальнене програмування, метапрограмування (шаблони, макроси).

Недоліки мови C++

Наявність безлічі можливостей, що порушують принципи типобезпеки приводить до того, що в С++ програми може легко закрастися важковловима помилка. Замість контролю з боку компілятора розробники вимушені дотримуватися вельми нетривіальних правил кодування. По суті, ці правила обмежують С++ рамками якоїсь безпечнішої підмови. Більшість проблем типобезпеки С++ успадкована від С, але важливу роль в цьому питанні грає і відмова автора мови від ідеї використовувати автоматичне управління пам'яттю (наприклад, збірку сміття). Так візитною карткою С++ стали вразливості типу «переповнювання буфера».
Погана підтримка модульності. Підключення інтерфейсу зовнішнього модуля через препроцесорну вставку заголовного файлу (#include) серйозно уповільнює компіляцію, при підключенні великої кількості модулів. Для усунення цього недоліку, багато компіляторів реалізують механізм прекомпіляциі заголовних файлів (англ. Precompiled Headers).
Недостача інформації про типи даних під час компіляції (CTTI).
Мова C++ є складною для вивчення і для компіляції.
Деякі перетворення типів неінтуїтивні. Зокрема, операція над беззнаковим і знаковим числами видає беззнаковий результат.
Препроцесор С++ (успадкований від C) дуже примітивний. Це приводить з одного боку до того, що з його допомогою не можна (або важко) здійснювати деякі завдання метапрограмування, а з іншою, в наслідку своєї примітивності, він часто приводить до помилок і вимагає багато дій з обходу потенційних проблем. Деякі мови програмування (наприклад, Scheme і Nemerle) мають набагато могутніші і безпечніші системи метапрограмування (також звані макросами, але макроси С/С++ вони мало нагадують).
З кінця 1990-х в співтоваристві С++ набуло поширення так зване метапрограмування на базі шаблонів. По суті, воно використовує особливості шаблонів C++ в цілях реалізації на їхній базі інтерпретатора примітивної функціональної мови програмування, що виконується під час компіляції. Сама по собі ця можливість вельми приваблива, але, внаслідкок вище згаданого, такий код вельми важко сприймати і зневаджувати. Мови Lisp/Scheme, Nemerle і деякі інші мають могутніші і водночас простіші для сприйняття підсистеми метапрограмування. Крім того, в мові D реалізована порівнянна за потужністю, але значно простіша в застосуванні підсистема шаблонного метапрограмування.
Хоча декларується, що С++ мультипарадигмена мова, реально в мові відсутня підтримка функціонального програмування. Частково, даний пропуск усувається різними бібліотеками (Loki, Boost) що використовують засоби метапрограмування для розширення мови функціональними конструкціями (наприклад, підтримкою лямбд/анонімних методів), але якість подібних рішень значно поступається якості вбудованих у функціональні мови рішень. Такі можливості функціональних мов, як зіставлення зі зразком взагалі украй складно емулювати засобами метапрограмування.

Критика мови C++

C++ успадкувала багато проблем мови C:

Операція присвоювання позначається як =, а операція порівняння як == . Їх легко сплутати, і така конструкція буде синтаксично правильною, але приведе до важковломимого багу. Особливо часто це відбувається в операторах if і while, наприклад, програміст може написати if (i=0) замість if (i==0) (Разом з тим, основна маса компіляторів видає в таких випадках попередження.) Уникнути помилку такого типу можна, якщо писати всі операції порівняння у такому вигляді: if (0==i). До того ж багато мов (Бейсик, Паскаль) використовують символ «=» саме в операціях порівняння.
Операції присвоювання (=), інкрементації (++), декрементації (--) та інші повертають значення. У поєднанні з великою кількістю операцій це дозволяє, але не зобов'язує, програміста створювати код, що важко читається. З іншого боку, один з основних принципів мов C і C++ — дозволяти програмістові писати в будь-якому стилі, а не нав'язувати «хороший» стиль. До того ж це іноді дозволяє компілятору створювати оптимальніший код.
Макроси (#define) є могутнім, але небезпечним засобом. У мові C++, на відміну від C, необхідність в небезпечних макросах з'являється значно рідше завдяки шаблонам і вбудованим функціям. Але в успадкованих стандартних С-бібліотеках багато потенційно небезпечних макросів.

Дехто вважає недоліком мови C++ відсутність системи збірки сміття. З іншого боку, в C++ є достатньо засобів (класи з конструкторами і деструкторами, стандартні шаблони, передача параметрів за посиланням), що дозволяють майже виключити використання небезпечних вказівників. Проте, відсутність вбудованої збірки сміття дозволяє користувачеві самому вибрати стратегію управління ресурсами.

Крім того, збірка сміття серйозно уповільнює роботу програми, і це недолік там, де продуктивність є критично важливою.
Порівняння C++ з мовами Java і C#

Мова С++ з появою перших трансляторів знайшла відразу ж дуже широке розповсюдження, на ній було створено величезну кількість програм і застосувань. У міру накопичення досвіду створення великих програмних систем спливли недоліки, які спонукали до пошуку альтернативних рішень. Таким альтернативним рішенням стала мова Java, яка в деяких областях стала конкурувати у популярності з C++, а фірма Майкрософт запропонувала мову C# як нову мову, що розвиває принципи C++ і що використовує переваги мови Java. Надалі з'явилася мова Nemerle, об'єднуюча переваги C# з можливістю функціонального програмування. Останнім часом з'явилася спроба об'єднання ефективності C++, безпеки і швидкості розробки, як в Java і C# — була запропонована мова D, яка поки не отримала широкого визнання.

Мова Java володіє такими особливостями, яких немає в мові C++ :

Java є типобезпечною мовою. Типобезпека гарантує відсутність в програмах помилок, що важко знайти і які пов'язані з невірною інтерпретацією пам'яті комп'ютера. Це робить процес розробки надійнішим і передбаченим, а отже швидшим. Так само це дозволяє привертати до розробки програмістів, що мають меншу кваліфікацію і мати великі групи розробників.
Java-код компілюються спочатку не в машинний код, а в певний проміжний код, який надалі інтерпретується або компілюється, тоді як багато C++ компіляторів орієнтіровані на компіляцію в машинний код заданої платформи.
У мові Java є чіткі певні стандарти на введення-виведення, графіку, геометрію, діалог, доступ до баз даних і інших типових застосувань. Завдяки цим особливостям, застосунки на Java мають значно кращу кросплатформенність, ніж С++, і часто, будучи написані для певного комп'ютера і операційної системи, працюють під іншими системами без змін. Програмісти, що пишуть на мові Java, не залежать від пакетів, нав'язаних розробниками компіляторів на дане конкретне середовище, що різко спрощує портування програм.
У мові Java реалізована повноцінна збірка сміття, якої немає в C++. Немає в С++ і засобів перевірки правильності вказівників. З іншого боку, C++ володіє набором засобів (конструктори і деструктори, стандартні шаблони, посилання), що дозволяють майже повністю виключити виділення і звільнення пам'яті вручну і небезпечні операції з вказівниками. Проте таке виключення вимагає певної культури програмування, тоді як в мові Java воно реалізується автоматично.
Мова Java є чисто об'єктно-орієнтованою, тоді як C++ підтримує як об'єктно-орієнтоване, так і процедурне програмування.
В C++ відсутня повноцінна інформація про типи під час виконання RTTI. Цю можливість можна було б реалізувати в C++, маючи повну інформацію про типи під час компіляції CTTI.
У C++ є можливість введення призначеного для користувача синтаксису за допомогою #define, що може привести до того, що модулі у великих пакетах програм стають сильно пов'язані один з одним. Це різко знижує надійність пакетів і можливість організації розділених модулів. З іншого боку, С++ надає достатньо засобів (константи, шаблони, вбудовані функції) для того, щоб практично повністю виключити використання #define.

Ці відмінності призводять до запеклих суперечок між прихильниками двох мов про те, яка мова краща. Прихильники Java вважають ці особливості перевагами; прихильники C++ вважають, що у багатьох випадках ці особливості є недоліками, зокрема

Ціною переносимості є вимога наявності на комп'ютері віртуальної Java-машини, що приводить до уповільнення обчислень і практичної неможливості використання нових можливостей апаратної архітектури.
Збірка сміття призводить до втрати ефективності.
Стандарти на графіку, доступ до баз даних тощо є недоліком, якщо програміст хоче визначити свій власний стандарт.
Вказівники у багатьох випадках є могутніми, або навіть необхідними засобом, а їхнє безконтрольне використання небезпечне лише в невмілих руках.
Підтримка процедурного програмування є корисною.

Далеко не всі програмісти є прихильниками однієї з мов. На думку більшості програмістів, Java і C++ не є конкурентами, тому що мають різні області застосування. Інші вважають, що вибір мови для багатьох завдань є питанням особистого смаку.
Стандарт C++11

Докладніше: C++11

У серпні 2011 завершилася тривала епопея з прийняттям нового стандарту для мови Сі++. Комітет ISO зі стандартизації C++ одноголосно затвердив специфікацію C++0X в якості міжнародного стандарту «C++11».[3] Стандарт C++0X планувалося випустити ще в 2008 році, але його прийняття постійно відкладалося. Більшість представлених в стандарті можливостей вже підтримуються в таких компіляторах, як GCC, IBM C++, Intel C++ і Visual C++. Підтримуючі C++11 стандартні бібліотеки реалізовані в рамках проекту Boost.

Новий стандарт розвивався більше 10 років і прийшов на зміну стандартам C++98 і C++03. Відзначається, що якщо відмінності між стандартами C++98 і C++03 були настільки незначними, що їх можна було не помітити, то стандарт C++11 містить низку кардинальних покращень, як самої мови, так і стандартної бібліотеки. За словами Б'ярна Страуструпа, творця C++, C++11 відчувається як нова мова, частини якої краще поєднуються одна з одною. У C++11 високорівневий стиль програмування став природнішим, а ефективність зросла як ніколи раніше. Крім того, мова стала простішою для вивчення і освоєння новачками.

Основні поліпшення, відображені в стандарті C++11:

Розширення стандартної бібліотеки в таких областях, як регулярні вирази, хеші, генератори випадкових чисел, інтелектуальні вказівники тощо;
Підтримка лямбда-виразів і лямбда-функцій, тобто анонімних функцій, які декларуються в місці використання. Наприклад,

«[] (int x, int y) {return x + y;}»;

Підтримка списків ініціалізації, тобто передачі структури або масиву у вигляді списку значень. Наприклад: для конструктора або функції Test можна вказати шаблонний клас std::initializer_list і потім для ініціалізації використовувати «Test testVar = {1, 2, 3, 4};» або «Test (1,2,3,4,5)»;
Універсальна форма ініціалізації для всіх видів об'єктів за допомогою розширення синтаксису списків ініціалізації;
Підтримка ключового слова «decltype» для визначення типу висловлювання під час компіляції, наприклад, можна вказати «decltype (someVar) otherIntegerVariable = 5;»;
Можливість автоматичного призначення типу при вказівці ключового слова «auto». Тип вибирається на підставі аналізу типу аргументу. Наприклад, «auto otherVariable = 5;»;
Можливість створення шаблону функції, що повертається, тип якого визначається автоматично на підставі іншої функції або виразу;
Аналог циклів «foreach» для перебору елементів колекції. Наприклад, для перебору елементом масиву my_array досить вказати «for (int & x: my_array)»;
Реалізація нового типу посилань на тимчасові об'єкти (Rvalue Referencea), які оголошуються через вираз «type &&»;
Реалізація ключового слова «constexpr», що дозволяє вказати, що вираз (функція або конструктор) повертає константу і ці вирази можна використовувати як константи, наприклад: «constexpr int GetFive () {return 5;}». Надалі GetFive можна вказати, наприклад, при визначенні масиву «int some_value [GetFive () + 7];»;
Ослаблені вимоги при визначенні типів простих даних. Наприклад, як тип простих даних можуть розглядатися класи, при дотриманні ряду правил;
Підтримка визначення зовнішніх шаблонів, що дозволяють збільшити швидкість компіляції;
Можливість створювати шаблони з перемінною кількістю аргументів;
Розширена підтримка символів в Unicode;
Можливість викликати одні конструктори класу з інших конструкторів цього ж класу, що дозволяє створювати конструктори, що використовують інші конструктори без дублювання коду;
Можливість використання локальних і безіменних типів як аргументів шаблонів;
Замість макросу NULL для позначення нульового вказівника введено ключове слово nullptr.

Майбутній розвиток

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

Стандарт Сі++ не описує способи іменування об'єктів, деякі деталі обробки винятків і інші можливості, пов'язані з деталями реалізації, що робить несумісним об'єктний код, створений різними компіляторами. Проте для цього третіми особами створено безліч стандартів для конкретної архітектури і операційних систем.

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

Одним із каменів спотикання у цьому питанні є ключове слово export, що використовується також і для розділення оголошення і визначення шаблонів.

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

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

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

Версія для друку
Кількість переглядів: 2677

Ключові слова: При створенні С++ прагнули зберегти сумісність з мовою С. Більшість програм на С справно працюватимуть і з компілятором С++. С++ має синтаксис, заснований на синтаксисі С (див. список операторів мов С та С++).