Функцията е подпрограма, която може да бъде извикана от главната програма, за извършване на определена задача. Например, ако имаме код, който се повтаря на много места в нашата програма, би било добре, ако го напишем във функция и я извикваме на всички места, когато ни потрябва, вместо да копираме кода отново и отново. Можем да декларираме функции по-същия начин, както декларираме и главната функция. Пример за функция, отпечатваща „Hello“:

  1. void PrintHello()
  2. {
  3.        cout << „Hello“ << endl;
  4. }

От какъв тип ще декларираме функцията, зависи от това какъв тип данни ще връща функцията след изпълнението си. В примера използваме тип void, защото не желаем функцията да връща никаква стойност. Ето как можем да извикаме нашата функция от главната main() функция:

  1. int main()
  2. {
  3.      PrintHello();
  4.      return 0;
  5. }

Забележете, че main() функцията е от тип int, защото в края на изпълнението й връщаме цяло число (return 0).

Вече след като можем да правим програми с повече от една функция, е хубаво да си припомним, че променливите се делят на локални и глобални (Справка C++ Променливи). Пример:

  1. int a; // глобална променлива
  2. void MyFunction()
  3. {
  4. int b; // локална променлива
  5. b = 5;
  6. a = 7;
  7. }
  8. int main()
  9. {
  10. a = 3;
  11. return 0;
  12. }

За да прехвърляме стойности между функциите трябва да използваме параметри. Те се дефинират между скобите, които са след името на функцията. Трябва да дефинираме типа данни за всеки параметър поотделно. Сега ще направим функция, която получава число като параметър и го отпечатва в конзолата:

  1. void PrintNumber(int n)
  2. {
  3.        cout << n << endl;
  4. }
  5. int main()
  6. {
  7.      PrintNumber(6);
  8.      return 0;
  9. }

Забележете как извикваме функцията от главната main() функция – PrintNumber(6), това означава, че нашата фунция ще бъде извикана с числото 6, това ще бъде и числото, което ще се отпечата в конзолата. Ако искаме да прехвърляме повече от един параметър, трябва да ги разделяме със запетая:

  1. void PrintNumber(int n, int m)
  2. {
  3.         cout << n << m << endl;
  4. }
  5. int main()
  6. {
  7.      PrintNumber(6, 5);
  8.      return 0;
  9. }

Задача 1: Напишете функция, която да отпечатва в конзолата сумата от две double числа. Например при извикване на вашата функция от main() функцията по следния начин: sum(5.6, 10.1), изходът в конзолата трябва да бъде 15.7.

Досега разглеждахме примери само с void функции, тоест фунции, които не връщат стойност към функцията, която ги е извикала. Нека разгледаме една функция, която връща цели числа (тип int):

  1. int GetNumber()
  2. {
  3. return 10; // стойности се връщат с помощта на ключовата дума return
  4. }
  5. int main()
  6. {
  7. int i = GetNumber(); // стойността, която функцията връща, се присвоява на променливата i
  8. return 0;
  9. }

След изпълнението на този код, стойността на променливата i ще бъде 10. Може да проверите това като я отпечатате.

А сега да приложим наученото в този урок, като направим програма, която пресмята квадрата на число, въведено от клавиатурата:

  1. #include <iostream>
  2. using namespace std;
  3. double func(double n){
  4. return n*n;
  5. }
  6. int main()
  7. {
  8.      double a;
  9.      cout<<„a = „;
  10.      cin>>a;
  11.      cout<<„a^2 = „<<func(a);
  12.      return 0;
  13. }

Задача 2: Променете вашата програма от първа задача, така че да връща сумата на двете числа, вместо да я отпечатва. След това може да отпечатате сумата от главната main() функция.
(Подсказка: Дефинирайте функцията си от тип double)

Вече знаем как се работи с параметри във функциите, но сигурно се питате: Как мога да прехвърлям цели масиви като параметър? Представете си например, че имате масив с цели числа и искате да направите функция, която да връща сумата на елементите от масива. Да, това е напълно възможно да се направи, но първо трябва да научим за Указателите в C++.

Автор: Мартин Михайлов