Merge pull request #2050 from virtyaluk/master

[c++/ru]

1 files changed, 892 insertions, 0 deletions

diff --git a/ru-ru/c++-ru.html.markdown b/ru-ru/c++-ru.html.markdown
new file mode 100644
index 00000000..0cf580d5
--- /dev/null
+++ b/ru-ru/c++-ru.html.markdown
@@ -0,0 +1,892 @@
+---
+language: c++
+filename: learncpp-ru.cpp
+contributors:
+    - ["Steven Basart", "http://github.com/xksteven"]
+    - ["Matt Kline", "https://github.com/mrkline"]
+    - ["Geoff Liu", "http://geoffliu.me"]
+    - ["Connor Waters", "http://github.com/connorwaters"]
+translators:
+    - ["Bohdan Shtepan", "http://modern-dev.com"]
+lang: ru-ru
+---
+
+C++ - компилируемый, статически типизированный язык программирования общего назначения, который,
+[как заявляет создатель языка Бьёрн Страуструп](http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Keynote),
+был разработан как
+
+- "лучшая замена C"
+- язык с поддержкой абстракции данных
+- язык с поддержкой объектно-ориентированого программирования
+- язык с поддержкой обобщенного программирования
+
+Хотя его синтаксис может показаться более трудным или сложным для понимания, чем в более современных языках,
+он широко применяется, так как код, написанный на C++, компилируется в набор инструкций, которые могут быть выполнены напрямую
+процессором. C++ широко используется для разработки программного обеспечения, являясь одним из самых популярных языков
+программирования. Область его применения включает создание операционных систем, разнообразных прикладных программ, драйверов
+устройств, приложений для встраиваемых систем, высокопроизводительных серверов, а также развлекательных приложений (игр).
+
+```c++
+//////////////////
+// Сравнение с C
+//////////////////
+
+// C++ практически представляет собой надмножество C и имеет схожий синтаксис
+// для объявления переменных, примитивов и функций.
+
+// Так же, как и в С, точкой входа в программу является функция с именем main,
+// которая возвращает целочисленное значение.
+// Это значение является кодом ответа программы.
+// Смотрите https://goo.gl/JYGKyv для более подробной информации.
+int main(int argc, char** argv)
+{
+    // Аргументы командной строки, переданные в программу, хранятся в переменных
+	// argc и argv, так же, как и в C.
+    // argc указывает на количество аргументов,
+    // а argv является массивом C-подобных строк (char*), который непосредсвенно
+	// содержит аргументы.
+    // Первым аргументом всегда передается имя программы.
+    // argc и argv могут быть опущены, если вы не планируете работать с аругментами
+	// коммандной строки.
+	// Тогда сигнатура функции будет иметь следующий вид: int main()
+
+    // Возвращаемое значение 0 указывает на успешное завершение программы.
+    return 0;
+}
+
+// Тем не менее, C++ имеет свои отличия:
+
+// В C++ символьные литералы имеют тип char.
+sizeof('c') == sizeof(char) == 1
+
+// В C символьные литералы - целые числа.
+sizeof('c') == sizeof(int)
+
+
+// C++ имеет строгое прототипирование.
+void func(); // функция, которая не принимает аргументов.
+
+// В языке C
+void func(); // функция, которая может принять сколько угодно аргументов.
+
+// Использование nullptr вместо NULL в C++.
+int* ip = nullptr;
+
+// Стандартные заголовочные файлы С доступны в С++,
+// но с префиксом "с" и не имеют суффикса .h.
+#include <cstdio>
+
+int main()
+{
+    printf("Hello, world!\n");
+    return 0;
+}
+
+///////////////////////
+// Перегрузка функций
+///////////////////////
+
+// С++ поддерживает перегрузку функций, при условии,
+// что каждая функция принимает различные параметры.
+
+void print(char const* myString)
+{
+    printf("String %s\n", myString);
+}
+
+void print(int myInt)
+{
+    printf("My int is %d", myInt);
+}
+
+int main()
+{
+    print("Hello"); // Использование void print(const char*)
+    print(15); // Использование void print(int)
+}
+
+/////////////////////////////
+// Аргументы функций по умолчанию
+/////////////////////////////
+
+// Вы можете предоставить аргументы по умолчанию для функции,
+// если они не предоставлены при вызове функции.
+
+void doSomethingWithInts(int a = 1, int b = 4)
+{
+    // Здесь что-то делаем с числами
+}
+
+int main()
+{
+    doSomethingWithInts();      // a = 1,  b = 4
+    doSomethingWithInts(20);    // a = 20, b = 4
+    doSomethingWithInts(20, 5); // a = 20, b = 5
+}
+
+// Аргументы по умолчанию должны быть в конце списка аргументов.
+
+void invalidDeclaration(int a = 1, int b) // Ошибка!
+{
+}
+
+
+/////////////
+// Пространства имен
+/////////////
+
+// Пространства имен предоставляют отдельные области для переменной,
+// функции и других объявлений.
+// Пространства имен могут быть вложенными.
+
+namespace First {
+    namespace Nested {
+        void foo()
+        {
+            printf("This is First::Nested::foo\n");
+        }
+    } // конец пространства имен Nested
+} // конец пространства имен First
+
+namespace Second {
+    void foo()
+    {
+        printf("This is Second::foo\n")
+    }
+}
+
+void foo()
+{
+    printf("This is global foo\n");
+}
+
+int main()
+{
+    // Включает все функци из пространства имен Second в текущую область видимости.
+    // Обратите внимание, что простой вызов foo() больше не работает,
+    // так как теперь не ясно, вызываем ли мы foo из пространства имен Second, или
+	// из глобальной области видимости.
+    using namespace Second;
+
+    Second::foo(); // напечатает "This is Second::foo"
+    First::Nested::foo(); // напечатает "This is First::Nested::foo"
+    ::foo(); // напечатает "This is global foo"
+}
+
+///////////////
+// Ввод и вывод
+///////////////
+
+// Ввод и вывод в C++ использует потоки
+// cin, cout и cerr представляют потоки stdin, stdout и stderr.
+// << - оператор вставки, >> - оператор извлечения.
+
+#include <iostream> // Включение файла для работы с потоками Ввода\Вывода.
+
+using namespace std; // Потоки доступны в пространстве имен std (стандартная библиотека)
+
+int main()
+{
+   int myInt;
+
+   // Выводит в stdout (или в терминал/на экран)
+   cout << "Enter your favorite number:\n";
+   // Принимает ввод
+   cin >> myInt;
+
+   // cout может принимать форматирование
+   cout << "Your favorite number is " << myInt << "\n";
+   // напечатает "Your favorite number is <myInt>"
+
+    cerr << "Used for error messages";
+}
+
+//////////
+// Строки
+//////////
+
+// Строки в C++ являются объектами и имеют много функций-членов.
+#include <string>
+
+using namespace std; // Строки также доступны в пространстве имен std (стандартная библиотека)
+
+string myString = "Hello";
+string myOtherString = " World";
+
+// + используется для конкатенации строк.
+cout << myString + myOtherString; // "Hello World"
+
+cout << myString + " You"; // "Hello You"
+
+// Строки в C++ могут изменяться и имеют семантику значений.
+myString.append(" Dog");
+cout << myString; // "Hello Dog"
+
+
+/////////////
+// Ссылки
+/////////////
+
+// Кроме указателей, доступных в C,
+// C++ имеет _ссылки_.
+// Это такой тип указателя, который не может быть переназначен после инициализации
+// и не может иметь значения null.
+// Ссылки имеют схожий с переменными синтаксис:
+// * больше не используется для разыменования и
+// & (адрес) не используется для назначения.
+
+using namespace std;
+
+string foo = "I am foo";
+string bar = "I am bar";
+
+
+string& fooRef = foo; // Здесь создается ссылка на foo.
+fooRef += ". Hi!"; // Изменяет foo по ссылке
+cout << fooRef; // Печатает "I am foo. Hi!"
+
+// Не переназначает "fooRef". Это то же самое, что и "foo = bar", и
+//   foo == "I am bar"
+// после этой строчки.
+cout << &fooRef << endl; // Печатает адрес foo
+fooRef = bar;
+cout << &fooRef << endl; // По-прежнему печатает адрес foo
+cout << fooRef;  // Печатает "I am bar"
+
+// Адрес fooRef остается тем же, то есть он по-прежнему ссылается на foo.
+
+
+const string& barRef = bar; // Создает константную ссылку.
+// Так же, как и в C, константные значения (а также указатели и ссылки) не могут быть изменены.
+barRef += ". Hi!"; // Ошибка, константная ссылка не может быть изменена.
+
+// Обходной путь: Прежде чем мы рассмотрим указатели более детально, нам нужно ознакомиться
+// с концепцией, известной как "временный объект". Представьте, что мы имеем следующий код
+string tempObjectFun() { ... }
+string retVal = tempObjectFun();
+
+// Вот что на самом деле происходит во второй строке:
+//   - tempObjectFun возвращает строковый объект
+//   - из возвращаемого объекта создается новая строка в качестве аргумента конструктору
+//   - возвращаемый объект уничтожается
+// Возвращаемый объект называется временным объектом. Временные объекты создаются,
+// когда функция возвращает объект, и уничтожаются в конце выполнения обрамляющего
+// выражения (По крайней мере, так это описывает спецификация, хотя компиляторы могут
+// изменять это поведение. Для более подробной информации смотрите "оптимизация
+// возвращаемого значения".) Таким образом в этом коде:
+foo(bar(tempObjectFun()))
+
+// предполагая, что foo и bar существуют, объект, возвращаемый tempObjectFun, передается
+// в bar, и уничтожается перед вызовом foo.
+
+// Возвращаемся к указателям. Исключением для правила "в конце выполнения обрамляющего
+// выражения" является временный объект, привязанный к ссылке const, в этом случае
+// его жизненный цикл продлевается до текущей области видимости:
+
+void constReferenceTempObjectFun() {
+  // constRef получает временный объект, и он действителен до конца этой функции.
+  const string& constRef = tempObjectFun();
+  ...
+}
+
+// В C++11 предоставлен еще один тип ссылок специально для временных объектов.
+// objects. Вы не можете объявить переменную этого типа, но он имеет приоритет
+// в резолюции перегрузки:
+
+void someFun(string& s) { ... }  // Обычная ссылка
+void someFun(string&& s) { ... }  // Ссылка на временный объект
+
+string foo;
+someFun(foo);  // Выполняет версию с обычной ссылкой
+someFun(tempObjectFun());  // Выполняет версию с временной ссылкой.
+
+// Например, существуют следующие две версии конструктора std::basic_string:
+basic_string(const basic_string& other);
+basic_string(basic_string&& other);
+
+// Идея в том, что если мы конструируем новую строку из временного объекта (который 
+// так или иначе будет уничтожен), мы можем использовать более эффективный конструктор,
+// который "спасает" части этой временной строки. Эта концепция была названа
+// "move semantics".
+
+/////////////////////
+// Перечисления
+/////////////////////
+
+// Перечисления - способ объявления констант и установки их значений, в основном
+// использующийся для упрощения чтения кода.
+enum ECarTypes
+{
+  Sedan,
+  Hatchback,
+  SUV,
+  Wagon
+};
+
+ECarTypes GetPreferredCarType()
+{
+	return ECarTypes::Hatchback;
+}
+
+// На момент выхода C++11 есть простой способ назначения типа перечисления, что
+// полезно в случае сериализации данных и преобразований между конечным типом и 
+// соответствующими константами.
+enum ECarTypes : uint8_t
+{
+  Sedan, // 0
+  Hatchback, // 1
+  SUV = 254, // 254
+  Hybrid // 255
+};
+
+void WriteByteToFile(uint8_t InputValue)
+{
+	// Сериализуем InputValue в файл
+}
+
+void WritePreferredCarTypeToFile(ECarTypes InputCarType)
+{
+	// Перечисление неявно преобразуется в uint8_t из-за ранее объявленного
+	// типа перечисления.
+	WriteByteToFile(InputCarType);
+}
+
+// С другой стороны, чтобы избежать случайного приведения к целочисленному типу или
+// другому перечислению, вы можете создать класс перечисления, который не будет
+// преобразовываться неявно.
+enum class ECarTypes : uint8_t
+{
+  Sedan, // 0
+  Hatchback, // 1
+  SUV = 254, // 254
+  Hybrid // 255
+};
+
+void WriteByteToFile(uint8_t InputValue)
+{
+	// Сериализуем InputValue в файл
+}
+
+void WritePreferredCarTypeToFile(ECarTypes InputCarType)
+{
+	// Хотя ECarTypes имеет тип uint8_t, код не будет скомпилирован из-за того,
+	// что перечисление было объявлено как класс перечисления.
+	WriteByteToFile(InputCarType);
+}
+
+//////////////////////////////////////////
+// Классы и объектно-ориентированное программирование
+//////////////////////////////////////////
+
+// Пример классов
+#include <iostream>
+
+// Объявление класса.
+// Обычно классы объявляют в заголовочном (.h или .hpp) файле.
+class Dog {
+    // Переменные-члены и функции являются приватными по умолчанию.
+    std::string name;
+    int weight;
+
+// Все члены после этой сроки являются открытыми
+// пока "private:" или "protected:" не будет объявлено.
+public:
+
+    // Конструктор по умолчанию
+    Dog();
+
+    // Объявление функций-членов
+    // Обратите внимание, мы используем std::string здесь вместо использования
+    // using namespace std;
+    // выше.
+    // Никогда не размещайте выражение "using namespace" в заголовке.
+    void setName(const std::string& dogsName);
+
+    void setWeight(int dogsWeight);
+
+    // Функции, которые не изменяют состояние объекта,
+    // должны быть помечены как const.
+    // Это позволяет вызывать их, если дана const ссылка на объект.
+    // Обратите внимание, функции должны быть явно объявлены как _virtual_,
+    // если вы хотите перегрузить их в производных классах.
+    // Функции не являются виртуальными по умолчанию для повышения производительности.
+    virtual void print() const;
+
+    // Также функции могут быть определены внутри тела класса.
+    // Функции, определенные следующим образом, автоматически встроены.
+    void bark() const { std::cout << name << " barks!\n"; }
+
+    // Наряду с конструкторами, в C++ есть деструкторы.
+    // Они вызываются, когда объект удаляется или выпадает из области видимости.
+    // Это активирует мощную парадигму программирования, известную как RAII
+    // (смотрите ниже)
+    // Деструктор должен быть виртуальным, если класс будет производным.
+    // Если он не виртуальный, тогда деструктор производного класса не будет вызван,
+    // если объект удален по ссылке или указателю базового класса.
+    virtual ~Dog();
+
+}; // Определение класса должно завершаться точкой с запятой.
+
+// Функции-члены класса, как правило, реализуются в .cpp файлах.
+Dog::Dog()
+{
+    std::cout << "A dog has been constructed\n";
+}
+
+// Объекты (такие как строки) должны передаваться по ссылке если вы будете
+// изменять их, или const-ссылке если нет.
+void Dog::setName(const std::string& dogsName)
+{
+    name = dogsName;
+}
+
+void Dog::setWeight(int dogsWeight)
+{
+    weight = dogsWeight;
+}
+
+// Обратите внимание, "virtual" требуется только в объявлении, не в определении.
+void Dog::print() const
+{
+    std::cout << "Dog is " << name << " and weighs " << weight << "kg\n";
+}
+
+Dog::~Dog()
+{
+    cout << "Goodbye " << name << "\n";
+}
+
+int main() {
+    Dog myDog; // Печатает "A dog has been constructed"
+    myDog.setName("Barkley");
+    myDog.setWeight(10);
+    myDog.print(); // Печатает "Dog is Barkley and weighs 10 kg"
+    return 0;
+} // Печатает "Goodbye Barkley"
+
+// Интерфейсы:
+
+// Этот класс наследует все открытые и защищенные члены класса Dog
+// так же, как и все закрытые, но не может непосредственно получить доступ к закрытым
+// членам\методам без открытых или защищенных методов для этого.
+class OwnedDog : public Dog {
+
+    void setOwner(const std::string& dogsOwner);
+
+    // Переопределяем поведение функции печати для всех OwnedDog. Смотрите
+    // https://goo.gl/3kuH2x для боле общего введения, если вы не знакомы
+    // с концепцией полиморфизма подтипов (включения).
+    // Ключевое слово override является необязательным, но указывает, что метод
+    // на самом деле перегружается в базовом классе.
+    void print() const override;
+
+private:
+    std::string owner;
+};
+
+// Тем временем, в соответствующем .cpp файле:
+
+void OwnedDog::setOwner(const std::string& dogsOwner)
+{
+    owner = dogsOwner;
+}
+
+void OwnedDog::print() const
+{
+    Dog::print(); // Вызывает функцию print в базовом классе Dog
+    std::cout << "Dog is owned by " << owner << "\n";
+    // Печатает "Dog is <name> and weights <weight>"
+    //        "Dog is owned by <owner>"
+}
+
+//////////////////////////////////////////
+// Инициализация и перегрузка операторов.
+//////////////////////////////////////////
+
+// В C++ вы можете перегрузить поведение таких операторов: +, -, *, / и др..
+// Это делается путем определения функции, которая вызывается,
+// когда используется оператор.
+
+#include <iostream>
+using namespace std;
+
+class Point {
+public:
+    // Значения по умолчанию для переменных-членов могут быть установлены
+	// следующим образом.
+    double x = 0;
+    double y = 0;
+
+    // Определяем новый конструктор, который инициализирует Point со значениями
+    // по умолчанию (0, 0)
+    Point() { };
+
+    // Следующий синтаксис известен как список инициализации и является верным способом 
+	// инициализировать значения членов класса.
+    Point (double a, double b) :
+        x(a),
+        y(b)
+    { /* Ничего не делайте, кроме инициализации значений */ }
+
+    // Перегружаем оператор +.
+    Point operator+(const Point& rhs) const;
+
+    // Перегружаем оператор +=.
+    Point& operator+=(const Point& rhs);
+
+    // Имеет смысл добавить перегрузку операторов - и -=,
+    // но для краткости мы опустим эти детали.
+};
+
+Point Point::operator+(const Point& rhs) const
+{
+    // Создает новую точку, которая является суммой этой точки и rhs.
+    return Point(x + rhs.x, y + rhs.y);
+}
+
+Point& Point::operator+=(const Point& rhs)
+{
+    x += rhs.x;
+    y += rhs.y;
+    return *this;
+}
+
+int main () {
+    Point up (0,1);
+    Point right (1,0);
+    // Здесь происходит вызов оператора + класса Point
+    // Точка "up" вызывает + (функция) с параметром "right"
+    Point result = up + right;
+    // Печатает "Result is upright (1,1)"
+    cout << "Result is upright (" << result.x << ',' << result.y << ")\n";
+    return 0;
+}
+
+/////////////////////
+// Шаблоны
+/////////////////////
+
+// Шаблоны в С++, в основном, используются для обобщенного программирования, хотя
+// они гораздо более мощны, чем дженерики в других языках. Они также поддерживают
+// явные, частные и функциональные типы классов; на самом деле, они являются
+// тьюринг-полным языком, встроенным в C++!
+
+// Мы начнем с наиболее распространенного типа обобщенного программирования. Чтобы
+// определить класс или функцию, которая принимает параметр типа:
+template<class T>
+class Box {
+public:
+    // В этом классе T может быть любого типа.
+    void insert(const T&) { ... }
+};
+
+// Во время компиляции компилятор фактически генерирует копии каждого шаблона
+// с замещенными параметрами, поэтому полное определение класса должно присутствовать
+// при каждом вызове. Именно поэтому классы шаблонов полностью определены в
+// заголовочных файлах.
+
+// Чтобы создать экземпляр класса шаблона на стеке:
+Box<int> intBox;
+
+// и вы можете использовать его, как и ожидалось:
+intBox.insert(123);
+
+// Вы, конечно, можете использовать вложенные шаблоны:
+Box<Box<int> > boxOfBox;
+boxOfBox.insert(intBox);
+
+// Вплоть до С++11, вы должны были ставить пробел между двумя символами '>', иначе '>>'
+// принимался парсером, как оператор сдвига вправо.
+
+// Иногда вы можете увидеть
+//   template<typename T>
+// вместо этого. В этом случае ключевые слова 'class' и 'typename' _в основном_
+// взаимозаменяемыми. Для более подробной информации смотрите
+//   http://en.wikipedia.org/wiki/Typename
+// (да-да, это ключевое слово имеет собственную страничку на вики).
+
+// Аналогичным образом, шаблонная функция:
+template<class T>
+void barkThreeTimes(const T& input)
+{
+    input.bark();
+    input.bark();
+    input.bark();
+}
+
+// Обратите внимание, что здесь ничего не указано о типе параметра. Компилятор
+// будет генерировать и затем проверять на тип каждый вызов шаблона, поэтому
+// данная функция работает с любым типом 'T', который имеет метод 'bark'.
+
+Dog fluffy;
+fluffy.setName("Fluffy");
+barkThreeTimes(fluffy); // Печатает "Fluffy barks" три раза.
+
+//Параметры шаблона не должны быть классами:
+template<int Y>
+void printMessage() {
+  cout << "Learn C++ in " << Y << " minutes!" << endl;
+}
+
+// В конце концов, вы можете явно специализировать шаблоны для более эффективного
+// кода. Конечно, большинство реальных случаев использования специализации
+// не так тривиально, как это. Обратите внимание, вам все еще нужно явно объявить
+// функцию (или класс) в качестве шаблона, даже если вы явно указали все параметры.
+template<>
+void printMessage<10>() {
+  cout << "Learn C++ faster in only 10 minutes!" << endl;
+}
+
+printMessage<20>();  // Печатает "Learn C++ in 20 minutes!"
+printMessage<10>();  // Печатает "Learn C++ faster in only 10 minutes!"
+
+
+/////////////////////
+// Обработка исключений
+/////////////////////
+
+// Стандартная библиотека предоставляет несколько типов исключений
+// (смотрите http://en.cppreference.com/w/cpp/error/exception)
+// но, в принципе, любой тип может быть брошен в качестве исключения.
+#include <exception>
+#include <stdexcept>
+
+// Все исключения, брошенные в блоке _try_ могут быть пойманы в последующем блоке
+// _catch_.
+try {
+    // Не выделяйте память в куче для исключений с помощью ключевого слова _new_.
+    throw std::runtime_error("A problem occurred");
+}
+
+// Поймайте исключение по константной ссылке, если оно является объектом
+catch (const std::exception& ex)
+{
+    std::cout << ex.what();
+}
+
+// Ловит любое исключение, не пойманное предыдущим блоком _catch_
+catch (...)
+{
+    std::cout << "Unknown exception caught";
+    throw; // Повторный выброс исключения
+}
+
+///////
+// Получение ресурса есть инициализация (RAII)
+///////
+
+// Программная идиома объектно-ориентированного программирования, смысл которой
+// заключается в том, что с помощью тех или иных программных механизмов получение
+// некоторого ресурса неразрывно совмещается с инициализацией, а освобождение -
+// с уничтожением объекта.
+
+// Чтобы понять, на сколько это полезно,
+// рассмотрим функцию, которая использует обработчик файлов в С:
+void doSomethingWithAFile(const char* filename)
+{
+    // Для начала, предположим, ничего не может потерпеть неудачу.
+
+    FILE* fh = fopen(filename, "r"); // Открываем файл в режиме чтения.
+
+    doSomethingWithTheFile(fh);
+    doSomethingElseWithIt(fh);
+
+    fclose(fh); // Закрываем обработчик файла.
+}
+
+// К сожалению, вещи быстро осложняются обработкой ошибок.
+// Предположим, fopen может потерпеть неудачу, тогда doSomethingWithTheFile и
+// doSomethingElseWithIt вернут коды ошибок, если потерпят неудачу.
+//  (Исключения являются предпочтительным способом обработки ошибок,
+//   но некоторые программисты, особенно те, кто имеет большой опыт работы с С,
+//   не согласны с аргументами о полезности исключений).
+// Теперь мы должны проверить каждый вызов на наличие ошибок и закрыть обработчик
+// файла, если он есть.
+bool doSomethingWithAFile(const char* filename)
+{
+    FILE* fh = fopen(filename, "r"); // Открывает файл в режиме чтения
+    if (fh == nullptr) // В случае неудачи возвращаемый указатель принимает значение null.
+        return false; // Сообщает о неудаче вызывающему.
+
+    // Предположим, каждая функция возвращает false в случае неудачи
+    if (!doSomethingWithTheFile(fh)) {
+        fclose(fh); // Закрываем обработчик файла, чтобы не было утечек
+        return false; // Сообщает об ошибке.
+    }
+    if (!doSomethingElseWithIt(fh)) {
+        fclose(fh); // Закрываем обработчик файла, чтобы не было утечек
+        return false; // Сообщает об ошибке.
+    }
+
+    fclose(fh); // Закрываем обработчик файла, чтобы не было утечек
+    return true; // Указывает на успех
+}
+
+// C-программисты часто упорядочивают это с помощью goto:
+bool doSomethingWithAFile(const char* filename)
+{
+    FILE* fh = fopen(filename, "r");
+    if (fh == nullptr)
+        return false;
+
+    if (!doSomethingWithTheFile(fh))
+        goto failure;
+
+    if (!doSomethingElseWithIt(fh))
+        goto failure;
+
+    fclose(fh); // Закрываем файл.
+    return true; // Указывает на успех
+
+failure:
+    fclose(fh);
+    return false; // Сообщает об ошибке.
+}
+
+// Если функции указывают на ошибки с помощью исключений, вещи становятся проще,
+// но все еще не оптимальны.
+void doSomethingWithAFile(const char* filename)
+{
+    FILE* fh = fopen(filename, "r"); // Открываем файл в режиме чтения
+    if (fh == nullptr)
+        throw std::runtime_error("Could not open the file.");
+
+    try {
+        doSomethingWithTheFile(fh);
+        doSomethingElseWithIt(fh);
+    }
+    catch (...) {
+        fclose(fh); // Убедитесь, что закрываете файл, если происходит ошибка.
+        throw; // Затем повторно бросает исключение.
+    }
+
+    fclose(fh); // Закрываем файл.
+    // Успех
+}
+
+// Сравните это с использованием класса потока файла (fstream) в С++, который
+// использует свой деструктор, чтобы закрыть файл. Еще раз взгляните выше,
+// деструктор вызывается автоматически, когда объект выпадает из области видимости.
+void doSomethingWithAFile(const std::string& filename)
+{
+    // ifstream определяет файловый поток
+    std::ifstream fh(filename); // Открыть файл
+
+    // Что-то делать с файлом
+    doSomethingWithTheFile(fh);
+    doSomethingElseWithIt(fh);
+
+} // Здесь файл автоматически закрывается в деструкторе.
+
+// Это имеет _огромнейшие_ преимущества:
+// 1. Неважно, что произойдет,
+//    ресурсы (в данном случае дескриптор файла) будут очищены.
+//    После того, как вы правильно напишете деструктор,
+//    Больше будет _невозможно_ закрыть обработчик файлов или допустить утечку.
+// 2. Обратите внимание, что код намного проще.
+//    Деструктор закрывает файловый поток "за кулисами", и вам больше не нужно об
+//     этом беспокоиться.
+// 3. Код устойчив к исключениям.
+//    Исключение может быть брошено в любом месте в функции, и это никак не повлияет
+//    на очистку.
+
+// Весь идиоматический код на С++ широко использует RAII для всех ресурсов.
+// Дополнительные примеры включат:
+// - Использование памяти unique_ptr и shared_ptr
+// - Контейнеры - стандартная библиотека связанных списков, векторы 
+//   (т.е. самоизменяемые массивы), хэш-таблицы и все остальное автоматически
+//    уничтожается сразу же, когда выходит за пределы области видимости.
+// - Ипользование мьютексов lock_guard и unique_lock
+
+// Контейнеры с пользовательскими классами в качестве ключей требуют
+// сравнивающих функций в самом объекте или как указатель на функцию. Примитивы
+// имеют компараторы по умолчанию, но вы можете перегрузить их.
+class Foo {
+public:
+	int j;
+	Foo(int a) : j(a) {}
+};
+struct compareFunction {
+    bool operator()(const Foo& a, const Foo& b) const {
+        return a.j < b.j;
+    }
+};
+// это не допускается (хотя это может варьироваться в зависимости от компилятора)
+// std::map<Foo, int> fooMap;
+std::map<Foo, int, compareFunction> fooMap;
+fooMap[Foo(1)]  = 1;
+fooMap.find(Foo(1)); //true
+
+/////////////////////
+// Веселые вещи
+/////////////////////
+
+// Аспекты С++, которые могут быть удивительными для новичков (и даже для некоторых
+// ветеранов). Этот раздел, к сожалению, очень неполон. С++ является одним из самых
+// простых языков, где очень легко выстрелить себе в ногу.
+
+// Вы можете перегрузить приватные методы!
+class Foo {
+  virtual void bar();
+};
+class FooSub : public Foo {
+  virtual void bar();  // Перегружает Foo::bar!
+};
+
+
+// 0 == false == NULL (в основном)!
+bool* pt = new bool;
+*pt = 0; // Устанавливает значение указателя 'pt' в false.
+pt = 0;  // Устанавливает значение 'pt' в нулевой указатель. Обе строки проходят
+		// компиляцию без ошибок.
+
+// nullptr приходит на помощь:
+int* pt2 = new int;
+*pt2 = nullptr; // Не пройдет компиляцию
+pt2 = nullptr;  // Устанавливает pt2 в null.
+
+// Существует исключение для булевых значений.
+// Это позволит вам проверить указатели с помощью if(!ptr),
+// но как следствие вы можете установить nullptr в bool напрямую!
+*pt = nullptr;  // Это по прежнему проходит компиляцию, даже если '*pt' - bool!
+
+
+// '=' != '=' != '='!
+// Вызывает Foo::Foo(const Foo&) или некий вариант (смотрите "move semantics")
+// копирования конструктора.
+Foo f2;
+Foo f1 = f2;
+
+// Вызывает Foo::Foo(const Foo&) или вариант, но копирует только часть 'Foo' из
+// 'fooSub'. Любые другие члены 'fooSub' пропускаются. Иногда это ужасное поведение
+// называют "object slicing."
+FooSub fooSub;
+Foo f1 = fooSub;
+
+// Вызывает Foo::operator=(Foo&) или вариант.
+Foo f1;
+f1 = f2;
+
+
+// Как по-настоящему очистить контейнер:
+class Foo { ... };
+vector<Foo> v;
+for (int i = 0; i < 10; ++i)
+  v.push_back(Foo());
+
+// В следующей точке размер v устанавливается в 0, но деструктор не вызывается
+// и не происходит очистка ресурсов!
+v.empty();
+v.push_back(Foo());  // Новые значения копируются в первый вставленный Foo
+
+// Настоящее уничтожение всех значений v. Смотрите раздел о временном объекте
+// для объяснения того, как это работает.
+v.swap(vector<Foo>());
+
+```
+## Дальнейшее чтение:
+
+Наиболее полное и обновленное руководство по С++ можно найти на
+<http://cppreference.com/w/cpp>
+
+Дополнительные ресурсы могут быть найдены на <http://cplusplus.com>