fix(guide): simplify directory structure

guide/russian/cplusplus/C- STL sets/index.md

@@ -0,0 +1,23 @@
+InlocaleTitle: undefined
+tрождение наборов в библиотеке STL C ++ Наборы - это тип ассоциативных контейнеров, в которых каждый элемент должен быть уникальным. Значение элемента не может быть изменено после его добавления в набор, хотя можно удалить и добавить измененное значение этого элемента. Они реализованы с использованием красно-черного дерева.
+
+Преимущества использования наборов
+
+1.  Он сохраняет только уникальные значения.
+2.  Значение элемента идентифицирует себя. Значение элемента также является ключом, используемым для его идентификации.
+3.  Обеспечивает быстрый поиск (O (log n)) с использованием ключей, т.е. самого элемента.
+4.  Существует множество встроенных функций в наборах, определяющих класс, которые облегчают программирование.
+
+Пример: '' 'C ++
+
+# включают
+
+использование пространства имен std; int main () { задавать s;
+
+s.insert (2); // вставляем элемент 2 в набор s s.insert (3); s.insert (5); s.insert (2); // вставка того же элемента 2 s.insert (6); для (auto i: s) cout << i << ""; соиЬ << s.size () << епсИ; // задает размер набора
+
+s.erase (5); // стирание элемента 5 из набора s return 0; } «»» Создание заданного объекта '' 'C ++ задавать s; «»»
+
+вставка '' 'C ++ s.insert (значение _для_ be\_inserted); «»»
+
+Доступ к наборам элементов '' 'C ++ задавать :: iterator it; for (it = s.begin (); it! = s.end (); ++ it) соиЬ << \* это; «»»

guide/russian/cplusplus/arrays/index.md

@@ -0,0 +1,42 @@
+---
+title: C++ Arrays
+localeTitle: Массивы C ++
+---
+## Что такое массивы?
+
+Массив представляет собой ряд элементов одного и того же типа данных, которые хранятся в смежных ячейках памяти и могут ссылаться индивидуально.
+
+Например, массив, содержащий 5 целых значений, называемых числами, объявляется так:
+
+```C++
+int numbers [5]; 
+```
+
+Initializiation:
+
+```C++
+//Initialization with entries: 
+ int numbers [5] = {1, 2, 3, 4, 5}; 
+ 
+ //Initialization with no values: 
+ int numbers [5] = {}; 
+ 
+ //Initialization with declaration: 
+ int numbers [] = {1, 2, 3, 4, 5}; 
+ //Note that here the number of values defines the size of the array. 
+ //In the examples above, the size was fixed beforehand 
+```
+
+**Обратите внимание,** что массивы на C ++ не перестановочны по размеру, а это означает, что после объявления массива размером 5 он не может быть увеличен или уменьшен. Если вам действительно нужен большой массив с одинаковыми записями, вам придется скопировать все записи в новый массив большего размера.
+
+### Доступ:
+
+Элементы из массива можно получить через ссылку на их позицию в массиве. (Начать отсчет с 0).  
+Пример:
+
+```C++
+x = numbers[0]; // = 1. [0] == first position 
+ numbers[2] = 55; // Sets the third position (3) to the new number 55 
+ //numbers[] is now: {1, 2, 55, 4, 5} 
+
+```

guide/russian/cplusplus/casting/index.md

@@ -0,0 +1,88 @@
+---
+title: Casting
+localeTitle: Кастинг
+---
+## Кастинг
+
+Литье - это специальный оператор, который заставляет один тип данных преобразовываться в другой
+
+Кастинг в C ++ несколько отличается от C C. C ++ использует различные функции кастингов.
+
+### static\_cast
+
+Static cast используется для неявных преобразований между примитивами и перегрузками типов.
+
+### const\_cast
+
+Const cast может использоваться для изгнания константы. Это полезно, когда есть желание изменить постоянное значение. Это следует использовать экономно, вместо этого следует рассмотреть возможность создания параметров / функций не const в тех случаях, когда используется const-cast.
+
+Const cast также может привести к неопределенному поведению. Единственное приложение const cast должно всегда состоять в том, чтобы удалить константу из значения, которое было передано функции и помечено как const. Если значение истинно const, то есть оно помечено как const во время компиляции и назначено значение, const cast и мутация переменной приведет к неопределенному поведению.
+```
+const int y = 10;             // y is set to 10. 
+ const_cast<int &>(y) = 20;    // undefined behaviour. 
+```
+
+### dynamic\_cast
+
+Динамический кастинг используется для создания объекта внутри его иерархии классов (родительскому, от родительского и к родному брату). Динамический бросок может быть вызван только для полиморфных классов. Таким образом, исходный класс в этом случае `MyClass` должен иметь виртуальный член, который присутствует в форме виртуального деструктора.
+
+Если динамическое сканирование завершится неудачно, оно вернет `nullptr` . Динамический листинг может быть полезен при определении типов объектов во время выполнения. Однако следует отметить, что динамический кастинг не является бесплатным, и в некоторых случаях другие методы могут оказаться более эффективными при определении типа класса во время выполнения.
+
+### reinterpret\_cast
+
+Reinterpret cast - это, пожалуй, самый опасный из всех C ++-приведений, но при правильном использовании он может быть идеальным. Реинтерпрет не влияет на производительность, поскольку он не выполняет никаких преобразований. Он просто инструктирует компилятор обрабатывать литой объект, как если бы он был запрошенным типом. Это также может привести к проблемам выравнивания, поэтому его следует использовать экономно и только тогда, когда известны побочные эффекты и учитываются.
+
+#### Заметка о стилях C-стиля
+
+C ++ поддерживает использование стилей C-стиля, хотя они не рекомендуются. Использование стилей C-стиля даст указание компилятору сначала выполнить статическую _актерскую съемку, если статический_ приведение не выполняется, reinterpret\_cast используется на своем месте. По этой причине приведение в стиле C может привести к непредсказуемым результатам и вызвать неожиданные проблемы.
+
+## Примеры
+
+```cpp
+#include <iostream> 
+ 
+ class MyClass { 
+ public: 
+    virtual ~MyClass() = default; 
+ 
+    void greet() { 
+        std::cout << "Hello World!" << std::endl; 
+    } 
+ }; 
+ 
+ class MyClassChild : public MyClass { 
+ }; 
+ 
+ void reinterpretCastTest(void *objectPtr) { 
+    // Let's assume we know objectPtr is of type MyClass * 
+    auto myClassObj = reinterpret_cast<MyClassChild *>(objectPtr); 
+    myClassObj->greet(); 
+ } 
+ 
+ void constCastTest(const MyClassChild &myClassChild) { 
+    auto nonConst = const_cast<MyClassChild &>(myClassChild); 
+    nonConst.greet(); 
+ } 
+ 
+ void dynamicCastTest(MyClass *myClass) { 
+    auto *child = dynamic_cast<MyClassChild *>(myClass); 
+    child->greet(); 
+ } 
+ 
+ void staticCastTest(float floatVal) { 
+    // Convert the float into an int. 
+    auto intVal = static_cast<int>(floatVal); 
+    std::cout << intVal << std::endl; 
+ } 
+ 
+ int main() { 
+    MyClassChild myClass; 
+    reinterpretCastTest(&myClass); 
+    constCastTest(myClass); 
+    dynamicCastTest(&myClass); 
+    staticCastTest(10.5); 
+ 
+    return 0; 
+ } 
+
+```

guide/russian/cplusplus/clean-code-guidelines/index.md

@@ -0,0 +1,109 @@
+---
+title: Clean Code Guidelines
+localeTitle: Рекомендации по чистому коду
+---
+# Рекомендации по чистому коду
+
+При кодировании стиль кодирования, который вы следуете, может быть очень важным. Специально, когда вы работаете с командой или планируете поделиться своим код. Большинство из этих рекомендаций являются стандартными и могут применяться к большинству языков программирования, однако здесь у вас есть приложения и фрагменты с кодом на C ++, поэтому вы можете легко ознакомиться с ним. Помните, что это только рекомендации для достижения ясности, которые могут быть личным преференцией, поэтому возьмите эти советы а не принимать их к письму. Иногда нарушение некоторых из этих правил может привести к созданию более чистого кода.
+
+## Использовать хорошие имена переменных и делать комментарии
+
+Убедитесь, что вы создаете хорошие имена переменных, например, если вы создаете игру, избегайте использования переменной «a», используйте что-то вроде «p1», ссылаясь на игрока 1. [Венгерская нотация](https://en.wikipedia.org/wiki/Hungarian_notation) обычно распространяется и может дать вам некоторые путевые точки для объявления переменные.
+
+Кроме того, ПОЖАЛУЙСТА, используйте комментарии, я даже не шучу, просто попробуйте прочитать некоторые старые проекты, которые вы сделали без комментариев ... теперь представьте, что вы кто-то другой, который даже не закодировал его.
+
+## Глобальные переменные
+
+Глобальные переменные могут быть просты в использовании, и с небольшим кодом он может выглядеть как отличное решение. Но, когда код становится все больше и больше, становится все труднее узнать, когда они используются.
+
+Вместо использования глобальных переменных вы можете использовать переменные, объявленные в функциях, которые могут помочь вам рассказать, какие значения передаются и быстрее выявлять ошибки.
+
+```cpp
+#include <iostream> 
+ using namespace std; 
+ 
+ // Global variables are declared outside functions 
+ int cucumber; // global variable "cucumber" 
+```
+
+## Использование goto, продолжить и т. Д.
+
+Это обычное обсуждение среди программистов, как и глобальные переменные, эти типы утверждений обычно считаются плохими. Они считаются плохими, потому что они приводят к [«коду spaguetti»](https://en.wikipedia.org/wiki/Spaghetti_code) . Когда мы программируем, мы хотим линейный поток, при использовании этих утверждений поток изменяется и приводит к «скрученному и запутанному» потоку.
+
+Goto использовался в прошлом, когда, хотя, если функции, однако, были введены в действие для такого структурированного программирования. В общем, избегайте использования goto, если вы не уверены, что сделает ваш код более чистым и более легким для чтения. В качестве примера можно использовать его в вложенных циклах.
+
+Использование разрыва и продолжения практически одинаково. Используйте их в переключателях и пытайтесь выполнять функции с единственной целью, поэтому у вас есть только одна точка выхода.
+
+![IMG](https://imgs.xkcd.com/comics/goto.png)
+
+## Избегайте изменения управляющей переменной внутри цикла for
+
+Обычно есть работы вокруг этого, которые выглядят яснее и менее запутанными, например. в то время как циклы. Делать:
+
+```cpp
+int i=1; 
+ while (i <= 5) 
+ { 
+    if (i == 2) 
+        i = 4; 
+ 
+    ++i; 
+ } 
+```
+
+Вместо:
+
+```cpp
+for (int i = 1; i <= 5; i++) 
+ { 
+    if (i == 2) 
+    { 
+       i = 4; 
+    } 
+    // Do work 
+ } 
+```
+
+## Объявлять константы и типы вверху
+
+Они обычно объявляются после библиотек, что делает их доступными и более удобными для чтения. Для локальных переменных это происходит одинаково, объявляйте их наверху (другие люди предпочитают объявлять их как можно более поздними, чтобы сохранить память: [cplusplus.com](http://www.cplusplus.com/forum/general/33612/)
+
+## Используйте только одну функцию возврата в конце
+
+Как мы уже говорили, мы делаем только одну запись и выход, чтобы сделать поток более четким.
+
+## Используйте фигурные скобки, даже при написании однострочных
+
+Систематически это поможет вам сделать это быстрее, и если вы захотите изменить код в будущем, вы сможете сделать это без забот.
+
+Вместо:
+
+```cpp
+for (int i = 1; i <= 5; i++) 
+    //CODE 
+```
+
+Делать:
+
+```cpp
+for (int i = 1; i <= 5; i++) 
+ { 
+    //CODE 
+ } 
+```
+
+## Другие рекомендации
+
+*   #### Используйте, когда вы знаете количество итераций, пока и делаете, когда вы этого не делаете.
+    
+*   #### Используйте const, перейдите по значению / ссылке, когда это подходит. Это поможет сэкономить память.
+    
+*   \#### Записывать const в caps, datatypes, начиная с T и переменных в нижнем регистре.
+    
+
+```cpp
+const int MAX= 100;             //Constant 
+ typedef int TVector[MAX];       //Data type 
+ TVector vector;                 //Vector 
+
+```

guide/russian/cplusplus/compilers/index.md

@@ -0,0 +1,55 @@
+---
+title: C++ Compilers
+localeTitle: Компиляторы C ++
+---
+# Вступление к компиляторам на C ++
+
+Чтобы начать работу с C ++, вам нужно немного узнать о компиляторах и как работает C ++ на вашем компьютере.
+
+Когда все сказано и сделано, компьютеры понимают только один язык, машинный язык. Язык машины полностью состоит из двоичные биты, или 0s и 1s. Хотя можно было бы программировать в двоичном формате, это было бы невероятно утомительно и требовало много времени. Итак, мы, люди, разработали языки программирования, чтобы упростить разработку программного обеспечения. Язык сборки - прямой от 1 до 1 с машиной язык. Языки, такие как C, C ++ и COBOL, немного выше и их необходимо скомпилировать. Это еще больше. Языки как JavaScript и Python имеют компоненты, которые переводится на языки C ++ или других языков низкого уровня, прежде чем они будут скомпилированы, эффективно делая их «высшими» языками, чем C или C ++. Поскольку компьютерная архитектура состоит из электронных переключателей и кабелей, которые могут работать только с двоичными 1 и 0, вам нужен компилятор для перевода кода с высокого уровня C ++ на машинный язык, который может понять процессор.
+
+Компиляторы - это служебные программы, которые принимают ваш код и преобразуют его в исполняемые файлы машинного кода. Когда вы запускаете компилятор во-первых, препроцессор читает исходный код (файл C ++, который вы только что написали). Препроцессор выполняет поиск любого предпроцессорные директивы (строки кода, начинающиеся с символа #). Директивы препроцессора вызывают препроцессор, чтобы каким-то образом изменить ваш код (обычно добавляя некоторую библиотеку или другой файл C ++). Далее, компилятор работает через препроцитированную строку кода путем перевода строки каждой строке в соответствующую инструкцию машинного языка. Это также выявит любые синтаксические ошибки, которые присутствуют в вашем исходный код и вызовет ошибку в командной строке. Наконец, если ошибок нет, компилятор создает объект файл с бинарным файлом машины, который необходимо запустить на вашем компьютере. Хотя объектный файл, созданный компилятором вероятно, достаточно, чтобы что-то сделать на вашем компьютере, он по-прежнему не является исполняемым исполняемым файлом вашей программы на C ++. Существует окончательный важный шаг для достижения исполняемой программы.
+
+C ++ содержит обширную библиотеку, которая помогает выполнять сложные задачи, такие как ввод-вывод и аппаратное манипулирование. Вы можете включить эти библиотеки с препроцессорными директивами, но препроцессор автоматически не добавляет их в ваш код. Для того чтобы вы имели конечная исполняемая программа, другая утилита, известная как компоновщик, должна объединять ваши объектные файлы с библиотечными функциями необходимо для запуска кода. Подумайте об этом как о наличии всех необходимых блоков построить дом. Компилятор сделал все блоки, но компоновщик - тот, который объединяет их все вместе, чтобы наконец создать дом. Как только это будет сделано, теперь у вас есть исполняемый исполняемый файл!
+
+## Как скомпилировать файл
+
+Допустим, у вас есть файл C ++, `helloWorld.cpp` ...
+
+### Если вы находитесь в Windows -
+
+#### Использование и IDE, такие как CodeBlocks
+
+Это так же просто, как нажать кнопки сборки и запуска, они создадут файл в папке проекта. ![IMG](https://i.imgur.com/FwZuFGy.png)
+
+#### Использование командной строки
+
+1.  Откройте командную строку разработчика - для этого шага вам понадобится Microsoft Visual Studio или другая среда IDE, позволяет вам скомпилировать вашу программу из командной строки. Вы также можете искать онлайн-компиляторы C ++.
+    
+2.  Перейдите непосредственно к исходному коду
+    
+3.  Запустите компилятор в исходном коде (при условии, что вы используете компилятор Microsoft Visual Studio) `cl /EHsc helloWorld.cpp`
+    
+
+Теперь это создаст объектный файл и автоматически свяжет его для вас. Если вы посмотрите в ту же папку, вы увидите В настоящее время присутствует исполняемый файл hellWorld.exe (обратите внимание на расширение exe).
+
+4.  Введите `helloWorld` в приглашение для запуска исполняемого файла
+
+Кроме того, многие IDE позволяют быстро создавать и просматривать вашу программу. Это может быть проще, так как ваша версия окна могут не быть предварительно упакованы с помощью утилиты компилятора.
+
+### Если вы находитесь в Linux или OSX -
+
+1.  Откройте окно терминала и перейдите в каталог исходного кода
+2.  Запустите компилятор в исходном коде `g++ helloWorld.cpp -o helloWorld`
+
+Это создаст объектный файл и автоматически свяжет его для вас. Посмотрите в папку, и вы увидите helloWorld.exe исполняемый файл (обратите внимание на расширение exe).
+
+3.  Введите `./helloWorld` в окне терминала, чтобы запустить исполняемый файл
+
+g ++ является стандартным компилятором Linux и является отличной утилитой. Он поставляется в комплекте с операционной системой.
+
+ЗАМЕТКА: непосредственно компилировать и выполнять свой код, запускать `g++ -o helloWorld helloWorld.cpp; ./helloWorld` поэтому, когда вам нужно многократно компилировать и запускать код, вверх стрелка-введите
+
+* * *
+
+Существует несколько разных типов компиляторов. Два из них - это два, которые обычно упаковываются вместе с Windows или Linux / OSX.

guide/russian/cplusplus/conditional-operator/index.md

@@ -0,0 +1,44 @@
+---
+title: Conditional Operator
+localeTitle: Условный оператор
+---
+## Условный оператор
+
+Условный оператор - тернарный оператор, т. Е. Ему нужны 3 операнда. Он возвращает одно из двух значений в зависимости от результата выражения Условный оператор используется для замены простых операторов if-else.
+
+Синтаксис:
+
+```cpp
+  (condition)?(expression-1):(expression-2); 
+```
+
+Здесь выражение-1 оценивается, когда условие истинно, а выражение-2 оценивается, когда условие является ложным. Аналогичным оператором if-else будет:
+
+```cpp
+if(condition) 
+  { 
+    expression-1; 
+  } 
+ else 
+  { 
+    expression-2; 
+  } 
+```
+
+Следовательно, условный оператор очень удобен, когда вам нужно написать простую инструкцию if-else. Его также можно использовать в #define препроцессор, когда подобное условие должно использоваться в нескольких местах.
+
+Например, чтобы найти максимум двух условных операторов, можно использовать следующее:
+
+```cpp
+#define big(a,b) (a>=b)?a:b 
+ 
+ int maximum,x=5,y=6; // variable to store maximum of two numbers 
+ maximum=(x>y)?x:y; // directly using conditional operator 
+ maximum=big(x,y); // using the #define preprocessor defined above as big 
+```
+
+**Удачи всем вам**
+
+**Счастливое кодирование! :)**
+
+**Не стесняйтесь задавать любые вопросы на странице GitHub [FreeCodeCamp](https://forum.freecodecamp.org/) или [форуме FreeCodeCamp.](https://forum.freecodecamp.org/)**

guide/russian/cplusplus/do-while-loop/index.md

@@ -0,0 +1,43 @@
+---
+title: do while loop
+localeTitle: делать while loop
+---
+## Do While Loop
+
+Цикл `do while loop` почти такой же, как цикл while. Цикл `do while loop` имеет следующий вид:
+
+```cpp
+do 
+ { 
+  // do something; 
+ } while(expression); 
+```
+
+Примечание. Не забудьте использовать точку с запятой ';' в конце условия.
+
+## Подробная информация о цикле do-while
+
+Цикл do-while используется всякий раз, когда вы уверены, что определенный процесс (внутри цикла) должен выполняться хотя бы один раз. Он имеет много преимуществ, таких как инициализация контрольной переменной (например, char addmore = 'Y') и т. Д. Точка с запятой в конце while является обязательной.
+
+Сначала сделайте что-нибудь, а затем проверьте, нужно ли нам продолжать. В результате блок do выполняется хотя бы один раз. (Потому что тест выражения приходит после этого). Взгляните на пример:
+
+```cpp
+#include <iostream> 
+    using namespace std; 
+ 
+    int main() 
+    { 
+        int counter, howmuch; 
+ 
+        cin >> howmuch; 
+        counter = 0; 
+        do 
+        { 
+            counter++; 
+            cout << counter << '\n'; 
+        } 
+        while ( counter < howmuch); 
+        return 0; 
+    } 
+
+```

guide/russian/cplusplus/dynamic-memory-allocation/index.md

@@ -0,0 +1,40 @@
+---
+title: Dynamic Memory Allocation
+localeTitle: Динамическое распределение памяти
+---
+## Распределение динамической памяти в C ++
+
+### Что такое динамическое распределение памяти на C ++?
+
+*   **Распределение памяти** в C ++ относится к памяти, выделенной для переменных, которые вы используете в своей программе.
+*   **Динамическое распределение памяти** - это память, которая привязана к переменным во время выполнения, и объем требуемой памяти также определяется во время выполнения.
+*   Эта память исходит из **кучи** , тогда как _нестатические_ переменные и _локальные_ переменные получают память из **стека** .
+*   В C ++ программист может выполнять выделение памяти вручную и называется распределением **_динамической памяти_** .
+*   В C можно было выполнять динамическое распределение памяти, используя функции _calloc_ и _malloc_ для выделения памяти и использования _свободной_ функции для де-распределения динамической памяти.
+*   В C ++ в дополнение к выше, есть две функции: _новые_ и _удаленные_ для выполнения динамического распределения памяти и де-распределения.
+
+### Оператор NEW
+
+*   `new` оператор может предоставить память программиста из кучи (если доступно). Если память, запрошенная программистом, доступна, то `new` оператор инициализирует память, а затем возвращает адрес (ссылку) выделенной памяти.
+*   **Синтаксис**  
+    `pointer-variable-type` = **новый** `data-type;`  
+    Пример 1: `int *ptr` = **new** `int;`  
+    Пример 2: `int *ptr2` = **новый** `int[10];`  
+    Здесь `pointer-variable-type` является **указателем** типа `data type` . Тип `data-type` может быть int, char и т. Д. Или определяемым пользователем типом данных.
+
+### Оператор DELETE
+
+*   Ответственность программиста заключается в том, чтобы де-распределить динамически выделенную память, иначе память не будет доступна для перераспределения до конца программы.
+    
+*   Чтобы освободить память, оператор `delete` доступен и может быть использован программистом.
+    
+*   **Синтаксис**  
+    **удалить** `pointer-type-variable;`  
+    Например, чтобы освободить память, выделенную в примере 1 выше, мы вводим:  
+    `delete ptr;`  
+    Аналогично, например, память может быть освобождена:  
+    `delete ptr2` ;
+    
+    ### Утечки памяти
+    
+    Утечки вызывают, когда вы не можете освободить динамическую память, которую вы выделили с помощью оператора `New` в конце вашей программы. Если вы не освободите его с помощью оператора Delete, ваш компьютер будет продолжать создавать новую память в куче каждый раз, когда запускается программа. Это приводит к замедлению работы вашего компьютера, поскольку память не удаляется, а доступная память уменьшается.

guide/russian/cplusplus/erase-remove/index.md

@@ -0,0 +1,88 @@
+---
+title: Erase–remove idiom
+localeTitle: Стирать-удалить идиому
+---
+## Desctiprion
+
+Как удалить элементы из контейнера - это общий вопрос об интервью с C ++, поэтому вы можете заработать несколько пунктов коричневого цвета, если внимательно прочитать эту страницу. Идиома erase-remove - это метод C ++ для устранения элементов, которые выполняют определенный критерий из контейнера. Как бы то ни было, можно исключить элементы с традиционным рукописным циклом, но идиома стирания-удаления имеет ряд преимуществ.
+
+### сравнение
+
+```cpp
+// Using a hand-written loop 
+ std::vector<int> v = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; 
+ for (auto iter = v.cbegin(); iter < v.cend(); /*iter++*/) 
+ { 
+    if (is_odd(*iter)) 
+    { 
+        iter = v.erase(iter); 
+    } 
+    else 
+    { 
+        ++iter; 
+    } 
+ } 
+ 
+ // Using the erase–remove idiom 
+ std::vector<int> v = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; 
+ v.erase(std::remove_if(v.begin(), v.end(), is_odd), v.end()); 
+```
+
+Как вы можете видеть, код с ручным циклом требует немного более типизации, но также имеет проблемы с производительностью. Каждый вызов `erase` должен перемещать все элементы после удаленной, чтобы избежать «пробелов» в коллекции. Вызов `erase` несколько раз на том же самом контейнере создает много накладных расходов на перемещение элементов.
+
+С другой стороны, код с идиомой стирания-удаления не только более выразителен, но и более эффективен. Во-первых, вы используете `remove_if/remove` для перемещения всех элементов, которые не соответствуют критериям удаления, перед фронтом диапазона, сохраняя относительный порядок элементов. Таким образом , после вызова `remove_if/remove` , один вызов `erase` удаляет все остальные элементы в конце диапазона.
+
+### пример
+
+```cpp
+#include <vector> // the general-purpose vector container 
+ #include <iostream> // cout 
+ #include <algorithm> // remove and remove_if 
+ 
+ bool is_odd(int i) 
+ { 
+    return (i % 2) != 0; 
+ } 
+ 
+ void print(const std::vector<int> &vec) 
+ { 
+    for (const auto& i : vec) 
+        std::cout << i << ' '; 
+    std::cout << std::endl; 
+ } 
+ 
+ int main() 
+ { 
+    // initializes a vector that holds the numbers from 1-10. 
+    std::vector<int> v = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; 
+    print(v); 
+ 
+    // removes all elements with the value 5 
+    v.erase(std::remove(v.begin(), v.end(), 5), v.end()); 
+    print(v); 
+ 
+    // removes all odd numbers 
+    v.erase(std::remove_if(v.begin(), v.end(), is_odd), v.end()); 
+    print(v); 
+ 
+    // removes multiples of 4 using lambda 
+    v.erase(std::remove_if(v.begin(), v.end(), [](int n) { return (n % 4) == 0; }), v.end()); 
+    print(v); 
+ 
+    return 0; 
+ } 
+ 
+ /* 
+ Output: 
+ 1 2 3 4 5 6 7 8 9 10 
+ 1 2 3 4 6 7 8 9 10 
+ 2 4 6 8 10 
+ 2 6 10 
+ */ 
+```
+
+### источники
+
+«Стереть-удалить идиому» Википедия: свободная энциклопедия. Wikimedia Foundation, Inc. [ru.wikipedia.org/wiki/Erase-remove\_idiom](https://en.wikipedia.org/wiki/Erase%E2%80%93remove_idiom)
+
+Мейерс, Скотт (2001). Эффективный STL: 50 конкретных способов улучшить использование стандартной библиотеки шаблонов. Addison-Wesley.

guide/russian/cplusplus/error handling/index.md

@@ -0,0 +1,49 @@
+---
+title: Error Handling
+localeTitle: Обработка ошибок
+---
+# Обработка исключений на C ++
+
+Исключением является проблема, возникающая во время выполнения программы. Исключения обеспечивают способ передачи управления из одной части программы в другую. Обработка исключений C ++ построена на трех ключевых словах: #try, #catch и #throw.
+
+*   # throw - программа выдает исключение, когда возникает проблема. Это делается с использованием ключевого слова throw.
+    
+*   # catch - программа выхватывает исключение с обработчиком исключений в месте в программе, где вы хотите справиться с этой проблемой. Ключевое слово catch указывает на улавливание исключения.
+    
+*   #try - блок try идентифицирует блок кода, для которого будут активированы определенные исключения. За ним следует один или несколько блоков catch.
+    
+
+```CPP
+#include <iostream> 
+ using namespace std; 
+ 
+ int main() 
+ { 
+   int x = -1; 
+ 
+   // Some code 
+   cout << "Before try \n"; 
+   try { 
+      cout << "Inside try \n"; 
+      if (x < 0) 
+      { 
+         throw x; 
+         cout << "After throw (Never executed) \n"; 
+      } 
+   } 
+   catch (int x ) { 
+      cout << "Exception Caught \n"; 
+   } 
+ 
+   cout << "After catch (Will be executed) \n"; 
+   return 0; 
+ } 
+```
+
+# Прежде чем продолжить ...
+
+## Обзор
+
+*   Группировка типов ошибок.
+*   Разделение кода обработки ошибок из нормального кода.
+*   Функции / методы могут обрабатывать любые исключения, которые они выбирают.

guide/russian/cplusplus/for-loop/index.md

@@ -0,0 +1,91 @@
+---
+title: For Loop
+localeTitle: Для цикла
+---
+A For Loop - это повторяющийся оператор, который используется для проверки какого-либо условия, а затем на основании условия блок кода выполняется несколько раз, пока не будет выполнено указанное условие.
+
+Цикл for отличается от других операторов циклов через явный счетчик циклов или переменную цикла, которая позволяет телу цикла знать точное упорядочение каждой итерации.
+
+Следовательно, цикл for представляет собой структуру управления повторением, которая позволяет эффективно писать цикл, который должен выполняться определенное количество раз.
+
+## Синтаксис
+```
+for ( init; condition; increment ) { 
+   statement(s); 
+ } 
+```
+
+Разрешено помещать инкремент в цикл for, как в цикле while. Значение синтаксиса, подобного этому, также может работать.
+```
+for ( init; condition;) { 
+   statement(s); 
+   increment; 
+ } 
+```
+
+### в этом
+
+Этот шаг позволяет объявлять и инициализировать любые переменные управления контуром. Этот шаг выполняется сначала и только один раз.
+
+### состояние
+
+Затем выполняется условие. Если он выполняется, тело цикла выполняется. Если он содержит false, тело цикла не выполняется и поток управляющих переходов на следующую итерацию (повторение процесса).
+
+### Обновить
+
+Оператор update используется для изменения переменной цикла с помощью простых операций, таких как сложение, вычитание, умножение или деление. Заявление об обновлении выполняется после выполнения цикла цикла.
+
+## РЕАЛИЗАЦИЯ:
+
+```C++
+#include <iostream> 
+ using namespace std; // Here we use the scope resolution operator to define the scope of the standar functions as std:: 
+ 
+ int main () { 
+   // for loop execution 
+   for( int a = 10; a < 20; a = a + 1 ) { // The loop will run till the value of a is less than 20 
+      cout << "value of a: " << a << endl; 
+   } 
+ 
+   return 0; 
+ }``` 
+ 
+ Output: 
+ value of a: 10 
+ value of a: 11 
+ value of a: 12 
+ value of a: 13 
+ value of a: 14 
+ value of a: 15 
+ value of a: 16 
+ value of a: 17 
+ value of a: 18 
+ value of a: 19 
+ 
+ ##Single lined loop 
+ The body of the for loop need not be enclosed in braces if the loop iterates over only one satatement. 
+ ##Example 
+```
+
+C ++ #включают использование пространства имен std;
+
+int main () { // Одиночная линия для цикла для (int a = 10; a <20; a = a + 1) cout << "значение a:" << a << endl;
+
+return 0; } \`\` \`
+
+Это будет генерировать тот же результат, что и предыдущая программа. т.е. Вывод: значение a: 10 значение a: 11 значение a: 12 значение a: 13 значение a: 14 значение a: 15 значение a: 16 значение a: 17 значение a: 18 значение a: 19
+```
+## Explanation 
+ Here's the initialization condition is first set to a=10. The loop first checks for this condition. It then checks for the condition expression ie a<20 which holds true as 10<20(for the first case). Now the body of the loop is executed and we get the output "Value of a: 10". Then the update expression is executed which adds the number 1 to 'a' and the value of 'a' gets updated to 11 and the same steps are followed (as above) until the value of v reaches less than 20 ie 19. 
+ 
+ # Range-based for-loop 
+ C++ also has what we call range-based for loops which iterates through all the elements of a container(eg array). 
+ 
+ ## Syntax 
+```
+
+для (элемент: контейнер) заявления); }
+
+int \[5\] array = {1, 2, 3, 4, 5} for (int i: array) cout << i << endl; }
+
+Вывод: 1 2 3 4 5 \`\` \`

guide/russian/cplusplus/functions/index.md

@@ -0,0 +1,59 @@
+---
+title: Functions in C++
+localeTitle: Функции в C ++
+---
+## Определение:
+
+Функция представляет собой группу операторов, которые вместе выполняют задачу. Каждая программа на C ++ имеет хотя бы одну функцию, которая является main ().
+
+Объявление функции сообщает компилятору о имени функции, типе возвращаемого значения и параметрах. Определение функции обеспечивает фактическое тело функции.
+
+## Общая форма определения функции C ++:
+
+```cpp
+return_type function_name( parameter list ) 
+ { 
+   body of the function 
+ } 
+```
+
+### Тип возврата:
+
+Функция может вернуть значение. Тип возврата _\- это тип данных значения, возвращаемого функцией. Некоторые функции выполняют требуемые операции без возврата значения. В этом случае возвращаемым_ типом является ключевое слово void.
+
+### Имя функции:
+
+Это фактическое имя функции. Имя функции и список параметров вместе составляют подпись функции.
+
+### Параметры:
+
+Параметр подобен заполнителю. Когда функция вызывается, вы передаете значение параметру. Это значение называется фактическим параметром или аргументом. Список параметров относится к типу, порядку и количеству параметров функции. Параметры являются необязательными; то есть функция не может содержать никаких параметров.
+
+### Тело функции:
+
+Тело функции содержит набор операторов, которые определяют, что делает функция.
+
+## Пример:
+
+```cpp
+int max(int num1, int num2) 
+ { 
+   // local variable declaration 
+   int result; 
+ 
+   if (num1 > num2) 
+      result = num1; 
+   else 
+      result = num2; 
+ 
+   return result; 
+ } 
+```
+
+## Почему важны функции?
+
+Функции поддерживают модульность (разбиение работы на более мелкие фрагменты, называемые модулями), что является существенной особенностью ООП, которая в основном отделяет C ++ от C. Наличие определенных функций для выполнения конкретных задач устраняет путаницу и сокращает длину основной функции. Функция также выполняет повторное использование кода. Таким образом, в следующий раз, когда вам нужно будет вычислить максимум двух разных чисел в азарте и снова в одной программе, вам не нужно копировать и вставлять код. Вам просто нужно вызвать функцию, и она оставит работу.
+
+## Больше информации
+
+*   [TutorialsPoint](https://www.tutorialspoint.com/cplusplus/cpp_functions.htm)

guide/russian/cplusplus/goto/index.md

@@ -0,0 +1,27 @@
+---
+title: goto as a powerful utility
+localeTitle: goto как мощная утилита
+---
+# Введение в использование goto и меток
+
+goto - одна из самых мощных, но очень недооцененных частей логики в c ++. Сумасшедший объем оптимизации может быть достигнут с использованием goto при условии, что он используется должным образом. Он делает то, что называется. Это относится к упомянутому появлению следующей метки, где бы она ни была.
+
+# терминология
+```
+goto - The keyword used to go to the particular label. 
+ label - this can be named anything. 
+```
+
+# синтаксис
+
+goto ;
+
+(без <>);
+
+// Это переводит exe в следующий вид метки.
+
+goto - это нечто, превосходящее все циклы. Чтобы быть более ясным в этом вопросе, вот пример.
+
+https://code.sololearn.com/cI4qqQA8W2q3
+
+Тем не менее, следует очень внимательно относиться к goto, особенно в первые дни кодирования, поскольку это может привести к сумасшедшим проблемам, если их недостаточно понять.

guide/russian/cplusplus/if-else-statement/index.md

@@ -0,0 +1,192 @@
+---
+title: If-Else Statement
+localeTitle: If-Else Statement
+---
+## Что делает заявление If-Else?
+
+*   Оператор If-Else является расширением простого оператора If.
+*   В простой инструкции If, если значение тестового выражения ложно, мы пропустим код блока и продолжим наш следующий оператор.
+*   Но много раз мы хотим выполнить определенные шаги, если значение тестового выражения ложно.
+*   В таких случаях мы используем оператор if-else.
+
+### Общая форма выражения If-Else
+
+```cpp
+if (test expression) 
+ { 
+  //statements that run if the test expression is true 
+ } 
+ else 
+ { 
+  //statements that run if the test expression is false 
+ } 
+```
+
+### Пример выражения If-Else
+
+Если тестовое выражение истинно:
+
+```cpp
+int a=10; 
+ if (a < 20) // This expression is true, so... 
+ { 
+  //...the code in this block gets executed, and... 
+ } 
+ else 
+ { 
+  //...the code in this block gets skipped. 
+ } 
+ //program continues 
+```
+
+Если тестовое выражение ложно:
+
+```cpp
+int a=10; 
+ if (a>20) // This expression is false, so this time... 
+ { 
+  //...this code gets skipped... 
+ } 
+ else 
+ { 
+  //...and this code executes instead. 
+ } 
+ //program continues 
+```
+
+### Пример в C ++:
+
+```cpp
+//Program to check whether number entered by user is positive or negative 
+ #include <iostream> 
+ using namespace std; 
+ int main() 
+ { 
+  int no; 
+  cout << "Enter a number: " << endl; 
+ 
+  cin >> no; 
+ 
+  // condition to check if number is positive or negative 
+  if (no >= 0) // positive 
+  { 
+    // block if value is true 
+    cout << "You entered a positive number: " << no << endl; 
+  } 
+  else         // negative 
+  { 
+    // block if value is false 
+    cout << "You entered a negative number: " << no << endl; 
+  } 
+ 
+  // program continues 
+  cout << "This step is always printed" << endl; 
+  return 0; 
+ } 
+```
+
+#### Вывод
+
+*   Когда вводится положительное число:
+```
+Enter a number: 
+ 4 
+ You entered a positive number: 4 
+ This step is always printed 
+```
+
+*   Когда вводится отрицательное число:
+```
+Enter a number: 
+ -200 
+ You entered a negative number: -200 
+ This step is always printed 
+```
+
+[Попробуйте сам код](https://repl.it/MzBq)
+
+# **Не стесняйтесь задавать любые вопросы на странице GitHub [FreeCodeCamp](https://forum.freecodecamp.org/) или [форуме FreeCodeCamp.](https://forum.freecodecamp.org/)**
+
+[Попробуйте сам код](https://repl.it/MzBq)
+
+### Использование if ... else if ... else ladder
+
+Если мы должны принимать решения, основанные на более чем одном условии, используя, если иначе. Мы используем else, если условие следующим образом:
+
+```cpp
+#include<iostream> 
+ int main() 
+ { 
+    int score; 
+    std::cout<<"Enter your score: \n"; 
+    std::cin>>score; 
+    if(score>=90) 
+        std::cout<<"Top performance."; 
+    else if(score<90 && score>=70) 
+        std::cout<<"Good performance"; 
+    else if(score<70 && score>=45) 
+        std::cout<<"Average performance"; 
+    else if(score<45 && score>=30) 
+        std::cout<<"You can improve it."; 
+   return 0; 
+ } 
+```
+
+#### Вывод
+```
+Enter your score: 
+ 85 
+ Good performance 
+```
+
+### Другой пример if ... else if ... else ladder
+
+Предположим, что пользователь вводит два числа, и мы собираемся отобразить, если либо число больше, чем другое. И если ни один не больше другого, тогда мы печатаем утверждение «Оба равны».
+
+В этом scinerio нам понадобится if ... else if ... else ladder statement. Программа будет выглядеть так:
+```
+#include<iostream> 
+ using namespace std; 
+ int main() 
+ { 
+    int number1,number2; 
+    cout << "Enter first number: \n"; 
+    cin >> number1; 
+    cout << "Enter second number: \n"; 
+    cin >> number2; 
+ 
+    if(number1 > number2)     // Checks if the first number is greater than the second number 
+    { 
+        cout << "Number 1 is greater."; 
+    } 
+    else if(number2 > number1)    // Checks if the second number is greater than the first number 
+    { 
+        cout << "Number 2 is greater."; 
+    } 
+    else    // If both of the above cases return false, then both numbers are equal 
+    { 
+        cout << "Both the numbers are equal."; 
+    } 
+ 
+    return 0; 
+ } 
+```
+
+#### Вывод
+```
+Enter first number: 
+ 85 
+ Enter second number: 
+ 86 
+ Number 2 is greater. 
+```
+
+*   Обратите внимание, что программа будет проверять условие «else if», если условие «если» не выполнено. И если ни одно из этих условий не выполняется, выполняется последний блок «else», который печатает утверждение: «Оба числа равны».
+    
+*   Размер if ... else if ... else ladder может варьироваться в зависимости от проблемы, которую пытается решить программа, и количества условий, которые необходимо проверить.
+    
+
+**Удачи всем вам**
+
+**Счастливое кодирование! :)**
+

guide/russian/cplusplus/index.md

@@ -0,0 +1,103 @@
+---
+title: C++
+localeTitle: C ++
+---
+# Привет, мир! - Ваша первая программа на C ++
+
+## Что такое C ++?
+
+*   C ++ - это язык программирования общего назначения, который использовался с 1990-х годов
+    
+*   Он был разработан Бьярне Страуступом под названием «C с классами».
+    
+*   Это версия C, которая включает объектно-ориентированные элементы, включая классы и функции.
+    
+*   Он считается одним из самых больших языков программирования, как вы можете видеть на следующем изображении: ![Img](http://static1.businessinsider.com/image/59deb30392406c21008b6148-1200/for-bonus-points-heres-the-chart-showing-these-languages-relative-popularity.jpg) _источник: Github_
+    
+
+### Ваша первая программа на C ++
+
+```cpp
+#include <iostream> 
+ using namespace std; 
+ int main() 
+ { 
+    cout << "Hello World" << endl; 
+    return 0; 
+ } 
+```
+
+#### Результат этой программы будет просто:
+```
+Hello World! 
+```
+
+Теперь давайте разложим код:
+
+#### Строки 1 и 2
+
+```cpp
+#include <iostream> 
+ using namespace std; 
+```
+
+*   Первая строка сообщает компьютеру использовать заголовочный файл «iostream» для этой конкретной программы. Заголовочный файл представляет собой отдельный файл с предварительно написанным кодом на C ++. Существует много других файлов заголовков, которые требуются для правильной работы определенной программы. Некоторые из них: математика, вектор и строка. Заголовочные файлы обычно представлены расширением «.h» (вам не нужно добавлять .h при включении стандартных файлов библиотеки C ++)
+*   `iostream` обозначает поток ввода-вывода. Файл «iostream» содержит код, позволяющий компьютеру принимать входные данные и генерировать выходные данные с использованием языка C ++.
+*   Вторая строка указывает компьютеру использовать стандартное пространство имен, которое включает в себя функции стандартного C ++. Вы можете написать эту программу без этой строки, но вам придется использовать `std::cout` вместо `cout` и `std::endl` вместо `endl` в строке 4. Это делает код более читабельным и наша жизнь проще программистов.
+
+#### Строки 3 и 4
+
+```cpp
+int main() 
+ { 
+```
+
+*   C ++ запускает выполнение программы из -main function- `int main()` . Во время выполнения компьютер запускает код из каждой строки из `{` (открывающая скобка) до `}` (закрывающая скобка) **ПРИМЕЧАНИЕ. Каждая функция начинается с открывающей фигурной скобки «{» и заканчивается закрывающей фигурной скобкой «}».**
+*   Строка 4 указывает начало функции main ().
+
+#### Строки 5, 6 и 7
+
+```cpp
+    cout << "Hello World" << endl; 
+    return 0; 
+ } 
+```
+
+*   Для вывода используется слово `cout` в C ++.
+*   За ним следует `<<` , _оператор вставки_ .
+*   Что бы ни было в двойных кавычках `""` печатается. Некоторые специальные символы имеют другой синтаксис для операторов печати
+*   Теперь, чтобы печатать любые другие данные, вы должны добавить `<<` .
+
+**_Задача: попробуйте изменить Hello World на любое другое предложение или слово (и). Какой будет выход?_**
+
+*   `endl` - зарезервированное слово при использовании языка C ++ для **завершения этой строки и перехода к следующей строке во время вывода** . - _cout означает «консольный вывод»_
+*   Наконец, завершите команду точкой с запятой `;` ,
+
+**ПРИМЕЧАНИЕ. Каждая команда, кроме определения основной функции и директивы #include, должна заканчиваться точкой с запятой. Без ";" , вы можете столкнуться с ошибкой.**
+
+*   `return 0;` безопасно завершает текущую функцию, то есть «main ()» в этом случае, и поскольку после «main ()» функция не прекращается, программа прекращается.
+*   Не забудьте сообщить компьютеру, что это конец функции main (). Для этого вы добавляете закрывающуюся фигурную скобку «}». Вы столкнетесь с ошибкой перед выполнением программы, если вы не включите **}** .
+
+### Код должен выглядеть примерно так:
+
+![Img](https://i.imgur.com/d1liGwI.png)
+
+Программисты используют программу Hello World (например, эту) в качестве ритуала использования нового языка программирования. Это символ удачи.  
+_Вы закончили кодирование своей первой программы на C ++ и поняли большую часть кода, который вы написали / набрали. ПОЗДРАВЛЯЕМ!_
+
+**Удачи всем вам и счастливым кодированием! :)**
+
+**Счастливое кодирование! :)**
+
+**Не стесняйтесь задавать любые вопросы на странице GitHub [FreeCodeCamp](https://forum.freecodecamp.org/) или [форуме FreeCodeCamp.](https://forum.freecodecamp.org/)**
+
+[Попробуй сам ! :)](https://repl.it/L4k3)
+
+**Возможно, вам понадобится программное обеспечение для написания и выполнения кода на C ++. Я рекомендую использовать CodeBlocks. Ниже приведена ссылка для загрузки:**
+
+Ссылка для [скачивания](http://www.codeblocks.org/downloads/26) : [Загрузить здесь](http://www.codeblocks.org/downloads/26)
+
+*   Нажмите ссылку с компилятором GNU / GCC для окон. Это не потребует дополнительной установки
+
+Другие альтернативы могут быть визуальной студией, используя компилятор или интерактивную среду IDE, такую ​​как Cloud9 или repl.it
+

guide/russian/cplusplus/inline-function/index.md

@@ -0,0 +1,80 @@
+---
+title: Inline Function
+localeTitle: Встроенная функция
+---
+# Встроенная функция
+
+## Введение
+
+Встроенная функция - это специальная функция, определенная в C ++, и при ее вызове расширяется встроенная.
+
+Теперь, что это значит?
+
+Всякий раз, когда вызывается функция, требуется много дополнительного времени для выполнения ряда действий, таких как переход к функции, сохранение регистров, перенос аргументов в стек и возврат к вызывающей функции. Так что это занимает много времени. Но встроенная функция - это функция, в которой компилятор был запрошен для выполнения встроенного расширения. Если функция запрашивает компилятор для вставки полного тела функции в каждое место, вызываемое функцией, вместо генерации кода для вызова функции в одном месте, она определена.
+
+Однако мы не можем гарантировать, что каждая функция, объявленная inline, будет встроенной. Потому что, когда мы объявляем функцию `inline` , это запрос, а не команда. Компилятор может игнорировать запрос вложения в следующих ситуациях: - 1) Если функция содержит цикл, например, `for` цикла, `while` loop, `do-while` loop и т. Д. 2) Если функция содержит оператор `switch` или `goto` . 3) Если функция ничего не возвращает, даже если указан тип возврата (кроме, конечно, `void` ). 4) Если функция содержит статическую переменную. 5) Если функция содержит рекурсивный вызов.
+
+\`\` \`c ++
+
+## синтаксис: -
+
+inline return _type_ имя _функции_ (argument\_list) {
+
+// функция тела
+
+}
+```
+## When to use Inline function 
+ 
+ * When the function performs small tasks and is called very often. 
+ * When performance is important. 
+ * Instead of a macro. 
+```
+
+C ++
+
+# включают
+
+использование пространства имен std;
+
+класс MathOperation {
+
+общественности:
+```
+inline int add(int x, int y){ 
+ 
+  return(x+y); 
+ } 
+ 
+ inline float div(int n1, float n2){ 
+ 
+  return(n1/n2); 
+ } 
+```
+
+};
+
+int main () {
+
+MathOperation obj;
+
+cout << "Дополнение:" << obj.add (34,12) << <"\\ n"; cout << "Раздел:" << obj.div (12,3.4) << "\\ n";
+
+return 0;
+
+} \`\` \`
+
+## Преимущества функции Inline
+
+*   Это экономит накладные расходы на возврат вызова из функции.
+*   Он увеличивает локальность ссылок, используя кеш команд.
+*   Это ускоряет работу вашей программы, избегая накладных расходов на функции.
+*   Это экономит накладные расходы на операции push / pop в стеке, когда происходят вызовы функций.
+*   В заголовочном файле можно поместить определение функции, то есть оно может быть включено в несколько единиц компиляции без жалобы компоновщика.
+
+## Недостатки встроенной функции
+
+*   При использовании в заголовке он делает ваш заголовочный файл более крупным с информацией, которую пользователи не заботятся.
+*   Это увеличивает размер исполняемого файла из-за расширения кода.
+*   C ++ inlining разрешается во время компиляции. Это означает, что если вы измените код встроенной функции, вам нужно будет перекомпилировать весь код, используя его, чтобы убедиться, что он будет обновлен.
+*   Как упоминалось выше, он увеличивает размер исполняемого файла, что может привести к переполнению памяти. Больше ошибок страницы, что снижает производительность вашей программы.

guide/russian/cplusplus/inline-functions/index.md

@@ -0,0 +1,119 @@
+---
+title: Inline Functions in C++
+localeTitle: Встроенные функции в C ++
+---
+## Встроенные функции в C ++
+
+Когда программа выполняет инструкцию вызова функции, CPU сохраняет адрес памяти инструкции после вызова функции, копирует аргументы функции в стеке и, наконец, передает управление указанной функции. Затем CPU выполняет код функции, сохраняет возвращаемое значение функции в предопределенной ячейке памяти / регистре и возвращает управление вызывающей функции. Это может стать накладным, если время выполнения функции меньше времени переключения от вызывающей функции до вызываемой функции (вызываемого абонента). Для функций, которые являются большими и / или выполняют сложные задачи, накладные расходы на вызов функции обычно незначительны по сравнению с количеством времени, которое должна выполнять функция. Однако для небольших, часто используемых функций время, необходимое для выполнения вызова функции, часто намного больше, чем время, необходимое для фактического выполнения кода функции. Эти накладные расходы возникают для небольших функций, поскольку время выполнения небольшой функции меньше времени переключения.
+
+C ++ предоставляет встроенные функции для сокращения служебных вызовов функции. Встроенная функция - это функция, которая расширяется в строке при ее вызове. Когда встроенная функция называется целым кодом встроенной функции, она вставлена ​​или заменяется в точке встроенного вызова функции. Эта подстановка выполняется компилятором C ++ во время компиляции. Встроенная функция может повысить эффективность, если она мала. Синтаксис для определения функции inline:
+
+```cpp
+inline return-type function-name(parameters) 
+ { 
+    // function code 
+ } 
+```
+
+Помните, что inlining - это всего лишь запрос компилятору, а не команда. Компилятор может игнорировать запрос на inlining. Компилятор не может выполнять инкрустацию в таких ситуациях, как:
+
+*   Если функция содержит цикл. (пока, пока-то)
+*   Если функция содержит статические переменные.
+*   Если функция рекурсивна.
+*   Если возвращаемый тип функции отличен от void, а оператор return не существует в теле функции.
+*   Если функция содержит оператор switch или goto.
+
+### Встроенные функции обеспечивают следующие преимущества:
+
+*   Невыполнение служебных вызовов функции не происходит.
+*   Он также экономит накладные расходы переменных push / pop в стеке при вызове функции.
+*   Это также экономит накладные расходы при обратном вызове функции.
+*   Когда вы встраиваете функцию, вы можете разрешить компилятору выполнять оптимизацию по контексту в теле функции. Такая оптимизация невозможна для обычных вызовов функций. Другие оптимизации можно получить, рассмотрев потоки вызывающего контекста и вызываемого контекста.
+*   Встроенная функция может быть полезна (если она мала) для встроенных систем, потому что inline может давать меньше кода, чем преамбула вызова функции и возврат.
+
+### Недостатки встроенной функции:
+
+*   Добавленные переменные из встроенной функции потребляют дополнительные регистры, после функции подкладки, если число переменных, которое будет использовать регистр, увеличивается, чем они могут создавать накладные расходы на использование переменных переменных реестра. Это означает, что когда тело встроенной функции заменяется в точке вызова функции, общее число переменных, используемых функцией, также вставлено. Таким образом, число регистров, которые будут использоваться для переменных, также будет увеличено. Таким образом, если после того, как функция, вставляющая число переменных, резко возрастает, это, несомненно, вызовет накладные расходы на использование регистра.
+    
+*   Если вы используете слишком много встроенных функций, размер двоичного исполняемого файла будет большим, из-за дублирования одного и того же кода.
+    
+*   Слишком большая инкрустация также может снизить скорость атаки кеша команд, тем самым уменьшая скорость выборки команд из памяти кеша до памяти первичной памяти.
+    
+*   Встроенная функция может увеличить время выполнения компиляции, если кто-то изменит код внутри встроенной функции, тогда все вызывающие места должны быть перекомпилированы, потому что компилятору потребуется заменить весь код еще раз, чтобы отразить изменения, в противном случае он будет продолжаться со старыми функциями.
+    
+*   Встроенные функции не могут быть полезны для многих встроенных систем. Потому что во встроенных системах размер кода более важен, чем скорость.
+    
+*   Встроенные функции могут вызывать избиение, поскольку вложение может увеличить размер исполняемого файла. Захват в памяти приводит к ухудшению производительности компьютера.
+    
+
+Следующая программа демонстрирует эту концепцию:
+
+```cpp
+#include <iostream> 
+ using namespace std; 
+ class operation 
+ { 
+    int a,b,add,sub,mul; 
+    float div; 
+ public: 
+    void get(); 
+    void sum(); 
+    void difference(); 
+    void product(); 
+    void division(); 
+ }; 
+ inline void operation :: get() 
+ { 
+    cout << "Enter first value:"; 
+    cin >> a; 
+    cout << "Enter second value:"; 
+    cin >> b; 
+ } 
+ 
+ inline void operation :: sum() 
+ { 
+    add = a+b; 
+    cout << "Addition of two numbers: " << a+b << "\n"; 
+ } 
+ 
+ inline void operation :: difference() 
+ { 
+    sub = ab; 
+    cout << "Difference of two numbers: " << ab << "\n"; 
+ } 
+ 
+ inline void operation :: product() 
+ { 
+    mul = a*b; 
+    cout << "Product of two numbers: " << a*b << "\n"; 
+ } 
+ 
+ inline void operation ::division() 
+ { 
+    div=a/b; 
+    cout<<"Division of two numbers: "<<a/b<<"\n" ; 
+ } 
+ 
+ int main() 
+ { 
+    cout << "Program using inline function\n"; 
+    operation s; 
+    s.get(); 
+    s.sum(); 
+    s.difference(); 
+    s.product(); 
+    s.division(); 
+    return 0; 
+ } 
+```
+
+Вывод:
+```
+Enter first value: 45 
+ Enter second value: 15 
+ Addition of two numbers: 60 
+ Difference of two numbers: 30 
+ Product of two numbers: 675 
+ Division of two numbers: 3 
+
+```

guide/russian/cplusplus/input-and-output/index.md

@@ -0,0 +1,136 @@
+---
+title: Input and Output
+localeTitle: Вход и выход
+---
+## Вход и выход с потоками
+
+Чтобы распечатать информацию на консоли или прочитать ее, вы используете `cout` и `cin` , которые являются так называемыми `streams` . Эта метафора используется, потому что вы используете потоки, как если бы вы использовали раковину, или крана: вы либо очищаете данные в раковине ( `cout` ), либо извлекаете данные из крана ( `cin` ).
+
+### Выход с cout
+
+Программа Hello World использует `cout` для печати «Hello World!». на консоль:
+
+```C++
+#include<iostream> 
+ using namespace std; 
+ 
+ int main() 
+ { 
+  cout << "Hello world!" << endl; 
+ } 
+```
+
+Первые две строки наверху необходимы для использования `cout` и других потоков. `#include<iostream>` делает объекты потока недоступными и `using namespace std;` позволяет вам вводить `cout` напрямую, а не вводить `std::cout` , то есть указывать, что мы хотим использовать `cout` из пространства имен `std` .
+
+`cout` означает «Консольный выход» и представляет собой так называемый _выходной поток_ , представляющий консоль. Когда вы хотите напечатать что-то на консоли, вы можете поместить его в `cout` ; Представьте, что это отверстие, ведущее к терминалу. Чтобы поместить вещи в это отверстие, по одному, вы используете оператор `<<` , также как _оператор вставки_ 1 . Оператор может быть привязан, т. Е. Вы можете поместить несколько вещей один за другим. Следующее напечатает «Торт - ложь».:
+
+`cout << "The cake " << "is " << "a " << "lie." << endl;`
+
+`endl` означает «End Line» и это еще один элемент, который исходит от `<iostream>` . Когда вы вставляете `endl` в `cout` , он будет печатать символ новой строки («\\ n») на консоли, а также _flush_ `cout` , что означает, что он заставит `cout` распечатать все, что вы вложили в него _прямо сейчас_ . Если вы не `endl` в `cout` , `cout` может сохранить данные, которые вы вложили в него, но подождите больше данных, прежде чем на самом деле распечатать все. Это называется _буферизацией_ и очень хорошо подходит для производительности, но если вы уже дали ему все, что он должен печатать, вы хотите, чтобы `cout` печатал его немедленно. Поэтому очень хорошая практика заканчиваться `endl` в тех местах, где это имеет смысл.
+
+Почти все можно поместить в поток: строки, числа, переменные, выражения и т. Д. Здесь приведены некоторые примеры действительных входов потока:
+
+```C++
+// Notice we can use the number 42 and not the string "42". 
+ cout << "The meaning of life is " << 42 << endl;` // Output: The meaning of life is 42 
+```
+
+```C++
+string name = "Tim"; 
+ cout << "Except for you, " << name << endl;`// Output: Except for you, Tim 
+```
+
+```C++
+string name = "Tim"; 
+ cout << name; 
+ cout << " is a great guy!" << endl;` 
+ // Output: Tim is a great guy! 
+```
+
+```C++
+int a = 3; 
+ cout << a*2 + 18/a << endl;`// Output: 12 
+```
+
+### Заметка о пробеле
+
+C ++ всегда ставит _вас_ под контроль и делает именно то, что вы ему говорите. Иногда это может удивлять, как в следующем примере:
+
+```C++
+string name = "Sarah"; 
+ cout << "Good morning" << name << "how are you today? << endl; 
+```
+
+Вы можете ожидать, что он напечатает «Доброе утро, Сара, как вы сегодня?», Но на самом деле выход будет «Доброе утро, как вы сегодня?». Причина этой ошибки в том , что вы не писали пробелы в строках , окружающих `name` , и поэтому, так как вы не указали никаких пробелов, `cout` не печатали никаких. Правильной версией будет: `cout << "Good morning " << name << " how are you today? << endl;`
+
+Разрывы строк не происходят сами по себе. Вы могли бы подумать, что это напечатает рецепт на четырех строках:
+
+```C++
+cout << "To make bread, you need:"; 
+ cout << "* One egg"; 
+ cout << "* One water"; 
+ cout << "* Two wheat"; 
+```
+
+но выход на самом деле все на одной линии: «Чтобы сделать хлеб, вам нужно: \* одно яйцо \* одна вода \* две пшеницы». Это связано с тем, что в конце строк нет символов новой строки, поэтому, естественно, C ++ предполагает, что мы не хотим, чтобы он печатал символы новой строки.
+
+Вы можете исправить это, добавив `endl` s после каждой строки, потому что, как обсуждалось ранее, `endl` вставляет символ новой строки в выходной поток. Тем не менее, это также заставляет буфер очищаться, что лишает нас небольшой производительности, так как мы могли напечатать все строки за один раз. Поэтому лучше всего было бы добавить фактических символов новой строки в конце строк и использовать `endl` в конце:
+
+```C++
+cout << "To make bread, you need:\n"; 
+ cout << "* One egg\n"; 
+ cout << "* One water\n"; 
+ cout << "* Two wheat" << endl; 
+```
+
+Если вы просто печатаете небольшой рецепт, время, которое вы сохраняете, является миниатюрным и не стоит хлопот, но если вы печатаете миллионы предметов, разница может быть очень заметной.
+
+### Вход с cin
+
+Чтобы читать с консоли, вы используете _входной поток_ `cin` же, как и `cout` , но вместо того, чтобы помещать вещи в `cin` , вы «вынимаете их». Следующая программа считывает два числа от пользователя и добавляет их вместе:
+
+```C++
+#include<iostream> 
+ using namespace std; 
+ 
+ int main() 
+ { 
+  int a, b; // Variables to hold the two numbers. 
+ 
+  cout << "Please enter the first number:" << endl; 
+  cin >> a; 
+  cout << "Please enter the second number:" << endl; 
+  cin >> b; 
+ 
+  cout << "The sum of your numbers is: " << a + b << endl; 
+ } 
+```
+
+`cin` означает «Console Input» и представляет собой _входной поток_ , представляющий ввод с консоли. В выражении `cin >> a;` , данные считываются из `cin` и сохраняются в переменной `a` , используя оператор `>>` , _оператор извлечения_ 2 . Оператор извлечения считывает ровно столько же данных, сколько требуется для записи в указанную переменную, и пропускает любые пробелы, поэтому, если пользователь набирает «6», который будет считан только как значение `6` .
+
+Стоит отметить, что `cin` остановит всю программу, чтобы ждать ввода пользователем значения. Программа не будет продолжаться до тех пор, пока пользователь не нажмет кнопку ввода, и в эту переменную будут записаны некоторые данные. Если пользователь просто нажимает клавишу ввода, не набрав ничего, `cin` будет продолжать ждать значения.
+
+Оператор экстракции `<<` может быть скован. Вот та же программа, что и в прошлый раз, но написана более кратким образом:
+
+```C++
+#include<iostream> 
+ using namespace std; 
+ 
+ int main() 
+ { 
+  int a, b; // Variables to hold the two numbers. 
+ 
+  cout << "Please enter two numbers:" << endl; 
+  cin >> a >> b; 
+  cout << "The sum of your numbers is: " << a + b << endl; 
+ } 
+```
+
+При прикованном цепочке оператор извлечения сначала считывает данные из `cin` для заполнения `a` , а затем считывает данные для заполнения `b` .
+
+Стандартные команды printf и scanf C также могут использоваться с c ++ путем импорта ' 'заголовочный файл.
+
+## источники
+
+1.  http://www.cplusplus.com/reference/ostream/ostream/operator%3C%3C/
+2.  http://www.cplusplus.com/reference/istream/istream/operator%3E%3E/

guide/russian/cplusplus/lists/index.md

@@ -0,0 +1,13 @@
+---
+title: C++ Lists
+localeTitle: Списки C ++
+---
+# Что такое список STL?
+
+Списки на C ++ - это мощный инструмент, похожий на его более известный кузен, C ++ Vectors. Векторы представляют собой последовательный контейнер где элементы индексируются в непрерывной цепочке, списки также являются последовательным контейнером, но они организованы по-разному. Элементы списка указывают на его следующий элемент, поэтому все элементы упорядочиваются последовательно, но они не используют индексацию. Как? Вы можете спросить. Они делают это не путем индексации, а с помощью специального инструмента, называемого итераторами. Итераторы похожи на специальные указатели чья задача состоит в том, чтобы поддерживать порядок элементов списка, как связь между двумя вагонами. Вот хороший визуальный как списки организованы по сравнению с векторами и массивами. ![IMG](https://imgur.com/SiU8uTe.png)
+
+## Как объявить список
+
+Если вы хотите объявить список номеров, вы пишете:
+
+«» 'ЗЬй :: список Числа; «»»

guide/russian/cplusplus/loops/index.md

@@ -0,0 +1,84 @@
+---
+title: Loops
+localeTitle: Loops
+---
+# Loops
+
+## Введение
+
+Теперь давайте обсудим что-то известное как цикл. Предположим, вы хотите напечатать четные цифры от 1 до 1000 на экране. В одну сторону для этого нужно написать следующие строки
+
+\`\` \`c ++ cout << 0 << endl; cout << 2 << endl; cout << 4 << endl; .... .... .... cout << 1000 << endl;
+```
+But the problem with this approach is that you have to write the same line again and again. And if suppose you have to print 
+ prime numbers from 1 to 1000 then this will be more hectic. 
+ Therefore, in order to solve such problems loops are introduced. 
+ 
+ There are different types of loop functions: 
+ ### While and do while loops 
+ 
+ While and do while loops allow you to make the loop until a condition finishes. 
+ The difference between While and Do while is that Do while always executes once. 
+ Here you can see an example: 
+```
+
+C ++ while (условие) { // Код, который будет выполняться, когда условие истинно } делать { // Выполняется один раз и до тех пор, пока условие не будет ложным } while (условие);
+```
+### For loops 
+ 
+ For loops are usually used when you know how many times the code will execute. 
+ The flow can be seen in this [graph](https://www.tutorialspoint.com/cplusplus/images/cpp_for_loop.jpg). 
+ 
+ They are declared this way: 
+```
+
+C ++ for (инициализировать переменную, проверить условие, прирастить инициализированную переменную) { // Код для выполнения }
+```
+Lets write a program which will print numbers from 0 to 1000 including 1000 on the screen using a for loop. 
+```
+
+C ++ for (int i = 0; i <= 1000; i ++) { cout << i << endl; }
+```
+When you execute this code in a c++ program numbers from 1 to 1000 will be printed. 
+ Now lets discuss how the for loop works. 
+ 
+ * You start a for loop by typing the keyword 'for'. It means you are starting a for loop 
+ ` for ` 
+ * Next you open and close a round bracket. In this brackets you write some conditions which will be discussed later 
+ ` for()` 
+ * Inside the brackets first you write the initial condition ie the value from where the loop will start. Like in the 
+  above program we write int i = 0 
+ ` for(int i = 0)` 
+ * Then you write the semicolon and then condition until when the loop will be executed. In the above code you define 
+   i < 1000. It means until value of i is less then 1000 execuete the loop. 
+   ` for(int i=0;i<=1000) ` 
+ * Then you define the incremented value that is how much i has to be incremented in each iteration. In the above code 
+   we write i++. It means value of i will be incremented by 1 every time. 
+    ` for(int i=0;i<=1000;i++) ` 
+ * If there is only one statement inside the loop then the curly bracket is optional but its better to write loop code 
+   within brackets so that you don't get confused. 
+    ``` c++ 
+    for(int i=0;i<=1000;i++) 
+        { 
+        } 
+     ``` 
+ * Then inside the loop you write what do you want to do. In the above program we output the value of i. 
+ 
+ So, in this way the for loop works 
+ 
+ If you want to print even numbers from 1 to 1000 then your program will look like this 
+```
+
+C ++ для (int i = 0; i <= 1000; i = i + 2) { cout << i << endl; }
+
+\`\` \`
+
+*   Разница в первой программе и вторая - часть приращения. Остальная часть кода такая же. Эта программа будет печатать 0 и затем добавьте 2 к нему и распечатайте 2 на консоли и так далее до значения i станет равным 1000.
+    
+    Наша окончательная программа для печати четных чисел от 0 до 1000 будет выглядеть так.
+    
+    \`\` \`c ++
+    
+    # включают
+    
+    использование пространства имен std; int main () { для (int i = 0; i <= 1000; i = i + 2) { cout << i << endl; } return 0; } \`\` \`

guide/russian/cplusplus/map/index.md

@@ -0,0 +1,81 @@
+---
+title: Map
+localeTitle: карта
+---
+## Введение карты
+
+`map` - ассоциативный контейнер, который хранит элементы в паре ключ-значение. Так же, как в `Java` есть коллекция, ассоциативный массив в PHP и так далее.
+
+## Преимущества использования карты
+
+*   В нем хранятся только уникальные ключи, и это тоже упорядочено в соответствии с его назначенными критериями сортировки.
+*   Поскольку ключи находятся в отсортированном порядке, поэтому поиск элемента на карте через ключ очень быстрый, т.е. он берет логарифмическое время.
+*   На `map` будет только одно значение, прикрепленное к каждому ключу.
+*   `map` может использоваться как ассоциативные массивы.
+*   Он может быть реализован с использованием сбалансированных двоичных деревьев.
+
+Вот пример:
+
+```c++
+#include <iostream> 
+ #include <map> 
+ 
+ using namespace std; 
+ 
+ int main (){ 
+  map<char,int> first; 
+ 
+  //initializing 
+  first['a']=10; 
+  first['b']=20; 
+  first['c']=30; 
+  first['d']=40; 
+ 
+   map<char, int>::iterator it; 
+   for(it=first.begin(); it!=first.end(); ++it){ 
+      cout << it->first << " => " << it->second << '\n'; 
+   } 
+ 
+  return 0; 
+ } 
+```
+
+Вывод:
+```
+a => 10 
+ b => 20 
+ c => 30 
+ d => 40 
+```
+
+## Создание объекта карты
+
+`map<string, int> myMap;`
+
+## вставка
+
+Вставка данных с функцией вставки.
+
+```c++
+myMap.insert(make_pair("earth", 1)); 
+ myMap.insert(make_pair("moon", 2)); 
+```
+
+Мы также можем вставлять данные в std :: map, используя оператор \[\], т.е.
+
+`myMap["sun"] = 3;`
+
+## Доступ к элементам карты
+
+Чтобы получить доступ к элементам карты, вам необходимо создать для нее итератор. Вот пример, как было сказано ранее.
+
+```c++
+map<char, int>::iterator it; 
+ for(it=first.begin(); it!=first.end(); ++it){ 
+  cout << it->first << " => " << it->second << '\n'; 
+ } 
+```
+
+Здесь вы можете узнать больше о карте: [cpluspluc\_map](http://www.cplusplus.com/reference/map/map/map/)
+
+NB: весь код в примере приведен в версии C ++ 11. Вы можете узнать больше о версии C ++ [здесь](http://en.cppreference.com/w/cpp/compiler_support)

guide/russian/cplusplus/object-oriented-programming/index.md

@@ -0,0 +1,78 @@
+---
+title: Object Oriented Programming using C++
+localeTitle: Объектно-ориентированное программирование с использованием C ++
+---
+## Объектно-ориентированное программирование с использованием C ++
+
+Объектно-ориентированное программирование, короткое ООП, предназначено для реализации объектов реального мира, таких как наследование, скрытие и полиморфизм в программировании. Основная цель ООП заключается в объединении данных и функций, которые работают на них, чтобы никакая другая часть кода не могла получить доступ к этим данным, кроме этой функции.
+
+Давайте узнаем о разных характеристиках объектно-ориентированного языка программирования:
+
+### Объект:
+
+Объекты - это базовые объекты времени выполнения в объектно-ориентированной системе, объекты - это экземпляры класса, это определенные пользователем типы данных.
+
+```cpp
+class person 
+ { 
+    char name[20]; 
+    int id; 
+ public: 
+    void getdetails(){} 
+ }; 
+ 
+ int main() 
+ { 
+   person p1; //p1 is an object 
+ } 
+```
+
+Объекты занимают пространство в памяти и имеют ассоциированный адрес, такой как запись в паскале или структура или объединение в C.
+
+Когда программа выполняется, объекты взаимодействуют, отправляя сообщения друг другу.
+
+Каждый объект содержит данные и код для управления данными. Объекты могут взаимодействовать, не зная деталей данных или кода друг друга. Достаточно знать тип принятого сообщения и тип ответа, возвращаемого объектами.
+
+### Учебный класс:
+
+Класс - это план данных и функций или методов. Класс не занимает никакого места.
+
+```cpp
+class class_name 
+ { 
+  private: 
+     //data members and member functions declarations 
+  public: 
+     //data members and member functions declarations 
+  protected: 
+     //data members and member functions declarations 
+ }; 
+```
+
+Класс - это определенный пользователем тип данных, такой как структуры и объединения в C.
+
+По умолчанию переменные класса являются частными, но в случае структуры они общедоступны. в приведенном выше примере человек - это класс.
+
+### Инкапсуляция и абстракция данных:
+
+Объединение (объединение) данных и функций в единый блок называется инкапсуляцией. Данные не доступны для внешнего мира, и к ним могут обращаться только те функции, которые обертываются в классе. Эта изоляция данных от прямого доступа к программе называется скрытием данных или скрытием информации.
+
+Абстракция данных означает предоставление только необходимой информации внешнему миру и скрытие деталей реализации. Например, рассмотрим класс Complex с публичными функциями как getReal () и getImag (). Мы можем реализовать класс как массив размером 2 или как две переменные. Преимущество абстракций заключается в том, что мы можем изменить реализацию в любой момент, пользователи класса Complex не будут затронуты, так как наш интерфейс метода остается таким же. Если бы наша реализация была публичной, мы бы не смогли ее изменить.
+
+### Наследование:
+
+Наследование - это процесс, посредством которого объекты одного класса приобретают свойства объектов другого класса. Он поддерживает концепцию иерархической классификации. Наследование обеспечивает повторное использование. Это означает, что мы можем добавить дополнительные функции к существующему классу, не изменяя его.
+
+### Полиморфизм:
+
+Полиморфизм означает способность принимать более одной формы. В разных случаях операция может демонстрировать разные типы поведения. Поведение зависит от типов данных, используемых в операции.
+
+C ++ поддерживает перегрузку и перегрузку функций. Перегрузка оператора - это процесс, при котором оператор может проявлять разные типы поведения в разных случаях. Перегрузка функций использует одно имя функции для выполнения различных задач. Полиморфизм широко используется при реализации наследования.
+
+### Динамическое связывание:
+
+В динамическом связывании код, который будет выполняться в ответ на вызов функции, определяется во время выполнения. У C ++ есть виртуальные функции для поддержки этого.
+
+### Сообщение:
+
+Объекты обмениваются данными друг с другом, отправляя и получая информацию друг другу. Сообщение для объекта - это запрос на выполнение процедуры и, следовательно, вызовет функцию в принимающем объекте, которая генерирует желаемые результаты. Передача сообщения включает указание имени объекта, имени функции и информации для отправки.

guide/russian/cplusplus/overloading/index.md

@@ -0,0 +1,102 @@
+---
+title: C++ Overloading
+localeTitle: Перегрузка C ++
+---
+C ++ позволяет указать более одного определения для имени функции или оператора в той же области, которая называется перегрузкой функций и перегрузкой оператора соответственно.
+
+Перегруженное объявление представляет собой объявление, объявленное с тем же именем, что и ранее объявленное объявление в той же области видимости, за исключением того, что обе декларации имеют разные аргументы и, очевидно, другое определение (реализация).
+
+Когда вы вызываете перегруженную функцию или оператор, компилятор определяет наиболее подходящее определение для использования, сравнивая типы аргументов, которые вы использовали для вызова функции или оператора, с типами параметров, указанными в определениях. Процесс выбора наиболее подходящей перегруженной функции или оператора называется разрешением перегрузки.
+
+### Перегрузка функций в C ++
+
+Вы можете иметь несколько определений для одного и того же имени функции в той же области. Определение функции должно отличаться друг от друга по типам и / или количеству аргументов в списке аргументов. Вы не можете перегружать объявления функций, которые отличаются только возвращаемым типом.
+
+Ниже приведен пример, когда одна и та же функция print () используется для печати разных типов данных -
+
+```cpp
+#include <iostream> 
+ #include <string> 
+ using namespace std; 
+ 
+ class printData { 
+   public: 
+      void print(int i) { 
+        cout << "Printing int: " << i << endl; 
+      } 
+      void print(double  f) { 
+        cout << "Printing float: " << f << endl; 
+      } 
+      void print(const string& s) { 
+        cout << "Printing string: " << s << endl; 
+      } 
+ }; 
+ 
+ int main() { 
+   printData pd; 
+ 
+   // Call print to print integer 
+   pd.print(5); 
+ 
+   // Call print to print float 
+   pd.print(500.263); 
+ 
+   // Call print to print string 
+   pd.print("Hello C++"); 
+ 
+   return 0; 
+ } 
+```
+
+Когда приведенный выше код компилируется и выполняется, он производит следующий результат:
+```
+Printing int: 5 
+ Printing float: 500.263 
+ Printing string: Hello C++ 
+```
+
+### Перегрузка оператора в C ++
+
+Большинство встроенных операторов также могут быть перегружены на C ++. Это позволяет программистам назначать различную реализацию операторам в зависимости от аргументов. Эти перегруженные операторы могут работать для определенного пользователем класса.
+```
+#include<iostream> 
+ using namespace std; 
+ 
+ class Complex_Number{ 
+ private: 
+    int real; 
+    int imag; 
+ public: 
+    Complex_Number(int i = 0, int j =0) 
+    { 
+        real = i; 
+        imag = j; 
+    } 
+    //Here the operator '+' is being overloaded 
+    Complex_Number operator + (Complex_Number const &a) 
+    { 
+         Complex_Number x; 
+         x.real = real + a.real; 
+         x.imag = imag + a.imag; 
+         return x; 
+    } 
+    void print() 
+    { 
+         cout<<real<<" + i"<<imag<<endl; 
+    } 
+ }; 
+ 
+ int main() 
+ { 
+    Complex_Number c1(3, 2), c2(1, 1); 
+    //Here, the overloaded operator is called. The numbers get added according to the function defined 
+    Complex_Number c3 = c1 + c2; 
+    c3.print(); 
+ } 
+```
+
+Выход для вышеуказанной программы
+```
+4 + i3 
+
+```

guide/russian/cplusplus/preprocessors/index.md

@@ -0,0 +1,160 @@
+---
+title: Preprocessors
+localeTitle: Препроцессоры
+---
+## Препроцессоры в C / CPP
+
+Как видно из названия, препроцессоры - это программы, которые обрабатывают наш исходный код перед компиляцией. Существует несколько шагов, связанных с написанием программы и выполнением программы на C / C ++. Давайте посмотрим на эти шаги, прежде чем мы начнем узнавать о препроцессорах.
+
+![Img](https://i.imgur.com/Pb0aTkV.png)
+
+Вы можете увидеть промежуточные шаги на приведенной выше диаграмме. Исходный код, написанный программистами, хранится в файле program.c. Затем этот файл обрабатывается препроцессорами, а файл расширенного исходного кода создается с именем program. Этот расширенный файл компилируется компилятором и создается файл объектного кода с именем program.obj. Наконец, компоновщик связывает этот файл объектного кода с объектным кодом библиотечных функций для генерации исполняемого файла program.exe.
+
+Препроцессорные программы предоставляют директивы препроцессоров, которые сообщают компилятору предварительно обработать исходный код перед компиляцией. Все эти директивы препроцессора начинаются с символа `#` (хеш). Этот символ ('#') в начале инструкции в программе C / C ++ указывает, что это предпроцессорная директива. Мы можем разместить эти предпроцессорные директивы в любой нашей программе. Примерами некоторых препроцессорных директив являются: `#include` , `#define` , `#ifndef` и т. Д.
+
+### Типы предпроцессорных директив:
+
+1.  макрос
+2.  Включение файлов
+3.  Условная компиляция
+4.  Другие директивы
+
+### Макросы:
+
+Макросы являются частью кода в программе, которому дано какое-то имя. Всякий раз, когда это имя встречается компилятором, компилятор заменяет это имя фактическим фрагментом кода. Директива `#define` используется для определения макроса.
+
+```cpp
+  #include<iostream> 
+  #define LIMIT 3 
+  int main() 
+  { 
+    for(int i=0; i < LIMIT; i++) 
+    { 
+      std::cout<<i<<" " ; 
+    } 
+      return 0; 
+  } 
+```
+
+Вывод:
+
+`0 1 2`
+
+В вышеприведенной программе, когда компилятор выполняет слово `LIMIT` он заменяет его на 3. Слово `LIMIT` в определении макроса называется макромодом, а «3» - расширением макроса.
+
+В конце определения макроса не должно быть запятой (';'). Определения макросов не нуждаются в полуточке.
+
+### Включение файла:
+
+Этот тип предпроцессорной директивы сообщает компилятору включить файл в программу исходного кода. Существует два типа файлов, которые могут быть включены пользователем в программу:
+
+*   \#### Файл заголовка или стандартные файлы: Эти файлы содержат определение предопределенных функций, таких как printf (), ... scanf () и т. Д. Эти файлы должны быть включены для работы с этими функциями. ... Различные функции объявляются в разных файлах заголовков. Например ... стандартные операции ввода-вывода находятся в файле «iostream», тогда как функции, которые ... выполняют строковые операции, находятся в файле «string».
+
+#### Синтаксис:
+
+`#include< file_name >` где file\_name - это имя файла, который будет включен. Скобки `<` и `>` сообщают компилятору искать файл в стандартном каталоге.
+
+*   \#### Пользовательские файлы: Когда программа становится очень большой, целесообразно разделить ее на более мелкие файлы и включать в случае необходимости. Эти типы файлов являются определяемыми пользователем файлами. Эти файлы могут быть включены как: ... `#include"filename"`
+
+### Условная компиляция:
+
+Условные директивы компиляции - это типы директив, которые помогают скомпилировать определенную часть программы или пропустить компиляцию некоторой определенной части программы на основе некоторых условий. Это можно сделать с помощью двух команд предварительной обработки `ifdef` и `endif` .
+
+#### Синтаксис:
+
+```cpp
+  ifdef macro_name 
+    statement1; 
+    statement2; 
+    statement3; 
+    . 
+    . 
+    . 
+    statementN; 
+  endif 
+```
+
+Если макрос с именем «macroname» определен, тогда блок операторов будет выполняться нормально, но если он не определен, компилятор просто пропустит этот блок операторов.
+
+### Другие директивы:
+
+Помимо вышеуказанных директив есть еще две директивы, которые обычно не используются. Это:
+
+1.  \##### `#undef` Директива: Директива `#undef` используется для определения существующего макроса. Эта директива работает как:
+
+##### Синтаксис:
+
+`#undef LIMIT` Использование этого оператора будет определять неопределенный существующий макрос LIMIT. После этого утверждения каждый оператор `#ifdef LIMIT` будет оценивать значение false.
+
+2.  \##### # `#pragma` директива: Эта директива является директивой специального назначения и используется для включения или отключения некоторых функций. Этот тип директив специфичен для компилятора, т. Е. Они варьируются от компилятора к компилятору. Некоторые из директив `#pragma` обсуждаются ниже:
+
+##### `#pragma startup` и `#pragma exit` :
+
+Эти директивы помогают нам определить функции, которые необходимы для запуска до запуска программы (до того, как элемент управления переходит к main ()) и непосредственно перед выходом программы (как раз перед возвратом элемента управления из main ()).
+
+```cpp
+#include<stdio.h> 
+ void func1(); 
+ void func2(); 
+ #pragma startup func1 
+ #pragma exit func2 
+ void func1() 
+ { 
+    printf("Inside func1() "); 
+ } 
+ void func2() 
+ { 
+    printf("Inside func2() "); 
+ } 
+ int main() 
+ { 
+    printf("Inside main() "); 
+ 
+    return 0; 
+ } 
+```
+
+Вывод:  
+`Inside func1() Inside main() Inside func2()`  
+Вышеприведенный код будет выдавать результат, указанный ниже при запуске на компиляторах GCC:  
+Вывод:  
+`Inside main()`  
+Это происходит потому, что GCC не поддерживает запуск #pragma или выход. Однако вы можете использовать приведенный ниже код для аналогичного вывода на компиляторах GCC.
+
+```cpp
+#include<stdio.h> 
+ void func1(); 
+ void func2(); 
+ void __attribute__((constructor)) func1(); 
+ void __attribute__((destructor)) func2(); 
+ void func1() 
+ { 
+    printf("Inside func1()\n"); 
+ } 
+ void func2() 
+ { 
+    printf("Inside func2()\n"); 
+ } 
+ int main() 
+ { 
+    printf("Inside main()\n"); 
+ 
+    return 0; 
+ } 
+```
+
+##### `#pragma warn` Директива:
+
+Эта директива используется, чтобы скрыть предупреждающее сообщение, которое отображается во время компиляции. Мы можем скрыть предупреждения, как показано ниже:
+
+##### `#pragma warn -rvl` :
+
+Эта директива скрывает предупреждение, которое возникает, когда функция, которая должна возвращать значение, не возвращает значение.
+
+##### `#pragma warn -par` :
+
+Эта директива скрывает предупреждение, которое возникает, когда функция не использует переданные ей параметры.
+
+##### `#pragma warn -rch` :
+
+Эта директива скрывает предупреждение, которое возникает, когда код недостижим. Например: любой код, написанный после оператора return в функции, недоступен.

guide/russian/cplusplus/queue/index.md

@@ -0,0 +1,197 @@
+---
+title: queue
+localeTitle: очередь
+---
+## Очереди
+
+`queue` является одним из наиболее используемых контейнеров в C ++. Контейнер представляет собой структуру данных, которая хранит коллекцию объектов, некоторые по порядку, некоторые - нет. Все контейнеры имеют другой набор функций, которые позволяют вам получить доступ к объекту (объектам) в этой коллекции.
+
+`std::queue` является частью стандартной библиотеки C ++ (отсюда и префикс `std::` и позволяет хранить данные в порядке First In First Out (FIFO). ПРИМЕЧАНИЕ. **Все объекты в очереди должны иметь один и тот же тип данных**
+
+Тип данных, который вы храните в очереди, находится в угловых скобках рядом с ключевым словом очереди. Например, если вы хотите сохранить коллекцию целых чисел, то очередь будет `std::queue<int> queue_name`
+
+### Очередь LIFO Пояснение
+
+`queue` позволяет нам нажимать / вставлять в очередь и поп / деактивировать в определенном порядке. **Push** означает вставку объекта в начале очереди. **Pop** означает вытащить «самый старый» объект из конца очереди. Поэтому, когда вы нажимаете его на передний план, и когда вы поп, вы извлекаете самый старый элемент.
+
+![alt text](https://github.com/mohammadaziz313/helloworld/blob/master/Fifo_queue.png "Пример очереди очереди FIFO и Dequeue")
+
+### Операции в очереди
+
+Контейнер очереди поддерживает следующие операции:
+
+*   push (enqueue)
+*   pop (dequeue)
+*   пустой
+*   размер
+*   фронт
+*   назад
+
+#### От себя
+
+Позволяет вставлять новый элемент в конце очереди после последнего текущего элемента.
+
+```cpp
+//Push operation in Queue 
+ #include <iostream>       // std::cout 
+ #include <queue>          // std::queue 
+ 
+ int main () 
+ { 
+  std::queue<int> q; 
+ 
+  q.push(1);    //Pushing 1 at front of the queue 
+  q.push(2);    //Pushing 2 at front of the queue 
+ 
+  return 0; 
+ } 
+```
+
+#### Фронт
+
+Позволяет получить доступ к следующему элементу в очереди, не удаляя его. Следующий элемент - это «самый старый» элемент в очереди.
+
+```cpp
+//Front operation in Queue 
+ #include <iostream>       // std::cout 
+ #include <queue>          // std::queue 
+ 
+ int main () 
+ { 
+  std::queue<int> q; 
+ 
+  q.push(1);    //Pushing 1 at front of the queue 
+  q.push(2);    //Pushing 2 at front of the queue 
+ 
+  std::cout<<q.front()<<'\n';     //Accessing the front of the queue 
+  std::cout<<q.front()<<'\n';     //Accessing the front of the queue 
+ 
+  return 0; 
+ } 
+```
+
+```
+Output: 
+ 1 
+ 1 
+```
+
+#### поп
+
+Позволяет удалить следующий элемент в очереди, эффективно уменьшая его размер на единицу. Удаленный элемент является «самым старым» элементом.
+
+```cpp
+//Pop operation in Queue 
+ #include <iostream>       // std::cout 
+ #include <queue>          // std::queue 
+ 
+ int main () 
+ { 
+  std::queue<int> q; 
+ 
+  q.push(1);    //Pushing 1 at front of the queue 
+  q.push(2);    //Pushing 2 at front of the queue 
+ 
+  std::cout<<q.front()<<'\n';     //Accessing the front of the queue 
+  q.pop();                        //Removing the oldest element 
+  std::cout<<q.front()<<'\n';     //Accessing the front of the queue 
+  q.pop();                        //Removing the oldest element 
+ 
+  return 0; 
+ } 
+```
+
+```
+Output: 
+ 1 
+ 2 
+```
+
+#### Размер
+
+Возвращает количество элементов в `queue` .
+
+```cpp
+//Size operation in Queue 
+ #include <iostream>       // std::cout 
+ #include <queue>          // std::queue 
+ 
+ int main () 
+ { 
+  std::queue<int> q; 
+ 
+  q.push(1);    //Pushing 1 at front of the queue 
+  q.push(2);    //Pushing 2 at front of the queue 
+ 
+  std::cout<<q.size()<<'\n';     //Accessing the front of the queue 
+  q.pop();                        //Removing the oldest element 
+  std::cout<<q.size()<<'\n';     //Accessing the front of the queue 
+  q.pop();                        //Removing the oldest element 
+  std::cout<<q.size()<<'\n';     //Accessing the front of the queue 
+ 
+  return 0; 
+ } 
+```
+
+```
+Output: 
+ 2 
+ 1 
+ 0 
+```
+
+#### пустой
+
+Возвращает, является ли `queue` пустой, т. Е. Будет ли ваш размер очереди равен нулю. Он возвращает `true` если размер очереди 0 else возвращает `false`
+
+\`\` \`cpp // Пустая операция в очереди
+
+# включают // std :: cout
+
+# включают // std :: stack
+
+int main () { станд :: очереди д;
+
+q.push (1); q.push (2);
+
+while (q.empty ()! = true) { станд :: соиЬ << q.front () << '\\ п'; q.pop (); }
+
+std :: cout << "Вне цикла" << '\\ n'; return 0; }
+```
+    Output: 
+    1 
+    2 
+    Out of loop 
+ 
+ #### Back 
+ 
+ Allows you to access the last element in the queue without removing it. 
+ The next element is the "newest" element in the queue. 
+```
+
+CPP // Назад в очереди
+
+# включают // std :: cout
+
+# включают // std :: queue
+
+int main () { станд :: очереди д;
+
+q.push (1); // Нажатие 1 перед очередью q.push (2); // Нажатие 2 перед очередью
+
+станд :: соиЬ << q.back () << '\\ п'; // Доступ к задней части очереди станд :: соиЬ << q.back () << '\\ п'; // Доступ к задней части очереди
+
+return 0; } \`\` \`
+```
+Output: 
+ 2 
+ 2 
+```
+
+### Дополнительные ресурсы:
+
+http://www.cplusplus.com/reference/queue/queue/
+
+### Цитирование:
+
+Предоставлено: https://en.wikipedia.org/wiki/FIFO _(вычислительная и_ электронная электроника)

guide/russian/cplusplus/random-functions/index.md

@@ -0,0 +1,88 @@
+---
+title: Random Functions
+localeTitle: Случайные функции
+---
+*   Случайные числа - это удобный способ введения рандомизации в вашу программу. Например, если вы хотите запускать какие-либо симуляции или играть в игры, удаляйте случайные индексы массива и т. Д., Тогда случайные числа - это путь.
+*   Файл заголовка для включения случайных чисел в c ++ - `cstdlib` .
+*   _Pro tip: -_ Вы можете использовать `cpp #include<bits/stdc++.h>` чтобы включить все функции из всех файлов заголовков.
+
+Функция: - rand ()  
+\- Возвращает псевдослучайное число (целое число) от 0 до RAND _MAX. Не принимает никаких аргументов. - RAND_ MAX - максимально допустимое целое число. Это компилятор depedent и обычно составляет 2147483647.
+
+Ниже приведен пример: -
+
+```cpp
+#include <cstdlib> 
+ #include <iostream> 
+ using namespace std; 
+ 
+ int main() { 
+  cout << rand() << endl; 
+  cout << rand() << endl; 
+  cout << rand() << endl; 
+  return 0; 
+ } 
+ 
+ /* 
+ Output:- (Note that the output is random and will differ from what is mentioned here) 
+ 1804289383 
+ 846930886 
+ 1681692777 
+ */ 
+```
+
+Теперь запустите программу еще раз. И опять. И опять. Что ты видишь? Тот же вывод печатается снова и снова.
+
+Давайте вернемся к определению функции rand (): -
+
+rand (): - _возвращает **псевдослучайное** число (целое число) от 0 до RAND\_MAX. Не принимает никаких аргументов._
+
+Итак, что такое псевдослучайное число?
+
+*   Как следует из названия, число, которое не является действительно случайным, является псевдослучайным.
+*   Псевдоэкспертные номера arent криптографически безопасны и уязвимы для атак.
+*   В контексте C ++ число кажется случайным, но не по-настоящему случайным. Функция предполагает, что каждое число от 0 до RAND\_MAX одинаково вероятно и выплескивает одно число. (В действительности, это не тот случай, но он близок). Например, число 5 используется почти везде. Если случайное число плюет 5, вы можете не думать, что число является интактным, случайным.
+*   Случайное funtion rand () принимает очень большое число, применяется по модулю большим простым числом и выполняет все виды операций над числом и возвращает значение. Как бы он ни был сложным, его все еще можно сломать.
+
+Как мы получаем уникальный набор случайных чисел, выполняемых при выполнении каждой программы?
+
+Мы используем `void srand(int seed)` ;
+
+*   «Семя» - это имя, присвоенное числу, которое запускает генератор случайных последовательностей каждый раз в другой отправной точке. Это гарантирует, что случайная функция не выплевывает одинаковые значения во время прогона программы.
+*   **Важно только вызвать вызов srand ONCE в начале программы.**
+*   Нет необходимости в повторных вызовах для генерации генератора случайных чисел (фактически, это сделает ваш номер менее равномерным распространяемый).
+*   Обычно используемый метод заключается в том, чтобы засевать генератор случайных чисел с использованием часов, поскольку часы дают вам разные результаты каждый раз, когда вы смотрите на него. Итак, для семени вы можете взять время и подключить его к генератору случайных чисел.
+*   Функция time () вернет время компьютера. Это выражается в терминах количества секунды, прошедшие с 1 января 1970 года (Эпоха).
+*   Время функции (NULL) вернет количество секунд, прошедших в компьютерное время.
+*   Файл заголовка, который должен быть включен для функций времени: \`ctime '.
+
+Фрагмент кода:
+
+```cpp
+#include <ctime> 
+ 
+ srand(time(NULL)); 
+ cout << rand(); 
+ 
+ /* 
+ Output: (Will differ from computer to computer, and because of the seed, will also differ from time to time, literally. :D) 
+ 1696269016 
+ */ 
+```
+
+Это дает разные значения при каждом запуске программы.
+
+Бонус: Тонкая настройка rand () для вашего удобства.
+
+*   Так как rand () возвращает случайное число от 0 до RAND\_MAX, если вы хотите, например, число от 0 до 8, -rand ()% 9. Любое число по модулю 9 вернет значение от 0 до 8.
+    
+*   Более формально, если вы хотите, чтобы число между L (включительно) и U (включительно), вы должны сделать `int num = L + rand()%(U-L+1).` Объяснение: - rand ()% (UL + 1) возвращает случайное (псевдослучайное, не забытое) число с 0 и (UL). Следовательно, добавление L гарантирует, что мы получим значение между L и U.
+    
+    Резюме:-
+    
+
+1.  int rand (): возвращает случайное число между 0 и RAND\_MAX.
+    
+2.  void srand (int seed): используется для засева генератора случайных чисел. Достаточно вызвать эту функцию только _один раз_ .
+    
+    ### Источники: - [Генерация случайных чисел](http://www.math.uaa.alaska.edu/~afkjm/csce211/handouts/RandomFunctions)

guide/russian/cplusplus/range-for-loop/index.md

@@ -0,0 +1,30 @@
+---
+title: Range For Loop
+localeTitle: Диапазон для цикла
+---
+## Диапазон для цикла
+
+Цикл, основанный `for` диапазоне, позволяет легко выполнять цикл по целому ряду элементов (например, элементов в контейнере).
+
+С традиционным `for` цикла:
+
+```cpp
+std::vector<std::string> stringList {"one", "two", "three"}; 
+ 
+ for (size_t il; il < stringList.size(); il++ 
+ { 
+  std::cout << stringList.at(il) << std::endl; 
+ } 
+```
+
+С диапазоном `for` цикла:
+
+```cpp
+std::vector<std::string> stringList {"one", "two", "three"}; 
+ 
+ for (auto& singleString : stringList) 
+ { 
+  std:cout << singleString << std::endl; 
+ } 
+
+```

guide/russian/cplusplus/set/index.md

@@ -0,0 +1,94 @@
+---
+title: Set
+localeTitle: Задавать
+---
+Сложная структура данных в c ++ определяется так же, как набор определяется в контексте математики.
+
+Более формально говоря, наборы - это тип ассоциативных контейнеров, в которых каждый элемент должен быть уникальным.
+
+*   Значение элемента не может быть изменено после его ввода, хотя удаление элемента и вставка нового элемента разрешены так же, как мы делаем в математике.
+*   Установка структуры данных может быть использована для моделирования, ну, сама устанавливает. Легко найти пересечения, союзы и т. Д.
+*   Подобно вектору, но допускаются только уникальные значения.
+*   Устанавливает элементы в порядке возрастания, когда вы вставляете элементы в набор.
+
+Файл заголовка, необходимый для использования установленной структуры данных, «установлен». т.е. `#include<set>` должен быть в вашем коде, чтобы вы могли использовать установленную структуру данных.
+
+**Pro tip** : - Используйте `#include<bits/stdc++.h>` чтобы включить все структуры и функции данных C ++ вместо их добавления по одному.  
+Некоторые из функций, которые могут выполняться с набором: -
+
+1.  begin () - возвращает итератор в первый элемент в наборе
+2.  end () - возвращает итератор к теоретическому элементу, который следует за последним элементом в наборе
+3.  size () - возвращает количество элементов в наборе
+4.  max\_size () - возвращает максимальное количество элементов, которые может содержать набор
+5.  empty () - Возвращает, является ли набор пустым
+6.  erase (const g) - удаляет значение 'g' из набора
+7.  clear () - Удаляет все элементы из набора
+
+Давайте посмотрим на пример:
+
+```cpp
+#include <iostream> 
+ #include <set> 
+ #include <iterator> 
+ 
+ using namespace std; 
+ int main() 
+ { 
+    set <int> myset;   //an empty set container. Note that size of the set need not be declared, similar to vector. 
+ 
+    // insert elements in random order 
+    myset.insert(65); 
+    myset.insert(30); 
+    myset.insert(80); 
+    myset.insert(20); 
+    myset.insert(9); 
+    myset.insert(9); // only one 9 will be added to the list. 
+ 
+ 
+    // printing set myset 
+    set <int> :: iterator itr; //an iterator is like a pointer. 
+    cout << "\nThe contents of myset : "; 
+    for (itr = myset.begin(); itr != myset.end(); ++itr) 
+    { 
+        cout << '\t' << *itr; 
+    } 
+    cout << endl; 
+ 
+ 
+    // remove all elements up to 65 in myset from the beginning:- 
+    cout << "\nContents of myset after removal of elements less than 30 : "; 
+    myset.erase(myset.begin(), myset.find(30)); 
+    for (itr = myset.begin(); itr != myset.end(); ++itr) 
+    { 
+        cout << '\t' << *itr; 
+    } 
+ 
+    // remove element with value 50 in myset 
+ 
+    int num = myset.erase(80); //returns true (and deletes) if 80 is there in the list else returns 0. 
+    cout<<"\n\n After doing myset.erase(80), "<<num<<" element is removed\n\n"; 
+    cout<<"Contents of the modified set:\t"; 
+    for (itr = myset.begin(); itr != myset.end(); ++itr) 
+    { 
+        cout << '\t' << *itr; 
+    } 
+ 
+    cout << endl; 
+ 
+ 
+    return 0; 
+ 
+ } 
+```
+
+\`\` \`Каст Выход:- Содержимое myset: 9 20 30 65 80
+
+Содержание myset после удаления элементов менее 30: 30 65 80
+
+После выполнения myset.erase (80) удаляется 1 элемент
+
+Содержание модифицированного набора: 30 65 \`\` \`
+
+\### Источники
+
+1.  [Вундеркинды для вундеркиндов](https://www.geeksforgeeks.org/set-in-cpp-stl/)

guide/russian/cplusplus/stack/index.md

@@ -0,0 +1,174 @@
+---
+title: stack
+localeTitle: стек
+---
+## Стеки
+
+`stack` является одним из наиболее используемых контейнеров в C ++. Контейнер представляет собой структуру данных, которая хранит коллекцию объектов, некоторые по порядку, некоторые - нет. Все контейнеры имеют другой набор функций, которые позволяют вам получить доступ к объекту (объектам) в этой коллекции.
+
+`std::stack` является частью стандартной библиотеки C ++ (отсюда и префикс `std::` и позволяет хранить данные в порядке последнего в первом выводе (LIFO). ПРИМЕЧАНИЕ. **Все объекты в стеке должны быть одного типа данных**
+
+Тип данных, который вы храните в стеке, находится в угловых скобках рядом с ключевым словом стека. Например, если вы хотите сохранить коллекцию целых чисел, стек будет `std::stack<int> stack_name`
+
+### Стек LIFO Пояснение
+
+`stack` позволяет нам толкнуть и поп в определенном порядке. **Push** означает, что объект находится в верхней части стека. **Pop** означает вытащить последний вставленный объект из верхней части стека. Поэтому, когда вы нажимаете его вверху, и когда вы поп вы извлекаете последний вставленный элемент.
+
+![alt text](https://github.com/mohammadaziz313/helloworld/blob/master/Lifo_stack.png "Пример LIFO Stack Push и Pop")
+
+### Операции с стеками
+
+Контейнер стека поддерживает следующие операции:
+
+*   От себя
+*   поп
+*   пустой
+*   размер
+*   назад
+
+#### От себя
+
+Позволяет вставить новый элемент в верхней части стека, над текущим верхним элементом.
+
+```cpp
+//Push operation in Stack 
+ #include <iostream>       // std::cout 
+ #include <stack>          // std::stack 
+ 
+ int main () 
+ { 
+  std::stack<int> s; 
+ 
+  s.push(1);    //Pushing 1 at top of the stack 
+  s.push(2);    //Pushing 2 at top of the stack 
+ 
+  return 0; 
+ } 
+```
+
+#### верхний
+
+Позволяет получить доступ к верхнему элементу, не удаляя его из вашего стека.
+
+```cpp
+//Top operation in Stack 
+ #include <iostream>       // std::cout 
+ #include <stack>          // std::stack 
+ 
+ int main () 
+ { 
+  std::stack<int> s; 
+ 
+  s.push(1);    //Pushing 1 at top of the stack 
+  s.push(2);    //Pushing 2 at top of the stack 
+ 
+  std::cout<<s.top()<<'\n';     //Accessing the top of the stack 
+  std::cout<<s.top()<<'\n';     //Accessing the top of the stack 
+ 
+  return 0; 
+ } 
+```
+
+```
+Output: 
+ 2 
+ 2 
+```
+
+#### поп
+
+Удаляет элемент поверх стека, эффективно уменьшая размер вашего стека на единицу.
+
+```cpp
+//Pop operation in Stack 
+ #include <iostream>       // std::cout 
+ #include <stack>          // std::stack 
+ 
+ int main () 
+ { 
+  std::stack<int> s; 
+ 
+  s.push(1);    //Pushing 1 at top of the stack 
+  s.push(2);    //Pushing 2 at top of the stack 
+ 
+  std::cout<<s.top()<<'\n';   //Accessing the top of the stack 
+  s.pop();                    //Removing element from the top of stack 
+  std::cout<<s.top()<<'\n';   //Accessing the top of the stack 
+ 
+ 
+  return 0; 
+ } 
+```
+
+```
+Output: 
+ 2 
+ 1 
+```
+
+#### Размер
+
+Возвращает количество элементов в `stack` .
+
+```cpp
+//Size operation in Stack 
+ #include <iostream>       // std::cout 
+ #include <stack>          // std::stack 
+ 
+ int main () 
+ { 
+  std::stack<int> s; 
+ 
+  s.push(1);    //Pushing 1 at top of the stack 
+  s.push(2);    //Pushing 2 at top of the stack 
+ 
+  std::cout<<s.size()<<'\n';  //Showing the size of the stack 
+  s.pop();                    //Removing element from the top of stack 
+  std::cout<<s.size()<<'\n';  //Showing the size of the stack 
+  s.pop();                    //Removing element from the top of stack 
+  std::cout<<s.size()<<'\n';  //Showing the size of the stack 
+ 
+  return 0; 
+ } 
+```
+
+```
+Output: 
+ 2 
+ 1 
+ 0 
+```
+
+#### пустой
+
+Возвращает ли `stack` пуст, то есть ли ваш размер стека равен нулю. Он возвращает `true` если размер 0 в стеке возвращает `false`
+
+```cpp
+//Empty operation in Stack 
+ #include <iostream>       // std::cout 
+ #include <stack>          // std::stack 
+ 
+ int main () 
+ { 
+  std::stack<int> s; 
+ 
+  s.push(1); 
+  s.push(2); 
+ 
+  while(s.empty() != false){ 
+      std::cout<<s.top()<<'\n'; 
+      s.pop(); 
+  } 
+ 
+  std::cout<<"Out of loop"<<'\n'; 
+  return 0; 
+ } 
+```
+
+```
+Output: 
+ 2 
+ 1 
+ Out of loop 
+
+```

guide/russian/cplusplus/switch-statements/index.md

@@ -0,0 +1,43 @@
+---
+title:Switch Statement
+localeTitle: undefined
+---
+Оператор switch позволяет проверять переменную для равенства по отношению к списку значений. Каждое значение называется случаем, а переменная, включенная, проверяется для каждого случая.
+
+Синтаксис: switch (выражение) { постоянное выражение: заявления); перерыв; //необязательный постоянное выражение: заявления); перерыв; //необязательный
+
+// вы можете иметь любое количество операторов case. default: // Необязательный заявления); }
+
+К инструкции switch применяются следующие правила:
+
+Выражение, используемое в операторе switch, должно иметь интегральный или нумерованный тип или быть типом класса, в котором класс имеет одну функцию преобразования для интегрального или перечисляемого типа.
+
+Вы можете иметь любое количество операторов case в коммутаторе. За каждым случаем следует сравнимое значение и двоеточие.
+
+Константное выражение для случая должно быть тем же типом данных, что и переменная в коммутаторе, и должна быть константой или литералом.
+
+Когда переменная, включенная, равна случаю, утверждения, следующие за этим случаем, будут выполняться до тех пор, пока не будет достигнут оператор break.
+
+Когда оператор break достигнут, коммутатор завершается, и поток управления переходит к следующей строке, следующей за оператором switch.
+
+Не каждый случай должен содержать перерыв. Если разрыв не появляется, поток контроля будет просачиваться в последующие случаи, пока не будет достигнут разрыв.
+
+Оператор switch может иметь необязательный случай по умолчанию, который должен появиться в конце коммутатора. Случай по умолчанию может использоваться для выполнения задачи, когда ни один из случаев не является истинным. В случае по умолчанию не требуется перерыв.
+
+Пример: \`\` \`C ++
+
+# включают
+
+использование пространства имен std;
+
+int main () { // объявление локальной переменной: char grade = 'D';
+
+переключатель (класс) { case 'A': cout << «Отлично!» << endl; перерыв; case 'B': case 'C': cout << «Молодцы» << endl; перерыв; case 'D': cout << «Вы прошли» << endl; перерыв; case 'F': cout << «Лучше повторите попытку» << endl; перерыв; дефолт : cout << "Недопустимый класс" << endl; } cout << "Ваша оценка" << класс << endl;
+
+return 0; } \`\` \`
+
+Вывод: Вы прошли Ваша оценка D
+
+### источники
+
+https://www.tutorialspoint.com

guide/russian/cplusplus/terms-to-know-for-beginners/index.md

@@ -0,0 +1,142 @@
+---
+title: IDE and Printing different text 
+localeTitle: IDE и печать другого текста
+---
+# Введение в IDE и печать другого текста:
+
+*   В последней статье приведены некоторые ссылки для загрузки программного обеспечения, необходимого для программирования. Программное обеспечение, подобное этому, известно как IDE. **IDE означает интегрированную среду разработки**
+
+## IDE в основном состоят из 3-х видов программного обеспечения:
+
+**1 Редактор:** слегка измененный текстовый редактор, облегчающий кодирование. Примером редактора для кодирования является Notepad ++.
+
+**2 Debugger:** программное обеспечение, которое помогает вам находить ошибки в вашей программе и разрешать их перед выполнением. Представьте, что FaceBook рушится при загрузке приложения или сбое игры внезапно. Чтобы предотвратить ошибочное выполнение программы, отладчик является лучшим другом программиста.
+
+**3 Компилятор:** компилятор - это часть компьютера, которая преобразует ваш программный код высокого уровня в простой машинный код: 0s & 1s; так что компьютер понимает команды и выполняет их. С этого момента мы часто будем обсуждать **компилятор** слов.
+
+_В: Попробуйте найти IDE в Google и запустить на нем свою первую программу. Проверьте выход_
+
+Теперь установите IDE и попробуйте изменить текст из программы в последней статье.
+
+### Изменение текста на C ++
+
+*   Чтобы изменить текст, измените то, что набрано в `""` после `cout<<`
+
+Пример программы:
+
+```cpp
+#include <iostream> 
+ using namespace std : 
+ int main() 
+ { 
+    cout << "I Love freeCodeCamp ! "; 
+ } 
+```
+
+Вышеприведенный код возвращает ошибку, потому что в строке 2 мы использовали двоеточие (:) вместо точки с запятой (;) Итак, давайте отлаживаем ошибку:
+
+```C++
+#include <iostream> 
+ using namespace std ; 
+ int main() 
+ { 
+    cout << "I Love freeCodeCamp ! "; 
+    return 0; 
+ } 
+```
+
+Обратите внимание, что теперь программа работает отлично. Выход будет: `I Love freeCodeCamp!`
+
+### Теперь давайте сменим текст на нечто подобное:
+
+```cpp
+    cout << "Hello World!\t I love freeCodeCamp!"; 
+```
+
+На этот раз на выходе будет что-то другое:
+```
+Hello World!     I love freeCodeCamp! 
+```
+
+Если вы поняли, команда `\t` создала _пространство_ между двумя текстами. Это одна из специальных команд на C ++. Эти специальные команды называются _Escape Sequences_ . Они используются для печати определенных специальных символов, которые компилятор не может отобразить.
+
+#### Полезные escape-последовательности:
+
+*   `\'` для печати одной перевернутой запятой
+*   `\"` для печати двойной перевернутой запятой
+*   `\n` для печати на новой строке
+*   `\t` для горизонтальной вкладки
+*   `\f` для новой страницы
+*   `\\` для обратной косой черты
+*   `\?` для вопросительного знака
+
+##### Теперь попробуем напечатать числа и специальные символы с некоторыми escape-последовательностями:
+
+```cpp
+    cout << "40158 \t 236708 ! \n \\ @ \?" << endl; 
+```
+
+Выход изменяется на:
+```
+40158      236708 ! 
+ \ @ ? 
+```
+
+##### Давайте попробуем другие способы печати:
+
+```cpp
+    cout << "1+2" << endl; 
+    cout << 1+2 << endl; 
+```
+
+Вывод:
+
+*   Первый выходной оператор равен `1+2`
+*   Второй вывод - `3`
+
+Это связано с тем, что мы не добавляли перевернутые запятые для второго оператора печати, поэтому компилятор добавил номера перед их печатью.
+
+#### Комментарии:
+
+*   Комментарии - важная особенность многих языков программирования. Они позволяют программисту делать заметки для самостоятельной помощи и не будут влиять на работу программы.
+
+**Различные типы комментариев и синтаксис комментария** :
+
+1 `//` ~ _Однострочные комментарии_ : длина этих комментариев - 1 строка (строка, на которую она введена). 2 `/* */` ~ _Multi Line Комментарии_ : Эти комментарии могут занимать место более чем одной строки.
+
+#### Пример использования комментариев:
+
+\`\` \`Каст cout << "Hello Comment" << endl; // cout << "Hello Comment" << endl; , Комментарий к отдельной строке.
+```
+/* This is an example of a multi line comment. No output is generated for this . 
+ I now end the comment.  :) */ 
+```
+
+\`\` \`
+
+Выход будет:
+
+`Hello Comment`
+
+Как вы можете заметить, комментарии игнорируются во время выполнения программы и не отображаются при проверке вывода программы. Следует отметить, что, хотя комментарии добавляют дополнительный уровень удобочитаемости к своему коду, плохой привычкой слишком полагаться на комментарии для описания логики вашего кода. В общем, ваш код должен говорить сам за себя и отражать намерение программиста.
+
+Как вы можете заметить, комментарии игнорируются во время выполнения программы и не отображаются при проверке вывода программы.
+
+#### операторы
+
+*   Операторы позволяют сравнивать два или более выражения
+*   `==` равно
+*   `!=` не равна
+*   `<` меньше
+*   `>` больше, чем
+*   `<=` меньше или равно
+*   `>=` больше или равно
+
+```cpp
+    (7==5); 
+```
+
+Это оценивается как false
+
+`cpp (7!=5);` Это соответствует истинному
+

guide/russian/cplusplus/the-auto-feature/index.md

@@ -0,0 +1,74 @@
+---
+title: The Auto Feature
+localeTitle: Автофункция
+---
+## Автофункция
+
+`auto` - это функция C ++ 11, которая позволяет компилятору вывести тип данных для вас в определении. Это может сэкономить вам много информации, особенно со сложными типами.
+
+Без `auto` :
+
+```cpp
+double x = 10.425; 
+ double y = x * x; 
+```
+
+С `auto` :
+
+```cpp
+double x = 10.425; 
+ auto y = x * x; 
+```
+
+Хотя это может показаться тривиальным, становится невероятно полезным, когда типы данных начинают усложняться. Например, предположим, что вы хотите сохранить [`vector`](https://guide.freecodecamp.org/cplusplus/vector) сотрудников, и вас интересует только их имя и возраст. Одним из способов хранения имени и возраста может быть `pair` со `string` и `unsigned int` . Это объявляется как `std::vector<std::pair<std::string, unsigned int>> employees` . Теперь предположим, что вы хотите получить доступ к последнему добавленному сотруднику:
+
+```cpp
+std::vector<std::pair<std::string, unsigned int>> employees; 
+ 
+ // without auto, you have to write: 
+ std::pair<std::string, unsigned int>> last_employee = employees.back(); 
+ 
+ // with auto, you just have to write: 
+ auto last_employee = employees.back(); 
+```
+
+Как только компилятор определит тип в правой части `=` он заменяет `auto` этим типом.
+
+В современных версиях C ++ (начиная с C ++ 14) `auto` можно также использовать в объявлении функции как возвращаемый тип. Затем компилятор выводит возвращаемый тип из оператора return внутри функции. Следуя примеру сотрудников:
+```
+std::vector<std::pair<std::string, unsigned int>> employees; 
+ auto get_last_employee() { 
+    return employees.back(); // Compiler knows the return type from this line. 
+ } 
+```
+
+Компилятор будет знать из строки с оператором return, что тип возврата из функции должен быть `std::vector<std::pair<std::string, unsigned int>>` .
+
+В то время как довольно технически, [страница cppreference на авто](http://en.cppreference.com/w/cpp/language/auto) описывает еще много [способов](http://en.cppreference.com/w/cpp/language/auto) использования `auto` и деталей, когда это возможно и не может быть использовано.
+
+### `auto` перед C ++ 11
+
+В некоторых старых учебниках, содержащих _очень_ старый код, ключевое слово `auto` используется совсем по-другому.
+
+Этот конкретный `auto` был ключевым словом, заимствованным из C, и, вероятно, был наименее используемым ключевым словом всех времен.
+
+В C ++ все переменные имеют _автоматическую продолжительность_ , то есть они определяются до тех пор, пока вы не выйдете из функции, в которой они определены.
+
+Например:
+
+\`\` \`Каст
+
+# включают
+
+int main () { int a; a = 1; // имеет смысл, поскольку он был определен в той же функции
+```
+    return 0; 
+```
+
+} a = 2; // не имеет смысла, так как a здесь не определен \`\` \`
+
+Это задано в C ++, и `auto` указывает, что переменная должна иметь _автоматическую продолжительность_ , следовательно, отсутствие использования.
+
+## Дальнейшее чтение :
+
+*   http://www.stroustrup.com/C++11FAQ.html#auto

guide/russian/cplusplus/the-if-statement/index.md

@@ -0,0 +1,95 @@
+---
+title: C++ If Statement
+localeTitle: C ++ If Statement
+---
+# Утверждение IF.
+
+**Что делает оператор if?**
+
+*   Оператор `if` оценивает тестовое выражение, присутствующее в круглой скобке.
+*   Оператор `if` использует реляционные и логические операторы для создания логических выражений.
+
+* * *
+
+Общая форма выражения `if` :
+
+```cpp
+  if (Test Expression / Condition) 
+  { 
+    // Block of statements if test expression is True 
+  } 
+```
+
+Если значение тестового выражения **истинно** , тогда блок код внутри оператора if.
+
+Если значение тестового выражения **ложно** , то блок код внутри оператора if пропущен и ваш код продолжается.
+
+Пример `if` statement:
+
+```cpp
+  int a = 10; 
+ 
+  // true statement 
+  if (a < 20) 
+  { 
+    // execute this block of code 
+  } 
+ 
+  // false statement 
+  if (a < 0) 
+  { 
+    // Skip this block of code. 
+  } 
+```
+
+Пример В C ++:
+
+```cpp
+  // Program to check if number entered by the user is positive 
+  // If negative, the block of code is skipped 
+ 
+  #include <iostream> 
+  using namespace std; 
+ 
+  int main() 
+  { 
+    int no ; 
+    cout << "Enter a number: "; 
+    cin >> no; 
+ 
+    // if statement to check if the number is positive 
+    if ( no > 0) 
+    { 
+      cout << "You have entered a positive number: " << no << endl; 
+    } 
+ 
+    // If number is not positive, then if statement is skipped a program continues 
+    cout << "This step is always printed" << endl; 
+ 
+    return 0; 
+  } 
+```
+
+**Выход:**
+
+ВЫХОД 1:
+```
+Enter a number: 5 
+ You have entered a positive number: 5 
+ This step is always printed 
+ ``` 
+ This is the output when the number entered is positive. 
+ 
+ OUTPUT 2: 
+```
+
+Введите число: -1 Этот шаг всегда печатается \`\` \` Это результат, когда введенный номер отрицательный.
+
+[Попробуйте код самостоятельно! :)](https://repl.it/Mg9X)
+
+_ПОЗДРАВЛЯЕМ. Это конец статьи о заявлении IF_
+
+**Удачи всем вам**
+
+**Счастливое кодирование! :)**
+

guide/russian/cplusplus/tokens-operators/index.md

@@ -0,0 +1,186 @@
+---
+title: Operators
+localeTitle: операторы
+---
+# Операторы:
+
+*   Операторы позволяют выполнять операции с вашими данными.
+*   Данные, которые работают, называются _операндами_ .
+*   Различные типы операторов в C ++:
+*   _OPERANDS_ - это данные, на которых оператор выполняет определенные команды.
+*   Операторы имеют 3 типа: унарный (работает на 1 операнд), двоичный (работает на 2 операнда), тройной (работает на 3 операнда).
+
+### 1 Операторы ввода / вывода -
+
+*   Эти операторы позволяют вам направлять ввод и вывод.
+    
+    ## Входной оператор «>>» ##
+    
+    используется для чтения данных со стандартного ввода (инструкция «cin»).
+    
+    ## Оператор вывода «<<»
+    
+    используется для отправки вывода в инструкции `cout` .
+    
+
+### 2 Арифметические операторы -
+
+*   Эти операторы позволяют выполнять основные арифметические операции.
+
+1.  Оператор `+` _добавляет_ два операнда.
+    
+2.  Оператор `-` _вычитает_ два операнда.
+    
+3.  Оператор `*` _умножает_ два операнда.
+    
+4.  Оператор `/` _делит_ и дает _частное_ от двух операндов.
+    
+5.  Оператор `%` _делит_ и дает _оставшуюся_ часть двух операндов. (Или, для более математически наклоненного читателя, `a % b` является, по существу, результатом «mod b»,
+    
+    ### Пример использования арифметических операторов:
+    
+    \`\` \`Каст
+    
+
+# включают
+
+использование пространства имен std;
+
+int main () { int a = 5; // 1-й операнд int b = 10; // Второй операнд
+```
+    cout << "+ operator " << a+b << "\n"; //Add 
+    cout << "- operator " << ab << "\n"; //Subtract 
+    cout << "* operator " << a*b << "\n"; //Multiply 
+    cout << "/ operator " << b/a << "\n"; //Find Quotient 
+    cout << "modulus operator " << b%a << "\n"; //Find remainder 
+ 
+    return 0; 
+```
+
+} \`\` \`
+
+ВЫХОД :
+```
++ operator 15 
+ - operator -5 
+ * operator 50 
+ / operator 2 
+ modulus operator 0 
+```
+
+[Попробуйте код самостоятельно! :)](https://repl.it/Mge9)
+
+### Оператор приращения:
+
+*   `++` известен как оператор приращения. Он увеличивает значение целочисленной переменной на 1.
+
+2 типа приращения:
+
+*   Pre increment сначала увеличивает значение, а затем использует его. Пример: `int a ; ++a;`
+*   Приращение прихода сначала использует переменную, а затем увеличивает ее. Пример: `int b; b++;`
+
+### Оператор декремента:
+
+*   `--` известен как оператор декремента. Он уменьшает значение целочисленной переменной на 1.
+
+2 типа декремента:
+
+*   Предварительный декремент сначала уменьшает значение, а затем использует его. Пример: `int a ; --a;`
+*   Пост-декремент сначала использует переменную, а затем уменьшает ее. Пример: `int b; b--;`
+
+Пример операторов приращения и декремента:
+
+```cpp
+#include <iostream> 
+ using namespace std; 
+ 
+ int main() 
+ { 
+        int a = 3 ,b = 4; 
+ 
+         // INCREMENT 
+        cout<< "Value of int a PRE INCREMENTED : " << ++a << "\n"; 
+        cout<< "Value of int b POST INCREMENTED : " << b++ << "\n"; 
+        cout<< "Value of b is changed after using once : " << b << "\n"; 
+ 
+         // DECREMENT 
+        cout << "\n"; //go to next line 
+        a = 10; //Assigning a new value to a 
+        b = 10; //Assigning a new value to b 
+        cout << "Value of int a PRE DECREMENTED : " << --a << "\n"; 
+        cout << "Value of int b POST DECREMENTED : " << b-- << "\n"; 
+        cout << "Value of b is changed after using once : " << b << "\n"; 
+ 
+        return 0; 
+ } 
+```
+
+ВЫХОД :
+```
+Value of int a PRE INCREMENTED : 4 
+ Value of int b POST INCREMENTED : 4 
+ Value of b is changed after using once : 5 
+ 
+ Value of int a PRE DECREMENTED : 9 
+ Value of int b POST DECREMENTED : 10 
+ Value of b is changed after using once : 9 
+```
+
+[Попробуйте код самостоятельно! :)](https://repl.it/Mgg4/2)
+
+### 3: Реляционные операторы:
+
+*   Эти операторы сообщают нам отношение между 2 операндами и возвращают логическое значение (0 или 1). Если отношение `true` то это приводит к 1. Если realtion ложно, то результат равен 0.
+    
+*   6 реляционными операторами:
+    
+    1.  Менее `<`
+    2.  Больше чем `>`
+    3.  Меньше или равно `<=`
+    4.  Больше или равно `>=`
+    5.  Равно `==`
+    6.  Не равно `!=`
+
+### 4: Логические операторы:
+
+*   Эти операторы объединяют выражения для логических операций. Они есть :
+
+1.  Логическое AND `&&` : оценивает значение true, если оба значения истинны.
+    
+2.  Логический ИЛИ `||` : Вычисляет значение true, если какое-либо значение истинно.
+    
+3.  Логически НЕ `!` : Если _выражение_ истинно, _выражение!_ False. Этот оператор меняет значение истины и является унарным оператором.
+    
+    ### 5\. Тернарные операторы:
+    
+    Оператор `?:` Это тернарный оператор или _условный оператор_ , потому что его можно использовать для замены оператора `if else` или даже `if else if` . Синтаксис:
+    
+
+`condition ? ValueIfTrue : ValueIfFalse` . Это расширяется до:
+
+```cpp
+if(condition) 
+ ValueIfTrue; 
+ else ValueIfFalse; 
+```
+
+Вызов значения `ValueIfTrue` немного неверно, так как это не должно быть число. Что-то вроде этого:
+
+`condition ? FirstLevelTrueValue : ConditionIfFalse ? SecondLevelTrueValue : SecondLevelFalseValue` также работает и интерпретируется как следующий `if else if` statement:
+
+```cpp
+if(condition) 
+ FirstLevelTrueValue; 
+ else if(ConditionIfFalse) 
+ SecondLevelTrueValue; 
+ else SecondLevelFalseValue; 
+```
+
+Аналогично, вложенные операторы `if` также могут быть сделаны с использованием тернарных операторов.
+
+_Camper, Теперь вы знаете, что означают эти знаки. Следующая статья будет о_ _ПОЗДРАВЛЯЕМ_
+
+**Удачи всем вам**
+
+**Счастливое кодирование! :)**
+

guide/russian/cplusplus/tokens-variables/index.md

@@ -0,0 +1,208 @@
+---
+title: Tokens Part 1
+localeTitle: Токены Часть 1
+---
+### Что такое токены?
+
+Токены - это наименьшие единицы программы, которые важны для компилятора. Существуют различные виды токенов:
+
+*   Ключевые слова
+    
+*   операторы
+    
+*   знаки пунктуации
+    
+*   литералы
+    
+*   Идентификаторы
+    
+*   **Сочетание токенов формирует выражение**
+    
+
+### Что такое переменные?
+
+*   Определение учебника: переменные называются ячейками памяти, данные которых могут быть изменены.
+    
+*   Но я хотел бы, чтобы вы подумали, что переменная будет чем-то вроде коробки, что-то вроде этого: ![Img](https://i.imgur.com/YdbgWHL.png)
+    
+
+Так, например: Я перехожу на новое место, и мне нужно укладывать вещи в коробки. Таким образом, мне приходят две вещи. **Какие вещи будут храниться в ящике, так что размер с поля известен (тип данных)** и **как я могу определить поле? (Именование переменной)**  
+Следовательно, мы знаем, что переменная в C ++ нуждается в _имени_ и _типе данных_ и что значение, хранящееся в них, может быть изменено.
+
+### Типы данных в C ++:
+
+При объявлении переменных в c ++ у них должно быть имя, на которое вы позже будете ссылаться, значение (константа или нет) и тип. Тип подскажет компилятору значения, которые может использовать переменная, возможные операции и сохранит определенное пространство в memmory. В c ++ существуют два типа данных:
+
+*   Простой тип
+*   Тип структуры
+
+### Простые типы данных
+
+*   Boolean - bool Работает как переключатель, может быть включен или выключен.
+*   Символ - символ Сохраняет один символ.
+*   Integer - int Сохраняет [целое число](https://en.wikipedia.org/wiki/Integer) .
+*   Плавающая точка - поплавок Они могут использовать десятичные знаки.
+*   Двойная плавающая точка - двойная Двойная точность поплавкового типа.
+
+Здесь вы можете увидеть несколько примеров:
+
+```cpp
+bool GameRunning = true; 
+ char a; 
+ int x = 2; 
+```
+
+#### Эти типы также могут быть изменены с помощью таких модификаторов, как:
+
+подписанный неподписанный короткая длинный
+
+### Тип данных структуры
+
+#### Идентификаторы.
+
+*   Идентификаторы - это имена, присвоенные переменной или классу или функции или любой функции, определенной пользователем.
+
+## Правила для именования переменной:
+
+*   Начните именовать буквой из AZ или az.
+*   Числа могут следовать за первой буквой, но мы не можем начинать именовать цифры.
+*   НЕТ использования пробелов или специальных символов, вместо этого используйте UNDERSCORE \_.
+
+#### Объявление переменной:
+
+Синтаксис выглядит следующим образом < _тип данных_ > < _имя переменной_ >; или < _тип данных_ > < _имя переменной_ > = < _значение_ >; если мы также хотим инициализировать переменную.
+
+Например : `cpp int a ; //declaring a variable named 'a' of type integer. a=4; //initializing a variable int b = 5 ; //declaring and initializing a variable 'b' of type integer.`
+
+**Примеры объявления переменной:**
+
+```cpp
+int a9; 
+ char A; 
+ double area_circle; 
+ long l; 
+```
+
+**Неправильные способы объявления переменных** -
+
+```cpp
+int 9a; 
+ char -a; 
+ double area of circle; 
+ long l!!; 
+```
+
+*   Имена переменных не могут начинаться с числа
+*   Спецсимволы не допустимы
+*   Пробелы не допускаются
+
+Вы можете представить себе различные коробки разных размеров и хранить разные вещи как разные переменные.
+
+**ЗАМЕТКИ :**
+
+1.  **Компилятор C ++ игнорирует пробелы, и они обычно используются для улучшения кода, так что любой программист может отлаживать или понимать код.**
+2.  **Если переменная не инициализирована, она содержит значение мусора. Позвольте мне привести пример:**
+
+### Объем переменных
+
+Все переменные имеют свою область функционирования, и из этой границы они не имеют своей ценности, эта граница называется областью действия переменной. В большинстве случаев его между фигурными фигурными скобками, в которых объявляется переменная, существует переменная, а не вне ее. Мы изучим классы хранения позже, но на данный момент мы можем разделить переменные на два основных типа,
+
+\* Глобальные переменные.
+
+\* Локальные переменные.
+
+#### Глобальные переменные
+
+Глобальные переменные - это те, которые объявлены и могут использоваться на протяжении всего жизненного цикла программы любым классом или любой функцией. Они должны быть объявлены вне функции main (). Если объявлено только, они могут быть назначены разные значения в разное время в жизни программы. Но даже если они объявлены и инициализированы одновременно за пределами функции main (), тогда также им может быть присвоено любое значение в любой точке программы.
+
+Пример: Только объявлено, а не инициализировано.
+
+```cpp
+#include <iostream> 
+ using namespace std; 
+ int x;                // Global variable declared 
+ int main() 
+ { 
+ x=10;                 // Initialized once 
+ cout <<"first value of x = "<< x; 
+ x=20;                 // Initialized again 
+ cout <<"Initialized again with value = "<< x; 
+ } 
+```
+
+#### Локальные переменные
+
+Локальные переменные - это переменные, которые существуют только между фигурными фигурными скобками, в которых объявлено. Снаружи они недоступны и приводят к ошибке времени компиляции.
+
+Пример :
+
+```cpp
+#include <iostream> 
+ using namespace std; 
+ int main() 
+ { 
+ int i=10; 
+ if(i<20)        // if condition scope starts 
+  { 
+    int n=100;   // Local variable declared and initialized 
+  }              // if condition scope ends 
+ cout << n;      // Compile time error, n not available here 
+ } 
+```
+
+### Константные переменные
+
+Константная переменная - это переменные, которые нельзя изменить. Например, если вам нужен «pi» в вашем коде, вы не захотите изменить его после инициализации.
+
+Пример :
+
+```cpp
+#include <iostream> 
+ using namespace std; 
+ const double PI = 3.14159253; 
+ int main() 
+ { 
+ //Calculating the area of a circle, using user provided radius 
+ double radius; 
+ //input and output explained in other guide 
+ cin>>radius; 
+ //pi*r^2 
+ double area = PI*radius*radius; 
+ cout<<area<<endl; 
+ } 
+```
+
+### Значения мусора в переменной
+
+Если переменная не инициализирована, она содержит значение мусора. Например:
+
+Итак, с точки зрения ящиков, вы можете представить это как -
+
+![Img](https://i.imgur.com/YdbgWHL.png)
+
+\`\` \`Каст #включают использование пространства имен std; int main () { int a; cout << "Значение мусора в a:" << a << endl; // объявляем переменную с именем 'a' типа integer а = 5; // инициализация переменной. cout << "Новое значение в" << a << endl;
+
+} \`\` \`
+
+### Выход:
+```
+Garbage value in a : 0 
+ New value in a :  5 
+```
+
+Как вы можете видеть, уже есть значение, хранящееся в 'a', прежде чем мы дадим ему значение (здесь оно равно 0). Это должно оставаться в памяти каждого программиста, чтобы при использовании переменных они не создавали логическую ошибку и не печатали значения мусора.
+
+[Попробуйте код самостоятельно! :)](https://repl.it/Mg7j)
+
+#### Ключевые слова:
+
+_Ключевые слова - это зарезервированные слова, которые передают особый смысл компилятору. Они **НЕ МОГУТ** использоваться для именования в c ++._ Примеры ключевых слов: inline, operator, private int, double, void, char, template, using, virtual, break, case, switch, friend и т. д.
+
+**Каждое из этих ключевых слов используется для специальной функции в C ++.**
+
+_Токены часть 1 закончена. Увидимся в палатках во [второй](https://guide.freecodecamp.org/cplusplus/tokens-part-II) части токенов :)_
+
+**Удачи всем вам**
+
+**Счастливое кодирование! :)**
+

guide/russian/cplusplus/tokens-variables/static-variable-info/index.md

@@ -0,0 +1,120 @@
+---
+title: Variables
+localeTitle: переменные
+---
+Давайте обсудим что-то знакомое как переменные. Переменные напоминают ведро. Вы можете положить что-то в него, а затем изменить его после чего, когда это необходимо. В C ++ существует много типов переменных, таких как целые числа, строки, булевы и многие другие. Давайте рассмотрим простую программу с использованием целочисленных переменных. Целые числа хранят целые числа, положительные, отрицательные или нулевые. Целые числа не являются дробными числами, например, 1/2, 1/4 и 1/5. Давайте рассмотрим простую программу, которая использует целое число переменная.
+
+```cpp
+#include <iostream> 
+ using namespace std ; 
+ int main() 
+ { 
+    int a;          // Declare an integer variable a 
+    a = 5;          // Assign value of 5 to variable a 
+    cout << a;      // Display the value of variable a which contains 5 
+    return 0; 
+ } 
+```
+
+Когда вы выполняете эту программу, вы увидите 5 на экране
+
+*   Обратите внимание, что в указанной выше программе // помещается после строк. Символ «//» предназначен для комментирования нашего кода. Код после символа «//» не выполняется в строке, где она помещена.
+    
+*   В строке 5 объявлена ​​простая целочисленная переменная.
+    
+*   В строке 6 значение 5 присваивается переменной a. Теперь, когда мы используем переменную a в нашей программе, ее значение будет равно 5 если мы не изменим его.
+    
+*   В строке 7 отобразится значение переменной a и 5 на экране.
+    
+
+### Объем переменных
+
+Все переменные имеют свою область функционирования, и из этой границы они не имеют своей ценности, эта граница называется областью действия переменной. В большинстве случаев его между фигурными фигурными скобками, в которых объявляется переменная, существует переменная, а не вне ее. Мы изучим классы хранения позже, но на данный момент мы можем разделить переменные на два основных типа,
+
+\* Глобальные переменные.
+
+\* Локальные переменные.
+
+#### Глобальные переменные
+
+Глобальные переменные - это те, которые объявлены и могут использоваться на протяжении всего жизненного цикла программы любым классом или любой функцией. Они должны быть объявлены вне функции main (). Если объявлено только, они могут быть назначены разные значения в разное время в жизни программы. Но даже если они объявлены и инициализированы одновременно за пределами функции main (), тогда также им может быть присвоено любое значение в любой точке программы.
+
+Пример: Только объявлено, а не инициализировано.
+
+```cpp
+include <iostream> 
+ using namespace std; 
+ int x;                // Global variable declared 
+ int main() 
+ { 
+ x=10;                 // Initialized once 
+ cout <<"first value of x = "<< x; 
+ x=20;                 // Initialized again 
+ cout <<"Initialized again with value = "<< x;` 
+ } 
+```
+
+#### Локальные переменные
+
+Локальные переменные - это переменные, которые существуют только между фигурными фигурными скобками, в которых объявлено. Снаружи они недоступны и приводят к ошибке времени компиляции.
+
+Пример :
+
+```cpp
+include <iostream> 
+ using namespace std; 
+ int main() 
+ { 
+ int i=10; 
+ if(i<20)        // if condition scope starts 
+  { 
+    int n=100;   // Local variable declared and initialized 
+  }              // if condition scope ends 
+ cout << n;      // Compile time error, n not available here 
+ } 
+```
+
+Теперь давайте прочитаем о новом типе переменных-
+
+#### Статическая переменная
+
+Статические переменные: когда переменная объявляется как статическая, пространство для нее распределяется на время жизни программы. Даже если функция вызывается несколько раз, пространство для статической переменной выделяется только один раз, а значение переменной в предыдущем вызове переносится через следующий вызов функции. Это полезно для реализации сопрограмм в C / C ++ или в любом другом приложении, где необходимо сохранить предыдущее состояние функции. В условиях неспециалиста это означает, что нормальная переменная, выходящая за пределы области, теряет свою идентичность (значение), но статическая переменная имеет глобальную область действия и сохраняет ее значение до конца программы, но в отличие от глобальной переменной нет необходимости объявлять ее при запуске программы.
+
+#### экстра-
+
+Static - это ключевое слово в C ++, используемое для предоставления специальных характеристик элементу. Статические элементы выделяются хранилищем только один раз в течение жизненного цикла программы в области статического хранения. И у них есть объем до срока службы программы.
+
+#### КОД-
+```
+#include <iostream> 
+ #include <string> 
+ using namespace std; 
+ 
+ void howstaticworks() 
+ { 
+    static int count = 0;  // static variable 
+    cout << count << " "; 
+ 
+    /* value is updated and 
+     will be carried to next 
+     function calls*/ 
+    count++; 
+ } 
+ 
+ int main() 
+ { 
+    for (int i=0; i<5; i++) 
+        howstaticworks(); 
+    return 0; 
+ } 
+```
+
+#### Попробуйте сами
+
+просто скопируйте код и вставьте его в указанную ссылку. Запуск на IDE-https://ideone.com/
+
+Вывод: 0 1 2 3 4
+
+Вы можете видеть в приведенной выше программе, что счетчик переменных считается статическим. Таким образом, его значение переносится через вызовы функций. Счетчик переменных не получает инициализацию за каждый раз, когда вызывается функция.
+
+Давайте дадим тот же код попробовать, удалив «статическое» ключевое слово и угадав вывод и сравним его с одним из IDE. Статичность теперь преобразуется в обычную переменную

guide/russian/cplusplus/vector/index.md

@@ -0,0 +1,211 @@
+---
+title: Vectors
+localeTitle: векторы
+---
+## векторы
+
+`vector` C ++ является одним из наиболее используемых контейнеров в C ++. Контейнер представляет собой структуру данных, которая хранит коллекцию объектов, которые могут меняться от упорядоченного (например, `vector` !) До неупорядоченного (например, `set` ). Все контейнеры C ++ имеют другой набор функций, которые позволяют вам получать доступ к объекту (-ам) в этой коллекции, изменять и циклически перемещать элементы в этой структуре данных.
+
+Векторы аналогичны ArrayLists в Java, так как вам не нужно указывать длину контейнера. По сравнению с массивом, где вы должны определить, насколько он большой, его размер зависит от его содержимого.
+
+`std::vector` является частью стандартной библиотеки C ++ (отсюда и префикс `std::` и позволяет хранить смежные данные одного и того же типа данных. ПРИМЕЧАНИЕ. **Все объекты внутри вектора должны иметь один и тот же тип данных.**
+
+Тип данных, который вы храните в векторе, находится в квадратных скобках рядом с ключевым словом vector. Например, если вы хотите сохранить коллекцию строк, вектор будет `std::vector<std::string> vector_name`
+
+_ПРИМЕЧАНИЕ_ . Вы должны включать векторную библиотеку при использовании векторов!
+
+`#include <vector>`
+
+### Векторная конструкция
+
+Существует много удобных способов построения вектора.
+
+Использование списка инициализаторов - где объекты перечислены внутри набора фигурных скобок: `{ }`
+
+```cpp
+std::vector<int> a{1, 2, 3, 4, 5}; // a is a vector of 5 ints: 1, 2, 3, 4 and 5 
+ std::vector<std::string> b{"hello", "world"}; // b is a vector of 2 strings: "hello" and "world" 
+ std::vector<bool> v; // v is an empty vector 
+```
+
+Построить его из другого вектора (это называется построением копии)
+
+```cpp
+std::vector<double> a{1.0, 2.0, 3.0}; 
+ std::vector<double> b(a); // b is a vector of 3 doubles: 1.0, 2.0 and 3.0 
+```
+
+Инициализация его одним и тем же элементом:
+
+```cpp
+std::vector<int> a(100, -1); // a is a vector of 100 elements all set to -1 
+```
+
+### Векторные итераторы
+
+Итераторы можно рассматривать как указатели, специально используемые для навигации контейнеров (таких как векторы). Наиболее важными итераторами являются `begin()` и `end()` . `begin()` возвращает указатель на первый элемент в векторе, тогда как `end()` указывает к одной позиции после последнего элемента в векторе. Как таковой вектор может быть выполнен как:
+
+```cpp
+std::vector<int> vec{1, 2, 3}; 
+ 
+ for(auto vec_it = vec.begin(); vec_it != vec.end(); it++){ 
+    // since vec_it is a pointer and points to the memory address of the item 
+    // inside the vector, vec_it must be dereferenced using '*' 
+    std::cout << *it << '\n'; 
+ } 
+ /*  Output 
+    1 
+    2 
+    3 
+ */ 
+```
+
+### Изменение вектора
+
+Нажатие элементов на вектор:
+
+```cpp
+std::vector<int> vec; // constructs an empty vector 
+ 
+ for (int i = 0; i < 10; i = i + 2){ 
+    vec.push_back(i); 
+ } 
+ // vec now holds [0, 2, 4, 6, 8] 
+```
+
+Вставка элемента в определенную позицию немного отличается. Вставка вектора C ++ функция работает на итераторах. Он вставляет данный элемент в одну позицию до итератор.
+
+```cpp
+std::vector<unsigned int> vec{3, 400, 12, 45}; 
+ 
+ auto iter = vec.begin() + 2; // iter now points to '12' 
+ vec.insert(iter, 38); // inserts '38' before '12' 
+ 
+ // vec: [3, 400, 38, 12, 45] 
+```
+
+### Доступ к элементу
+
+Стандартная библиотека предоставляет различные функции для доступа к определенным элементам в вашем векторе.
+
+```cpp
+std::vector<std::string> a{"test", "element", "access"}; 
+ 
+ std::string first_item = a.front(); // gets the first item of the vector ("test") 
+ std::string last_item = a.back(); // gets the last item in the vector ("access") 
+ 
+ // To get an element at a specific index (remember: vector indices start at 0) 
+ std::string second_item = a.at(2); // gets "element" 
+ // OR 
+ std::string second_item = a[2]; // gets "element" 
+```
+
+### Зацикливание элементов в `vector`
+
+Зацикливание элементов в C ++ `std::vector` довольно отличается от перебора элементов в векторе в JavaScript или Ruby. Из-за того, что C ++ является тонкой абстракцией C, вы можете только перебирать элементы, используя эти изящные маленькие переменные, называемые итераторами, для доступа к каждому элементу. Итераторы часто бывают в виде указателей, которые являются переменными, которые сохраняют адрес памяти другой переменной. Вы можете узнать больше о указателях [здесь](https://www.tutorialspoint.com/cplusplus/cpp_pointers.htm) . Однако, поскольку итераторы действуют как указатели (или наоборот), чтобы увидеть, на что они указывают, вам необходимо разыменовать его в переменной типа притяжения. как нам это сделать? ВОТ. МЫ. ИДТИ!
+
+```cpp
+std::vector<std::string> a{"test", "element", "access"}; 
+ for(auto it = v.begin(); it != v.end(); it++) { //notice use of auto keyword 
+    cout<<*it<<endl; //Will print out string that the iterator is currently ppointing to 
+ } 
+```
+
+Отсюда вы можете делать всевозможные классные вещи, например, манипулировать вектором или беспорядок с его порядком, как вам заблагорассудится!
+
+### Некоторые полезные функции-члены
+
+Стандартная библиотека шаблонов (STL) также предоставляет вам различные _методы_ :
+
+```cpp
+std::vector.size(); // returns the size of the vector (the number of positions in the vector) 
+ std::vector.begin(); // returns an iterator which is a pointer to the beginning of the vector 
+ std::vector.end(); // returns an iterator which is a pointer to the end of the vector 
+ std::vector.empty(); // returns true if the vector is empty, otherwise returns false. 
+ std::vector.front(); // returns the first element of the vector. 
+ std::vector.back(); // returns the last element of the vector. 
+ std::vector.push_back(n); // inserts the element "n" to the end of the vector. 
+ std::vector.pop_back(n); // removes the last element of the vector 
+```
+
+### Векторный Итератор
+
+Итераторы предоставляют другой метод доступа к элементам в вашем векторе.
+
+Объявление итератора.
+
+```cpp
+std::vector<int> v; 
+ //Iterator delcaration for the above vector will correspond to 
+ std::vector<int>::iterator it; 
+```
+
+Использование итератора для печати элементов вектора с использованием цикла
+
+```cpp
+for(it=v.begin(); it!=v.end(); ++it) 
+ //std::vector::begin and std::vector::end return iterator pointing to first and last element of the vector respectively. 
+  cout<<*it; 
+```
+
+### Итерация через вектор
+
+Существуют различные способы итерации вектора и доступа к его содержимому. Следующие формы эквивалентны, первый включает использование выражения на основе диапазона (начиная с C ++ 11), второй использует итераторы, а последний - это итерация на основе индекса
+
+\`\` \`cpp
+
+# включают
+
+# включают
+
+// Сначала объявим вектор станд :: вектор myVector {1, 2, 3, 4, 5}; // a - вектор из 5 ints: 1, 2, 3, 4 и 5
+
+// Использование цикла на основе диапазона (с C ++ 11) for (int element: myVector) {// Читает как "для каждого элемента myVector" std :: cout << "Элемент" << element << std :: endl; }
+
+// Использование итератора станд :: вектор :: iterator it; // Объявляем итератор for (it = myVector.begin (); it! = myVector.end (); ++ it) { std :: cout << "Элемент" << \* it << std :: endl; // Разбираем итератор для доступа к его данным }
+
+// Использование индексов для (станд :: вектор :: size\_type i = 0; i! = myVector.size (); я ++) { std :: cout << "Элемент" << myVector \[i\] << std :: endl; // Разбираем итератор для доступа к его данным }
+```
+### Sorting A Vector In Ascending Order 
+ Sorting a vector based on ascending order can be done with the help of Sort() in C++. 
+```
+
+CPP
+
+# включают
+
+# включают
+
+# включают
+
+использование пространства имен std;
+
+int main () {
+
+вектор v {10, 5, 82, 69, 64, 70, 3, 42, 28, 0}; sort (v.begin (), v.end ());
+
+cout << "Vector Contents Сортировка по возрастанию: \\ n"; для (int e: v) { cout << e << ""; }
+
+return 0; }
+```
+### Sorting Vector In Descending Order 
+ Sorting Vector in descending order can be done with the help of third argument namely greater<int>() in Sort() in C++. 
+```
+
+CPP
+
+# включают
+
+# включают
+
+# включают
+
+использование пространства имен std;
+
+int main () {
+
+вектор v {10, 5, 82, 69, 64, 70, 3, 42, 28, 0}; sort (v.begin (), v.end (), больше ());
+
+cout << "Vector Contents Сортировка по возрастанию: \\ n"; для (int e: v) { cout << e << ""; }
+
+return 0; } \`\` \`

guide/russian/cplusplus/while-loop/index.md

@@ -0,0 +1,37 @@
+---
+title:While-loop
+localeTitle: undefined
+---
+Оператор while while повторно выполняет оператор-мишень, если данное условие истинно.
+
+Синтаксис: while (условие) { заявления); }
+
+Ключевым моментом цикла while является то, что цикл никогда не запускается. Когда условие проверено и результат будет ложным, тело цикла будет пропущено, и первый оператор после цикла while будет выполнен.
+
+Пример:
+
+```C++
+#include <iostream> 
+ using namespace std; 
+ 
+ int main () { 
+   // Local variable declaration: 
+   int a = 10; 
+ 
+   // while loop execution 
+   while( a < 20 ) { 
+      cout << "value of a: " << a << endl; 
+      a++; 
+   } 
+ 
+   return 0; 
+ } 
+```
+
+Вывод:
+
+значение a: 10 значение a: 11 значение a: 12 значение a: 13 значение a: 14 значение a: 15 значение a: 16 значение a: 17 значение a: 18 значение a: 19
+
+### источники
+
+www.tutorialspoint.com