Разбор программы

#include<iostream>
using namespace std;
 
void func1();
void func2();
 
int f;
 
int main()
{
    int i;
 
    for(i=0; i<10; i++)
    {
        f = i*2; 
        func1();                     \\Строчка
    }
    
    return 0;
}
 
void func1()
{
    cout << "f: " << f;
    cout << '\n';
    func2();                 \\Строчка
}
 
void func2()
{
    int f;
    for(f = 0; f < 3; f++)
        cout<< '.';
        system("pause");
}

#include<iostream>
using namespace std;  //включаем старый тип данных для того что бы работал
//потоковый вывод cout
 
void func1(); //2 прототипа функции т.к. если их не указать main() их не увидит 
void func2();//т.к. они расположенны ниже него
 
int f;  // глобальная переменная
 
int main()
{
    int i;  // локальная переменная
 
    for(i=0; i<10; i++)  // цикл
    {
        f = i*2;   // умножение на 2 
        func1();                     // вызов функции идет сюда =>>>
    }
    
    return 0;  // возвращаемое значение символизирует выход из программы
}
 
void func1()  // <========вот сюда
{
    cout << "f: " << f;  // вывод f
    cout << '\n';   // символ перехода стоки
    func2();                //вызывается функция 2 идет сюда ==>
}
 
void func2() // <== вот сюда
{
    int f;  // при объявлении локальной переменной в функции она существует только в данной функции
// хотя раз она объявленна как глобальная (такое же имя) не рекомендуется создавать такую же локальную
    for(f = 0; f < 3; f++)
        cout<< '.';  // цикл на вывод точки
        system("pause");  // системная пауза (ожидает какого нить щелчка для продолжения сделано что бы ты увидел результат)
}

using namespace std;

#include <iostream>     // подключаем заголовочный файл iostream для того,
                        // чтобы можно было использовать объект cout
 
using namespace std;    // подключаем пространство имён std
 
//объявление функции func1():
void func1();   // прототип функции func1()
/*
Прототип нужен для компилятора, чтобы он (компилятор) знал, сколько аргументов
будет передано в функцию (в нашем случае ни одного) и  какого типа будут эти
аргументы, каков будет тип возвращаемого значения (в нашем случае void).
void (англ.) - "пустой".
*/
 
//объявление функции func2():
void func2();   // прототип функции func1()
 
int f;  // глобальная переменная целочисленного типа (int - от англ. "integer")
 
int main()  // главная функция (тип возвращаемого значения int)
{   // открывающая фигурная скобка (начало тела функции main)
    
    int i;  // объявление переменной целочисленного типа
 
    // цикл for:
    for(i = 0; i < 10; i++) // переменная i используется в качестве счётчика
    {   // начало тела цикла for
        f = i * 2;  // инициализация переменной (присвоение значения)
        func1();    // вызов функции func1()                   
    }   // конец тела цикла for
/*
Перед выполнением цикла счётчику (переменной i) присваивается значение 0
(счётчик обнуляется). На каждой итерации (на каждом витке) цикла проверяется
условие i < 10. Если условие истинно, то цикл продолжается, иначе цикл
прекращается. После каждого витка счётчик инкрементируется (увеличивается на 1).
*/    
    return 0;   // оператор return возвращает операционной системе значение 0
                // (признак того, что программа отработала без ошибок)
    
}   // закрывающая фигурная скобка (конец тела функции main)
 
void func1()    // определение (реализация) функции func1
{   // начало тела функции func1
    cout << "f: " << f; // с помощью объекта cout выводим на консоль строковый
                        // литерал (то, что в кавычках) и значение глобальной
                        // переменной f
    cout << '\n';   // управляющая последовательность \n - специальная хреновина,
                    // позволяющая перевести курсор на новую строку
    
    func2();    //   вызов функции func2() 
    
}   // конец тела функции func1
 
void func2()    // определение (реализация) функции func2
{   // начало тела функции func2
    int f;  // объявление локальной переменной целочисленного типа
/*
Теперь в функции func2 будет своя (локальная) переменная int f, а глобальная
переменная int f, которая была объявлена в 18 строке кода, будет скрыта (для
функции func2 глобальная f как бы перестанет существовать, потому что локальная
f её собой скроет).
*/
    
    // цикл for:
    for(f = 0; f < 3; f++)
        cout << '.';
/*
Здесь у цикла for нет фигурных скобок - телом цикла является один единственный
оператор - cout << '.';
Этот же цикл можно было бы записать и с фигурными скобками (смысл останется
тот же самый):
 
    for(f = 0; f < 3; f++)
    {
        cout << '.';
    }
 
*/    
 
    system("pause");    // отправка системе команды pause (чтобы окно консоли
                        // не закрылось сразу же по завершении программы и
                        // пользователь смог прочитать то, что было выведено
                        // на экран
    
}   // конец тела функции func2