Функции в C++ для начинающих. Параметры по умолчанию
Тема параметров функций по умолчанию достаточно лёгкая. Вы можете иногда встречать их использование в чужих кодах, а после изучения статьи, возможно, и сами станете использовать.
- В С++ к параметрам функции можно применять операцию =
|
1 |
void foo1(int value = 50){} //value = 50 - это параметр, значение которого по умолчанию будет 50 |
Использование параметров по умолчанию:
|
1 2 3 4 5 6 7 |
void foo(int value = 50){} //value = 50, параметр со значением по умолчанию int main() { foo(); //В функцию foo не уходит никаких аргументов } |
Несмотря на то, что вовнутрь функции foo не ушло аргументов, функция с одним параметром сработала. Использование знака = в параметрах функции обозначает, что для этой функции аргумент можно будет не писать, а в случае ненаписанного аргумента параметр примет указанное значение:
|
1 2 3 4 5 6 7 8 9 10 |
void foo(int value = 50){ //value = 50, параметр со значением по умолчанию } int main() { int x = 20; foo(); //В функцию foo не уходит никаких аргументов foo(x); //В функцию ушёл аргумент x } |
Можно задавать много таких параметров, сколько угодно, но с одним условием: задавать параметры по умолчанию можно только в правой части списка параметров. Если перед таким параметром будет идти обычный параметр, без применения к нему =, тогда код не сможет быть скомпилирован:
|
1 2 3 4 5 6 7 8 9 10 |
//За параметром по умолчанию идёт параметр не по умолчанию, ошибка! void foo(int value = 50, int x){ //value = 50, параметр со значением по умолчанию } int main() { int x = 20; foo(x,x); //в функцию уходит два аргумента } |
Когда программист делает в списке параметров параметр по умолчанию, он, программист, предполагет возможность того, что при обращении к пишемой им функции можно будет не указывать аргументов: если аргументы в функцию уходить не будут, то параметры функции примут те значения, которые им предписаны, а если аргументы в функцию отдаваться будут, то параметры примут в себя значения аргументов. Это проще показать в коде:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
#include <iostream> using namespace std; void foo(int value = 50){ //value = 50, параметр со значением по умолчанию cout << "value = " << value << '\n'; } int main() { int x = 20; foo(); //50 //первый случай foo(x); //20 //второй случай cin.get(); } |
В первом случае аргументов в функцию не отдаётся, поэтому параметр подбирает значение, которое указано для случая по умолчанию. Во втором случае аргумент отдаётся, поэтому параметр подбирает значение, хранимое ушедшим в функцию аргументом.
Таким образом вы можете немного экономить в тексте кода: ведь вместо написания двух функций мы написали одну.
- Задание аргументов по умолчанию может упростить написание вызовов функции. Однако некоторые программисты считают, что для ясности лучше использовать параметры не по умолчанию.
Моя цель не рассуждать, хорошо это или плохо, а дать вам понять, что в С++ имеется такая возможность и просто объяснить смысл существования этой возможности.
В простейшем случае параметр по умолчанию может быть полезен для заполнения массива, например, по порядку с какого-то определённого числа: если для функции не указывается начало отсчёта, можно использовать параметр по умолчанию:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
#include <iostream> using namespace std; void fill_array(int* arr, int N, int start = 50){ //Функция заполнения массива for (int i = 0; i < N; i++) arr[i] = start++; //заполнение массива, начиная со значения start } int main() { const int N = 10; int arr[N]; //============================ fill_array(arr,N); //Стартовое значение не указано, но используется //Вывод массива на экран: for (int i=0; i<N; i++){ cout << arr[i] << ' '; } //============================= cout << '\n'; //============================ fill_array(arr,N, 25); //Стартовое значение указано явно, третьим аргументом //Вывод массива на экран: for (int i=0; i<N; i++){ cout << arr[i] << ' '; } //============================= cin.get(); } |
В этот же код можно добавить ещё один параметр со значением по умолчанию, например, выводить какую-нибудь информацию в ходе работы функции:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 |
#include <iostream> using namespace std; void fill_array(int* arr, int N, int start = 50, const char* info = "fill_array\n"){ //Функция заполнения массива cout << info; for (int i = 0; i < N; i++) arr[i] = start++; //заполнение массива, начиная со значения start } int main() { const int N = 10; int arr[N]; //============================ fill_array(arr,N); //Стартовое значение не указано, но используется //Вывод массива на экран: for (int i=0; i<N; i++){ cout << arr[i] << ' '; } //============================= cout << "\n\n"; //============================ fill_array(arr,N, 25); //Стартовое значение указано явно, третьим аргументом //Вывод массива на экран: for (int i=0; i<N; i++){ cout << arr[i] << ' '; } //============================= cout << "\n\n"; //============================ fill_array(arr,N, 0, "my_function\n"); //Все аргументы заданы явно, параметры внутри функции возьмут их значения //Вывод массива на экран: for (int i=0; i<N; i++){ cout << arr[i] << ' '; } //============================= cout << "\n\n"; cin.get(); } |
Смысл только в том, чтобы в некоторых случаях опускать указание аргументов при обращении к функции. Иногда это бывает действительно удобно.
Но есть здесь и подводные камни. Если вы опишете несколько функций, которые по сути будут похожи, и используете в них параметры по умолчанию, то код может не скомпилироваться:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
#include <iostream> using namespace std; void f00(){} //Функция без параметров void f00(const int value = 10){} //Функция с параметром по умолчанию int main() { f00(); //Ошибка компиляции } |
В последнем коде срабатывает механизм перегрузки функций. Для компилятора, в нашем случае, обе функции имеют равное право на вызов, компилятор не знает, какую выбрать, и начинает на вас ругаться. Это одна из причин, почему некоторые программисты не любят параметры по умолчанию. Функции без параметров по умолчанию более ясны, чем функции с параметрами по умолчанию.
Если вы хотите знать, как это работает и почему оно работает, то вот вам понятное пояснение: Когда указываются параметры по умолчанию, они просто создаются внутри функции.
Вот вам два кода, которые на самом деле не одно и то же, но эквивалентны друг другу:
|
1 2 |
void foo(const int N = 10){} //Функция с параметром по умолчанию int main(){} |
|
1 2 3 4 5 |
void foo(){ const int N = 10; //Это случается из параметра по умолчанию } int main(){} |
3 комментария на «“Функции в C++ для начинающих. Параметры по умолчанию”»
Добавить комментарий
Случайная книга в электронном формате
Вы не могли бы объяснить подробнее, что это означает?
(!((i+1)%el)))
! -Элемент логики. Читается как логическое НЕ, как отрицание,
% — Это арифметическая операция, которая выдает остаток от деления. Ноль — всегда отрицание, НЕ ноль всегда НЕ отрицание.
================
Такое выражение можно было записать так
Спасибо)