함수

함수를 사용하면 개별 작업을 수행하기 위해 코드 블럭으로 프로그램을 구성할 수 있습니다.

C++에서 함수는 이름이 주어지고 프로그램의 특정 지점에서 호출될 수 있는 명령문의 그룹입니다. 함수를 정의하는 가장 일반적인 구문은 다음과 같습니다. 

type name ( parameter1, parameter2, ...) { statements }

type 반환되는 데이터의 타입입니다.

name 함수의 이름입니다.

(parameter 1,  parameter 2, …), 전달인자 입니다. 호출된 위치에서 함수에 인수를 전달할 수 있도록 하는 것입니다.

- statements함수의 본체입니다. 함수가 실제로 수행하는 작업을 지정하는 중괄호 { }로 둘러싸인 명령문 블록입니다.

예를 살펴보겠습니다.

// function example
#include <iostream>
using namespace std;

int addition (int a, int b)
{
  int r;
  r=a+b;
  return r;
}

int main ()
{
  int z;
  z = addition (5,3);
  cout << "The result is " << z;
}

The result is : 8

위의 예에서 전달인자(argument)가 매개변수(parameter)에 복사가 되어서 넘어가게 된다.

 

return r;

Return 키워드가 실행되면 해당 함수에서 return 값이 함수를 호출한 main으로 돌아가

Z변수에 값을 넣어줄수 있게 됩니다.

 

그런 다음 main은 다음을 호출하여 이 값을 간단히 인쇄합니다.

cout << "The result is " << z;

함수는 실제로 프로그램 내에서 여러 번 호출될 수 있으며 해당 인수는 당연히 리터럴에만 국한되지 않습니다.

// function example
#include <iostream>
using namespace std;

int subtraction (int a, int b)
{
  int r;
  r=a-b;
  return r;
}

int main ()
{
  int x=5, y=3, z;
  z = subtraction (7,2);
  cout << "The first result is " << z << '\n';
  cout << "The second result is " << subtraction (7,2) << '\n';
  cout << "The third result is " << subtraction (x,y) << '\n';
  z= 4 + subtraction (x,y);
  cout << "The fourth result is " << z << '\n';
}

첫 번째 결과는 5입니다.
두 번째 결과는 5입니다.
세 번째 결과는 2입니다.
네 번째 결과는 6입니다

 

void 타입 함수

함수에 대해 위에 표시된 구문: 타입 으로 시작하는 선언이 필요합니다. 이것은 함수가 반환하는 값의 유형입니다. 하지만 함수가 값을 반환할 필요가 없다면 어떻게 될까요? 이때 사용되는 타입은 , 값이 없음을 나타내는 특수한 타입이다. 예를 들어, 단순히 메시지를 출력하는 함수는 어떤 값도 반환할 필요가 없을 수 있습니다:

// void function example
#include <iostream>
using namespace std;

void printmessage ()
{
  cout << "I'm a function!";
}

int main ()
{
  printmessage ();
}

"I'm a function!"

void함수의 매개변수 목록에서 함수가 호출될 때 실제 매개변수를 사용하지 않도록 명시적으로 지정할 수도 있습니다. 예를 들어 다음 printmessage과 같이 선언할 수 있습니다.

void printmessage (void)
{
  cout << "I'm a function!";
}

main의 반환 값

값	설명
0	프로그램은 성공적이었다
EXIT_SUCCESS	프로그램이 성공했습니다(위와 동일). 이 값은 header 에 정의되어 <cstdlib>있습니다.
EXIT_FAILURE	프로그램이 실패했습니다. 이 값은 header 에 정의되어 <cstdlib>있습니다.

 

 

전달인자(argument)

앞에서 본 함수에서 인수는 항상 값으로 전달되었습니다 . 즉, 함수를 호출할 때 함수에 전달되는 것은 호출 순간에 이러한 인수의 값이며 함수 매개변수가 나타내는 변수에 복사됩니다. 예를 들면 다음과 같습니다.

int x=5, y=3, z;
z = addition ( x, y );

X, y의 경우, 함수 추가는 각각 및 의 값의 복사본인 5와 3이 전달 됩니다. 

 

그러나 어떤 경우에는 함수 내에서 외부 변수를 직접적으로 수정하는 경우가 유용할 수 있습니다.  그렇게 하려면 값 대신 참조 로 인수를 전달할 수 있습니다 . 

// passing parameters by reference
#include <iostream>
using namespace std;

void duplicate (int& a, int& b, int& c)
{
  a*=2;
  b*=2;
  c*=2;
}

int main ()
{
  int x=1, y=3, z=7;
  duplicate (x, y, z);
  cout << "x=" << x << ", y=" << y << ", z=" << z;
  return 0;
}

x=2, y=6, z=14

참조는 복사본이 아닌 원본 그대로의 변수가 매개변수에 들어가게 됩니다. 

 

밑에는 참조 로 전달되지 않고 값으로 전달되어 값 의 복사본을 대신 생성합니다. 이 경우 프로그램의 출력은 수정되지 않은 x, y, 값 z이 됩니다(즉, 1, 3, 7).

void duplicate (int& a, int& b, int& c)
void duplicate (int a, int b, int c)

 

 

효율성 고려 사항 및 const 참조

값을 그대로 복사해서 인자로 넘겨주게 되면 모든 값들을 복사해주어야 하기 떄문에

생각보다 많은 부하가 생길수 있습니다.

string concatenate (string a, string b)
{
  return a+b;
}

그러나 두 매개변수가 모두 참조 되는 경우 이 복사를 모두 피할 수 있습니다 .

string concatenate (string& a, string& b)
{
  return a+b;
}

참조에 의한 인수에는 사본이 필요하지 않습니다. 함수는 인수로 전달된 문자열(별칭)에서 직접 작동하며 기껏해야 함수에 대한 특정 포인터를 전달하는데  이와 관련하여 참조를 받는 버전은 값을 받는 버전보다 복사 비용이 많이 적게 들어 훨씬 효율적 입니다.

참조 매개변수가 이 함수에 의해 수정되지 않도록 보장하려면 const 를 붙여 상수화 시키는 방법도 있습니다.

string concatenate (const string& a, const string& b)
{
  return a+b;
}

const의 값을 수정할 수 없지만 실제로 문자열의 실제 복사본을 만들지 않고도 참조(인수의 별칭)로 해당 값에 접근 할 수 있습니다. 

 

인라인 함수

함수를 호출하면 일반적으로 특정 오버헤드(인수 쌓기, 점프 등...)가 발생하므로 매우 짧은 함수의 경우 프로세스를 수행하는 대신 호출된 함수의 코드를 단순히 삽입하는 것이 더 효율적일 수 있습니다. 

Inline을 선언하면 특정 함수에 대한 일반적인 함수 호출 메커니즘보다 인라인 확장이 선호됨을 컴파일러에 알립니다. 이것은 함수의 동작을 전혀 변경하지 않지만, 일반 함수 호출로 호출되는 대신 함수 본문에 의해 생성된 코드가 함수가 호출되는 각 지점에 삽입되어야 한다는 컴파일러를 제안하는 데만 사용됩니다.

예를 들어 위의 연결 함수는 인라인으로 다음과 같이 선언할 수 있습니다.

inline string concatenate (const string& a, const string& b)
{
  return a+b;
}

이것은 컴파일러가 concatenate가 호출될 때 프로그램이 일반 호출을 수행하는 대신 인라인으로 확장되는 함수를 선호한다는 것을 알려줍니다. inline호출될 때가 아니라 함수 선언에서만 지정됩니다.

대부분의 컴파일러는 명시적으로 지정자로 표시되지 않은 경우에도 효율성을 개선할 기회가 있을 때 인라인 함수를 생성하도록 코드를 이미 최적화 inline합니다. 따라서 이 지정자는 컴파일러가 이 함수에 대해 인라인이 선호됨을 나타낼 뿐이지만 컴파일러는 인라인하지 않고 그렇지 않으면 최적화할 수 있습니다. C++에서 최적화는 컴파일러에 위임된 작업입니다.

 

매개변수의 기본값

C++에서 함수는 호출에 인수가 필요하지 않은 선택적 매개변수를 가질 수도 있습니다. 이를 위해 함수는 더 적은 인수로 호출될 때 함수에서 사용되는 마지막 매개변수에 대한 기본값을 설정 해줄 수 있습니다.

// default values in functions
#include <iostream>
using namespace std;

int divide (int a, int b=2)
{
  int r;
  r=a/b;
  return (r);
}

int main ()
{
  cout << divide (12) << '\n';
  cout << divide (20,4) << '\n';
  return 0;
}

6
5

이 예에서는 function 에 대한 두 개의 호출이 있습니다 divide. 첫 번째에서:

divide (12)

함수에 두 개의 매개변수가 있더라도 호출은 하나의 인수만 함수에 전달합니다. 이 경우 함수는 두 번째 매개변수를 2로 가정합니다(함수 정의에서 두 번째 매개변수를 로 선언함 int b=2). 따라서 결과는 6입니다

두 번째 호출에서:

divide (20,4)

호출은 함수에 두 개의 인수를 전달합니다. b따라서 ( ) 의 기본값 int b=2은 무시 b되고 인수로 전달된 값, 즉 4를 취하여 결과 5를 산출합니다.

 

함수 선언

통상적으로 함수를 사용하기 위해서는 해당함수보다 앞 부분에 존재해야 합니다.

하지만 함수가 더 코드의 뒤에 존재하더라도 앞부분해서 해당함수의 형태를 미리

선언해주면 사용이 가능합니다.

 

int protofunction (int first, int second);
int protofunction (int, int);

매개변수의 이름을 포함하면 가독성이 향상됩니다.

 

// declaring functions prototypes
#include <iostream>
using namespace std;

void odd (int x);
void even (int x);

int main()
{
  int i;
  do {
    cout << "Please, enter number (0 to exit): ";
    cin >> i;
    odd (i);
  } while (i!=0);
  return 0;
}

void odd (int x)
{
  if ((x%2)!=0) cout << "It is odd.\n";
  else even (x);
}

void even (int x)
{
  if ((x%2)==0) cout << "It is even.\n";
  else odd (x);
}

이 예는 실제로 효율성의 예가 아닙니다. 코드 줄의 절반으로 이 프로그램의 버전을 직접 작성할 수 있습니다. 어쨌든 이 예제는 정의 전에 함수를 선언하는 방법을 보여줍니다

 

 

재귀

재귀성은 함수가 스스로 호출되어야 하는 속성입니다. 요소 정렬 또는 숫자의 계승 계산과 같은 일부 작업에 유용합니다. 예를 들어, 숫자( )의 계승을 얻으려면 n!수학 공식은 다음과 같습니다.

n! = n * (n-1) * (n-2) * (n-3) ... * 1
더 구체적으로 5!(5의 계승)은 다음

5! = 5 * 4 * 3 * 2 * 1 = 120
과 같습니다. C++에서 이를 계산하는 재귀 함수는 다음과 같습니다.

 

// factorial calculator
#include <iostream>
using namespace std;

long factorial (long a)
{
  if (a > 1)
   return (a * factorial (a-1));
  else
   return 1;
}

int main ()
{
  long number = 9;
  cout << number << "! = " << factorial (number);
  return 0;
}

재귀 함수에서 우리는 자신에 대한 호출을 포함했지만 전달된 인수가 1보다 큰 경우에만, 그렇지 않으면 함수가 0에 도달하면 계속해서 모든 값을 곱하는 무한 재귀 루프를 수행하기 때문입니다.