Локальные переменные, область видимости и продолжительность жизни в C++ / Ravesli

Урок №48. Локальные переменные, область видимости и продолжительность жизни

Обновл. 13 Сен 2021 |

71291

ǀ 29

Этот материал является продолжением урока №15.

Оглавление:

Область видимости и продолжительность жизни
Сокрытие имен
Область видимости переменных
Параметры функций
Заключение
Тест

Область видимости и продолжительность жизни

Прежде чем мы начнем, нам нужно сначала разобраться с двумя терминами: область видимости и продолжительность жизни. Область видимости определяет, где можно использовать переменную. Продолжительность жизни (или «время жизни») определяет, где переменная создается и где уничтожается. Эти две концепции связаны между собой.

Переменные, определенные внутри блока, называются локальными переменными. Локальные переменные имеют автоматическую продолжительность жизни: они создаются (и инициализируются, если необходимо) в точке определения и уничтожаются при выходе из блока. Локальные переменные имеют локальную область видимости (или «блочную»), т.е. они входят в область видимости с точки объявления и выходят в самом конце блока, в котором определены.

Например, рассмотрим следующую программу:

#include <iostream>

int main()
{
    int x(4); // переменная x создается и инициализируется здесь 
    double y(5.0); // переменная y создается и инициализируется здесь
 
    return 0;
 
} // x и y выходят из области видимости и уничтожаются здесь

#include <iostream>

int main()

{

int x(4); // переменная x создается и инициализируется здесь

double y(5.0); // переменная y создается и инициализируется здесь

return 0;

} // x и y выходят из области видимости и уничтожаются здесь

Поскольку переменные x и y определены внутри блока, который является главной функцией, то они обе уничтожаются, когда main() завершает свое выполнение.

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

#include <iostream>

int main() // внешний блок
{
    int m(4); // переменная m создается и инициализируется здесь 
 
    { // начало вложенного блока 
        double k(5.0); // переменная k создается и инициализируется здесь
    } // k выходит из области видимости и уничтожается здесь 
 
    // Переменная k не может быть использована здесь, так как она уже уничтожена!
 
    return 0;
} // переменная m выходит из области видимости и уничтожается здесь

#include <iostream>

int main() // внешний блок

{

int m(4); // переменная m создается и инициализируется здесь

{ // начало вложенного блока

double k(5.0); // переменная k создается и инициализируется здесь

} // k выходит из области видимости и уничтожается здесь

// Переменная k не может быть использована здесь, так как она уже уничтожена!

return 0;

} // переменная m выходит из области видимости и уничтожается здесь

Такие переменные можно использовать только внутри блоков, в которых они определены. Поскольку каждая функция имеет свой собственный блок, то переменные из одной функции никак не соприкасаются и не влияют на переменные из другой функции:

#include <iostream>

void someFunction()
{
    int value(5); // value определяется здесь
 
    // value можно использовать здесь 
 
} // value выходит из области видимости и уничтожается здесь 
 
int main()
{
    // value нельзя использовать внутри этой функции 
 
    someFunction();
 
    // value здесь также нельзя использовать
 
    return 0;
}

#include <iostream>

void someFunction()

{

int value(5); // value определяется здесь

// value можно использовать здесь

} // value выходит из области видимости и уничтожается здесь

int main()

{

// value нельзя использовать внутри этой функции

someFunction();

// value здесь также нельзя использовать

return 0;

}

В разных функциях могут находиться переменные или параметры с одинаковыми именами. Это хорошо, потому что не нужно беспокоиться о возможности возникновения конфликтов имен между двумя независимыми функциями. В примере, приведенном ниже, в обеих функциях есть переменные x и y. Они даже не подозревают о существовании друг друга:

#include <iostream>
 
// Параметр x можно использовать только внутри функции add() 
int add(int x, int y) // параметр x функции add() создается здесь
{
    return x + y;
} // параметр x функции add() уничтожается здесь
 
// Переменную x функции main() можно использовать только внутри функции main() 
int main()
{
    int x = 5; // переменная x функции main() создается здесь
    int y = 6;
    std::cout << add(x, y) << std::endl; // значение x функции main() копируется в переменную x функции add()
    return 0;
} // переменная x функции main() уничтожается здесь

#include <iostream>

// Параметр x можно использовать только внутри функции add()

int add(int x, int y) // параметр x функции add() создается здесь

{

return x + y;

} // параметр x функции add() уничтожается здесь

// Переменную x функции main() можно использовать только внутри функции main()

int main()

{

int x = 5; // переменная x функции main() создается здесь

int y = 6;

std::cout << add(x, y) << std::endl; // значение x функции main() копируется в переменную x функции add()

return 0;

} // переменная x функции main() уничтожается здесь

Вложенные блоки считаются частью внешнего блока, в котором они определены. Следовательно, переменные, определенные во внешнем блоке, могут быть видны и внутри вложенного блока:

#include <iostream>

int main()
{ // начало внешнего блока 
 
    int x(5);
 
    { // начало вложенного блока 
        int y(7);
        // Мы можем использовать x и y здесь
        std::cout << x << " + " << y << " = " << x + y;
    } // переменная y уничтожается здесь
 
    // Переменную y здесь нельзя использовать, поскольку она уже уничтожена!
 
    return 0;
} // переменная x уничтожается здесь

#include <iostream>

int main()

{ // начало внешнего блока

int x(5);

{ // начало вложенного блока

int y(7);

// Мы можем использовать x и y здесь

std::cout << x << " + " << y << " = " << x + y;

} // переменная y уничтожается здесь

// Переменную y здесь нельзя использовать, поскольку она уже уничтожена!

return 0;

} // переменная x уничтожается здесь

Сокрытие имен

Переменная внутри вложенного блока может иметь то же имя, что и переменная внутри внешнего блока. Когда подобное случается, то переменная во вложенном (внутреннем) блоке «скрывает» внешнюю переменную. Это называется сокрытием имен:

#include <iostream>

int main()
{ // внешний блок
	int oranges(5); // внешняя переменная oranges

	if (oranges >= 5) // относится к внешней oranges
	{ // вложенный блок
		int oranges; // скрывается внешняя переменная oranges

		// Идентификатор oranges теперь относится к вложенной переменной oranges.
		// Внешняя переменная oranges временно скрыта

		oranges = 10; // здесь мы присваиваем значение 10 вложенной переменной oranges, не внешней!

		std::cout << oranges << std::endl; // выводим значение вложенной переменной oranges
	} // вложенная переменная oranges уничтожается

	// Идентификатор oranges опять относится к внешней переменной oranges

	std::cout << oranges << std::endl; // выводим значение внешней переменной oranges

	return 0;
} // внешняя переменная oranges уничтожается

#include <iostream>

int main()

{ // внешний блок

int oranges(5); // внешняя переменная oranges

if (oranges >= 5) // относится к внешней oranges

{ // вложенный блок

int oranges; // скрывается внешняя переменная oranges

// Идентификатор oranges теперь относится к вложенной переменной oranges.

// Внешняя переменная oranges временно скрыта

oranges = 10; // здесь мы присваиваем значение 10 вложенной переменной oranges, не внешней!

std::cout << oranges << std::endl; // выводим значение вложенной переменной oranges

} // вложенная переменная oranges уничтожается

// Идентификатор oranges опять относится к внешней переменной oranges

std::cout << oranges << std::endl; // выводим значение внешней переменной oranges

return 0;

} // внешняя переменная oranges уничтожается

Результат выполнения программы:

10 5

Здесь мы сначала объявляем переменную oranges во внешнем блоке. Затем объявляем вторую переменную oranges, но уже во вложенном (внутреннем) блоке. Когда мы присваиваем oranges значение 10, то оно относится к переменной во вложенном блоке. После вывода этого значения (и окончания внутреннего блока), внутренняя переменная oranges уничтожается, оставляя внешнюю oranges с исходным значением (5), которое затем выводится. Результат выполнения программы был бы тот же, даже если бы мы назвали вложенную переменную по-другому (например, nbOranges).

Обратите внимание, если бы мы не определили вложенную переменную oranges, то идентификатор oranges относился бы к внешней переменной и значение 10 было бы присвоено внешней переменной:

#include <iostream>
 
int main()
{ // внешний блок 
    int oranges(5); // внешняя переменная oranges 
 
    if (oranges >= 5) // относится к внешней переменной oranges 
    { // вложенный блок 
        // Никакого определения внутренней переменной oranges здесь нет
 
        oranges = 10; // это применяется к внешней переменной oranges, хоть мы и находимся во вложенном блоке
 
        std::cout << oranges << std::endl; // выводим значение внешней переменной oranges 
    } // значением переменной oranges будет 10 даже после того, как мы выйдем из вложенного блока
 
    std::cout << oranges << std::endl; // выводим значение переменной oranges 
 
    return 0;
} // переменная oranges уничтожается

#include <iostream>

int main()

{ // внешний блок

int oranges(5); // внешняя переменная oranges

if (oranges >= 5) // относится к внешней переменной oranges

{ // вложенный блок

// Никакого определения внутренней переменной oranges здесь нет

oranges = 10; // это применяется к внешней переменной oranges, хоть мы и находимся во вложенном блоке

std::cout << oranges << std::endl; // выводим значение внешней переменной oranges

} // значением переменной oranges будет 10 даже после того, как мы выйдем из вложенного блока

std::cout << oranges << std::endl; // выводим значение переменной oranges

return 0;

} // переменная oranges уничтожается

Результат выполнения программы:

10 10

В обоих примерах на внешнюю переменную oranges никак не влияет то, что происходит с вложенной переменной oranges. Единственное различие между двумя программами — это то, к чему применяется выражение oranges = 10.

Сокрытие имен — это то, чего, как правило, следует избегать, поскольку оно может быть довольно запутанным!

Правило: Избегайте использования вложенных переменных с именами, идентичными именам внешних переменных.

Область видимости переменных

Переменные должны определяться в максимально ограниченной области видимости. Например, если переменная используется только внутри вложенного блока, то она и должна быть определена в нем:

#include <iostream>
 
int main()
{
    // Не определяйте x здесь
 
    {
        // Переменная x используется только внутри этого блока, поэтому определяем её здесь 
        int x(7);
        std::cout << x;
    }
 
    // В противном случае, переменная x может быть использована и здесь
 
    return 0;
}

#include <iostream>

int main()

{

// Не определяйте x здесь

{

// Переменная x используется только внутри этого блока, поэтому определяем её здесь

int x(7);

std::cout << x;

}

// В противном случае, переменная x может быть использована и здесь

return 0;

}

Ограничивая область видимости, мы уменьшаем сложность программы, поскольку число активных переменных уменьшается. Таким образом, легче увидеть, где какие переменные используются. Переменная, определенная внутри блока, может использоваться только внутри этого же блока (или вложенных в него подблоков). Этим мы упрощаем понимание и логику программы.

Если во внешнем блоке нужна переменная, то её необходимо объявлять во внешнем блоке:

#include <iostream>
 
int main()
{
    int y(5); // мы объявляем переменную y здесь, потому что она нам будет нужна как во внутреннем, так и во внешнем блоке чуть позже
 
    {
        int x;
        std::cin >> x;
        // Если бы мы объявили y здесь, непосредственно перед её первым фактическим использованием,
        if (x == 4)
            y = 4;
    } // то она бы уничтожилась здесь
 
    std::cout << y; // а переменная y нам нужна еще здесь 
 
    return 0;
}

#include <iostream>

int main()

{

int y(5); // мы объявляем переменную y здесь, потому что она нам будет нужна как во внутреннем, так и во внешнем блоке чуть позже

{

int x;

std::cin >> x;

// Если бы мы объявили y здесь, непосредственно перед её первым фактическим использованием,

if (x == 4)

y = 4;

} // то она бы уничтожилась здесь

std::cout << y; // а переменная y нам нужна еще здесь

return 0;

}

Это один из тех редких случаев, когда вам может понадобиться объявить переменную до её первого использования.

Правило: Определяйте переменные в наиболее ограниченной области видимости.

Параметры функций

Хотя параметры функций не определяются внутри основного блока (тела) функции, в большинстве случаев они имеют локальную область видимости:

int max(int x, int y) // x и y определяются здесь
{
    // Присваиваем большее из значений (x или y) переменной max
    int max = (x > y) ? x : y; // max определяется здесь
    return max;
} // x, y и max уничтожаются здесь

int max(int x, int y) // x и y определяются здесь

{

// Присваиваем большее из значений (x или y) переменной max

int max = (x > y) ? x : y; // max определяется здесь

return max;

} // x, y и max уничтожаются здесь

Заключение

Переменные, определенные внутри блоков, называются локальными переменными. Они доступны только внутри блока, в котором определены (включая вложенные блоки) и уничтожаются при завершении этого же блока.

Определяйте переменные в наиболее ограниченной области видимости. Если переменная используется только внутри вложенного блока, то и определять её следует внутри этого же вложенного блока.

Тест

Задание №1

Напишите программу, которая просит пользователя ввести два целых числа: второе должно быть больше первого. Если пользователь введет второе число меньше первого, то используйте блок и временную переменную, чтобы поменять местами пользовательские числа. Затем выведите значения этих переменных. Добавьте в свой код комментарии, объясняющие, где и какая переменная уничтожается.

Результат выполнения программы должен быть примерно следующим:

Введите число: 4 Введите большее число: 2 Меняем значения местами Меньшее число: 2 Большее число: 4

Подсказка: Чтобы использовать кириллицу, добавьте следующую строчку кода в самое начало функции main():

setlocale(LC_ALL, "rus");

1	setlocale(LC_ALL, "rus");

Ответ №1

#include <iostream>
 
int main()
{
    // Используем кириллицу
    setlocale(LC_ALL, "rus");

    std::cout << "Введите число: ";
    int smaller;
    std::cin >> smaller;
 
    std::cout << "Введите большее число: ";
    int larger;
    std::cin >> larger;
 
    // Если пользователь ввел числа не так, как нужно
    if (smaller > larger)
    {
        // То меняем местами эти значения 
        std::cout << "Меняем значения местами\n";
 
        int temp = larger;
        larger = smaller;
        smaller = temp;
    } // temp уничтожается здесь
 
    std::cout << "Меньшее число: " << smaller << "\n";
    std::cout << "Большее число: " << larger << "\n";
 
    return 0;
} // smaller и larger уничтожаются здесь

#include <iostream>

int main()

{

// Используем кириллицу

setlocale(LC_ALL, "rus");

std::cout << "Введите число: ";

int smaller;

std::cin >> smaller;

std::cout << "Введите большее число: ";

int larger;

std::cin >> larger;

// Если пользователь ввел числа не так, как нужно

if (smaller > larger)

{

// То меняем местами эти значения

std::cout << "Меняем значения местами\n";

int temp = larger;

larger = smaller;

smaller = temp;

} // temp уничтожается здесь

std::cout << "Меньшее число: " << smaller << "\n";

std::cout << "Большее число: " << larger << "\n";

return 0;

} // smaller и larger уничтожаются здесь

Задание №2

В чём разница между областью видимости и продолжительностью жизни переменной? Какую область видимости и продолжительность жизни по умолчанию имеют локальные переменные (и что это значит)?

Ответ №2

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

Локальные переменные имеют локальную (блочную) область видимости, доступ к ним осуществляется только внутри блока, в котором они определены.

Локальные переменные имеют автоматическую продолжительность жизни, что означает, что они создаются в точке определения и уничтожаются в конце блока, в котором определены.

Оценить статью:

(462 оценок, среднее: 4,94 из 5)

Загрузка...

Комментариев: 29

ОЛЕГ-777:

14 февраля 2021 в 03:29

Конечно это не по теме урока, но просто тянется рука использовать условный тернарный оператор, который мы уже прошли в уроке 41. Короткий вариант программы:

main.ccp:

#include <iostream>
using namespace std;
int main()
{
  cout<<"Enter a smaller number: "<<endl;
  int x;
  cin>>x;
  cout<<"Enter a greater number: "<<endl;
  int y;
  cin>>y;
  cout<<"A smaller number is "<<((y>x)?x:y)<<endl;
  cout<<"A greater number is "<<((y>x)?y:x)<<endl;
  system ("pause");
    return 0;
}

#include <iostream>

using namespace std;

int main()

{

cout<<"Enter a smaller number: "<<endl;

int x;

cin>>x;

cout<<"Enter a greater number: "<<endl;

int y;

cin>>y;

cout<<"A smaller number is "<<((y>x)?x:y)<<endl;

cout<<"A greater number is "<<((y>x)?y:x)<<endl;

system ("pause");

return 0;

}

Ответить

skillpa11:

7 января 2021 в 21:24

Добрый день!
В уроке 12
https://ravesli.com/urok-12-funktsii-i-return/#toc-4
указано —
"процессор встречает в функции оператор return, он немедленно выполняет возврат значения обратно в caller и точка выполнения также переходит в caller. Любой код, который находится за return-ом в функции — игнорируется."
В ответе №1 на Задание №1 Вы указали в комментарии

return 0; } // smaller и larger уничтожаются здесь

1
2

return 0;
} // smaller и larger уничтожаются здесь

, что временные переменные уничтожаются ЗА ОПЕРАТОРОМ return
Вопрос- действительно ли это так? ведь за return уже ничего нет…
Т.е. уничтожение ДОЛЖНО произойти в момент return
В источнике https://docs.microsoft.com/ru-ru/cpp/cpp/functions-cpp?view=msvc-160
"Переменные, объявленные в теле функции, называются локальными. Они исчезают из области видимости при выходе из функции, поэтому функция никогда не должна возвращать ссылку на локальную переменную."

Есть также интересный эксперимент — с уничтожением временных объектов.

https://ru.stackoverflow.com/questions/430567/%D0%9F%D0%BE%D1%80%D1%8F%D0%B4%D0%BE%D0%BA-%D1%83%D0%BD%D0%B8%D1%87%D1%82%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D1%8F-%D0%B2%D1%80%D0%B5%D0%BC%D0%B5%D0%BD%D0%BD%D1%8B%D1%85-%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D0%BE%D0%B2

Ответить
1. Богдан:
  
  14 января 2021 в 01:03
  
  Вот по этому и стоит учить ассемблер. Для понимания, что, как и когда делается. На самом деле ничего не уничтожается.
  
  Ответить
  1. Сергей:
    
    6 марта 2021 в 10:38
    
    Молодец, Богдан. "На самом деле ничего не уничтожается."
    При объявлении переменной в функции часть оперативной памяти выделяется под этот объект (урок 10) https://ravesli.com/urok-10-peremennye-initsializatsiya-i-prisvaivanie-v-s/
    После возвращения из функции область памяти, где хранились переменные помечается 'как свободная' (для программистов там мусор). Значения в этой области или от прежних событий (т. е. ваши бывшие локальные переменный ), или перезаписаны сервисами операционной системы.
    В любом случае доступ к этой области памяти через "псевдоимя" типа x или подобное ("объект с именем") — не доступен.
    
    Ответить
Сосед:

20 ноября 2020 в 12:41

Блин, ни как не получается перевести иероглифы в кирилицу, я пробовал:
———————-

#include <clocale> setlocale(LC_ALL, ""); (и вот так тоже пробовал (0, ""), (LC_ALL, "Russian"), (LC_ALL, "rus") )

1
2

#include <clocale>
setlocale(LC_ALL, ""); (и вот так тоже пробовал (0, ""), (LC_ALL, "Russian"), (LC_ALL, "rus") )

———————-

#include <windows.h> SetConsoleCP(1251); SetConsoleOutputCP(1251);

1
2
3

#include <windows.h>
SetConsoleCP(1251);
SetConsoleOutputCP(1251);

———————-
Может кто сталкивался, че подскажите?
компилирую через g++

Ответить
1. Viktor:
  
  24 ноября 2020 в 16:56
  
  Инклуде виндовх пишешь в самом верху.
  Сет консоле сп 1251 пишешь сразу после инт мэйн в теле.
  Так же файл блокнота тоде должен быть в кодировке 1251
  
  Ответить
2. Иван:
  
  6 августа 2021 в 21:20
  
  В самом начале функции main нужно написать setlocale (LC_ALL, "Russian") и по идее всегда будет работать.
  
  Ответить
AHTOH:

2 ноября 2020 в 14:31

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

Ответить

Виктор:

2 октября 2020 в 06:04

#include <iostream>
#include <windows.h>

using namespace std;

int main(){
	SetConsoleCP(1251);
	SetConsoleOutputCP(1251);
	
	int x;
	cout<<"Введите целое число X: ";
	cin>>x;
	cout<<"Ваш X: "<<x<<endl;
	
    int y;
	cout<<"Введите целое число Y которое больше X: ";	
	cin>>y;
	if (y>x)
		cout<<"Ваш Y: "<<y<<" Больше чем X: "<<x<<endl;
	else 
	{
		cout<<"Меняем значения местами"<<endl;
		
		int a(y);
		cout<<"X = "<<a<<endl;
		
		int b(x);
		cout<<"Y = "<<b<<endl;
	}	
	
	
	return 0;
}

#include <iostream>

#include <windows.h>

using namespace std;

int main(){

SetConsoleCP(1251);

SetConsoleOutputCP(1251);

int x;

cout<<"Введите целое число X: ";

cin>>x;

cout<<"Ваш X: "<<x<<endl;

int y;

cout<<"Введите целое число Y которое больше X: ";

cin>>y;

if (y>x)

cout<<"Ваш Y: "<<y<<" Больше чем X: "<<x<<endl;

else

{

cout<<"Меняем значения местами"<<endl;

int a(y);

cout<<"X = "<<a<<endl;

int b(x);

cout<<"Y = "<<b<<endl;

}

return 0;

}

Ответить

Максим:

5 июля 2022 в 15:40

В задаче требуется использовать только 1 доп переменную

Ответить

Александр:

17 июля 2020 в 23:05

#include <iostream>
using namespace std;

int main()
{
    setlocale(LC_ALL, "rus");
    cout << "Введите число: " << "\n";
    double number1; //обьявление number1
    cin >> number1; 
    cout << "Введите большее число" << "\n";
    double number2; //обьявление number2
    cin >> number2;
    if (number1 > number2) 
    {
        double x = number1; //определяем х
        number1 = number2;
        number2 = x;
        cout << "Меняем значения местами" << "\n";
    }//переменная х уничтожается
    
    cout << "Меньшее число: " << number1 << "\n";
    cout << "Большее число: " << number2 << "\n";

    return 0;
} //переменные number1, number2 уничтожаются

#include <iostream>

using namespace std;

int main()

{

setlocale(LC_ALL, "rus");

cout << "Введите число: " << "\n";

double number1; //обьявление number1

cin >> number1;

cout << "Введите большее число" << "\n";

double number2; //обьявление number2

cin >> number2;

if (number1 > number2)

{

double x = number1; //определяем х

number1 = number2;

number2 = x;

cout << "Меняем значения местами" << "\n";

}//переменная х уничтожается

cout << "Меньшее число: " << number1 << "\n";

cout << "Большее число: " << number2 << "\n";

return 0;

} //переменные number1, number2 уничтожаются

Ответить

Денис:

11 июля 2020 в 22:36

Думаю, так даже проще должно быть

#include <iostream>

int main()
{
	setlocale(LC_ALL, "rus");

	std::cout << "Введите первое число: ";
	int a = 0;
	std::cin >> a;

	std::cout << "Введите второе число: ";
	int b = 0;
	std::cin >> b;

	if (b > a)
		std::cout << b << ">" << a << std::endl;
	else
	{
		int x = a;
		int y = b;
		std::cout << x << ">" << y << std::endl;
	}//уничтожаются переменные x и y

	return 0;
}//уничтожаются переменные a и b

#include <iostream>

int main()

{

setlocale(LC_ALL, "rus");

std::cout << "Введите первое число: ";

int a = 0;

std::cin >> a;

std::cout << "Введите второе число: ";

int b = 0;

std::cin >> b;

if (b > a)

std::cout << b << ">" << a << std::endl;

else

{

int x = a;

int y = b;

std::cout << x << ">" << y << std::endl;

}//уничтожаются переменные x и y

return 0;

}//уничтожаются переменные a и b

Ответить

Sagynysh:

23 мая 2020 в 12:40

#include<iostream>
using namespace std;                                // используем пространство имён std
int main()
{
	setlocale(LC_ALL,"rus");                        // используем кириллицу
	int x,y;
	cout << "Введите меньшее число : ";             
	cin >> x ;
	cout << "Введите большее число : ";
	cin >> y;
	if(x > y)
	{                                               // начало вложенного блока
		int z;                                      // объявляем переменную z во вложенном блоке
		z = x;
		x = y;
		y = z;
	}                                               // конец вложенного блока, z уничтожается здесь
	cout << "большее число : " << y << endl;
	cout << "меньшее число : "<< x << endl;
	system("pause");
	return 0;
}

#include<iostream>

using namespace std; // используем пространство имён std

int main()

{

setlocale(LC_ALL,"rus"); // используем кириллицу

int x,y;

cout << "Введите меньшее число : ";

cin >> x ;

cout << "Введите большее число : ";

cin >> y;

if(x > y)

{ // начало вложенного блока

int z; // объявляем переменную z во вложенном блоке

z = x;

x = y;

y = z;

} // конец вложенного блока, z уничтожается здесь

cout << "большее число : " << y << endl;

cout << "меньшее число : "<< x << endl;

system("pause");

return 0;

}

Ответить

Alex:

29 апреля 2020 в 12:48

#include <iostream>	
#include <cmath>
using namespace std;	// используем именное пространство std


int main()
{
	setlocale(LC_ALL, "rus");
	began:
	cout << "Введите число: ";
	int x;
	cin >> x;
	
	cout << "Введите большее число: ";
	int y;
	cin >> y;

	if (x == y)
	{
		cout << "Вы ввели одно и то же число дважды!" << endl;
		goto began;
	}

	if (x < y)
	{
		cout << "Меньшее число: " << x << endl;
		cout << "Большее число: " << y << endl;
	}
	else
	{
		int z = y;
		cout << "Меняем значения местами" << endl;
		cout << "Меньшее число: " << z << endl;
		cout << "Большее число: " << x << endl;
	} // z уничтожается сдесь

} // x, y уничтожаются сдесь

#include <iostream>

#include <cmath>

using namespace std; // используем именное пространство std

int main()

{

setlocale(LC_ALL, "rus");

began:

cout << "Введите число: ";

int x;

cin >> x;

cout << "Введите большее число: ";

int y;

cin >> y;

if (x == y)

{

cout << "Вы ввели одно и то же число дважды!" << endl;

goto began;

}

if (x < y)

{

cout << "Меньшее число: " << x << endl;

cout << "Большее число: " << y << endl;

}

else

{

int z = y;

cout << "Меняем значения местами" << endl;

cout << "Меньшее число: " << z << endl;

cout << "Большее число: " << x << endl;

} // z уничтожается сдесь

} // x, y уничтожаются сдесь

Ответить

Павел Карпов:

11 февраля 2020 в 22:28

#include <iostream>
using namespace std;

int main()
{
	cout << "Введите число: ";         // выводим сообщение "Введите число: "
	int x;                             // добавляем целое число x
	cin >> x;                          // даем пользователю ввести значение x
	cout << "Введите большее число: "; // выводим сообщение "Введите большее число: "
	int y;                             // добавляем целое число y
	cin >> y;                          // даем пользователю ввести значение y
	int max;                           // добавляем целое число max
	if (y > x)                         // если y больше x то...
	{
		max = y;                       // числу max присваивают значение y
		y = x;                         // числу y присваивают значение x
		x = max;                       // числу x присваивают значение max
		cout << x << " " << y << endl; // выводим переменные x и y через пробел
	} else                             // если x больше или равен y то...
	{
		cout << x << " " << y << endl; // выводим переменные x и y через пробел
	}
	return 0;
}

#include <iostream>

using namespace std;

int main()

{

cout << "Введите число: "; // выводим сообщение "Введите число: "

int x; // добавляем целое число x

cin >> x; // даем пользователю ввести значение x

cout << "Введите большее число: "; // выводим сообщение "Введите большее число: "

int y; // добавляем целое число y

cin >> y; // даем пользователю ввести значение y

int max; // добавляем целое число max

if (y > x) // если y больше x то...

{

max = y; // числу max присваивают значение y

y = x; // числу y присваивают значение x

x = max; // числу x присваивают значение max

cout << x << " " << y << endl; // выводим переменные x и y через пробел

} else // если x больше или равен y то...

{

cout << x << " " << y << endl; // выводим переменные x и y через пробел

}

return 0;

}

Ответить

Inviser666:

8 января 2020 в 15:19

#include <iostream>
#include <cstdlib>

int entfirstnum();
int entsecondnum();
void result(int x, int y);

int main() {
	setlocale(LC_ALL, "rus");

	int firstnum = entfirstnum();       //firstnum объявляется
	int secondnum = entsecondnum();     //secondnum объявляется
	result(firstnum, secondnum);

	system("pause");
}                            //уничтожаются переменные firstnum и secondnum
int entfirstnum() {
	std::cout << "Введите число: ";
	int x;                   //x объявляется
	std::cin >> x;
	return x;
}                            //x уничтожается
int entsecondnum() {
	std::cout << "Введите большее число: ";
	int x;                   //x объявляется
	std::cin >> x;
	return x;
}                            //x уничтожается
void result(int x,int y) {   //x и y определяются
	if (x < y) {
		std::cout << "меньшее число: " << x << '\n';
		std::cout << "большее число: " << y << '\n';
	}
	else {
		std::cout << "меняем значения местами" << '\n';
		std::cout << "меньшее число: " << y << '\n';
		std::cout << "большее число: " << x << '\n';
	}
}                            //x и y уничтожаются

#include <iostream>

#include <cstdlib>

int entfirstnum();

int entsecondnum();

void result(int x, int y);

int main() {

setlocale(LC_ALL, "rus");

int firstnum = entfirstnum(); //firstnum объявляется

int secondnum = entsecondnum(); //secondnum объявляется

result(firstnum, secondnum);

system("pause");

} //уничтожаются переменные firstnum и secondnum

int entfirstnum() {

std::cout << "Введите число: ";

int x; //x объявляется

std::cin >> x;

return x;

} //x уничтожается

int entsecondnum() {

std::cout << "Введите большее число: ";

int x; //x объявляется

std::cin >> x;

return x;

} //x уничтожается

void result(int x,int y) { //x и y определяются

if (x < y) {

std::cout << "меньшее число: " << x << '\n';

std::cout << "большее число: " << y << '\n';

}

else {

std::cout << "меняем значения местами" << '\n';

std::cout << "меньшее число: " << y << '\n';

std::cout << "большее число: " << x << '\n';

}

} //x и y уничтожаются

Ответить

armus1:

30 сентября 2019 в 23:02

#include <iostream>
using namespace std;

int main()
{
	setlocale(LC_ALL, "rus");
	int a;
	cout << "Введите целое число:";
	cin >> a;
	int b;
	cout << "Введите целое число, которое больше предыдущего:";
	cin >> b;

	if (a < b)
	{
		cout << "Меньшее число:" << a << endl;
		cout << "Большее число:" << b << endl;
	}
	else
	{
		int z = b;
		cout << "Меньшее число:" << z << endl;
		cout << "Большее число:" << a << endl;
	} // переменная z уничтожается

	return 0;
} //переменные a и b уничтожаются

#include <iostream>

using namespace std;

int main()

{

setlocale(LC_ALL, "rus");

int a;

cout << "Введите целое число:";

cin >> a;

int b;

cout << "Введите целое число, которое больше предыдущего:";

cin >> b;

if (a < b)

{

cout << "Меньшее число:" << a << endl;

cout << "Большее число:" << b << endl;

}

else

{

int z = b;

cout << "Меньшее число:" << z << endl;

cout << "Большее число:" << a << endl;

} // переменная z уничтожается

return 0;

} //переменные a и b уничтожаются

Ответить

Елена:

9 июля 2019 в 22:04

Еще вариант:

a > b ? (cout << a << " , " << b << endl) : (cout << b << " , " << a << endl);

1

a > b ? (cout << a << " , " << b << endl) : (cout << b << " , " << a << endl);

Ответить

Дмитрий:

9 ноября 2018 в 23:19

#include <iostream> 

      /* такие маленькие программы МНЕ гораздо СПОДРУЧНЕЕ писать В ОДНОЙ функции  */

int main()
{
	setlocale(0, "");

	std::cout << "Введите целое число: ";
	int a;
	std::cin >> a;

	std::cout << "Введите целое число побольше: ";
	int b;
	std::cin >> b;
	
		// проверка ЕСЛИ введено ДВА РАЗА ОДНО И ТОЖЕ ЧИСЛО
	if (a == b)
	{
		std::cout << "Вы ввели одно и то же число дважды!" << std::endl;
		system("pause");
		return 0;
	}
		
		// замена значений если Значения были введены НЕ так как требовалось
	if (b < a)
	{
		std::cout << "Меняем значения местами" << std::endl;
		int c;    // временная переменная C (облась видимости локальная - внутри этого блока)
		c = b;
		b = a;
		a = c;
	}		

	std::cout << "Меньшее число: " << a << std::endl;
	std::cout << "Большее число: " << b << std::endl;
	
	system("pause");
	return 0;
}

#include <iostream>

/* такие маленькие программы МНЕ гораздо СПОДРУЧНЕЕ писать В ОДНОЙ функции */

int main()

{

setlocale(0, "");

std::cout << "Введите целое число: ";

int a;

std::cin >> a;

std::cout << "Введите целое число побольше: ";

int b;

std::cin >> b;

// проверка ЕСЛИ введено ДВА РАЗА ОДНО И ТОЖЕ ЧИСЛО

if (a == b)

{

std::cout << "Вы ввели одно и то же число дважды!" << std::endl;

system("pause");

return 0;

}

// замена значений если Значения были введены НЕ так как требовалось

if (b < a)

{

std::cout << "Меняем значения местами" << std::endl;

int c; // временная переменная C (облась видимости локальная - внутри этого блока)

c = b;

b = a;

a = c;

}

std::cout << "Меньшее число: " << a << std::endl;

std::cout << "Большее число: " << b << std::endl;

system("pause");

return 0;

}

Ответить

Игорь:

16 сентября 2018 в 22:41

#include <iostream>

using namespace std;
int input();
void exchange(int little, int big);

int main()
{
    setlocale(LC_ALL, "rus");
    int little, big;
    little = input();
    big = input();
    exchange(little, big);
    return 0;
}
int input()
{
    static int count = 0;
    if(count == 1)
    {
        cout<<"Введите большее число:";
    }
    else
      cout<<"Введите число:";


    int number;
    cin>>number;
    count++;
    return number;

}
void exchange(int little, int big)
{
    if(little > big)
    {
        cout<<"Меняем значение:"<<endl;
        int temp;
        temp = little;
        little = big;
        big = temp;
    }
    cout<<"Меньшее число: "<<little<<endl;
    cout<<"Большее число: "<<big<<endl;

}

#include <iostream>

using namespace std;

int input();

void exchange(int little, int big);

int main()

{

setlocale(LC_ALL, "rus");

int little, big;

little = input();

big = input();

exchange(little, big);

return 0;

}

int input()

{

static int count = 0;

if(count == 1)

{

cout<<"Введите большее число:";

}

else

cout<<"Введите число:";

int number;

cin>>number;

count++;

return number;

}

void exchange(int little, int big)

{

if(little > big)

{

cout<<"Меняем значение:"<<endl;

int temp;

temp = little;

little = big;

big = temp;

}

cout<<"Меньшее число: "<<little<<endl;

cout<<"Большее число: "<<big<<endl;

}

Ответить

Максим:

11 сентября 2018 в 21:30

#include <iostream>

using namespace std;

int inputSmaller()
{
    int x;
    cout<<"Введите число: ";
    cin>>x;
    return x;
}//Уничтожается x функции inputSmaller

int inputLarger()
{
    int x;
    cout<<"Введите большее число: ";
    cin>>x;
    return x;
}//Уничтожается x функции inputLarger

void output(int smaller, int larger)
{
    cout<<"Меньшее число: "<<smaller<<"\n";
    cout<<"Большее число: "<<larger<<"\n";
}//Уничтожаются smaller, larger функции output

int main()
{
    setlocale(LC_ALL, "rus");
    int smaller(inputSmaller());
    int larger(inputLarger());
    if (smaller>larger)
    {
        cout<<"Меняем значения\n";
        int intermediateVar(larger);
        larger=smaller;
        smaller=intermediateVar;
    }//Уничтожается  intermediateVar
    output(smaller,larger);

    return 0;
}//Уничтожаются smaller, larger функции main

#include <iostream>

using namespace std;

int inputSmaller()

{

int x;

cout<<"Введите число: ";

cin>>x;

return x;

}//Уничтожается x функции inputSmaller

int inputLarger()

{

int x;

cout<<"Введите большее число: ";

cin>>x;

return x;

}//Уничтожается x функции inputLarger

void output(int smaller, int larger)

{

cout<<"Меньшее число: "<<smaller<<"\n";

cout<<"Большее число: "<<larger<<"\n";

}//Уничтожаются smaller, larger функции output

int main()

{

setlocale(LC_ALL, "rus");

int smaller(inputSmaller());

int larger(inputLarger());

if (smaller>larger)

{

cout<<"Меняем значения\n";

int intermediateVar(larger);

larger=smaller;

smaller=intermediateVar;

}//Уничтожается intermediateVar

output(smaller,larger);

return 0;

}//Уничтожаются smaller, larger функции main

Ответить

Георгий:

29 июля 2018 в 22:14

хм, сделал немного наоборот, но вроде смысл тот же

#include <stdafx.h>
#include <iostream>

int Enter()
{
	std::cout << "Введите число: ";
	int x;
	std::cin >> x;
	return x;
}

int EnterMax()
{
	std::cout << "Введите большее число: ";
	int x;
	std::cin >> x;
	return x;
}

int main()
{
	setlocale(LC_ALL, "rus");
	int a = Enter();
	int b = EnterMax();
	if (b > a)
	{
		std::cout << "Большее число: " << b << "\n";
		std::cout << "Меньшее число: " << a << "\n";
	}
	else
	{
		std::cout << "Меняем значения \n";
		std::cout << "Большее число: " << a << "\n";
		std::cout << "Меньшее число: " << b << "\n";
	}
	system("pause");
	return 0;
}

#include <stdafx.h>

#include <iostream>

int Enter()

{

std::cout << "Введите число: ";

int x;

std::cin >> x;

return x;

}

int EnterMax()

{

std::cout << "Введите большее число: ";

int x;

std::cin >> x;

return x;

}

int main()

{

setlocale(LC_ALL, "rus");

int a = Enter();

int b = EnterMax();

if (b > a)

{

std::cout << "Большее число: " << b << "\n";

std::cout << "Меньшее число: " << a << "\n";

}

else

{

std::cout << "Меняем значения \n";

std::cout << "Большее число: " << a << "\n";

std::cout << "Меньшее число: " << b << "\n";

}

system("pause");

return 0;

}

Ответить

master114:

23 апреля 2018 в 11:48

У меня получился такой вариант — ibb.co/jJLATc. Сделал пару функций. Перед выполнением думал, что получится поменять без временной переменной (в моем случае Z).

Ответить
1. Юрий:
  
  28 апреля 2018 в 00:00
  
  Вы правильно сделали, разбив программу на функции. А насчет временной переменной, то без неё здесь не обойтись 🙂
  
  Ответить
  1. master114:
    
    4 мая 2018 в 15:38
    
    Нашел вариант без временной переменной — onlinegdb.com/B1E-4RKpM.
    
    Ответить
    1. Юрий:
      
      5 мая 2018 в 22:42
      
      Хоть и работает, но у вас здесь вместо одной временной переменной используются две временные переменные: xFunc и yFunc. + еще глобальные переменные, которые нежелательно лишний раз использовать.
      
      Но в общем, реализация интересная однозначно.
  2. Mirovengil:
    
    19 августа 2019 в 12:39
    
    В каком смысле "без дополнительной переменной не обойтись"? А как же классика?
    
    a += b; b = a - b; a -= b;
    
    1
    2
    3
    
    a += b;
    b = a - b;
    a -= b;
    
    PS: имена переменным поставил простейшие, чтобы было понятно, что происходит.
    
    Ответить
Sergey Groysman:

16 апреля 2018 в 15:50

Юрий, доброго дня.
При решении теста №1, как сюда ввести вариант, если ввели равные числа?
Спасибо.

Ответить
1. Юрий:
  
  17 апреля 2018 в 22:56
  
  Если ввести правильные числа сразу, то они и выведутся после, без выполнения условия if. Дополнительно ничего прописывать не нужно. В условии if ведь и указывается, что менять значение нужно только при условии что значение smaller, которое ввел пользователь — больше значения large. Если же это не так, то ничего менять и не нужно.
  
  Ответить

Урок №48. Локальные переменные, область видимости и продолжительность жизни

Область видимости и продолжительность жизни

Сокрытие имен

Область видимости переменных

Параметры функций

Заключение

Тест

Задание №1

Задание №2

Комментариев: 29

Добавить комментарий для master114 Отменить ответ