Перейти к содержимому

Функции с параметрами

  • Функция
  • Вызов функции
  • Определение функции
  • Параметр, аргумент
  • Возвращаемое значение, return, void
  • Как обозначается интерфейс функции (сигнатура)

В данных примерах объясните:

  • Сколько переменных будет существовать на разных этапах выполнения программы;
  • Скомпилируется ли вообще программа и если нет, почему;
  • Какие значения будут в каждой из переменных по окончанию программы.
int a = 5;
F();
static void F()
{
int b = 6;
}
Ответ:

Одна переменная a создается в основной программе, она имеет значение 5.

После этого, при вызове функции F, функция создает еще одну переменную b со значением 6. Она попадает в следующую свободную ячейку после a (если игнорировать другие данные, попадающие в стек, необходимые для вызова функций) во временной памяти (стеке).

При завершении F вторая переменная b перестает существовать — то есть к ее памяти уже невозможно будет сослаться из основной программы, однако значение 6 продолжает существовать в этой ячейке памяти.

int a = 5;
F();
static void F()
{
int a = 6;
}
Ответ:

Ситуация эквивалентна предыдущему примеру. Разница в том, что локальная переменная b теперь носит то же имя a. Память этих переменных также различна.

3. Использование переменной после завершения функции

Заголовок раздела «3. Использование переменной после завершения функции»
int a = 5;
F();
b = 7;
static void F()
{
int b = 6;
}
Ответ:

Данный код иллюстрирует тот факт, что переменная b перестает существовать после завершения F. Код не скомпилируется: в основной программе нет переменной с именем b.

int a = 5;
F(a);
static void F(int b)
{
b = 6;
}
Ответ:

При вызове функции для ее параметров выделится по локальной переменной. В эти переменные перекопируются значения аргументов, то есть выражений в соответствующих позициях при вызове (a).

b = 6 изменит локальную переменную, существующую при вызове F. b = 6 не повлияет на a.

В a будет 5.

5. Перезапись переданной переменной с тем же именем

Заголовок раздела «5. Перезапись переданной переменной с тем же именем»
int a = 5;
F(a);
static void F(int a)
{
a = 6;
}
Ответ:

Ситуация эквивалентна предыдущей. a как параметр в функции F — это имя локальной переменной, создаваемой при вызове F. Этот a не привязан к a из основной программы.

В a будет 5.

int b = 6;
F(1, b);
static int F(int a, int b)
{
return a + b;
}
Ответ:

Несмотря на то, что F возвращает ответ, он никуда не сохраняется. В b будет ее старое значение.

int b = 6;
int s = F(1, b);
b = s;
static int F(int a, int b)
{
return a + b;
}
Ответ:

В b и в s будет 7.

int b = 6;
int s = F(F(1, F(2, b)), b);
static int F(int a, int b)
{
return a + b;
}
Ответ:

F(F(1, F(2, b)), b) — это сложное выражение, оно будет вычисляться наизнанку:

  • F(2, b) -> F(2, 6) -> 8;
  • F(1, 8) -> 9;
  • F(9, b) -> F(9, 6) -> 15.
F(1);
static void F(int a)
{
F(a);
}
Ответ:

Здесь будет выделяться бесконечно памяти при каждом вызове F самой себя, как минимум для переменной a, поскольку при вызове каждой последующей F будет создаваться a, локальная ей, инициализированная a из F, что была вызвана до этого (то есть, 1).

В определенный момент память в стеке кончится, и программа упадет (StackOverflowException).

int a = 1;
F(a + 2);
a = 10;
static void F(int x)
{
Console.WriteLine(x);
}
Ответ:

Напечатается 3, потому что сначала высчитывается результат выражения a + 2, после чего этот результат передается функции. Функция всегда принимает параметром не выражение, а результат вычисления выражения.

Изменение a после вызова никак не влияет на параметр, поскольку это две никак не связанные ячейки памяти.

11. Передача параметра, его смена после вызова

Заголовок раздела «11. Передача параметра, его смена после вызова»
int a = 1;
int b = F(a);
a = 2;
Console.WriteLine(a);
Console.WriteLine(b);
static int F(int x)
{
return x;
}
Ответ:

В a будет 2, в b будет 1.

На строчке int b = F(a); происходит 3 вещи:

  • выделяется память для переменной b;
  • высчитывается результат выражения F(a);
  • результат выражения присваивается к b.

Результат выражения присваивается к b!

Что произойдет при вычислении F(a)?
  • Создаются локальные переменные для параметров. В данном случае создается одна переменная для параметра x.
  • В x записывается значение аргумента — результат вычисления выражения a — 1.
  • Выполнение переходит на первую инструкцию функции F.
  • Выполняется return x, что выставляет результат выражения после return как результат вызова F. Результат выражения x (считывание из локальной переменной x), что есть значение 1, становится результатом вызова функции.
  • Все локальные переменные, созданные при вызове F, пропадают. В данном случае пропадает переменная x.

Так как в b на строчке int b = F(a); попадет результат вызова функции, в b попадает a после всех вышеописанных операций.

string s = GetGreeting();
Console.WriteLine(s);
static string GetGreeting()
{
return "Привет";
}
Ответ

Напечатается Привет.

Результат выражения берется от выполнения функции, значит ее возвращаемый тип и есть тип результата выражения. А ее возвращаемый тип прописан в определении функции — string.

Поскольку у s тоже тип string, результат сможет сохраниться туда.

Сработает ли, если тип у s заменить с string на int?

Имеется в виду подобный код:

int s = GetGreeting();
static string GetGreeting()
{
return "Привет";
}

Не скомпилируется, потому что тип выражения (тип результата выражения — то же самое) GetGreeting() это string, а int нельзя создать из string.