Основы программирования на языке с++. Часть 3

Hello, SSU!

[По русскому - "3", ни слова, про логистику, грамматику, порядок изложения, пунктуацию и т.д.]

Тут можно узнать немного полезной информации, если ты только начал(-a) кодить.

Оглавление
1)Изменение цвета консоли.
2) Макросы
    2.1 Макросы без параметров
    2.2 Макросы с параметрами
    2.3 Стоит ли использовать макросы
3) Функции
    3.1) Функции возвращающие значение
    3.2) Функции не возвращающие значение
    3.3) Передача массива в функцию
    3.4) HIDE
4) Область видимости переменной. Глобальные переменные. Константы
5) Рекурсия. Рекурсивные функции
6) HIDE
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#1 - Изменение цвета консоли.

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Итак, первый лайфхак(нет) связан с цветом консольного окна.

Чтобы изменить цвет шрифта и/или консольного окна нужно
    - создать константу int с любым именем и задать ей значение = system("color XY"), где
        X - Номер цвета для фона консольного окна
        Y - Номер цвета для текста в консольном окне
        номера заданы в 16-й системе счисления :
                Black         = 0,(Черный)
                Blue          = 1,(Голубой)
                Green         = 2,(Зеленый)
                Cyan          = 3,(Бирюзовый)
                Red           = 4,(Красный)
                Magenta       = 5,(Пурпурный)
                Brown         = 6,(Коричневый; бурый)
                LightGray     = 7,(Светло серый)
                DarkGray      = 8,(Темно серый)
                LightBlue     = 9,(Светло Голубой)
                LightGreen    = a,(Светло Зеленый)
                LightCyan     = b,(Светло Бирюзовый)
                LightRed      = c,(Светло Красный)
                LightMagenta  = d,(Светло Пурпурный)
                Yellow        = e,(Желтый)
                Bright White  = f,(Ярко - Белый)
|--------------------------|
|    пример программы      |
|--------------------------|
    #include<iostream>
    using namespace std;
    const int ANY_NAME = system("color 80");
    int main()
    {
       cout << "Hello, SSU !!!";
    }
|--------------------------|
|      Конец примера       |
|--------------------------|
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#2 - Макросы( "дефайн"-ы )

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Макросы  - это функция, созданная с помощью директивы #difine
После директивы #define указывается имя макроса, за которым в скобках (без пробелов) параметры, если таковые нужны,
отделенные запятыми и определение макроса(в дальнейшем - Тело), отделенное пробелом.

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
# 2.2 - Макросы без параметров(Англ. "function-like macro")
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Общий вид(условно): #define Имя Тело
Простыми словами, если есть
    #defind X Y
    ,то все встреченные в программе
    X заменяются на Y
|------------------------------|
|Примеры макросов без параметра|
|------------------------------|
...
#define fs first
#defind sc second
#define ret return
#define sz size()
#define len length()
...
|------------------------------|
|        Конец примеров        |
|------------------------------|

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#2.2 - Макросы с параметрами (Англ. " object-like macro ")
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Общий вид(условно):
    #define имя(аргументы через запятую) тело
    -ВСЕ параметры, которые вы используете теле нужно указывать в скобках,
         т.к. в некоторых случаях, это может привести к появлению багов
    -Советую использовать приведение типов
        type(<variable_name>) перед переменными в теле, где type - тип, который вы предполагаете для параметра

|------------------------------|
|Примеры макросов c параметрами|
|------------------------------|
#include<iostream>
#include<algorithm>

using namespace std;

#define forn(i, n) for(int i = 0; i < int(n); i++)
// макрос на цикл от 0 до n с шагом в 1

#define forab(i, a, b) for (int i = int(a); i <= int(b); i++)
// макрос на цикл с a до b с шагом в 1

#define sqr(x) (int(x) * int(x))
// макрос для нахождения квадрата целого числа

#define all(a) (a).begin(), (a).end()
// заменяет выражение (a).begin(), (a).end()
int main()
{
    forn(k, 10)
        cout << sqr(k) << endl;
    string s = "abs";
    reverse(all(s));
    cout << s;
}

|------------------------------|
|        Конец примеров        |
|------------------------------|


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#2.3 -  Стоит ли использовать макросы
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//////////////
Кратко - Да.
//////////////


//////////////
Сжато:
Многие считают макросы вредными для программы, на это есть множество обоснованных причин.
    1)Макросы нельзя отлаживать
        (в режиме отладки вы не зайдете в директиву define, что лишает вас возможности проверить правильность работы макроса)
    2)При разворачивании макроса могут появиться странные побочные эффекты
    3)Макросы не имеют пространства имен
    4)Макросы могут делать что-то, о чем вы не подозреваете
Но все эти "минусы" можно исправить(смотри подробную версию), а плюсы которые дают нам макросы очевидны :
- Упрощенное чтение/понимание кода
- Меньшее количество ляпов:
    когда вы, например, пишите for (int i = n; i > 0; i++) и у вас получается бесконечный цикл
- Скорость :
    написать forn(i,n) куда быстрее, чем for (int i = n; i > 0; i++)
//////////////


//////////////
Подробно: читай статью ---> https://habr.com/post/246971/

//////////////

/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#3 - Функции.

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Функция - это такая конструкция, которая позволяет вынести повторяющийся участок кода за main()

Общий вид функции:

Тип_возвращаемого_значения имя_функции(аргументы)
{
    программный код(Тело функции)
}

аргументы нужно указывать через запятую, каждый раз указывая тип переменной.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#3.1 - Функции возвращающие значение
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    Разберем конкретный пример
-------------------------------------------------------------
    #include<iostream>

    using namespace std;

    int sum(int a, int b)// объявляем функцию sum, которая возвращает значение типа int, принимая 2 аргумента типа int
    {
        return a + b;    // возвращаем значение
    }

    int main()          //Объявляем функцию main, которая не принимает аргументы.
    {
        int first, second;
        cin >> first >> second;
        int result = sum(first, second);
        // объявляем новую переменную результата, которой присвоим значение функции.
        cout << result << endl;
        if (result == sum(first, second)) // функцию можно вызывать в условных операторах
            cout << sum (first, second);
            // значение функции можно выводить
        int pause;cin >> pause;
        return 0;
        // возвращаем значение "0" для функции main()
    }
-----------------------------------------------------------
    В данном примере мы имеем 2 функции возвращающие значение:
        1) "sum" с аргументами (int, int)
        2) "main" без аргументов.
    Заметим, что аргументы функции sum отличаются от тех, которые мы передаем ей в main_e :"sum(first, second)"
    Переменные, которые мы передаем в функцию называются "фактическими", а те, что мы используем в функции - "формальными".
    Очевидно, что функция может не принимать значение. Проанализируйте след. Пример.
----------------------------------------------------------
    #include<iostream>
    using namespace std;

    int sum(int x, int y)
    {
        return x + y;
    }

    int ReadInt()
    {
        int n;
        cin >> n;
        return n;
    }

    int main()
    {
        cout << sum(ReadInt(), ReadInt());
        int pause; cin >> pause;
        return 0;
    }

-------------------------------------------------------------
Ф-я ReadInt()  не принимает значения, она вызывается в вызове ф-и sum(int, int)

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
# 3.2  - Функции не возвращающие значение
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Функция, которая не возвращает никакого значение, имеет вид:

void Имя_функции(аргументы)
{
    программный код(Тело функции)
}

Рассмотрим примеры нескольких функций типа void
-------------------------------------------------------------
#include<iostream>
using namespace std;

void DeBug()// Функция предназначена для отладки программы.
{
    cout << "I was here\n";
}
void SWAP(int &a, int &b)
/*
                        !!!!!!!!!!ВАЖНЫЙ МОМЕНТ!!!!!!!!!!
'a' и 'b' передаются по ссылке, изменив значение этих формальных переменных в
функции SWAP, изменятся и фактические аргументы, от которых была вызвана функция.
*/
{
    int temp = a;
    a = b;
    b = temp;
    DeBug();//если программа дойдет до этого места, то она выведет сообщение об этом.
}
void my_print(const int &x, const int &y)
/*
 Так же можно фиксировать значение переменной. В этом случае значение
 'x' и 'y' изменить невозможно(в данной функции)
*/
{
    cout << x << ' ' << y << endl;
}

int main() // Да, можно писать void main(), но делать этого не стоит.
{
    int x, y;
    cin >> x >> y;
    SWAP(x, y);     // меняем местами 2 переменные
    my_print(x, y); // выводим их значение
    int pause;cin >> pause;
    return 0;
}
-------------------------------------------------------------
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
# 3.3  - Передача массива в функцию
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Массив - это указатель, поэтому если изменить формальную переменную, то изменится и фактическая.
-------------------------------------------------------------
#include<iostream>
using namespace std;

void Fill(int* a, int n)// массив - это указатель на тип,
{
    for (int i = 0; i < n; ++i)
        cin >> a[i];
}
void Print(int a[], int n)// еще 1 способ передачи массива в функцию
{
    for (int i = 0; i < n; ++i)
        cout << a[i] << ' ';
}
int main()
{
    int * a = new int[5];
    Fill(a, 5);
    Print(a, 5);
    return 0;
}
-------------------------------------------------------------
ДИНАМИЧЕСКИЙ МАССИВ
-------------------------------------------------------------
#include<iostream>
using namespace std;

void create(int* a, int n)
/* Чтобы программа заработала, нужно заменить
void create(int* a, int n) ---> void create(int* &a, int n)
*/
{
    a = new int[n];
    for (int i = 0; i < n;++i)
        a[i] = rand() % 10;
/*rand() - генератор чисел. берем по модулю, чтобы числа не превышали "9" */
    cout << "I create : \n";
    for (int i = 0; i < n; ++i)
       cout << a[i] << ' ';
    cout << "\n";
}
void Print(int* a, int n)
{
    cout << "But found :\n";
    for (int i = 0; i < n; ++i)
        cout << a[i] << ' ';
}
int main()
{
    int* a;
    int n;
    cin >> n;
    create(a, n);
    Print(a, n);
}
-------------------------------------------------------------

/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#4 - Область видимости переменной. Глобальные переменные. Константы

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Область видимости переменной - это область на которой она определена, существует и к ней можно обратиться.
 На начальном этапе можно представить, что переменная действительна только с момента ее объявления до конца
 {}, в которых она была объявлена.
-------------------------------------------------------------
#include<iostream>
using namespace std;
int main()
{
...
    int i = 0;//область видимости - функция main, начиная с этой строки.
    while(i < 10)
    {//  (1)
        int c // область видимости - от (1) до (2)
        c = i * i;
        cout << c << "\n";
        i++;
    }// (2)
...
}
-------------------------------------------------------------
Заметим, что грамотная расстановка фигурных скобочек упрощает чтение кода. Например, намного
проще определить область видимости той или иной переменной.

/*
Хороший программист, по-моему мнению, должен минимизировать область видимости всех переменных.
*/

Заметим, что в цикле for ()нет никаких {}, однако переменные ,объявленные в нем, определены лишь до конца цикла.
-------------------------------------------------------------
#include<iostream>
using namespace std;
int main()
{
    for(int i = 0, k = 1; i < 10; ++i, k ^= 1)
    // k ^= 1 <=> k = k ^ 1 - исключающее или.
        {
            cout << i << '\t' << k << '\n';
        }
    // в этом месте переменные i & k не определены.
}
-------------------------------------------------------------
Ещё одно очень важное понятие - глобальная переменная.
Это такая переменная, которая имеет максимально возможную область видимости - вся программа.
Из-за особенностей хранения глобальных переменных они изначально инициализированы и равны "0", что даёт ряд преимуществ.
Р/м примеры использования глобальных переменных
-------------------------------------------------------------
Задача: дан набор из n чисел, найти самое часто встречающиеся
число. Если ответов несколько - вывести любой из них.
-------------------------------------------------------------
#include<iostream>

using namespace std;

int cnt[100];

int main()
{
    int n;
    cin >> n;
    int answer = 0;
    for (int i = 0; i < n; ++i)
    {
        int cur;
        cin >> cur;
        cnt[cur]++;
        if (cnt[cur] > cnt[answer])
            answer = cur;
    }
    cout << answer;

}
-------------------------------------------------------------
Задача: написать функцию чтения и вывода массива.
Как я и говорил, нужно минимизировать область видимости, но
знать такую особенность вы должны.
-------------------------------------------------------------
#include<iostream>
using namespace std;

int n;
int* a;

void READ()
{
    for (int i = 0; i < n; ++i)
        cin >> a[i];
}
void PRINT()
{
    for (int i = 0; i < n; ++i)
        cout << a[i] << ' ';
}
int main()
{
    cin >> n;
    a = new int[n];
    READ();
    PPRINT();
}
-------------------------------------------------------------
Константы - это переменные с фиксированным значением. Обычно константам дают имя, содержащее исключительно заглавные буквы, цифры и знаки подчеркивания, чтобы в дальнейшем понимать, что используемая переменная неизменна.
-------------------------------------------------------------
...
#include<math.h>
...
const double PI = acos(-1.0);
const double TAU = 2 * PI;
const int MOD = 1e8;//используется приведение типа, 1e8 -> int(10^8)
...
Так же можно передавать переменные в функцию с припиской
"const", что не даёт программисту права менять ее в процессе. Это особенно важно при передачи параметров по ссылке
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#5 - Рекурсия. Рекурсивные функции

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Рекурсия - это вызов программы(функции) самой себя
У рекурсии обязательно должно быть условие выхода из нее, иначе возникнет ошибка переполнения стека.

Пример /*плохой*/ рекурсии
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void bad()
{
    bad();
}
int main()
{
    bad();
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Рассмотрим примеры рабочих рекурсий
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include<iostream>
using namespace std;

void Hello_World_N(int n)
{
    if (n <= 0) return;//условие выхода из функции
    Hello_World_N(n - 1);
     cout << n << "  -  Hello, world!\n";
}
int ToZero(int c)
{
    if (c <= 0)
        return 0;
    cout << c << endl;
    return ToZero(c - 1);
}

int main()
{
    Hello_World_N(3);
    ToZero(3);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*
вывод программы:
--------------------
1  -  Hello, world!
2  -  Hello, world!
3  -  Hello, world!
3
2
1
--------------------
Заметим, что в первом случае прямой порядок, а во втором - обратный.
Рекурсия сначала доходит до самого ее последнего вызова(т.е. условия выхода) и возвращается к первому через стек.
Если вам не понятен этот момент, то запустите эту программу в режиме отладки с точками останова внутри функций.

*/
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Примеры полезных рекурсивных функций
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include<iostream>
using namespace std;

int my_gcd(int a, int b)// поиск НОД
{
    if (a == 0)
        return b;
    else
        return my_gcd(b % a, a);
}

 int fib(int n)//N-е число Фибоначчи
 {
     if (n == 1 || n == 2)
         return 1;
     if (n == 0)
         return 0;
    return fib(n - 1) + fib(n - 2);
 }

 double pow(double base, int exp)//возведение в степень(epx >= 0)
 {
     if (exp == 0)return 1;
     if (exp == 1)return base;
     return base * pow(base, exp - 1);
 }

 int fact(int n)//факториал числа N
 {
     if (n == 0) return 0;
     if (n == 1) return 1;
     return n * fact(n - 1);
 }

int main()
{
    cout << "gcd : " << my_gcd(60, 12) << endl;
    cout << fib(6) << endl;
    cout << pow(2, 4) << endl;
    cout << fact(5);
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
pow(double, int)
Если степень = 0, то функция должна вернуть 1, по определению.
Если степень = 1, то нужно вернуть само число,
Ну и во всех остальных случаях - умножить основание на функцию от этого же основания, но в степени на единицу меньше.

2 ^ 4 =
pow(2, 4) = 2 * pow(2, 3)
pow(2, 3) = 2 * pow(2, 2)
pow(2, 2) = 2 * pow(2, 1)
pow(2, 1) = 2;

 2,4
  |  * 2
 2,3
  |  * 2
 2,2
  |  * 2
 2,1 = 2

--------------------------------------------------
*Взято с ru.stackoverflow.com*

Рекурсивный вызов функции fib(6) можно представить следующим образом

fib( 6 ) = fib( 5 ) + fib( 4 )
fib( 5 ) = fib( 4 ) + fib( 3 )
fib( 4 ) = fib( 3 ) + fib( 2 )
fib( 3 ) = fib( 2 ) + fib( 1 )
fib( 2 ) = fib( 1 ) + fib( 0 )
fib( 1 ) = 1
fib( 0 ) = 0
Или можно представить в виде дерева, где листья будут вызовами для функции с аргументами 0 или 1, так как эти вызовы более не вызывают функцию рекурсивно

                                       6
                  ------------------------------------------
                 |                                          |
                 4                     +                    5
        -------------------                        -------------------
       |                   |                      |                   |
       2         +         3                      3        +          4
   ---------           ---------              ---------           ---------
  |         |         |         |            |         |          |        |
  0    +    1         1    +    2            1   +     2          2   +    3
                              -----                  -----      -----    -----
                             |     |                |     |    |     |  |     |
                             0  +  1                0  +  1    0  +  1  1  +  2
                                                                            -----
                                                                           |     |
                                                                           0  +  1
/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/



....to be continued
[Массивы]
[Функции](will upd)
[Рекурсия]+
[Манипуляторы](hate)
[Асимптотическое время работы программы O(?)]



---------------Change Log---------------
20.12.18 - косметические фиксы
21.12.18 - add (3; 3.1; 3.2)
21.12.18 - косметические фиксы
22.12.18 - add (3.3; 4)
23.12.18 - add (5)