По мере увеличения размера и сложности ваших программ вам следует разделить их на небольшие легко управляемые части, называемые функциями. Каждая функция в вашей программе должна выполнять определенную задачу. Например, если вы пишете программу платежей, можете создать одну функцию, определяющую количество часов, отработанных служащим, вторую функцию, определяющую сверхурочную оплату, третью функцию, выводящую на печать и т. д. Если программе необходимо выполнить определенную задачу, то она вызывает соответствующую функцию, обеспечивая эту функцию информацией, которая ей понадобится в процессе обработки. Из этого урока вы узнаете, как создавать и использовать функции в ваших программах на C++. К концу данного урока вы освоите следующие основные концепции:
• Функции группируют связанные операторы для выполнения определенной задачи.
• Ваша программа вызывает функцию, обращаясь к ее имени, за которым следуют круглые скобки, например bеер ().
• После завершения обработки большинство функций возвращают значение определенного типа, например int или float, которое программа может проверить или присвоить переменной.
• Ваши программы передают параметры (информацию) функциям, например имя, возраст или оклад служащего, заключая параметры в круглые скобки, которые следуют за именем функции.
• C++ использует прототипы функций для определения типа возвращаемого функцией значения, а также количества и типов параметров, передаваемых функции.
По мере увеличения ваших программ использование функций становится их неотъемлемой необходимостью. Однако, как вы увидите, создавать и использовать функции в C++ очень легко.
СОЗДАНИЕ И ИСПОЛЬЗОВАНИЕ ВАШИХ ПЕРВЫХ ФУНКЦИЙ
При создании программ вам следует спроектировать каждую функцию для выполнения определенной задачи. Если вы обнаружите, что функция выполняет несколько задач, вам следует разделить ее на две или более функций. Каждая создаваемая в программах функция должна иметь уникальное имя.
Как в случае с именами переменных, имена функций, которые вы выбираете те, должны соответствовать операции, выполняемой функцией. Например глядя на имена функций, перечисленные в табл. 9, вы получите хорошее представление о назначении каждой функции.
Таблица 9. Примеры смысловых имен функций.
Имя функции
Назначение функции
Print_test_scores
Печатать тестовые очки класса
Accounts_payable
Обработать счета компании
Get_user_name
Запрос имени пользователя
Print_document
Напечатать указанный документ
Calculate_income_tax
Определить подоходный налог пользователя
Функция C++ по структуре подобна программе main, которую вы использовали во всех предыдущих программах. Другими словами, имя функции предваряется ее типом, а за ним следует список параметров, описание которых появляется в скобках. Вы группируете операторы функций внутри левой и правой фигурных скобок, как показано ниже:
тип_возврата имя_функции (список_параметров)
{
объявления_переменных;
операторы;
}
Рассмотрите, например, как структура этой функции соответствует следующей программе main:
void main (void) //-----------> тип имя (список_параметров)
{
int count; // ---------------------------> объявления_переменных;
for (count = 0; count < 10; count++) cout << count << ' '; // -----> Оператор
}
Следующие операторы определяют функцию с именем show_message, которая выводит сообщение на экран, используя cout.
void show_message (void)
{
cout << "Привет, учусь программировать на C++" << endl;
}
Как вы, возможно, помните из урока 2, слово void, предшествующее имени функции, указывает функции не возвращать значение. Подобно этому, слово void, содержащееся внутри круглых скобок, указывает (компилятору C++ и программистам, читающим ваш код), что функция не использует параметры (информацию, которую программа передает функции). Следующая программа SHOW_ MSG.CPP использует функцию show_message для вывода сообщения на экран:
#include <iostream.h>
void show_message (void)
{
cout << "Привет, учусь программировать на C++" << endl;
}
void main (void)
{
cout << "Перед вызовом функции" << endl;
show_message ();
cout << "Вернулись из функции" << endl;
}
Вы уже знаете, что выполнение программы всегда начинается внутри main. Внутри main следующий оператор (вызов функции) вызывает функцию show_message:
show_message ();
Круглые скобки после имени функции сообщают компилятору C++, что ваша программа использует функцию. Позже вы узнаете, что внутри этих скобок программа может передавать в функции информацию (параметры). Если вы откомпилируете и запустите эту программу, на вашем экране появится следующий вывод:
С: \>SHOW_MSG <ENTER>
Перед вызовом функции
Привет, учусь программировать на C++
Вернулись из функции
Если программа встречает вызов функции, она начинает выполнять операторы, находящиеся внутри функции. После того как программа выполнит все операторы, которые содержит функция (другими словами, функция завершится); выполнение программы продолжается с оператора, следующего непосредственно за вызовом функции:
#include <iostream.h>
void show_message (void)
{
cout << "Привет, учусь программировать на C++" << endl;
}
void main (void)
{
cout << "Перед вызовом функции" << endl;
show_message ();
cout << "Вернулись из функции" << endl;
}
В данном случае программа выполняет первый оператор в main, которой выводит сообщение для пользователя, что программа собирается вызвать функцию. Далее программа встречает вызов функции и запускает выполнение операторов в show_messsage. После того как программа выполнит единственный оператор функции, она возвращается обратно в main и продолжает свое выполнение с оператора, непосредственно следующего за вызовом функции. В этом случае программа выводит сообщение, извещая пользователя о том, что она возвратилась из функции, и после этого заканчивает свою работу. Следующая программа TWO__MSGS.CPP использует две функции - show_title и show_lesson для вывода информации об этой книге:
#include <iostream.h>
void show_title (void)
{
cout << "Книга: Учимся программировать на C++" << endl;
}
void show_lesson (void)
{
cout << "Урок: Знакомство с функциями" << endl;
}
void main (void)
{
show_title ();
show_lesson ();
}
Когда программа начинает выполнение, она сначала вызывает функцию show_title, которая выводит сообщение с помощью cout. После завершения show_title программа вызывает функцию show_lesson, также выводящую сообщение. После завершения show_lesson программа завершается, поскольку в main больше нет операторов.
Функции, представленные в этом уроке, выполняли очень простые задачи. В каждом случае ваша программа могла бы легко выполнить ту же самую обработку без использования функции просто включением тех же операторов в main. Однако назначение функций заключалось в том, чтобы показать вам, как программа определяет и затем вызывает функцию. По мере усложнения ваших программ вы будете использовать функции, чтобы упростить большие задачи, разбивая программу на небольшие легко управляемые части. При создании функций вы обнаружите, что, поскольку они содержат меньше строк кода, чем одна большая программа, их легче понять и изменить. В дополнение к этому в большинстве случаев функцию, созданную для одной программы, вы можете использовать без изменений в другой программе. Создавая библиотеку функций, вы тем самым снижаете количество времени, израсходованного на кодирование и тестирование подобных функций в будущем.
Вызов функции
Функция Представляет собой набор связанных операторов, которые Выполняют определенную задачу. Создавая функции внутри программы, вы можете делить большие задачи на небольшие легко управляемые части.
Ваши программы выполняют операторы функций посредством вызова функции. Для вызова функции программы просто обращаются к имени функции, за которым следуют круглые скобки, как показано ниже:
function_name();
Если программа передает информацию (параметры) в функцию, она размещает эту информацию внутри круглых скобок, разделяя ее запятыми:
payroll(employee_name, employee_id, salary);
После того как последний оператор функции завершен, выполнение программы продолжается с первого оператора следующего за вызовом функции.
ПРОГРАММА МОЖЕТ ПЕРЕДАВАТЬ ИНФОРМАЦИЮ В ФУНКЦИИ
Для увеличения потенциальных возможностей ваших функций C++ позволяет программам передавать информацию (параметры) в функции. Если функция использует параметры, вы должны сообщить C++ тип каждого параметра, например int, float, char и т.д. Следующая функция show_number использует параметр типа int.
void show_number (int value)
{
cout << "Значение параметра равно " << value << endl;
}
Если ваша программа вызывает функцию show_number, она должна передать ей значение, как показано ниже:
show_number ( 1001 ) ; //----------------> Значение, передаваемое в функцию
C++ будет подставлять переданное число вместо каждого имени параметра value внутри функции:
show_number (1001)
void show_number (int value )
{
cout << "Значение параметра равно " << value << endl;
}
void show_number (1001)
{
cout << "Значение параметра равно " << 1001 << endl;
}
Как видите, поскольку C++ замещает значение параметра, функция show_number выводит число 1001, переданное ей главной программой.
Следующая программа USEPARAM.CPP использует функцию show_number несколько раз, каждый раз передавая разные числа:
#include <iostream.h>
void show_number (int value)
{
cout << "Значение параметра равно " << value << endl;
}
void main (void)
{
show_number (1);
show_number (1001);
show_number (-532);
}
Если вы откомпилируете и запустите эту программу, на вашем экране будет отображено следующее:
С: \>USEPARAM <ENTER>
Значение параметра равно 1
Значение параметра равно 1001
Значение параметра равно -532
Как видите, каждый раз, когда программа вызывает функцию, C++ присваивает передаваемое число переменной value. Найдите время для эксперимента с этой программой, изменяя значения, которые main передает в функцию, и обращая внимание на результат.
Каждый параметр функции имеет определенный тип. В случае функции show_number параметр value должен быть типа int. Если вы попытаетесь передать в функцию значение другого типа, например с плавающей точкой, компилятор будет сообщать об ошибке. В большинстве случаев ваши программы будут передавать несколько значений в функцию. Для каждого передаваемого параметра функция должна указать имя и тип. Например, следующая программа BIGSMALL.CPP использует функцию show_big_and_little для вывода самого большого и самого маленького из трех полученных целочисленных значений:
#include <iostream.h>
void show_big_and_little (int a, int b, int c)
{
int small = a;
int big = a;
if (b > big)
big = b;
if (b < small)
small = b;
if (c > big)
big = c;
if (c < small)
small = c;
cout << "Самое большое значение равно " << big << endl;
cout << "Самое маленькое значение равно " << small << endl;
}
void main (void)
{
show_big_and_little (1, 2, 3);
show_big_and_little (500, 0, -500);
show_big_and_little (1001, 1001, 1001);
}
Если вы откомпилируете и запустите эту программу, на вашем экране появится следующий вывод:
С: \> BIGSMALL <ENTER>
Самое большое значение равно 3
Самое маленькое значение равно 1
Самое большое значение равно 500
Самое маленькое значение равно -500
Самое большое значение равно 1001
Самое маленькое значение равно 1001
Наконец, следующая программа SHOW_EMP.CPP использует функцию show_employee для вывода возраста (тип int) и оклада (тип float) служащего:
#Include <iostream.h>
void show_employee (int age, float salary)
{
cout << "Возраст служащего " << age << " года (лет)" << endl;
cout << "Служащий получает $" << salary << endl;
}
void main (void)
{
show_employee (32, 25000.00);
}
Как видите, функция show_employee определяет параметры типа int и float
Передача параметров в функцию
Если ваша функция использует параметры, она должна указать уникальное имя и тип для каждого параметра. Когда программа вызывает функцию, C++ присваивает значения параметров именам параметров функции слева направо. Каждый параметр функции имеет определенный тип, например int, float или char. Значения, которые ваша программа передает в функцию, используя параметры, должны соответствовать типу параметров.
ФУНКЦИИ МОГУТ ВОЗВРАЩАТЬ РЕЗУЛЬТАТ ВЫЗВАВШЕЙ ФУНКЦИИ
Функция должна выполнять определенную задачу для вашей программы. В большинстве случаев функции будут выполнять некоторые типы вычислений. Затем функция возвратит свой результат вызвавшей функции. Когда функция возвращает значение, вы должны сообщить C++ тип значения, например int, float, char т. д. Чтобы информировать C++ о типе возвращаемого функцией значения, просто поставьте перед именем функции соответствующий тип. Например, следующая функция add_values складывает два своих целочисленных параметра и возвращает результат типа int вызвавшей программе:
int add_values (int а, int b)
{
int result;
result= а+b;
return (result);
}
В данном случае слово int, появляющееся перед именем функции, указывает тип возвращаемого значения функции. Функции используют оператор return для возврата значения вызвавшей функции. Когда ваша программа встречает оператор return, она возвращает заданное значение и завершает выполнение функции, возвращая управление вызвавшей программе. В программе вы можете использовать возвращаемое значение, как показано ниже:
result=add_values (1, 2);
В данном случае программа присваивает возвращаемое функцией значение переменной result. Ваша программа может также сразу же напечатать возвращаемое функцией значение с помощью cout, как показано ниже:
cout << "Сумма значений равна " << add_values (500, 501) << endl;
Предыдущая реализация функции add_values использовала три оператора, чтобы было легче понять смысл функции. Однако вы можете сократить функцию до единственного оператора return, как показано ниже:
int add_values (int a, int b)
{
return (a+ b);
}
Следующая программа ADDVALUE.CPP использует функцию add_values для сложения нескольких значений:
#include <iostream.h>
int add_values (int a, int b)
{
return (a+ b);
}
void main (void)
{
cout << " 100 + 200 = " << add_values(100, 200) << endl;
cout << " 500 + 501 = " << add_values(500, 501) << endl ;
cout << "-1 + 1 = " << add_values(-1, 1) << endl;
}
Выберите время для эксперимента с этой программой, изменяя значения, которые программа передает в функцию. Вы могли бы попытаться передать в функцию большие значения, например 20000 и 30000. Как и можно предложить, выполнение функции, возвращающей значение типа int, приведет к ошибке переполнения.
Не все функции возвращают значение типа int. Следующая функция average_ value возвращает среднее двух целочисленных значений, которое может быть дробным, например 3.5:
float average_value(int a, int b)
{
return( (a + b) / 2.0);
}
В этом случае слово float, которое предшествует имени функции, указывает тип возвращаемого функцией значения.
ФУНКЦИИ, КОТОРЫЕ НЕ ВОЗВРАЩАЮТ ЗНАЧЕНИЕ
Если функция не возвращает значение, вам необходимо предварить имя функции типом void. В противном случае вы должны предварять имя функции типом возвращаемого функцией значения, например, int, float, char и т. д. Чтобы возвратить значение вызвавшей функции, функция использует оператор return. Когда ваша программа встречает оператор return, выполнение функции завершается и указанное значение возвращается вызвавшей функции. Возможны ситуации, когда вы встретите оператор return в функции, которая не возвращает значение:
return;
В этом случае функция имеет тип void (не возвращает значение) и оператор return просто завершает выполнение функции.
Замечание: Если операторы появляются в функции после оператора return они не будут выполняться. Как уже обсуждалось выше, если ваша программа встречает оператор return в функции, то возвращается соответствующее значение, функция заканчивается и выполнение программы продолжается с первого оператора, следующего за вызовом функции.
ИСПОЛЬЗОВАНИЕ ВОЗВРАЩАЕМОГО ФУНКЦИЕЙ ЗНАЧЕНИЯ
Когда функция возвращает значение, вызвавшая программа может присвоить возвращенное значение переменной, используя оператор присваивания, как показано ниже:
payroll_amount = payroll (employee, hours, salary);
В дополнение к этому вызвавшая программа просто может обращаться к функции. Например, следующий оператор выводит возвращаемое функцией значение, используя cout.
cout << "Служащий получил" << payroll(employee, hours, salary) < < endl;
Вызвавшая функция может также использовать возвращаемое значение в условии, как показано ниже:
if (payroll(employee, hours, salary) < 500.00)
cout << "Этот служащий нуждается в повышении" << endl;
Как видите, программа может использовать возвращаемое функцией значение различными способами.
ПРЕДСТАВЛЕНИЕ О ПРОТОТИПАХ ФУНКЦИЙ
Прежде чем ваша программа сможет вызвать функцию, C++ должен знать тип воозвращаемого значения, а также количество и тип параметров, используемых функцией. В каждой из программ, представленных в этом уроке, определение функции, вызываемой программой, всегда предшествует вызову функции в исходном файле. Однако в большинстве случаев функции появляются в вашем исходном файле и, как правило, одна функция вызывает другую. Чтобы гарантировать, что C++ знает особенности каждой функции, используемой в программе, вы можете поместить прототипы функций в начало исходного файла. В общем случае прототип функции обеспечивает информацию о типе возвращаемого функцией значения и ее параметрах. Следующий оператор иллюстрирует прототипы функций для нескольких функций, используемых в данном уроке:
void show_message(void);
void show_number(int);
void show_employee(int, float);
int add_values(int, int);
float average_value(int, int);
Как видите, прототип функции указывает тип возвращаемого значения, а также количество и тип каждого параметра. Обратите внимание на точку с запятой в конце каждого прототипа.
float average_value ( int, int) ;
Если ваша программа вызывает функцию, для которой компилятор C++ не нашел определения или прототипа, компилятор сообщает о синтаксической ошибке. При исследовании заголовочных файлов C++ или других программ вы будете постоянно сталкиваться с прототипами функций. Следующая программа PROTO.CPP иллюстрирует использование прототипа Функции:
#include <iostream.h>
float average_value(int, int); // Прототип функции
void main(void)
{
cout << "Среднее значение 2000 и 2 равно " << average_value(2000, 2) << endl;
}
float average_value (int a, int b)
{
return((a + b) / 2.0);
}
В этом случае программа вызывает функцию average_value до того, как функция определена. Таким образом, программа использует прототип функции, который предваряет определение main. Если вы удалите прототип функции и откомпилируете эту программу, компилятор C++ будет сообщать о синтаксических ошибках.
Использование прототипов функций
Прототип функции сообщает компилятору C++ тип возвращаемого значения, а также количество и тип параметров функции. Когда вы компилируете вашу программу, компилятор C++ использует прототип каждой функции, чтобы убедиться, что вы не перепутали тип возвращаемого функцией значения (например, не присваиваете возвращаемое значение типа float переменной типа int) и что вы не передаете в качестве параметра значение неверного типа. Раньше многие компиляторы C++ не выполняли подобную проверку. В результате программисты часто тратили часы, пытаясь найти ошибки, возникающие из-за того, что вместо ожидаемого значения типа float в функцию передавалось значение типа int. Если вы встречаете синтаксическую ошибку, которая возникает из-за противоречия с прототипом функции, будьте благодарны. В прошлом компилятор не определял подобную ошибку, и ваша программа просто не работала.
ЧТО ВАМ НЕОБХОДИМО ЗНАТЬ
Из этого урока вы узнали, как использовать функции в программах на C++. Данный урок охватил целый ряд основных понятий, таких как параметры, типы возвращаемых значений и прототипы функций. Сейчас вы можете потратить несколько больше времени на эксперименты с простыми программами. Из урока 10 вы узнаете, как изменять значения параметров внутри функций. Однако до изучения урока 10 убедитесь, что вы освоили следующие основные концепции:
По мере усложнения ваших программ вам следует делить их на небольшие легко управляемые части, называемые функциями. Каждая функция должна иметь уникальное имя. Присваивайте вашим функциям имена, выражающие смысл задач, которые выполняют функции.
Функции могут возвращать значение вызвавшей функции. При этом вы должны указать тип возвращаемого функцией значения (int, char и т. д.) до имени функции, в противном случае вы должны предварять имя функции словом void.
Программы передают информацию в функции с помощью параметров. Если функция получает параметры, вы должны указать уникальное имя и тип каждого параметра. Если функция не получает параметры, вы должны поместить ключевое слово void внутри круглых скобок, следующих за именем функции.
C++ должен знать тип возвращаемого значения и количество и тип параметров, которые получает функция. Если определение функции следует за использованием функции, вы должны поместить прототип функции в начале исходного файла.