C++

Що таке C ++?

C ++ -це крос -платформна мова, яка може бути використана для створення високоефективних програм.

C ++ був розроблений Bjear Strobustrup як розширення мови C.

C ++ надає програмістам високий рівень контролю над системними ресурсами та пам'яттю.

Мова була оновлена ​​4 рази у 2011, 2014, 2017 та 2020 роках до C ++ 11, C ++ 14, C ++ 17, C ++ 20.

Навіщо використовувати C ++

C ++ - одна з найпопулярніших мов програмування у світі.

C ++ можна знайти в сучасних операційних системах, графічних інтерфейсах користувачів та вбудованих системах.

C ++-це об'єктно-орієнтована мова програмування, яка надає програмам чітку структуру і дозволяє повторно використовувати код, що зменшує витрати на розвиток.

C ++ переноситься і може використовуватися для розробки додатків, які можна адаптувати для різних платформ.

C ++ - це весело і легко вчитися!

C ++ - це весело і легко вчитися!

Давайте проаналізуємо наступний код, щоб краще зрозуміти його:

#include <iostream>

using namespace std;

int main() {

  cout << "Hello World!";

  return 0;

} 

Пояснення прикладу

Рядок 1: #include <iostream> — це бібліотека файлів заголовків, яка дозволяє нам працювати з вхідними та вихідними об'єктами, такими як cout (використовується у рядку 5). Файли заголовків додають функціональність програм C++.

Рядок 2: використання простору імен std означає, що ми можемо використовувати імена для об'єктів та змінних зі стандартної бібліотеки.

Не турбуйтеся, якщо ви не розумієте, як працює #include <iostream> та використання простору імен std. Просто подумайте про це як щось, що (майже) завжди з'являється у вашій програмі.

Рядок 3: Порожній рядок. C++ ігнорує прогалини. Але ми використовуємо його, щоб зробити код читальнішим.

Рядок 4: Ще одна річ, яка завжди з'являється в програмі C++, це int main(). Це називається функцією. Будь-який код усередині фігурних дужок {} буде виконано.

Рядок 5: cout (вимовляється як «see-out») — це об'єкт, який використовується разом із оператором вставки (<<) для виводу/друку тексту. У нашому прикладі він виведе Hello World.

Примітка. Кожен оператор C++ закінчується крапкою з комою;.

Примітка. Тіло int main() також можна було б записати так:

int main() { cout << "Привіт, мир!"; return 0; }

Пам'ятайте: компілятор ігнорує прогалини. Однак кілька рядків роблять код більш читаним.

Рядок 6: return 0 завершує основну функцію.

Рядок 7: не забудьте додати фігурну дужку, що закриває }, щоб фактично завершити основну функцію.

Пропуск простору імен

Деякі програми C++ можуть працювати без стандартної бібліотеки просторів імен. Рядок using namespace std може бути опущений і замінений ключовим словом std, за яким слідує оператор :: для деяких об'єктів:

#include <iostream>

int main() {

  std::cout << "Hello World!";

  return 0;

} 

Вам вирішувати, чи ви хочете включати стандартну бібліотеку просторів імен чи ні.

Об'єкт cout разом із оператором << використовується для виведення значень/друку тексту:

#include <iostream>

using namespace std;

int main() {

  cout << "Hello World!";

  return 0;

} 

Ви можете додати стільки об'єктів cout, скільки захочете. Однак зверніть увагу, що він не вставляє новий рядок у кінці виводу:

#include <iostream>

using namespace std;

int main() {

  cout << "Hello World!";

  cout << "I am learning C++";

  return 0;

} 

Нові рядки

Щоб вставити новий рядок, можна використовувати символ \n:

#include <iostream>

using namespace std;

int main() {

  cout << "Hello World! \n";

  cout << "I am learning C++";

  return 0;

} 

Порада: два символи \n один за одним створять порожній рядок:

#include <iostream>

using namespace std;

int main() {

  cout << "Hello World! \n\n";

  cout << "I am learning C++";

  return 0;

} 

Інший спосіб вставити новий рядок – за допомогою маніпулятора endl:

#include <iostream>

using namespace std;

int main() {

  cout << "Hello World!" << endl;

  cout << "I am learning C++";

  return 0;

} 

Та \n, і endl використовуються для розриву рядків. Однак найчастіше використовується \n.

Але що таке \n?

Символ нового рядка (\n) називається керуючою послідовністю, і він змушує курсор змінити своє положення на початок наступного рядка на екрані. В результаті з'явиться новий рядок.

Приклади інших допустимих escape-послідовностей:

• \t - Створює горизонтальну вкладку

• \\ - Вставляє символ зворотної косої межі (\)

• \" - Вставляє символ подвійної лапки

Коментарі можна використовувати для пояснення коду C++ і для того, щоб зробити його більш читабельним. Його також можна використовувати для запобігання виконання при тестуванні альтернативного коду. Коментарі можуть бути однорядковими або багаторядковими.

Однорядкові коментарі

Однорядкові коментарі починаються з двох косих характеристик (//).

Будь-який текст між // і кінцем рядка ігнорується компілятором (не виконуватиметься).

У цьому прикладі використовується однорядковий коментар перед рядком коду:

// This is a comment

cout << "Hello World!"; 

У цьому прикладі використовується однорядковий коментар наприкінці рядка коду:

cout << "Hello World!"; // This is a comment 

Багаторядкові коментарі

Багаторядкові коментарі починаються з /* та закінчуються */.

Будь-який текст між /* і */ ігноруватиметься компілятором:

/* The code below will print the words Hello World!

to the screen, and it is amazing */

cout << "Hello World!"; 

Однорядкові та багаторядкові коментарі?

Це залежить від вас, що ви хочете використати. Зазвичай ми використовуємо // для коротких коментарів та /* */ для довших.

Змінні— це контейнери для збереження значень даних.

У C++ існують різні типи змінних (визначаються різними ключовими словами), наприклад:

int — зберігає цілі числа (цілі числа) без десяткових знаків, наприклад, 123 або -123.

double — зберігає числа з плаваючою комою з десятковими знаками, наприклад, 19,99 або -19,99.

char — зберігає окремі символи, такі як "a" або "B". Значення Char укладені в одинарні лапки

string - зберігає текст, наприклад "Hello World". Строкові значення укладені у подвійні лапки

bool — зберігає значення з двома станами: true чи false

Оголошення (створення) змінних

Щоб створити змінну, вкажіть тип та надайте їй значення:

type variableName = value; 

Де type — це один із типів C++ (наприклад, int), а variableName — Ім'я змінної (наприклад, x або myName). Знак рівності використовується для визначення значення змінної.

Щоб створити змінну, яка повинна зберігати число, перегляньте наступний приклад:

int myNum = 15;

cout << myNum; 

Ви також можете оголосити змінну без надання значення і присвоїти значення пізніше:

int myNum;

myNum = 15;

cout << myNum; 

Зверніть увагу, що якщо ви надасте нове значення існуючій змінній, воно перезапише попереднє значення:

int myNum = 15;  // myNum is 15

myNum = 10;  // Now myNum is 10

cout << myNum;  // Outputs 10 

Інші типи

Демонстрація інших типів даних:

int myNum = 5;               // Integer (whole number without decimals)

double myFloatNum = 5.99;    // Floating point number (with decimals)

char myLetter = 'D';         // Character

string myText = "Hello";     // String (text)

bool myBoolean = true;       // Boolean (true or false) 

Відображення змінних

Об'єкт cout використовується разом із оператором << для відображення змінних.

Щоб поєднати текст та змінну, розділіть їх оператором <<:

int myAge = 35;

cout << "I am " << myAge << " years old."; 

Додати змінні разом

Щоб додати змінну до іншої змінної, можна використовувати оператор +:

int x = 5;

int y = 6;

int sum = x + y;

cout << sum; 

Оголосити багато змінних

Щоб оголосити більше однієї змінної одного типу, використовуйте список, розділений комами:

int x = 5, y = 6, z = 50;

cout << x + y + z; 

Одне значення для кількох змінних

Ви також можете призначити те саме значення кільком змінним в одному рядку:

int x, y, z;

x = y = z = 50;

cout << x + y + z; 

Ідентифікатори С++

Усі змінні C++ мають бути ідентифіковані унікальними іменами.

Ці унікальні імена називаються ідентифікаторами.

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

Примітка. Рекомендується використовувати описові імена для створення зрозумілого та зручного у супроводі коду:

// Good

int minutesPerHour = 60;

// OK, but not so easy to understand what m actually is

int m = 60; 

Загальні правила іменування змінних такі:

Імена можуть містити літери, цифри та символи підкреслення.

Імена повинні починатися з літери або символу підкреслення (_)

Імена чутливі до регістру (myVar та myvar - різні змінні)

Імена не можуть містити пробіли або спеціальні символи, такі як !, #, % і т.д.

Зарезервовані слова (наприклад, ключові слова C++, такі як int) не можуть використовуватися як імена.

Константи

Якщо ви не хочете, щоб інші (або самі) перевизначали існуючі значення змінних, використовуйте ключове слово const (це оголосить змінну як «константу», що означає незмінність і доступ тільки для читання):

const int myNum = 15;  // myNum will always be 15

myNum = 10;  // error: assignment of read-only variable 'myNum' 

Ви завжди повинні оголошувати змінну як константу, коли у вас є значення, які навряд чи зміняться:

const int minutesPerHour = 60;

const float PI = 3.14; 

Ви вже дізналися, що cout використовується для виведення (друку) значень. Тепер ми будемо використовувати cin для отримання введення користувача.

cin - це зумовлена змінна, яка зчитує дані з клавіатури за допомогою оператора вилучення (>>).

У цьому прикладі користувач може ввести число, яке зберігається в змінній x. Потім ми друкуємо значення x:

int x; 

cout << "Type a number: "; // Type a number and press enter

cin >> x; // Get user input from the keyboard

cout << "Your number is: " << x; // Display the input value 

Добре знати

cout вимовляється як "бачити". Використовується для виведення та використовує оператор вставки (<<)

cin вимовляється як «видимий». Використовується для введення та використовує оператор вилучення (>>)

Створення простого калькулятора

У цьому прикладі користувач має ввести два числа. Потім ми друкуємо суму, обчислюючи (додаючи) два числа:

int x, y;

int sum;

cout << "Type a number: ";

cin >> x;

cout << "Type another number: ";

cin >> y;

sum = x + y;

cout << "Sum is: " << sum; 

int myNum = 5;               // Integer (whole number)

float myFloatNum = 5.99;     // Floating point number

double myDoubleNum = 9.98;   // Floating point number

char myLetter = 'D';         // Character

bool myBoolean = true;       // Boolean

string myText = "Hello";     // String 

Основні типи даних

Тип даних визначає розмір та тип інформації, яку зберігатиме змінна:

• boolean 1 байт Зберігає справжні або неправдиві значення

• char 1 байт Зберігає один символ/літер/число або значення ASCII

• int 2 або 4 байти Зберігає цілі числа без десяткових знаків

• float 4 байти Зберігає дробові числа, що містять один або кілька десяткових знаків. Достатньо для зберігання 7 десяткових цифр

• double 8 байт Зберігає дрібні числа, що містять один або кілька десяткових знаків. Достатньо для зберігання 15 десяткових цифр

Числові типи

Використовуйте int, коли потрібно зберегти ціле число без десяткових знаків, наприклад 35 або 1000, і float або double, коли вам потрібно число з плаваючою комою (з десятковими знаками), наприклад 9,99 або 3,14515.

int myNum = 1000;

cout << myNum; 

----------------------------------------

float myNum = 5.75;

cout << myNum; 

----------------------------------------

double myNum = 19.99;

cout << myNum; 

float vs. double

Точність значення з плаваючою комою вказує, скільки цифр значення може мати після коми. Точність float складає всього шість або сім десяткових цифр, в той час, як точність змінних типу double становить близько 15 цифр. Тому для більшості розрахунків безпечніше використовувати double.

Наукові числа

Число з плаваючою комою також може бути науковим числом з літерою «е», що означає ступінь 10:

float f1 = 35e3;

double d1 = 12E4;

cout << f1;

cout << d1; 

Логічні типи

Логічний тип даних оголошується за допомогою ключового слова bool і може набувати лише значення true або false.

Коли значення повертається, true = 1 та false = 0.

bool isCodingFun = true;

bool isFishTasty = false;

cout << isCodingFun;  // Outputs 1 (true)

cout << isFishTasty;  // Outputs 0 (false) 

Символьні типи

Тип даних Char використовується для зберігання одного символу. Символ повинен бути поміщений у одинарні лапки, наприклад 'A' або 'c':

char myGrade = 'B';

cout << myGrade; 

Крім того, ви можете використовувати значення ASCII для відображення певних символів:

char a = 65, b = 66, c = 67;

cout << a;

cout << b;

cout << c; 

Строкові типи

string тип використовується для зберігання символів послідовності (тексту). Це не вбудований тип, але він веде себе як тип при найпростішому використанні. Строкові значення повинні бути укладені у подвійні лапки:

string greeting = "Hello";

cout << greeting; 

Щоб використовувати рядки, ви повинні включити до вихідного коду додатковий заголовний файл, бібліотеку <string>:

// Include the string library

#include <string>

// Create a string variable

string greeting = "Hello";

// Output string value

cout << greeting; 

Оператори використовуються для виконання операцій над змінними та значеннями.

У наведеному прикладі ми використовуємо оператор + для складання двох значень:

int x = 100 + 50; 

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

int sum1 = 100 + 50;        // 150 (100 + 50)

int sum2 = sum1 + 250;      // 400 (150 + 250)

int sum3 = sum2 + sum2;     // 800 (400 + 400) 

• C++ ділить оператори такі групи:

• Арифметичні оператори

• Оператори присвоєння

• Оператори порівняння

• Логічні оператори

• Побітові оператори

Арифметичні оператори

Арифметичні оператори використовують для виконання загальних математичних операцій.

Name Operator Description Example

+ Addition Adds together two values x + y

- Subtraction Subtracts one value from another x - y

* Multiplication Multiplies two values x * y

/ Division Divides one value by another x / y

% Modulus Returns the division remainder x % y

++ Increment Increases the value of a variable by 1 ++x

-- Decrement Decreases the value of a variable by 1 --x

Оператори присвоєння

Оператори привласнення використовуються для присвоєння значень змінним.

У наведеному нижче прикладі ми використовуємо оператор присвоєння (=), щоб надати значення 10 змінної з ім'ям x:

int x = 10; 

Оператор додавання (+=) додає значення до змінної:

int x = 10;

x += 5; 

Operator Example Same As

= x = 5 x = 5

+= x += 3 x = x + 3

-= x -= 3 x = x - 3

*= x *= 3 x = x * 3

/= x /= 3 x = x / 3

%= x %= 3 x = x % 3

//= x //= 3 x = x // 3

**= x **= 3 x = x ** 3

&= x &= 3 x = x & 3

|= x |= 3 x = x | 3

^= x ^= 3 x = x ^ 3

>>= x >>= 3 x = x >> 3

<<= x <<= 3 x = x << 3

Оператори порівняння

Оператори порівняння використовуються для порівняння двох значень.

Примітка. Значення порівняння, що повертається - або істина (1), або брехня (0).

У наступному прикладі ми використовуємо оператор «більше» (>), щоб дізнатися, чи більше 5, ніж 3:

int x = 5;

int y = 3;

cout << (x > y); // returns 1 (true) because 5 is greater than 3

Operator Name Example

== Equal x == y

!= Not equal x != y

> Greater than x > y

< Less than x < y

>= Greater than or equal to x >= y

<= Less than or equal to x <= y

Логічні оператори

Логічні оператори використовуються для визначення логіки між змінними чи значеннями:

Operator Name Description Example

&& Logical and Returns true if both statements are true x < 5 &&  x < 10

|| Logical or Returns true if one of the statements is true x < 5 || x < 4

! Logical not Reverse the result, returns false if the result is true !(x < 5 && x < 10)

Рядки використовуються для зберігання тексту.

Рядкова змінна містить набір символів, укладених у подвійні лапки:

string greeting = "Hello"; 

Щоб використовувати рядки, ви повинні включити до вихідного коду додатковий заголовний файл, бібліотеку <string>:

// Include the string library

#include <string>

// Create a string variable

string greeting = "Hello"; 

Конкатенація рядків

Оператор + можна використовувати між рядками, щоб скласти їх разом і створити новий рядок. Це називається конкатенацією:

string firstName = "John ";

string lastName = "Doe";

string fullName = firstName + lastName;

cout << fullName; 

У наведеному вище прикладі ми додали пробіл після першогоназви, щоб створити пробіл між John і Doe на виході. Однак ви також можете додати пробіл з лапками(" " or ' '): 

string firstName = "John";

string lastName = "Doe";

string fullName = firstName + " " + lastName;

cout << fullName; 

Додати

Рядок у C++ насправді є об'єктом, що містить функції, які можуть виконувати певні операції над рядками. Наприклад, ви також можете об'єднати рядки за допомогою функції append():

string firstName = "John ";

string lastName = "Doe";

string fullName = firstName.append(lastName);

cout << fullName; 

Додавання чисел та рядків

ПОПЕРЕДЖЕННЯ!

C++ використовує оператор + як складання, так конкатенації.

Додаються числа. Рядки об'єднані.

Якщо ви додасте два числа, результатом буде число:

int x = 10;

int y = 20;

int z = x + y;      // z will be 30 (an integer) 

Якщо ви додасте два рядки, результатом буде конкатенація рядків:

string x = "10";

string y = "20";

string z = x + y;   // z will be 1020 (a string) 

При спробі додати число до рядка виникає помилка:

string x = "10";

int y = 20;

string z = x + y; 

Довжина рядка

Щоб отримати довжину рядка, скористайтеся функцієюlength():

string txt = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

cout << "The length of the txt string is: " << txt.length(); 

Ви можете зустріти деякі програми C++, які використовують функцію size() для отримання довжини рядка. Це просто псевдонім length(). Це повністю залежить від вас, чи ви хочете використовувати length() або size():

string txt = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

cout << "The length of the txt string is: " << txt.size(); 

Доступ до рядків

Ви можете отримати доступ до символів у рядку, звернувшись до його порядкового номера у квадратних дужках [].

Цей приклад друкує перший символ myString:

string myString = "Hello";

cout << myString[0];

// Outputs H 

Примітка. Рядкові індекси починаються з 0: [0] перший символ. [1] - Другий символ і т. д.

Цей приклад друкує другий символ myString:

string myString = "Hello";

cout << myString[1];

// Outputs e 

Змінити символи рядка

Щоб змінити значення певного символу в рядку, зверніться до номера індексу та використовуйте одинарні лапки:

string myString = "Hello";

myString[0] = 'J';

cout << myString;

// Outputs Jello instead of Hello 

Рядки введення користувача

Можна використовувати оператор вилучення >> на cin для відображення рядка, введеного користувачем:

string firstName;

cout << "Type your first name: ";

cin >> firstName; // get user input from the keyboard

cout << "Your name is: " << firstName;

// Type your first name: John

// Your name is: John 

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

string fullName;

cout << "Type your full name: ";

cin >> fullName;

cout << "Your name is: " << fullName;

// Type your full name: John Doe

// Your name is: John 

У наведеному вище прикладі ви очікуєте, що програма надрукує "John Doe", але вона надрукує лише "John".

Ось чому під час роботи з рядками ми часто використовуємо функцію getline() для читання рядка тексту. Він приймає cin як перший параметр і рядкову змінну як другий:

string fullName;

cout << "Type your full name: ";

getline (cin, fullName);

cout << "Your name is: " << fullName;

// Type your full name: John Doe

// Your name is: John Doe 

Пропуск простору імен

Деякі програми C++ можуть працювати без стандартної бібліотеки просторів імен. Рядок using namespace std може бути опущений і замінений ключовим словом std, за яким слідує оператор :: для рядкових (і cout) об'єктів:

#include <iostream>

#include <string>

int main() {

  std::string greeting = "Hello";

  std::cout << greeting;

  return 0;

} 

C++ має багато функцій, що дозволяють виконувати математичні завдання над числами.

Макс та мін

Функцію max(x,y) можна використовувати для знаходження найбільшого значення x та y:

cout << max (5, 10);

А функцію min(x,y) можна використовувати для знаходження найменшого значення x та y:

cout << min(5, 10);

<cmath> Заголовок

Інші функції, такі як sqrt (квадратний корінь), round (округлення числа) та log (натуральний логарифм), можна знайти у заголовному файлі <cmath>:

// Include the cmath library

#include <cmath>

cout << sqrt(64);

cout << round(2.6);

cout << log(2); 

Інші математичні функції

Список інших популярних математичних функцій (з бібліотеки <cmath>) можна знайти у таблиці нижче:

Function Description

abs(x) Returns the absolute value of x

acos(x) Returns the arccosine of x

asin(x) Returns the arcsine of x

atan(x) Returns the arctangent of x

cbrt(x) Returns the cube root of x

ceil(x) Returns the value of x rounded up to its nearest integer

cos(x) Returns the cosine of x

cosh(x) Returns the hyperbolic cosine of x

exp(x) Returns the value of Ex

expm1(x) Returns ex -1

fabs(x) Returns the absolute value of a floating x

fdim(x, y) Returns the positive difference between x and y

floor(x) Returns the value of x rounded down to its nearest integer

hypot(x, y) Returns sqrt(x2 +y2) without intermediate overflow or underflow

fma(x, y, z) Returns x*y+z without losing precision

fmax(x, y) Returns the highest value of a floating x and y

fmin(x, y) Returns the lowest value of a floating x and y

fmod(x, y) Returns the floating point remainder of x/y

pow(x, y) Returns the value of x to the power of y

sin(x) Returns the sine of x (x is in radians)

sinh(x) Returns the hyperbolic sine of a double value

tan(x) Returns the tangent of an angle

tanh(x) Returns the hyperbolic tangent of a double value

Дуже часто у програмуванні вам знадобиться тип даних, який може мати лише одне з двох значень, наприклад:

• YES / NO

• ON / OFF

• TRUE / FALSE

Для цього C++ є тип даних bool, який може приймати значення true (1) або false (0).

Логічні значення

Логічна змінна оголошується з ключовим словом bool і може набувати лише значення true або false:

bool isCodingFun = true;

bool isFishTasty = false;

cout << isCodingFun;  // Outputs 1 (true)

cout << isFishTasty;  // Outputs 0 (false) 

З наведеного вище прикладу ви можете прочитати, що дійсне значення повертає 1, а хибне повертає 0.

Однак найчастіше повертаються логічні значення з логічних виразів

Логічне вираження

Логічне вираз – це вираз C++, який повертає логічне значення: 1 (істина) або 0 (брехня).

Ви можете використовувати оператор порівняння, наприклад, оператор більше (>), щоб дізнатися, чи істинно вираз (або змінна):

int x = 10;

int y = 9;

cout << (x > y); // returns 1 (true), because 10 is higher than 9 

Або ще простіше:

cout << (10 > 9); // returns 1 (true), because 10 is higher than 9 

У наведених нижче прикладах ми використовуємо оператор рівності (==) для обчислення виразу:

int x = 10;

cout << (x == 10);  // returns 1 (true), because the value of x is equal to 10 

--------------------------------------------------

cout << (10 == 15);  // returns 0 (false), because 10 is not equal to 15 

Цикл Цикли можуть виконувати блок коду, поки виконується задана умова.

Цикли зручні тим, що вони економлять час, зменшують кількість помилок і роблять код читальнішим.

Цикл while проходить через блок коду доти, доки виконується зазначена умова:

while (condition) {

  // code block to be executed

} 

У наведеному нижче прикладі код циклу буде виконуватися знову і знову, поки змінна (i) менше 5:

int i = 0;

while (i < 5) {

  cout << i << "\n";

  i++;

} 

Цикл do/while

Цикл do/while є варіантом циклу while. Цей цикл виконає блок коду один раз перед перевіркою істинності умови, потім цикл повторюватиметься до тих пір, поки умова істинна.

do {

  // code block to be executed

}

while (condition); 

У наведеному прикладі використовується цикл do/while. Цикл завжди буде виконуватися хоча б один раз, навіть якщо умова помилкова, тому що блок коду виконується до перевірки умови:

int i = 0;

do {

  cout << i << "\n";

  i++;

}

while (i < 5); 

for цикл for

Коли ви точно знаєте скільки разів ви хочете пройти через блок коду, використовуйте цикл for замість циклу while:

for (statement 1; statement 2; statement 3) {

  // code block to be executed

} 

Оператор 1 виконується (один раз) перед виконанням кодового блоку.

Оператор 2 визначає умову виконання блоку коду.

Оператор 3 виконується (щоразу) після виконання блоку коду.

У наведеному нижче прикладі буде надруковано числа від 0 до 4:

for (int i = 0; i < 5; i++) {

  cout << i << "\n";

} 

Пояснення прикладу

Оператор 1 встановлює змінну на початок циклу (int i = 0).

Оператор 2 визначає умову запуску циклу (i має бути менше 5). Якщо умова є істинною, цикл починається заново, якщо хибно, цикл завершується.

Оператор 3 збільшує значення (i++) щоразу, коли блок коду циклі виконується.

Інший приклад

У цьому прикладі друкуються лише парні значення від 0 до 10:

for (int i = 0; i <= 10; i = i + 2) {

  cout << i << "\n";

} 

break

Він використовувався, щоб вийти з оператора switch.

Оператор break також може бути використаний для виходу з циклу.

Цей приклад виходить із циклу, коли i дорівнює 4:

for (int i = 0; i < 10; i++) {

  if (i == 4) {

    break;

  }

  cout << i << "\n";

} 

continue 

Оператор continue перериває одну ітерацію (у циклі), якщо виникає зазначена умова, і продовжує наступну ітерацію циклу.

У цьому прикладі пропускається значення 4:

for (int i = 0; i < 10; i++) {

  if (i == 4) {

    continue;

  }

  cout << i << "\n";

} 

break та continue у циклі while

Ви також можете використовувати break і continue у циклах while:

int i = 0;

while (i < 10) {

  cout << i << "\n";

  i++;

  if (i == 4) {

    break;

  }

} 

----------------------------------------

int i = 0;

while (i < 10) {

  if (i == 4) {

i++;

    continue;

  }

  cout << i << "\n";

  i++;

} 

Масиви використовуються для зберігання кількох значень в одній змінній замість оголошення окремих змінних кожного значення.

Щоб оголосити масив, визначте тип змінної, вкажіть ім'я масиву, за яким йдуть квадратні дужки, та вкажіть кількість елементів, які він повинен зберігати:

string cars[4]; 

Тепер ми оголосили змінну, яка містить масив із чотирьох рядків. Щоб вставити в нього значення, ми можемо використовувати літерал масиву - помістіть значення в список, розділений комами, всередині фігурних дужок:

string cars[4] = {"Volvo", "BMW", "Ford", "Mazda"}; 

Щоб створити масив із трьох цілих чисел, ви можете написати:

int myNum[3] = {10, 20, 30}; 

Доступ до елементів масиву

Ви отримуєте доступ до елемента масиву, звертаючись до номера індексу у квадратних дужках [].

Цей оператор отримує доступ до значення першого елемента в cars:

string cars[4] = {"Volvo", "BMW", "Ford", "Mazda"};

cout << cars[0];

// Outputs Volvo 

Примітка. Індекси масиву починаються з 0: [0] перший елемент. [1] - Другий елемент і т. д.

Змінити елемент масиву

Щоб змінити значення певного елемента, зверніться до номера індексу:

cars[0] = "Opel"; 

приклад

string cars[4] = {"Volvo", "BMW", "Ford", "Mazda"};

cars[0] = "Opel";

cout << cars[0];

// Now outputs Opel instead of Volvo 

Цикл через масив

Можна перебирати елементи масиву за допомогою циклу for.

У наступному прикладі виводяться всі елементи масиву cars:

string cars[4] = {"Volvo", "BMW", "Ford", "Mazda"};

for (int i = 0; i < 4; i++) {

  cout << cars[i] << "\n";

} 

У наступному прикладі виводиться індекс кожного елемента разом із його значенням:

string cars[4] = {"Volvo", "BMW", "Ford", "Mazda"};

for (int i = 0; i < 4; i++) {

  cout << i << ": " << cars[i] << "\n";

} 

Пропустити розмір масиву

Вам не потрібно вказувати розмір масиву. Але якщо ви цього не зробите, він буде таким самим великим, як елементи, які в нього вставлені:

string cars[] = {"Volvo", "BMW", "Ford"}; // size of array is always 3

Це абсолютно нормально. Однак проблема виникає, якщо вам потрібне додаткове місце для майбутніх елементів. Потім потрібно перезаписати існуючі значення:

string cars[] = {"Volvo", "BMW", "Ford"};

string cars[] = {"Volvo", "BMW", "Ford", "Mazda", "Tesla"}; 

Однак, якщо ви вкажете розмір, масив зарезервує додатковий простір:

string cars[5] = {"Volvo", "BMW", "Ford"}; // size of array is 5, even though it's only three elements inside it

Тепер ви можете додати четвертий та п'ятий елементи, не перезаписуючи інші:

cars[3] = "Mazda";

cars[4] = "Tesla"; 

Опустити елементи в оголошенні

Також можна оголосити масив без вказівки елементів при оголошенні та додати їх пізніше:

string cars[5];

cars[0] = "Volvo";

cars[1] = "BMW";

... 

Отримати розмір масиву

Отримати розмір масиву sizeof():

int myNumbers[5] = {10, 20, 30, 40, 50};

cout << sizeof(myNumbers); 

Чому результат показав 20 замість 5 коли масив містить 5 елементів?

Це з тим, що оператор sizeof() повертає розмір типу у байтах.

З розділу "Типи даних" ви дізналися, що тип int зазвичай має розмір 4 байти, тому з наведеного вище прикладу 4 x 5 (4 байти x 5 елементів) = 20 байт.

Щоб дізнатися, скільки елементів має масив, ви повинні розділити розмір масиву на розмір типу даних, що міститься в ньому:

int myNumbers[5] = {10, 20, 30, 40, 50};

int getArrayLength = sizeof(myNumbers) / sizeof(int);

cout << getArrayLength; 

Багатовимірні масиви

Багатовимірний масив – це масив масивів.

Щоб оголосити багатовимірний масив, визначте тип змінної, вкажіть ім'я масиву, за яким йдуть квадратні дужки, які вказують, скільки елементів має основний масив, за яким слідує ще один набір квадратних дужок, що вказує, скільки елементів мають підмасиви:

string letters[2][4]; 

Як і у випадку зі звичайними масивами, ви можете вставляти значення за допомогою літералу масиву - списку, розділеного комами, всередині фігурних дужок. У багатовимірному масиві кожен елемент літералу є іншим літералом масиву.

string letters[2][4] = {

  { "A", "B", "C", "D" },

  { "E", "F", "G", "H" }

}; 

Кожен набір квадратних дужок в оголошенні масиву додає масиву ще один вимір. Кажуть, що масив, подібний до наведеного вище, має два виміри.

Масиви можуть мати будь-яку кількість вимірів. Чим більше розмірностей у масиву, тим складнішим стає код. Наступний масив має три виміри:

string letters[2][2][2] = {

  {

{ "A", "B" },

    { "C", "D" }

  },

  {

{ "E", "F" },

    { "G", "H" }

  }

}; 

Доступ до елементів багатовимірного масиву

Щоб отримати доступ до елемента багатовимірного масиву, вкажіть номер індексу в кожному вимірюванні масиву.

Цей оператор отримує доступ до значення елемента в першому рядку (0) та третьому стовпці (2) масиву літер.

string letters[2][4] = {

  { "A", "B", "C", "D" },

  { "E", "F", "G", "H" }

};

cout << letters[0][2];  // Outputs "C" 

Пам'ятайте, що: Індекси масиву починаються з 0: [0] перший елемент. [1] - Другий елемент і т. д.

Зміна елементів у багатовимірному масиві

Щоб змінити значення елемента, зверніться до порядкового номера елемента у кожному з вимірів:

string letters[2][4] = {

  { "A", "B", "C", "D" },

  { "E", "F", "G", "H" }

};

letters[0][0] = "Z";

cout << letters[0][0];  // Now outputs "Z" instead of "A" 

Цикл через багатовимірний масив

Щоб перебрати багатовимірний масив, вам знадобиться один цикл для кожного вимірювання масиву.

У наступному прикладі виводяться всі елементи масиву letter:

string letters[2][4] = {

  { "A", "B", "C", "D" },

  { "E", "F", "G", "H" }

};

for(int i = 0; i < 2; i++) {

  for(int j = 0; j < 4; j++) {

cout << letters[i][j] << "\n";

  }

} 

У цьому прикладі показано, як пройтися тривимірним масивом:

string letters[2][2][2] = {

  {

{ "A", "B" },

     { "C", "D" }

  },

  {

{ "E", "F" },

     { "G", "H" }

  }

};

for(int i = 0; i < 2; i++) {

  for(int j = 0; j < 2; j++) {

    for(int k = 0; k < 2; k++) {

   cout << letters[i][j][k] << "\n";

    }

  }

} 

Чому багатовимірні масиви?

Багатовимірні масиви добре підходять для представлення сіток. Цей приклад показує їхнє практичне застосування. У наступному прикладі ми використовуємо багатовимірний масив для представлення невеликої гри.

// We put "1" to indicate there is a ship.

bool ships[4][4] = {

  { 0, 1, 1, 0 },

  { 0, 0, 0, 0 },

  { 0, 0, 1, 0 },

  { 0, 0, 1, 0 }

};

// Keep track of how many hits the player has and how many turns they have played in these variables

int hits = 0;

int numberOfTurns = 0;

// Allow the player to keep going until they have hit all four ships

while (hits < 4) {

  int row, column;

  cout << "Selecting coordinates\n";

  // Ask the player for a row

  cout << "Choose a row number between 0 and 3: ";

  cin >> row;

  // Ask the player for a column

  cout << "Choose a column number between 0 and 3: ";

  cin >> column;

  // Check if a ship exists in those coordinates

  if (ships[row][column]) {

    // If the player hit a ship, remove it by setting the value to zero.

    ships[row][column] = 0;

    // Increase the hit counter

    hits++;

    // Tell the player that they have hit a ship and how many ships are left

cout << "Hit! " << (4-hits) << " left.\n\n";

  } else {

    // Tell the player that they missed

cout << "Miss\n\n";

  }

  // Count how many turns the player has taken

  numberOfTurns++;

}

cout << "Victory!\n";

cout << "You won in " << numberOfTurns << " turns"; 

Структури (також звані структурами) — це спосіб групувати кілька пов'язаних змінних одному місці. Кожна змінна у структурі відома як член структури.

На відміну від масиву, структура може містити безліч різних типів даних (int, string, bool тощо).

Створити структуру

Щоб створити структуру, використовуйте ключове слово struct і оголосіть кожен із її елементів усередині фігурних дужок.

Після оголошення вкажіть ім'я структурної змінної (myStructure у прикладі нижче):

struct {             // Structure declaration

  int myNum;         // Member (int variable)

  string myString;   // Member (string variable)

} myStructure;       // Structure variable 

Доступ до елементів структури

Для доступу до членів структури використовуйте синтаксис із точкою (.):

// Create a structure variable called myStructure

struct {

  int myNum;

  string myString;

} myStructure;

// Assign values to members of myStructure

myStructure.myNum = 1;

myStructure.myString = "Hello World!";

// Print members of myStructure

cout << myStructure.myNum << "\n";

cout << myStructure.myString << "\n"; 

Одна структура з кількома змінними

Ви можете використовувати кому (,), щоб використовувати одну структуру в багатьох змінних:

struct {

  int myNum;

  string myString;

} myStruct1, myStruct2, myStruct3; // Multiple structure variables separated with commas 

У цьому прикладі показано, як використовувати структуру двох різних змінних:

struct {

  string brand;

  string model;

  int year;

} myCar1, myCar2; // We can add variables by separating them with a comma here

// Put data into the first structure

myCar1.brand = "BMW";

myCar1.model = "X5";

myCar1.year = 1999;

// Put data into the second structure

myCar2.brand = "Ford";

myCar2.model = "Mustang";

myCar2.year = 1969;

// Print the structure members

cout << myCar1.brand << " " << myCar1.model << " " << myCar1.year << "\n";

cout << myCar2.brand << " " << myCar2.model << " " << myCar2.year << "\n"; 

Іменовані структури

Даючи ім'я структурі, ви можете поводитися з нею як з типом даних. Це означає, що ви можете створювати змінні з такою структурою будь-де програми в будь-який час.

Щоб створити іменовану структуру, помістіть ім'я структури одразу після ключового слова struct:

struct myDataType { // This structure is named "myDataType"

  int myNum;

  string myString;

}; 

Щоб оголосити змінну, яка використовує структуру, використовуйте ім'я структури як тип даних змінної:

myDataType myVar;

Використовуйте одну структуру для представлення двох автомобілів:

// Declare a structure named "car"

struct car {

  string brand;

  string model;

  int year;

};

int main() {

  // Create a car structure and store it in myCar1;

  car myCar1;

  myCar1.brand = "BMW";

  myCar1.model = "X5";

  myCar1.year = 1999;

  // Create another car structure and store it in myCar2;

  car myCar2;

  myCar2.brand = "Ford";

  myCar2.model = "Mustang";

  myCar2.year = 1969;

  // Print the structure members

  cout << myCar1.brand << " " << myCar1.model << " " << myCar1.year << "\n";

  cout << myCar2.brand << " " << myCar2.model << " " << myCar2.year << "\n";

  return 0;

} 

Створення посилань

Посилальна змінна — це посилання на існуючу змінну, і вона створюється за допомогою оператора &:

string food = "Pizza";  // food variable

string &meal = food;    // reference to food 

Теперь мы можем использовать либо имя переменной food, либо имя ссылки food для ссылки на переменную food:

string food = "Pizza";

string &meal = food;

cout << food << "\n";  // Outputs Pizza

cout << meal << "\n";  // Outputs Pizza 

Адреса пам'яті

У прикладі з попередньої сторінки оператор & використовувався для створення змінної посилання. Але його можна використовувати для отримання адреси пам'яті змінної; це місце, де змінна зберігається на комп'ютері.

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

Щоб отримати доступ до нього, використовуйте оператор &, і результат представлятиме, де зберігається змінна:

string food = "Pizza";

cout << &food; // Outputs 0x6dfed4 

Примітка. Адреса пам'яті вказана у шістнадцятковому форматі (0x..). Зверніть увагу, що ви можете не отримати такий же результат у програмі.

А навіщо корисно знати адресу пам'яті?

Ці дві функції є однією з тих речей, які відрізняють C++ від інших мов програмування, таких як Python і Java.

З попереднього розділу ви дізналися, що ми можемо отримати адресу пам'яті змінної за допомогою оператора &:

string food = "Pizza"; // A food variable of type string

cout << food;  // Outputs the value of food (Pizza)

cout << &food; // Outputs the memory address of food (0x6dfed4) 

Однак покажчик — це змінна, яка зберігає адресу пам'яті як своє значення.

Змінна вказівник вказує на тип даних (наприклад, int або string) того ж типу і створюється за допомогою оператора *. Адреса змінної, з якою ви працюєте, надається покажчику:

string food = "Pizza";  // A food variable of type string

string* ptr = &food;    // A pointer variable, with the name ptr, that stores the address of food

// Output the value of food (Pizza)

cout << food << "\n";

// Output the memory address of food (0x6dfed4)

cout << &food << "\n";

// Output the memory address of food with the pointer (0x6dfed4)

cout << ptr << "\n"; 

Пояснення прикладу

Створіть змінну-покажчик з ім'ям ptr, яка вказує на рядкову змінну, використовуючи знак зірочки *(string*ptr). Зверніть увагу, що тип покажчика повинен відповідати типу змінної, з якою ви працюєте.

Використовуйте оператор &, щоб зберегти адресу пам'яті змінної з ім'ям food та присвоїти її вказівнику.

Тепер ptr містить значення адреси food.

Порада: Є три способи оголосити змінні-покажчики, але перший спосіб краще:

string* mystring; // Preferred

string *mystring;

string * mystring; 

Отримати адресу пам'яті та значення

У прикладі з попередньої сторінки ми використовували змінну-покажчик для отримання адреси пам'яті змінної (використовується разом із оператором посилання &). Однак, ви також можете використовувати покажчик для отримання значення змінної, використовуючи оператор * (оператор розіменування):

string food = "Pizza";  // Variable declaration

string* ptr = &food;    // Pointer declaration

// Reference: Output the memory address of food with the pointer (0x6dfed4)

cout << ptr << "\n";

// Dereference: Output the value of food with the pointer (Pizza)

cout << *ptr << "\n"; 

Змінити значення вказівника

Ви також можете змінити значення вказівника. Але зверніть увагу, що це також змінить значення вихідної змінної:

string food = "Pizza";

string* ptr = &food;

// Output the value of food (Pizza)

cout << food << "\n";

// Output the memory address of food (0x6dfed4)

cout << &food << "\n";

// Access the memory address of food and output its value (Pizza)

cout << *ptr << "\n";

// Change the value of the pointer

*ptr = "Hamburger";

// Output the new value of the pointer (Hamburger)

cout << *ptr << "\n";

// Output the new value of the food variable (Hamburger)

cout << food << "\n"; 

Функція – це блок коду, який запускається лише під час виклику.

Ви можете передавати дані, відомі як параметри, у функцію.

Функції використовуються для виконання певних дій і важливі для повторного використання коду: визначте код один раз і використовуйте його багато разів.

Створити функцію

C++ надає деякі зумовлені функції, такі як main(), яка використовується для виконання коду. Але ви також можете створювати власні функції для виконання певних дій.

Щоб створити (часто зване оголошенням) функцію, вкажіть ім'я функції, за яким слідують круглі дужки ():

void myFunction() {

  // code to be executed

} 

Пояснення прикладу

myFunction() — це ім'я функції

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

всередині функції (тіла) додайте код, що визначає, що повинна виконувати функція

Виклик функції

Заявлені функції виконуються не відразу. Вони «зберігаються для подальшого використання» і будуть виконуватися пізніше, коли їх буде викликано.

Щоб викликати функцію, напишіть ім'я функції, за яким слідують дві круглі дужки () та крапка з комою;

У прикладі myFunction() використовується для друку тексту (дії) при його викликі:

// Create a function

void myFunction() {

  cout << "I leatning C++";

}

int main() {

  myFunction(); // call the function

  return 0;

}

// Outputs "I leatning C++" 

Функцію можна викликати кілька разів:

void myFunction() {

  cout << "I leatning C++\n";

}

int main() {

  myFunction();

  myFunction();

  myFunction();

  return 0;

}

Оголошення та визначення функції

Функція C++ і двох частин:

Оголошення: тип значення, що повертається, ім'я функції та параметри (якщо є).

Визначення: тіло функції (виконуваний код)

void myFunction() { // declaration

  // the body of the function (definition)

} 

Примітка. Якщо функція, що визначається користувачем, така як myFunction(), оголошена після функції main(), відбудеться помилка:

int main() {

  myFunction();

  return 0;

}

void myFunction() {

  cout << "I just got executed!";

}

// Error 

Однак можна розділити оголошення та визначення функції для оптимізації коду.

Ви часто бачитимете програми на C++, в яких оголошення функції знаходиться над main(), а визначення функції - під main(). Це зробить код краще організованим та зручнішим для читання:

// Function declaration

void myFunction();

// The main method

int main() {

  myFunction();  // call the function

  return 0;

}

// Function definition

void myFunction() {

  cout << "I just got executed!";

} 

Параметри та аргументи

Інформація може передаватися функціям як параметр. Параметри діють як змінні функції.

Параметри вказуються після імені функції у круглих дужках. Ви можете додати стільки параметрів, скільки хочете, просто розділіть їх комою:

void functionName(parameter1, parameter2, parameter3) {

  // code to be executed

} 

У наступному прикладі є функція, яка приймає рядок з ім'ям fname як параметр. Коли функція викликається, ми передаємо ім'я, яке використовується всередині функції для повного імені:

void myFunction(string fname) {

  cout << fname << " Refsnes\n";

}

int main() {

  myFunction("Liam");

  myFunction("Jenny");

  myFunction("Anja");

  return 0;

}

Значення параметра за замовчуванням

Ви також можете використовувати значення за промовчанням, використовуючи знак рівності (=).

Якщо ми викликаємо функцію без аргументу, вона використовує значення за замовчуванням (Норвегія):

void myFunction(string country = "Norway") {

  cout << country << "\n";

}

int main() {

  myFunction("Sweden");

  myFunction("India");

  myFunction();

  myFunction("USA");

  return 0;

} 

Декілька параметрів

Всередині функції можна додати стільки параметрів, скільки хочете:

  cout << fname << " Refsnes. " << age << " years old. \n";

}

int main() {

  myFunction("Liam", 3);

  myFunction("Jenny", 14);

  myFunction("Anja", 30);

  return 0;

} 

Значення, що повертаються

Ключове слово void, використане попередніх прикладах, вказує, що функція має повертати значення. Якщо ви хочете, щоб функція повертала значення, ви можете використовувати тип даних (наприклад, int, string тощо) замість void і використовувати ключове слово return всередині функції:

int myFunction(int x) {

  return 5 + x;

}

int main() {

  cout << myFunction(3);

  return 0;

} 

Цей приклад повертає суму функції із двома параметрами:

int myFunction(int x, int y) {

  return x + y;

}

int main() {

  cout << myFunction(5, 3);

  return 0;

} 

Ви також можете зберегти результат у змінній:

int myFunction(int x, int y) {

  return x + y;

}

int main() {

  int z = myFunction(5, 3);

  cout << z;

  return 0;

} 

Надіслати за посиланням

Ви також можете надіслати посилання на функцію. Це може бути корисним, коли вам потрібно змінити значення аргументів:

void swapNums(int &x, int &y) {

  int z = x;

  x = y;

  y = z;

}

int main() {

  int firstNum = 10;

  int secondNum = 20;

  cout << "Before swap: " << "\n";

  cout << firstNum << secondNum << "\n";

  // Call the function, which will change the values of firstNum and secondNum

  swapNums(firstNum, secondNum);

  cout << "After swap: " << "\n";

  cout << firstNum << secondNum << "\n"

  return 0;

} 

Передайте масиви як параметри функції

Ви також можете передавати масиви у функцію:

void myFunction(int myNumbers[5]) {

  for (int i = 0; i < 5; i++) {

    cout << myNumbers[i] << "\n";

  }

}

int main() {

  int myNumbers[5] = {10, 20, 30, 40, 50};

  myFunction(myNumbers);

  return 0;

} 

Пояснення прикладу

Функція (myFunction) приймає масив як параметр (int myNumbers[5]) і перебирає елементи масиву з допомогою циклу for.

Коли функція викликається всередині main(), ми передаємо масив myNumbers, який виводить елементи масиву.

Зверніть увагу, що при виклику функції потрібно використовувати тільки ім'я масиву при передачі його в якості аргументу myFunction(myNumbers). Однак повне оголошення масиву необхідне параметр функції (int myNumbers[5]).

З перевантаженням функцій кілька функцій можуть мати однакові назви з різними параметрами:

int myFunction(int x)

float myFunction(float x)

double myFunction(double x, double y) 

Розглянемо наступний приклад, який містить дві функції, які додають числа різного типу:

int plusFuncInt(int x, int y) {

  return x + y;

}

double plusFuncDouble(double x, double y) {

  return x + y;

}

int main() {

  int myNum1 = plusFuncInt(8, 5);

  double myNum2 = plusFuncDouble(4.3, 6.26);

  cout << "Int: " << myNum1 << "\n";

  cout << "Double: " << myNum2;

  return 0;

} 

Замість того, щоб визначати дві функції, які повинні робити те саме, краще перевантажити одну.

У наведеному нижче прикладі ми перевантажуємо функцію plusFunc для роботи як для int, так і для double:

int plusFunc(int x, int y) {

  return x + y;

}

double plusFunc(double x, double y) {

  return x + y;

}

int main() {

  int myNum1 = plusFunc(8, 5);

  double myNum2 = plusFunc(4.3, 6.26);

  cout << "Int: " << myNum1 << "\n";

  cout << "Double: " << myNum2;

  return 0;

} 

Рекурсія — це техніка здійснення самого виклику функції. Ця техніка дає змогу розділити складні проблеми на прості, які легше вирішити.

Рекурсія може бути трохи складною для розуміння. Найкращий спосіб зрозуміти, як це працює, — поекспериментувати з ним.

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

int sum(int k) {

  if (k > 0) {

    return k + sum(k - 1);

  } else {

    return 0;

  }

}

int main() {

  int result = sum(10);

  cout << result;

  return 0;

} 

Коли викликається функція sum(), вона додає параметр k до суми всіх чисел, менших за k, і повертає результат. Коли k стає 0, функція просто повертає 0. Під час роботи програма виконує такі дії:

10 + sum(9)

10 + ( 9 + sum(8) )

10 + ( 9 + ( 8 + sum(7) ) )

...

10 + 9 + 8 + 7 + 6 + 5 + 4 + 3 + 2 + 1 + sum(0)

10 + 9 + 8 + 7 + 6 + 5 + 4 + 3 + 2 + 1 + 0 

Оскільки функція не викликає сама себе, коли k дорівнює 0, програма зупиняється на цьому та повертає результат.

Розробник має бути дуже обережним з рекурсією, оскільки може бути дуже легко сковзнути до написання функції, яка ніколи не закінчується, або такої, яка використовує надмірну кількість пам’яті чи потужності процесора. Однак, коли рекурсія написана правильно, вона може бути дуже ефективним і математично елегантним підходом до програмування.

C++ - це об'єктно-орієнтована мова програмування.

Усе в C++ пов’язане з класами та об’єктами разом із його атрибутами та методами. Наприклад: у реальному житті автомобіль є предметом. Автомобіль має атрибути, такі як вага та колір, і методи, такі як водіння та гальмування.

Атрибути та методи - це в основному змінні та функції, які належать до класу. Їх часто називають «членами класу».

Клас — це визначений користувачем тип даних, який ми можемо використовувати в нашій програмі, і він працює як конструктор об’єктів або «схема» для створення об’єктів.

Щоб створити клас, використовуйте ключове слово class:

class MyClass {       // Клас

  public:             // Специфікатор доступу

    int myNum;        // Атрибут (змінна int)

string myString;  // Атрибут (рядкова змінна)

}; 

Пояснений приклад

Ключове слово class використовується для створення класу під назвою MyClass.

Ключове слово public є специфікатором доступу, який визначає, що члени (атрибути та методи) класу доступні поза класом.

Усередині класу є ціла змінна myNum і рядкова змінна myString. Коли змінні оголошуються в класі, вони називаються атрибутами.

Нарешті, завершіть визначення класу крапкою з комою;

Створeння об'єкту

У C++ об’єкт створюється з класу. Ми вже створили клас під назвою MyClass, тож тепер ми можемо використовувати його для створення об’єктів.

Щоб створити об’єкт MyClass, вкажіть ім’я класу, а потім ім’я об’єкта.

Щоб отримати доступ до атрибутів класу (myNum і myString), використовуйте синтаксис крапки (.) на об’єкті:

class MyClass {       // The class

  public:             // Access specifier

    int myNum;        // Attribute (int variable)

string myString;  // Attribute (string variable)

};

int main() {

  MyClass myObj;  // Створіть об'єкт MyClass

  // Доступ до атрибутів і встановлення значень

  myObj.myNum = 15; 

  myObj.myString = "Some text";

  // Print attribute values

  cout << myObj.myNum << "\n";

  cout << myObj.myString;

  return 0;

} 

Кілька об'єктів

Ви можете створити кілька об'єктів одного класу:

// Create a Car class with some attributes

class Car {

  public:

string brand;   

string model;

    int year;

};

int main() {

  // Create an object of Car

  Car carObj1;

  carObj1.brand = "BMW";

  carObj1.model = "X5";

  carObj1.year = 1999;

  // Create another object of Car

  Car carObj2;

  carObj2.brand = "Ford";

  carObj2.model = "Mustang";

  carObj2.year = 1969;

  // Print attribute values

  cout << carObj1.brand << " " << carObj1.model << " " << carObj1.year << "\n";

  cout << carObj2.brand << " " << carObj2.model << " " << carObj2.year << "\n";

  return 0;

} 

Методи - це функції, які належать до класу.

Існує два способи визначення функцій, які належать до класу:

Внутрішнє визначення класу

Визначення поза класом

У наступному прикладі ми визначаємо функцію всередині класу та називаємо її «myMethod».

Примітка. Ви отримуєте доступ до методів так само, як і до атрибутів; шляхом створення об’єкта класу та використання синтаксису крапки (.):

class MyClass {        // The class

  public:              // Access specifier

    void myMethod() {  // Method/function defined inside the class

   cout << "Hello World!";

    }

};

int main() {

  MyClass myObj;     // Create an object of MyClass

  myObj.myMethod();  // Call the method

  return 0;

} 

Щоб визначити функцію поза визначенням класу, ви повинні оголосити її всередині класу, а потім визначити поза класом. Це робиться шляхом вказівки назви класу, після оператора дозволу області видимості::, а потім назви функції:

class MyClass {        // The class

  public:              // Access specifier

    void myMethod();   // Method/function declaration

};

// Method/function definition outside the class

void MyClass::myMethod() {

  cout << "Hello World!";

}

int main() {

  MyClass myObj;     // Create an object of MyClass

  myObj.myMethod();  // Call the method

  return 0;

} 

Параметри

Ви також можете додати параметри:

#include <iostream>

using namespace std;

class Car {

  public:

    int speed(int maxSpeed);

};

int Car::speed(int maxSpeed) {

  return maxSpeed;

}

int main() {

  Car myObj; // Create an object of Car

  cout << myObj.speed(200); // Call the method with an argument

  return 0;

} 

Конструктор у C++ — це спеціальний метод, який автоматично викликається під час створення об’єкта класу.

Щоб створити конструктор, використовуйте те ж саме ім’я, що й клас, а потім круглі дужки ():

class MyClass {     // The class

  public:           // Access specifier

MyClass() {     // Constructor

   cout << "Hello World!";

    }

};

int main() {

  MyClass myObj;    // Create an object of MyClass (this will call the constructor)

  return 0;

} 

Примітка. Конструктор має те саме ім’я, що й клас, він завжди публічний і не має жодного значення, що повертається.

Параметри конструктора

Конструктори також можуть приймати параметри (як і звичайні функції), що може бути корисним для встановлення початкових значень для атрибутів.

Наступний клас має атрибути марки, моделі та року, а також конструктор з різними параметрами. Всередині конструктора ми встановлюємо атрибути, що дорівнюють параметрам конструктора (brand=x тощо). Коли ми викликаємо конструктор (шляхом створення об’єкта класу), ми передаємо конструктору параметри, які встановлять значення відповідних атрибутів такими ж:

class Car {        // The class

  public:          // Access specifier

    string brand;  // Attribute

string model;  // Attribute

    int year;      // Attribute

Car(string x, string y, int z) { // Constructor with parameters

   brand = x;

   model = y;

      year = z;

}

};

int main() {

  // Create Car objects and call the constructor with different values

  Car carObj1("BMW", "X5", 1999);

  Car carObj2("Ford", "Mustang", 1969);

  // Print values

  cout << carObj1.brand << " " << carObj1.model << " " << carObj1.year << "\n";

  cout << carObj2.brand << " " << carObj2.model << " " << carObj2.year << "\n";

  return 0;

} 

Як і функції, конструктори також можуть бути визначені поза класом. Спочатку оголосите конструктор усередині класу, а потім визначте його за межами класу, вказавши ім’я класу, а потім оператор розділення області видимості ::, а потім ім’я конструктора (яке те саме, що й клас) :

class Car {        // The class

  public:          // Access specifier

string brand;  // Attribute

    string model;  // Attribute

    int year;      // Attribute

Car(string x, string y, int z); // Constructor declaration

};

// Constructor definition outside the class

Car::Car(string x, string y, int z) {

  brand = x;

  model = y;

  year = z;

}

int main() {

  // Create Car objects and call the constructor with different values

  Car carObj1("BMW", "X5", 1999);

  Car carObj2("Ford", "Mustang", 1969);

  // Print values

  cout << carObj1.brand << " " << carObj1.model << " " << carObj1.year << "\n";

  cout << carObj2.brand << " " << carObj2.model << " " << carObj2.year << "\n";

  return 0;

} 

Наразі ви добре знайомі з ключовим словом public, яке з’являється в усіх прикладах наших класів:

class MyClass {  // The class

  public:        // Access specifier

    // class members goes here

}; 

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

Однак що, якщо ми хочемо, щоб учасники були приватними та прихованими від зовнішнього світу?

У C++ є три специфікатори доступу:

public - учасники доступні поза класом

private - до учасників неможливо отримати доступ (або переглянути) поза класом

protected - доступ до членів поза класом неможливий, однак доступ до них можна отримати в успадкованих класах. Ви дізнаєтеся більше про спадщину пізніше.

У наступному прикладі ми демонструємо відмінності між публічними та приватними членами:

class MyClass {

  public:    // Public access specifier

    int x;   // Public attribute

  private:   // Private access specifier

    int y;   // Private attribute

};

int main() {

  MyClass myObj;

  myObj.x = 25;  // Allowed (public)

  myObj.y = 50;  // Not allowed (private)

  return 0;

} 

Якщо ви намагаєтеся отримати доступ до приватного атрибуту, виникає помилка:

Примітка. Можна отримати доступ до приватних членів класу за допомогою відкритого методу всередині того самого класу. Про те, як це зробити, див. у наступному розділі (Інкапсуляція).

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

Примітка. За замовчуванням усі члени класу є приватними, якщо ви не вкажете специфікатор доступу:

class MyClass {

  int x;   // Private attribute

  int y;   // Private attribute

}; 

Сенс інкапсуляції полягає в тому, щоб переконатися, що "конфіденційні" дані приховані від користувачів. Щоб досягти цього, ви повинні оголосити змінні/атрибути класу як приватні (до них не можна отримати доступ поза класом). Якщо ви хочете, щоб інші читали або змінювали значення приватного члена, ви можете надати загальнодоступні методи get і set.

Доступ до приватних учасників

Щоб отримати доступ до приватного атрибута, використовуйте публічні методи "get" і "set":

#include <iostream>

using namespace std;

class Employee {

  private:

    // Private attribute

    int salary;

  public:

    // Setter

    void setSalary(int s) {

   salary = s;

}

    // Getter

    int getSalary() {

      return salary;

}

};

int main() {

  Employee myObj;

  myObj.setSalary(50000);

  cout << myObj.getSalary();

  return 0;

} 

Пояснений приклад

Атрибут salary є приватним, доступ до якого обмежений.

Загальнодоступний метод setSalary() приймає параметр(и) і призначає його атрибуту salary (salary = s).

Загальнодоступний метод getSalary() повертає значення приватного атрибута salary.

Всередині main() створюємо об’єкт класу Employee. Тепер ми можемо використовувати метод setSalary(), щоб встановити значення приватного атрибута на 50000. Потім ми викликаємо метод getSalary() для об’єкта, щоб повернути значення.

Чому саме інкапсуляція?

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

Підвищена безпека даних

У C++ є можливість успадковувати атрибути та методи від одного класу до іншого. Ми групуємо «концепцію успадкування» у дві категорії:

похідний клас (child) - клас, який успадковує інший клас

базовий клас (батьківський) - клас, від якого успадковується

Щоб успадкувати від класу, використовуйте символ :.

У наведеному нижче прикладі клас Car (дочірній) успадковує атрибути та методи від класу Vehicle (батьківського):

// Base class

class Vehicle {

  public:

    string brand = "Ford";

    void honk() {

      cout << "Tuut, tuut! \n" ;

}

};

// Derived class

class Car: public Vehicle {

  public:

    string model = "Mustang";

};

int main() {

  Car myCar;

  myCar.honk();

  cout << myCar.brand + " " + myCar.model;

  return 0;

} 

Багаторівневе успадкування

Клас також може бути похідним від одного класу, який уже є похідним від іншого класу.

У наступному прикладі MyGrandChild є похідним від класу MyChild (який походить від MyClass).

// Base class (parent)

class MyClass {

  public:

    void myFunction() {

      cout << "Some content in parent class." ;

}

};

// Derived class (child)

class MyChild: public MyClass {

};

// Derived class (grandchild)

class MyGrandChild: public MyChild {

};

int main() {

  MyGrandChild myObj;

  myObj.myFunction();

  return 0;

} 

Множинне успадкування

Клас також може бути отриманий з кількох базових класів за допомогою списку, розділеного комами:

// Base class

class MyClass {

  public:

    void myFunction() {

      cout << "Some content in parent class." ;

}

};

// Another base class

class MyOtherClass {

  public:

    void myOtherFunction() {

      cout << "Some content in another class." ;

}

};

// Derived class

class MyChildClass: public MyClass, public MyOtherClass {

};

int main() {

  MyChildClass myObj;

  myObj.myFunction();

  myObj.myOtherFunction();

  return 0;

} 

Специфікатори доступу

З глави Специфікатори доступу ви дізналися, що в C++ є три специфікатори. До цього часу ми використовували лише public (члени класу доступні поза межами класу) і private (до членів можна отримати доступ лише в межах класу). Третій специфікатор, protected, схожий на private, але до нього також можна отримати доступ у успадкованому класі:

// Base class

class Employee {

  protected: // Protected access specifier

    int salary;

};

// Derived class

class Programmer: public Employee {

  public:

    int bonus;

    void setSalary(int s) {

   salary = s;

    }

    int getSalary() {

      return salary;

}

};

int main() {

  Programmer myObj;

  myObj.setSalary(50000);

  myObj.bonus = 15000;

  cout << "Salary: " << myObj.getSalary() << "\n";

  cout << "Bonus: " << myObj.bonus << "\n";

  return 0;

} 

Поліморфізм

Поліморфізм означає «багато форм», і це відбувається, коли ми маємо багато класів, пов’язаних один з одним успадкуванням.

Як ми вказали в попередньому розділі; Спадкування дозволяє нам успадковувати атрибути та методи з іншого класу. Поліморфізм використовує ці методи для виконання різних завдань. Це дозволяє нам виконувати одну дію різними способами.

Наприклад, подумайте про базовий клас під назвою Animal, який має метод під назвою animalSound(). Похідними класами Тварин можуть бути Свині, Кішки, Собаки, Птахи – і вони також мають власну реалізацію звуку тварин (свиня хрюкає, а кіт нявкає тощо):

// Base class

class Animal {

  public:

    void animalSound() {

   cout << "The animal makes a sound \n";

}

};

// Derived class

class Pig : public Animal {

  public:

    void animalSound() {

   cout << "The pig says: wee wee \n";