Adds complete translation

1 files changed, 289 insertions, 293 deletions

diff --git a/ru-ru/c++-ru.html.markdown b/ru-ru/c++-ru.html.markdown
index 99798bbb..5137ec1f 100644
--- a/ru-ru/c++-ru.html.markdown
+++ b/ru-ru/c++-ru.html.markdown
@@ -162,7 +162,7 @@ void foo()
 
 int main()
 {
-    // Включает все функци с пространства имен Second в текущую область видиомти.
+    // Включает все функци с пространства имен Second в текущую область видимости.
     // Обратите внимание, что простой вызов foo() больше не работает,
     // так как теперь не ясно вызываем ли мы foo с пространства имен Second или
 	// из глобальной области видимости.
@@ -177,26 +177,26 @@ int main()
 // Ввод/Вывод
 ///////////////
 
-// C++ input and output uses streams
-// cin, cout, and cerr represent stdin, stdout, and stderr.
-// << is the insertion operator and >> is the extraction operator.
+// Вводи и вывод в C++ использует потоки
+// cin, cout и cerr предоставлнеы методами stdin, stdout и stderr.
+// << - оператор вставки, >> - оператор извлечения.
 
-#include <iostream> // Include for I/O streams
+#include <iostream> // Включение файла для работы с потоками Ввода\Вывода.
 
-using namespace std; // Streams are in the std namespace (standard library)
+using namespace std; // Потоки доступны в пространстве имен std (стандартная библиотека)
 
 int main()
 {
    int myInt;
 
-   // Prints to stdout (or terminal/screen)
+   // Выводит stdout (или терминал\экран)
    cout << "Enter your favorite number:\n";
-   // Takes in input
+   // Принимает ввод
    cin >> myInt;
 
-   // cout can also be formatted
+   // cout может принимать форматирование
    cout << "Your favorite number is " << myInt << "\n";
-   // prints "Your favorite number is <myInt>"
+   // напечатает "Your favorite number is <myInt>"
 
     cerr << "Used for error messages";
 }
@@ -205,35 +205,35 @@ int main()
 // Строки
 //////////
 
-// Strings in C++ are objects and have many member functions
+// Строки в C++ являются объектами и имеют много функций-членов.
 #include <string>
 
-using namespace std; // Strings are also in the namespace std (standard library)
+using namespace std; // Строки также доступны в пространстве имен std (стандартная библиотек)
 
 string myString = "Hello";
 string myOtherString = " World";
 
-// + is used for concatenation.
+// + используется для конкатенации строк.
 cout << myString + myOtherString; // "Hello World"
 
 cout << myString + " You"; // "Hello You"
 
-// C++ strings are mutable and have value semantics.
+// Строки в C++ могут изменяться и имеют семантику значений.
 myString.append(" Dog");
 cout << myString; // "Hello Dog"
 
 
 /////////////
-// References
+// Ссылки
 /////////////
 
-// In addition to pointers like the ones in C,
-// C++ has _references_.
-// These are pointer types that cannot be reassigned once set
-// and cannot be null.
-// They also have the same syntax as the variable itself:
-// No * is needed for dereferencing and
-// & (address of) is not used for assignment.
+// В добавок к указателям доступных в C,
+// C++ имеет _ссылки_.
+// Это такой тип указателя, который не может быть переназначен после инициализации
+// и не может иметь значения null.
+// Ссылки имеют схожий с переменными синтаксис:
+// * больше не используется для разыменования и
+// & (адрес) не используется для назначения.
 
 using namespace std;
 
@@ -241,84 +241,80 @@ string foo = "I am foo";
 string bar = "I am bar";
 
 
-string& fooRef = foo; // This creates a reference to foo.
-fooRef += ". Hi!"; // Modifies foo through the reference
-cout << fooRef; // Prints "I am foo. Hi!"
+string& fooRef = foo; // Здесь создается указатель на foo.
+fooRef += ". Hi!"; // Изменяет foo по ссылке
+cout << fooRef; // Печатает "I am foo. Hi!"
 
-// Doesn't reassign "fooRef". This is the same as "foo = bar", and
+// Не переназначает "fooRef". Это тоже самое как "foo = bar", и
 //   foo == "I am bar"
-// after this line.
-cout << &fooRef << endl; //Prints the address of foo
+// после этой строчки.
+cout << &fooRef << endl; // Печатает адрес foo
 fooRef = bar;
-cout << &fooRef << endl; //Still prints the address of foo
-cout << fooRef;  // Prints "I am bar"
+cout << &fooRef << endl; // По-прежнему печатает адрес foo
+cout << fooRef;  // Печатает "I am bar"
 
-//The address of fooRef remains the same, i.e. it is still referring to foo.
+// Адрес fooRef остается тем же, то есть он по-прежнему ссылается на foo.
 
 
-const string& barRef = bar; // Create a const reference to bar.
-// Like C, const values (and pointers and references) cannot be modified.
-barRef += ". Hi!"; // Error, const references cannot be modified.
+const string& barRef = bar; // Создает const со ссылкой на bar.
+// Также как и C, значения const (и указателей и ссылок) не могут быть изменены.
+barRef += ". Hi!"; // Ошибка, указатель const не может быть изменен.
 
-// Sidetrack: Before we talk more about references, we must introduce a concept
-// called a temporary object. Suppose we have the following code:
+// Обходной путь: Прежде чем мы рассмотрим указатели более детально, нам нужно ознакомится
+// с концепцией известной как "временный объект". Представьте, что мы имеем следующий код
 string tempObjectFun() { ... }
 string retVal = tempObjectFun();
 
-// What happens in the second line is actually:
-//   - a string object is returned from tempObjectFun
-//   - a new string is constructed with the returned object as argument to the
-//     constructor
-//   - the returned object is destroyed
-// The returned object is called a temporary object. Temporary objects are
-// created whenever a function returns an object, and they are destroyed at the
-// end of the evaluation of the enclosing expression (Well, this is what the
-// standard says, but compilers are allowed to change this behavior. Look up
-// "return value optimization" if you're into this kind of details). So in this
-// code:
+// Вот что на самом деле происходит во второй строе:
+//   - tempObjectFun возвращает строковый объект
+//   - с возвращаемого объекта создается новая строка в качестве аргумента конструктору
+//   - возвращаемый объект уничтожается
+// Возвращаемый объект называется временным объектом. Временные объекты создаются
+// когда функция возвращает объект, и уничтожаются в конце выполнения обрамляющего
+// выражения (По крайней мере, так это описывает спецификация, хотя компиляторы могут
+// изменять это поведение. Для более подробной информации смотрите "оптимизация
+// возвращаемого значения". Таким образом в этом коде:
 foo(bar(tempObjectFun()))
 
-// assuming foo and bar exist, the object returned from tempObjectFun is
-// passed to bar, and it is destroyed before foo is called.
+// предполагая, что foo и bar существуют, объект возвращаемый tempObjectFun передается
+// в bar, и уничтожается перед вызовом foo.
 
-// Now back to references. The exception to the "at the end of the enclosing
-// expression" rule is if a temporary object is bound to a const reference, in
-// which case its life gets extended to the current scope:
+// Возвращаемся к указателям. Исключением для правила "в конце выполнения обрамляющего
+// выражения" является временный объект привязанный к ссылке const, в этом случае
+// его жизненный цикл продлевается до текущей области видимости:
 
 void constReferenceTempObjectFun() {
-  // constRef gets the temporary object, and it is valid until the end of this
-  // function.
+  // constRef получает временный объект, и он действителен до конца этой функции.
   const string& constRef = tempObjectFun();
   ...
 }
 
-// Another kind of reference introduced in C++11 is specifically for temporary
-// objects. You cannot have a variable of its type, but it takes precedence in
-// overload resolution:
+// В C++11 предоставлен еще один тип ссылок специально для временных объектов.
+// objects. Вы не можете объявить переменную этого типа, но он имеет приоритет в
+// в резолюции перегрузки:
 
-void someFun(string& s) { ... }  // Regular reference
-void someFun(string&& s) { ... }  // Reference to temporary object
+void someFun(string& s) { ... }  // Обычная ссылка
+void someFun(string&& s) { ... }  // Ссылка на временный объект
 
 string foo;
-someFun(foo);  // Calls the version with regular reference
-someFun(tempObjectFun());  // Calls the version with temporary reference
+someFun(foo);  // Выполняет версию с обычной ссылкой
+someFun(tempObjectFun());  // Выполняет версию с временной ссылкой.
 
-// For example, you will see these two versions of constructors for
-// std::basic_string:
+// Например, существуют следующие две версии конструктора std::basic_string:
 basic_string(const basic_string& other);
 basic_string(basic_string&& other);
 
-// Idea being if we are constructing a new string from a temporary object (which
-// is going to be destroyed soon anyway), we can have a more efficient
-// constructor that "salvages" parts of that temporary string. You will see this
-// concept referred to as "move semantics".
+// Идея в том, если мы конструируем новую строку из временного объекта (который 
+// так или иначе будет уничтожен), мы можем использовать более эффективный конструктор,
+// который "спасает" части этой временной строки. Эта концепция была названа
+// "move semantics".
 
 /////////////////////
-// Enums
+// Перечисления
 /////////////////////
 
-// Enums are a way to assign a value to a constant most commonly used for
-// easier visualization and reading of code
+// Перечисления - способ объявления констант и установки их значений в основном
+// использующийся для упрощения чтения кода.
 enum ECarTypes
 {
   Sedan,
@@ -332,9 +328,9 @@ ECarTypes GetPreferredCarType()
 	return ECarTypes::Hatchback;
 }
 
-// As of C++11 there is an easy way to assign a type to the enum which can be
-// useful in serialization of data and converting enums back-and-forth between 
-// the desired type and their respective constants
+// На момент выхода C++11 есть простой способ назначения типа перечисления, что
+// полезно в случае сериализации данных и преобразований между конечным типом и 
+// соответствующими константами.
 enum ECarTypes : uint8_t
 {
   Sedan, // 0
@@ -345,18 +341,19 @@ enum ECarTypes : uint8_t
 
 void WriteByteToFile(uint8_t InputValue)
 {
-	// Serialize the InputValue to a file
+	// Сериализуем InputValue в файл
 }
 
 void WritePreferredCarTypeToFile(ECarTypes InputCarType)
 {
-	// The enum is implicitly converted to a uint8_t due to its declared enum type
+	// Перечисление неявно преобразуется в uint8_t из-за раннее объявленного
+	// типа перечисления.
 	WriteByteToFile(InputCarType);
 }
 
-// On the other hand you may not want enums to be accidentally cast to an integer
-// type or to other enums so it is instead possible to create an enum class which 
-// won't be implicitly converted
+// С другой стороны, чтобы избежать случайного приведения к целочисленному типу или
+// другому перечислению, вы можете создать класс перечисления, который не будет
+// преобразовываться неявно.
 enum class ECarTypes : uint8_t
 {
   Sedan, // 0
@@ -367,78 +364,78 @@ enum class ECarTypes : uint8_t
 
 void WriteByteToFile(uint8_t InputValue)
 {
-	// Serialize the InputValue to a file
+	// Сериализуем InputValue в файл
 }
 
 void WritePreferredCarTypeToFile(ECarTypes InputCarType)
 {
-	// Won't compile even though ECarTypes is a uint8_t due to the enum
-	// being declared as an "enum class"!
+	// Хотя ECarTypes имеет тип uint8_t, код не будет скомпилирован из-за того,
+	// что перечисление было объявлено как класс перечисления.
 	WriteByteToFile(InputCarType);
 }
 
 //////////////////////////////////////////
-// Classes and object-oriented programming
+// Классы и объектно-ориентированное программирование
 //////////////////////////////////////////
 
-// First example of classes
+// Пример классов
 #include <iostream>
 
-// Declare a class.
-// Classes are usually declared in header (.h or .hpp) files.
+// Объявление класса.
+// Обычно классы объявляют в заголовочном (.h или .hpp) файле.
 class Dog {
-    // Member variables and functions are private by default.
+    // Переменный-члены и функции являются частными по умолчанию.
     std::string name;
     int weight;
 
-// All members following this are public
-// until "private:" or "protected:" is found.
+// Все члены после этой сроки являются открытыми
+// пока "private:" или "protected:" не будет объявлено.
 public:
 
-    // Default constructor
+    // Конструктор по умолчанию
     Dog();
 
-    // Member function declarations (implementations to follow)
-    // Note that we use std::string here instead of placing
+    // Объявление функций-членов
+    // Обратите внимание, мы используем std::string здесь вместо использования
     // using namespace std;
-    // above.
-    // Never put a "using namespace" statement in a header.
+    // выше.
+    // Никогда не размещайте выражение "using namespace" в заголовке.
     void setName(const std::string& dogsName);
 
     void setWeight(int dogsWeight);
 
-    // Functions that do not modify the state of the object
-    // should be marked as const.
-    // This allows you to call them if given a const reference to the object.
-    // Also note the functions must be explicitly declared as _virtual_
-    // in order to be overridden in derived classes.
-    // Functions are not virtual by default for performance reasons.
+    // Функции, которые не изменяют состояние объекта,
+    // должны быть помечены как const.
+    // Это позволяет вызывать их если дана const ссылка на объект.
+    // Обратите внимание, функции должны быть явно объявлены как _virtual_
+    // если вы хотите перегрузить их в производных классах.
+    // Функции не являются виртуальными по умолчания для повышения производительности.
     virtual void print() const;
 
-    // Functions can also be defined inside the class body.
-    // Functions defined as such are automatically inlined.
+    // Такде функции могут быть определены внутри тела класса.
+    // Функции, определенные следующим образом, автоматически встроены.
     void bark() const { std::cout << name << " barks!\n"; }
 
-    // Along with constructors, C++ provides destructors.
-    // These are called when an object is deleted or falls out of scope.
-    // This enables powerful paradigms such as RAII
-    // (see below)
-    // The destructor should be virtual if a class is to be derived from;
-    // if it is not virtual, then the derived class' destructor will
-    // not be called if the object is destroyed through a base-class reference
+    // Наряду с конструкторами, в C++ есть деструкторы.
+    // Они вызываются, когда объект удаляется или выпадает с области видимости.
+    // Это активирует мощную парадигму программирования известную как RAII
+    // (смотрите ниже)
+    // Деструктор должен быть виртуальным, если класс будет производным.
+    // Если он не виртуальный, тогда деструктор производного класса не будет вызван
+    // если объект удален по ссылке или указателю базового класса.
     // or pointer.
     virtual ~Dog();
 
-}; // A semicolon must follow the class definition.
+}; // Определение класса должно завершатся точкой с запятой.
 
-// Class member functions are usually implemented in .cpp files.
+// Функции-члены класса, как правило, реализуются в .cpp файлах.
 Dog::Dog()
 {
     std::cout << "A dog has been constructed\n";
 }
 
-// Objects (such as strings) should be passed by reference
-// if you are modifying them or const reference if you are not.
+// Объекты (такие как строки) должны передаваться по ссылке если вы будете
+// изменять их, или const-ссылке если нет.
 void Dog::setName(const std::string& dogsName)
 {
     name = dogsName;
@@ -449,7 +446,7 @@ void Dog::setWeight(int dogsWeight)
     weight = dogsWeight;
 }
 
-// Notice that "virtual" is only needed in the declaration, not the definition.
+// Обратите внимание, "virtual" требуется только в объявлении, не в определении.
 void Dog::print() const
 {
     std::cout << "Dog is " << name << " and weighs " << weight << "kg\n";
@@ -461,35 +458,34 @@ Dog::~Dog()
 }
 
 int main() {
-    Dog myDog; // prints "A dog has been constructed"
+    Dog myDog; // Печатает "A dog has been constructed"
     myDog.setName("Barkley");
     myDog.setWeight(10);
-    myDog.print(); // prints "Dog is Barkley and weighs 10 kg"
+    myDog.print(); // Печатает "Dog is Barkley and weighs 10 kg"
     return 0;
-} // prints "Goodbye Barkley"
+} // Печатает "Goodbye Barkley"
 
-// Inheritance:
+// Интерфейсы:
 
-// This class inherits everything public and protected from the Dog class
-// as well as private but may not directly access private members/methods 
-// without a public or protected method for doing so
+// Этот класс наследует все открытые и защищенные члены класса Dog
+// также как и все закрытые, но не может непосредственно получить доступ к закрытым
+// членам\методам без открытых или защищенных методов для этого.
 class OwnedDog : public Dog {
 
     void setOwner(const std::string& dogsOwner);
 
-    // Override the behavior of the print function for all OwnedDogs. See
-    // http://en.wikipedia.org/wiki/Polymorphism_(computer_science)#Subtyping
-    // for a more general introduction if you are unfamiliar with
-    // subtype polymorphism.
-    // The override keyword is optional but makes sure you are actually
-    // overriding the method in a base class.
+    // Переопределяем поведение функции печати для всех OwnedDog. Смотрите
+    // https://goo.gl/3kuH2x для боле общего введения, если вы не знакомы
+    // с концепцией полиморфизма подтипов (включения).
+    // Ключевое слово override является необязательным, но указывает что метод
+    // на самом деле перегружается в базовом классе.
     void print() const override;
 
 private:
     std::string owner;
 };
 
-// Meanwhile, in the corresponding .cpp file:
+// Тем временем, в соответствующем .cpp файле:
 
 void OwnedDog::setOwner(const std::string& dogsOwner)
 {
@@ -498,53 +494,54 @@ void OwnedDog::setOwner(const std::string& dogsOwner)
 
 void OwnedDog::print() const
 {
-    Dog::print(); // Call the print function in the base Dog class
+    Dog::print(); // Вызывает функцию print в базовом классе Dog
     std::cout << "Dog is owned by " << owner << "\n";
-    // Prints "Dog is <name> and weights <weight>"
+    // Печатает "Dog is <name> and weights <weight>"
     //        "Dog is owned by <owner>"
 }
 
 //////////////////////////////////////////
-// Initialization and Operator Overloading
+// Инициализация и перегрузка операторов.
 //////////////////////////////////////////
 
-// In C++ you can overload the behavior of operators such as +, -, *, /, etc.
-// This is done by defining a function which is called
-// whenever the operator is used.
+// В C++ вы можете перегрузить поведение таких операторов: +, -, *, / и др..
+// Это делается путем определения функции, которая вызывается,
+// когда используется оператор.
 
 #include <iostream>
 using namespace std;
 
 class Point {
 public:
-    // Member variables can be given default values in this manner.
+    // Значения по умолчанию для переменных-членов могут быть установлены
+	// следующим образом.
     double x = 0;
     double y = 0;
 
-    // Define a default constructor which does nothing
-    // but initialize the Point to the default value (0, 0)
+    // Определяем новый конструктор, который инициализирует Point со значениями
+    // по умолчанию (0, 0)
     Point() { };
 
-    // The following syntax is known as an initialization list
-    // and is the proper way to initialize class member values
+    // Следующий синтаксис известен как список инициализации и является верным способом 
+	// инициализировать значения членов класса.
     Point (double a, double b) :
         x(a),
         y(b)
-    { /* Do nothing except initialize the values */ }
+    { /* Ничего не делайте кроме инициализации значений */ }
 
-    // Overload the + operator.
+    // Перегружаем оперот +.
     Point operator+(const Point& rhs) const;
 
-    // Overload the += operator
+    // Перегружаем оператор +=.
     Point& operator+=(const Point& rhs);
 
-    // It would also make sense to add the - and -= operators,
-    // but we will skip those for brevity.
+    // Имеет смысл добавить перегрузку операторов - и -=,
+    // но для краткости мы опустим эти детали.
 };
 
 Point Point::operator+(const Point& rhs) const
 {
-    // Create a new point that is the sum of this one and rhs.
+    // Создает новую точку, которая является суммой этой точки и rhs.
     return Point(x + rhs.x, y + rhs.y);
 }
 
@@ -558,59 +555,58 @@ Point& Point::operator+=(const Point& rhs)
 int main () {
     Point up (0,1);
     Point right (1,0);
-    // This calls the Point + operator
-    // Point up calls the + (function) with right as its parameter
+    // Здесь происходит вызов оператора + класса Point
+    // Точка "up" вызывает + (функция) с параметром "right"
     Point result = up + right;
-    // Prints "Result is upright (1,1)"
+    // Печатает "Result is upright (1,1)"
     cout << "Result is upright (" << result.x << ',' << result.y << ")\n";
     return 0;
 }
 
 /////////////////////
-// Templates
+// Шаблоны
 /////////////////////
 
-// Templates in C++ are mostly used for generic programming, though they are
-// much more powerful than generic constructs in other languages. They also
-// support explicit and partial specialization and functional-style type
-// classes; in fact, they are a Turing-complete functional language embedded
-// in C++!
+// Шаблоны в С++, в основном, используются для обобщенного программирования, хотя
+// они гораздо более мощны чем дженерики в других языках. Они также поддерживают
+// явные, частные и функциональные типы классов; на самом деле, они являются
+// тьюринг-полным языком встроенным в C++!
 
-// We start with the kind of generic programming you might be familiar with. To
-// define a class or function that takes a type parameter:
+// Мы начнем с наиболее распространенного типа обобщенного программирования. Чтобы
+// определить класс или функцию, которая принимает параметр типа:
 template<class T>
 class Box {
 public:
-    // In this class, T can be used as any other type.
+    // В этом классе T может быть любого типа.
     void insert(const T&) { ... }
 };
 
-// During compilation, the compiler actually generates copies of each template
-// with parameters substituted, so the full definition of the class must be
-// present at each invocation. This is why you will see template classes defined
-// entirely in header files.
+// Во время компиляции, компилятор фактически генерирует копии каждого шаблона
+// с замещенными параметрами, по-этому полное определение класса должно присутствовать
+// при каждом вызове. Именно по-этому классы шаблонов полностью определены в
+// заголовочных файлах.
 
-// To instantiate a template class on the stack:
+// Чтобы создать экземпляр класса шаблона на стеке:
 Box<int> intBox;
 
-// and you can use it as you would expect:
+// и вы можете использовать его, как и ожидалось:
 intBox.insert(123);
 
-// You can, of course, nest templates:
+// Вы, конечно, можете использовать вложенные шаблоны:
 Box<Box<int> > boxOfBox;
 boxOfBox.insert(intBox);
 
-// Until C++11, you had to place a space between the two '>'s, otherwise '>>'
-// would be parsed as the right shift operator.
+// Вплоть до С++11, вы должны были ставить пробел между двумя символами '>', иначе '>>'
+// принимался парсером, как оператор правого сдвига.
 
-// You will sometimes see
+// Иногда вы можете увидеть
 //   template<typename T>
-// instead. The 'class' keyword and 'typename' keywords are _mostly_
-// interchangeable in this case. For the full explanation, see
+// вместо этого. В этом случае, ключевые слова 'class' и 'typename' _в основном_
+// взаимозаменяемыми. Для более подробной информации смотрите
 //   http://en.wikipedia.org/wiki/Typename
-// (yes, that keyword has its own Wikipedia page).
+// (да-да, это ключевое слово имеет собственную страничку на вики).
 
-// Similarly, a template function:
+// Аналогичным образом, шаблонная функция:
 template<class T>
 void barkThreeTimes(const T& input)
 {
@@ -619,115 +615,115 @@ void barkThreeTimes(const T& input)
     input.bark();
 }
 
-// Notice that nothing is specified about the type parameters here. The compiler
-// will generate and then type-check every invocation of the template, so the
-// above function works with any type 'T' that has a const 'bark' method!
+// Обратите внимание, что здесь ничего не указано о типе параметра. Компилятор
+// будет генерировать и затем проверять тип каждый вызов шаблона, по-этому
+// данная функция работает с любым типом 'T', который имеет метод 'bark'.
 
 Dog fluffy;
 fluffy.setName("Fluffy")
-barkThreeTimes(fluffy); // Prints "Fluffy barks" three times.
+barkThreeTimes(fluffy); // Печатает "Fluffy barks" три раза.
 
-// Template parameters don't have to be classes:
+//Параметры шаблона не должны быть классами:
 template<int Y>
 void printMessage() {
   cout << "Learn C++ in " << Y << " minutes!" << endl;
 }
 
-// And you can explicitly specialize templates for more efficient code. Of
-// course, most real-world uses of specialization are not as trivial as this.
-// Note that you still need to declare the function (or class) as a template
-// even if you explicitly specified all parameters.
+// В конце концов, вы можете явно специализировать шаблоны для более эффективного
+// кода. Конечно, большинство реальных случаев использования специализации
+// не так тривиально, как это. Обратите внимание, вам все еще нужно явно объявить
+// функцию (или класс) в качестве шаблона, даже если вы явно указали все параметры.
 template<>
 void printMessage<10>() {
   cout << "Learn C++ faster in only 10 minutes!" << endl;
 }
 
-printMessage<20>();  // Prints "Learn C++ in 20 minutes!"
-printMessage<10>();  // Prints "Learn C++ faster in only 10 minutes!"
+printMessage<20>();  // Печатает "Learn C++ in 20 minutes!"
+printMessage<10>();  // Печатает "Learn C++ faster in only 10 minutes!"
 
 
 /////////////////////
-// Exception Handling
+// Обработка исключений
 /////////////////////
 
-// The standard library provides a few exception types
-// (see http://en.cppreference.com/w/cpp/error/exception)
-// but any type can be thrown an as exception
+// Стандартная библиотека предоставляет несколько типов исключений
+// (смотрите http://en.cppreference.com/w/cpp/error/exception)
+// но, в принципе, любой тип может быть брошен в качестве исключения.
 #include <exception>
 #include <stdexcept>
 
-// All exceptions thrown inside the _try_ block can be caught by subsequent
-// _catch_ handlers.
+// Все исключения брошены внутри блока _try_ могут быть пойманы в последующем блоке
+// _catch_.
 try {
-    // Do not allocate exceptions on the heap using _new_.
+    // Не выделяйте память в куче для исключений с помощью ключевого слова _new_.
     throw std::runtime_error("A problem occurred");
 }
 
-// Catch exceptions by const reference if they are objects
+// Поймайте исключение по константной ссылке, если они являются объектами
 catch (const std::exception& ex)
 {
     std::cout << ex.what();
 }
 
-// Catches any exception not caught by previous _catch_ blocks
+// Ловит любое исключение не пойманное предыдущим блоком _catch_
 catch (...)
 {
     std::cout << "Unknown exception caught";
-    throw; // Re-throws the exception
+    throw; // Повторный выброс исключения
 }
 
 ///////
-// RAII
+// Получение ресурса есть инициализация (RAII)
 ///////
 
-// RAII stands for "Resource Acquisition Is Initialization".
-// It is often considered the most powerful paradigm in C++
-// and is the simple concept that a constructor for an object
-// acquires that object's resources and the destructor releases them.
+// Программная идиома объектно-ориентированного программирования, смысл которой
+// заключается в том, что с помощью тех или иных программных механизмов получение
+// некоторого ресурса неразрывно совмещается с инициализацией, а освобождение -
+// с уничтожением объекта.
 
-// To understand how this is useful,
-// consider a function that uses a C file handle:
+// Чтобы понять на сколько это полезно,
+// рассмотрим функцию, которая использует обработчик файлов в С:
 void doSomethingWithAFile(const char* filename)
 {
-    // To begin with, assume nothing can fail.
+    // Для начала, предположим, ничего не может потерпеть неудачу.
 
-    FILE* fh = fopen(filename, "r"); // Open the file in read mode.
+    FILE* fh = fopen(filename, "r"); // Открываем файл в режиме чтения.
 
     doSomethingWithTheFile(fh);
     doSomethingElseWithIt(fh);
 
-    fclose(fh); // Close the file handle.
+    fclose(fh); // Закрываем обработчик файла.
 }
 
-// Unfortunately, things are quickly complicated by error handling.
-// Suppose fopen can fail, and that doSomethingWithTheFile and
-// doSomethingElseWithIt return error codes if they fail.
-//  (Exceptions are the preferred way of handling failure,
-//   but some programmers, especially those with a C background,
-//   disagree on the utility of exceptions).
-// We now have to check each call for failure and close the file handle
-// if a problem occurred.
+// К сожалению, вещи быстро осложняется обработкой ошибок.
+// Предположим fopen может потерпеть неудачу, тогда doSomethingWithTheFile и
+// doSomethingElseWithIt вернут коды ошибок если потерпят неудачу.
+//  (Исключения являются предпочтительным способом обработки ошибок,
+//   но некоторые программисты, особенно те, кто имеет большой опыт работы с С,
+//   не согласны с аргументами о полезности исключений).
+// Теперь мы должны проверить каждый вызов на наличие ошибок и закрыть обработчик
+// файла если таковы есть.
 bool doSomethingWithAFile(const char* filename)
 {
-    FILE* fh = fopen(filename, "r"); // Open the file in read mode
-    if (fh == nullptr) // The returned pointer is null on failure.
-        return false; // Report that failure to the caller.
+    FILE* fh = fopen(filename, "r"); // Открывает файл в режиме чтения
+    if (fh == nullptr) // В случае неудачи возвращаемый указатель принимает null.
+        return false; // Сообщает об неудаче вызывающему.
 
-    // Assume each function returns false if it failed
+    // Предположим, каждая функция возвращает false в случае неудачи
     if (!doSomethingWithTheFile(fh)) {
-        fclose(fh); // Close the file handle so it doesn't leak.
-        return false; // Propagate the error.
+        fclose(fh); // Закрываем обработчик файл чтобы не было утечек
+        return false; // Сообщает об ошибке.
     }
     if (!doSomethingElseWithIt(fh)) {
-        fclose(fh); // Close the file handle so it doesn't leak.
-        return false; // Propagate the error.
+        fclose(fh); // Закрываем обработчик файл чтобы не было утечек
+        return false; // Сообщает об ошибке.
     }
 
-    fclose(fh); // Close the file handle so it doesn't leak.
-    return true; // Indicate success
+    fclose(fh); // Закрываем обработчик файл чтобы не было утечек
+    return true; // Указывает на успех
 }
 
-// C programmers often clean this up a little bit using goto:
+// C-программисты часто упорядочивают это с помощью goto:
 bool doSomethingWithAFile(const char* filename)
 {
     FILE* fh = fopen(filename, "r");
@@ -741,18 +737,18 @@ bool doSomethingWithAFile(const char* filename)
         goto failure;
 
     fclose(fh); // Close the file
-    return true; // Indicate success
+    return true; // Указывает на успех
 
 failure:
     fclose(fh);
-    return false; // Propagate the error
+    return false; // Сообщает об ошибке.
 }
 
-// If the functions indicate errors using exceptions,
-// things are a little cleaner, but still sub-optimal.
+// Если функции указывают на ошибки с помощью исключений, вещи становятся проще,
+// но все еще не оптимальны.
 void doSomethingWithAFile(const char* filename)
 {
-    FILE* fh = fopen(filename, "r"); // Open the file in read mode
+    FILE* fh = fopen(filename, "r"); // Открываем файл в режиме чтения
     if (fh == nullptr)
         throw std::runtime_error("Could not open the file.");
 
@@ -761,52 +757,51 @@ void doSomethingWithAFile(const char* filename)
         doSomethingElseWithIt(fh);
     }
     catch (...) {
-        fclose(fh); // Be sure to close the file if an error occurs.
-        throw; // Then re-throw the exception.
+        fclose(fh); // Убедитесь, что закрываете файл, если происходит ошибка.
+        throw; // Затем повторно бросает исключение.
     }
 
     fclose(fh); // Close the file
-    // Everything succeeded
+    // Успех
 }
 
-// Compare this to the use of C++'s file stream class (fstream)
-// fstream uses its destructor to close the file.
-// Recall from above that destructors are automatically called
-// whenever an object falls out of scope.
+// Сравните это с использованием класса потока файла (fstream) в С++, который
+// использует свой деструктор чтобы закрыть файл. Еще раз взгляните выше,
+// деструктор вызывается автоматически, когда объект выпадает из области видимости.
 void doSomethingWithAFile(const std::string& filename)
 {
-    // ifstream is short for input file stream
-    std::ifstream fh(filename); // Open the file
+    // ifstream определяет файловый поток
+    std::ifstream fh(filename); // Открыть файл
 
-    // Do things with the file
+    // Что-то делать с файлом
     doSomethingWithTheFile(fh);
     doSomethingElseWithIt(fh);
 
-} // The file is automatically closed here by the destructor
-
-// This has _massive_ advantages:
-// 1. No matter what happens,
-//    the resource (in this case the file handle) will be cleaned up.
-//    Once you write the destructor correctly,
-//    It is _impossible_ to forget to close the handle and leak the resource.
-// 2. Note that the code is much cleaner.
-//    The destructor handles closing the file behind the scenes
-//    without you having to worry about it.
-// 3. The code is exception safe.
-//    An exception can be thrown anywhere in the function and cleanup
-//    will still occur.
-
-// All idiomatic C++ code uses RAII extensively for all resources.
-// Additional examples include
-// - Memory using unique_ptr and shared_ptr
-// - Containers - the standard library linked list,
-//   vector (i.e. self-resizing array), hash maps, and so on
-//   all automatically destroy their contents when they fall out of scope.
-// - Mutexes using lock_guard and unique_lock
-
-// containers with object keys of non-primitive values (custom classes) require
-// compare function in the object itself or as a function pointer. Primitives
-// have default comparators, but you can override it.
+} // Здесь файл автоматически закрывается в деструкторе.
+
+// Это имеет _огромнейшие_ преимущества:
+// 1. Неважно, что произойдет,
+//    ресурсы (в данном случае обработчик файлов) будут очищены.
+//    После того, как вы правильно напишите деструктор,
+//    Больше будет _не возможно_ закрыть обработчик файлов или допустить утечку.
+// 2. Обратите внимание, что код намного проще.
+//    Деструктор закрывает файловый поток "за кулисами" и вам больше не нужно об
+//     этом беспокоится.
+// 3. Код устойчив к исключениям.
+//    Исключение может быть брошено в любом месте в функции и это никак не повлияет
+//    на очистку.
+
+// Весь идиоматический код на С++ широко использует RAII для всех ресурсов.
+// Дополнительные примеры включат
+// - Использование памяти unique_ptr и shared_ptr
+// - Контейнеры - стандартная библиотека связанных списков, векторы 
+//   (т.е. самоизменяемые массивы), хэш-карты и все остальное автоматически
+//    уничтожается сразу-же, когда выходит за пределы области видимости.
+// - Ипользование мютексов lock_guard и unique_lock
+
+// Контейнеры с пользовательскими классами в качестве ключей требуют
+// функций-компаратор в самом объекте или как указатель на функцию. Примитивы
+// имеют компараторы по умолчанию, но вы можете перегрузить их.
 class Foo {
 public:
 	int j;
@@ -817,81 +812,82 @@ struct compareFunction {
         return a.j < b.j;
     }
 };
-//this isn't allowed (although it can vary depending on compiler)
-//std::map<Foo, int> fooMap;
+// это не допускается (хотя это может варьироваться в зависимости от компилятора)
+// std::map<Foo, int> fooMap;
 std::map<Foo, int, compareFunction> fooMap;
 fooMap[Foo(1)]  = 1;
 fooMap.find(Foo(1)); //true
 
 /////////////////////
-// Fun stuff
+// Веселые вещи
 /////////////////////
 
-// Aspects of C++ that may be surprising to newcomers (and even some veterans).
-// This section is, unfortunately, wildly incomplete; C++ is one of the easiest
-// languages with which to shoot yourself in the foot.
+// Аспекты С++, которые могут быть удивительными для новичком (и даже для некоторых
+// ветеранов). Этот раздел, к сожалению, очень неполон. С++ является одним из самых
+// простых языков, где очень легко выстрелить себе в ногу.
 
-// You can override private methods!
+// Вы можете перегрузить приватные методы!
 class Foo {
   virtual void bar();
 };
 class FooSub : public Foo {
-  virtual void bar();  // Overrides Foo::bar!
+  virtual void bar();  // Перегружает Foo::bar!
 };
 
 
-// 0 == false == NULL (most of the time)!
+// 0 == false == NULL (в основном)!
 bool* pt = new bool;
-*pt = 0; // Sets the value points by 'pt' to false.
-pt = 0;  // Sets 'pt' to the null pointer. Both lines compile without warnings.
+*pt = 0; // Устанавливает значение указателя 'pt' в false.
+pt = 0;  // Устанавливает значение 'pt' в нулевой указатель. Обе линии проходят
+		// компиляцию без ошибок.
 
-// nullptr is supposed to fix some of that issue:
+// nullptr приходит на помощь:
 int* pt2 = new int;
-*pt2 = nullptr; // Doesn't compile
-pt2 = nullptr;  // Sets pt2 to null.
+*pt2 = nullptr; // Не пройдет компиляцию
+pt2 = nullptr;  // Устанавливает pt2 в null.
 
-// There is an exception made for bools.
-// This is to allow you to test for null pointers with if(!ptr),
-// but as a consequence you can assign nullptr to a bool directly!
-*pt = nullptr;  // This still compiles, even though '*pt' is a bool!
+// Существует исключение для булевых значений.
+// Это позволит вам проверить указатели с помощью if(!ptr),
+// но как следствие вы можете установить nullptr в bool напрямую!
+*pt = nullptr;  // Это по прежнему проходит компиляцию, даже если '*pt' - bool!
 
 
 // '=' != '=' != '='!
-// Calls Foo::Foo(const Foo&) or some variant (see move semantics) copy
-// constructor.
+// Вызывает Foo::Foo(const Foo&) или некий вариант (смотрите "move semantics")
+// копирования конструктора.
 Foo f2;
 Foo f1 = f2;
 
-// Calls Foo::Foo(const Foo&) or variant, but only copies the 'Foo' part of
-// 'fooSub'. Any extra members of 'fooSub' are discarded. This sometimes
-// horrifying behavior is called "object slicing."
+// Вызывает Foo::Foo(const Foo&) или вариант, но копирует только часть 'Foo' из
+// 'fooSub'. Любые другие члены 'fooSub' пропускаются. Иногда это ужасное поведение
+// называют "object slicing."
 FooSub fooSub;
 Foo f1 = fooSub;
 
-// Calls Foo::operator=(Foo&) or variant.
+// Вызывает Foo::operator=(Foo&) или вариант.
 Foo f1;
 f1 = f2;
 
 
-// How to truly clear a container:
+// Как по-настоящему очистить контейнер:
 class Foo { ... };
 vector<Foo> v;
 for (int i = 0; i < 10; ++i)
   v.push_back(Foo());
 
-// Following line sets size of v to 0, but destructors don't get called
-// and resources aren't released!
+// В слудующей точке размер v устанавливается в 0, но деструктор не вызывается
+// и не происходит очистка ресурсов!
 v.empty();
-v.push_back(Foo());  // New value is copied into the first Foo we inserted
+v.push_back(Foo());  // Новые значения копируются в первый вставленный Foo
 
-// Truly destroys all values in v. See section about temporary objects for
-// explanation of why this works.
+// Настоящие уничтожение всех значений v. Смотрите раздел о временном объекте
+// для объяснения того, как это работает.
 v.swap(vector<Foo>());
 
 ```
-Further Reading:
+Дальнейшее чтение:
 
-An up-to-date language reference can be found at
+Наиболее полное и обновленное руководство по С++ можно найти на
 <http://cppreference.com/w/cpp>
 
-Additional resources may be found at <http://cplusplus.com>
+Дополнительные ресурсы могут быть найдены на <http://cplusplus.com>