Function declaration

선언 에서 언급된 바와 같이, 선언자 뒤에는 requires 절 이 올 수 있으며, 이는 함수의 연관된 제약 조건 을 선언합니다. 이 제약 조건은 오버로드 해결 에 의해 함수가 선택되기 위해 충족되어야 합니다. (예시: void f1 ( int a ) requires true ; ) 연관된 제약 조건은 함수 시그니처의 일부이지만, 함수 타입의 일부는 아닙니다.

volatile 한정 객체 타입을 매개변수 타입이나 반환 타입으로 사용하는 것은 deprecated되었습니다.

다른 선언과 마찬가지로, 선언 앞에 나타나는 속성과 선언자 내 식별자 바로 뒤에 나타나는 속성 모두 선언되거나 정의되는 개체(이 경우 함수)에 적용됩니다:

[[noreturn]] void f [[noreturn]] (); // OK: 두 속성 모두 함수 f에 적용됨

그러나 선언자 뒤에 나타나는 속성(위 구문에서)은 함수 자체가 아닌 함수의 타입에 적용됩니다:

void f() [[noreturn]]; // 오류: 이 속성은 함수 자체에 아무런 영향을 미치지 않음

반환 타입 추론

함수 선언의 decl-specifier-seq 에 auto 키워드가 포함된 경우, 후행 반환 타입을 생략할 수 있으며 컴파일러가 폐기되지 않은 return 문에서 사용된 피연산자의 타입으로부터 추론합니다. 반환 타입이 decltype ( auto ) 를 사용하지 않는 경우, 추론은 템플릿 인수 추론 의 규칙을 따릅니다:

int x = 1;
auto f() { return x; }        // 반환 타입은 int
const auto& f() { return x; } // 반환 타입은 const int&

반환 타입이 decltype ( auto ) 인 경우, 반환 타입은 반환문에서 사용된 피연산자가 decltype 으로 감싸진 것과 동일하게 얻어집니다:

int x = 1;
decltype(auto) f() { return x; }  // 반환 타입은 int, decltype(x)와 동일
decltype(auto) f() { return(x); } // 반환 타입은 int&, decltype((x))와 동일

(참고: “ const decltype ( auto ) & ”는 오류입니다. decltype ( auto ) 는 반드시 단독으로 사용되어야 합니다)

여러 개의 return 문이 있는 경우, 모두 동일한 타입으로 추론되어야 합니다:

auto f(bool val)
{
    if (val) return 123; // 반환 타입 int로 추론됨
    else return 3.14f;   // 오류: 반환 타입 float로 추론됨
}

반환문이 없거나 반환문의 피연산자가 void 표현식인 경우(피연산자가 없는 반환문 포함), 선언된 반환 타입은 반드시 다음 중 하나여야 합니다: decltype ( auto ) , 이 경우 추론된 반환 타입은 void 입니다, 또는 (possibly cv-qualified) auto , 이 경우 추론된 반환 타입은 (동일하게 cv-qualified) void 가 됩니다:

auto f() {}              // void를 반환
auto g() { return f(); } // void를 반환
auto* x() {}             // 오류: void에서 auto*를 추론할 수 없음

함수에서 return 문이 한 번 확인되면, 해당 문에서 추론된 반환 타입은 함수의 나머지 부분, 다른 return 문을 포함하여 사용될 수 있습니다:

auto sum(int i)
{
    if (i == 1)
        return i;              // sum의 반환 타입은 int
    else
        return sum(i - 1) + i; // OK: sum의 반환 타입은 이미 알려져 있음
}

반환문이 중괄호로 둘러싸인 초기화 리스트 를 사용하는 경우, 추론은 허용되지 않습니다:

auto func() { return {1, 2, 3}; } // 오류

가상 함수 와 코루틴 (C++20부터) 은 반환형 추론을 사용할 수 없습니다:

struct F
{
    virtual auto f() { return 2; } // 오류
};

함수 템플릿 중 사용자 정의 변환 함수 를 제외한 다른 함수 템플릿들은 반환형 추론을 사용할 수 있습니다. 반환문의 표현식이 의존적 이지 않더라도 추론은 인스턴스화 시점에 발생합니다. 이 인스턴스화는 SFINAE 의 목적상 즉시 문맥에 속하지 않습니다.

template<class T>
auto f(T t) { return t; }
typedef decltype(f(1)) fint_t;    // f<int>를 인스턴스화하여 반환 타입을 추론함
template<class T>
auto f(T* t) { return *t; }
void g() { int (*p)(int*) = &f; } // 두 f를 모두 인스턴스화하여 반환 타입을 결정하고,
                                  // 두 번째 템플릿 오버로드를 선택함

반환형 추론을 사용하는 함수 또는 함수 템플릿의 재선언 또는 특수화는 동일한 반환형 자리 표시자를 사용해야 합니다:

auto f(int num) { return num; }
// int f(int num);            // 오류: 자리 표시자 반환 타입 없음
// decltype(auto) f(int num); // 오류: 다른 자리 표시자
template<typename T>
auto g(T t) { return t; }
template auto g(int);     // OK: 반환 타입은 int
// template char g(char); // 오류: 기본 템플릿 g의 특수화가 아님

마찬가지로, 반환형 추론을 사용하지 않는 함수나 함수 템플릿의 재선언이나 특수화는 플레이스홀더를 사용해서는 안 됩니다:

int f(int num);
// auto f(int num) { return num; } // 오류: f의 재선언이 아님
template<typename T>
T g(T t) { return t; }
template int g(int);      // OK: T를 int로 특수화
// template auto g(char); // 오류: 기본 템플릿 g의 특수화가 아님

명시적 인스턴스화 선언 은 반환 타입 추론을 사용하는 함수 템플릿을 자체적으로 인스턴스화하지 않습니다:

template<typename T>
auto f(T t) { return t; }
extern template auto f(int); // f<int>를 인스턴스화하지 않음
int (*p)(int) = f; // 반환 타입을 결정하기 위해 f<int>를 인스턴스화하지만,
                   // 명시적 인스턴스화 정의는 여전히 프로그램 어딘가에 필요함

함수 매개변수 중 하나라도 placeholder ( auto 또는 concept type )를 사용하면, 해당 함수 선언은 abbreviated function template 선언이 됩니다:

void f1(auto);    // same as template<class T> void f1(T)
void f2(C1 auto); // same as template<C1 T> void f2(T), if C1 is a concept

this 지정자를 가진 매개변수 선언( ( 2 ) / ( 5 ) 구문)은 explicit object parameter 를 선언합니다.

explicit object parameter는 function parameter pack 이 될 수 없으며, 다음 선언들의 매개변수 목록에서 첫 번째 매개변수로만 나타날 수 있습니다:

• member function 또는 member function template의 선언
• 템플릿화된 멤버 함수의 explicit instantiation 또는 explicit specialization
• lambda 선언

explicit object parameter를 가진 멤버 함수에는 다음과 같은 제한이 있습니다:

• 함수는 static 일 수 없습니다.
• 함수는 virtual 일 수 없습니다.
• 함수의 선언자에 cv 와 ref 가 포함될 수 없습니다.

struct C
{
    void f(this C& self);     // OK
    template<typename Self>
    void g(this Self&& self); // also OK for templates
    void p(this C) const;     // Error: “const” not allowed here
    static void q(this C);    // Error: “static” not allowed here
    void r(int, this C);      // Error: an explicit object parameter
                              //        can only be the first parameter
};
// void func(this C& self);   // Error: non-member functions cannot have
                              //        an explicit object parameter

• 예외 명세가 non-throwing 인 경우, 선언된 함수의 타입은
  "derived-declarator-type-list noexcept function of
  parameter-type-list cv  (optional) ref   (optional) returning T "입니다.

구문 (2) 에서, noptr-declarator 를 독립적인 선언으로 가정할 때, noptr-declarator 내의 qualified-id 또는 unqualified-id 의 타입이 "derived-declarator-type-list T "로 주어지면
( T 는 이 경우 auto 여야 함):

• 예외 명세가 non-throwing 인 경우, 선언된 함수의 타입은
  "derived-declarator-type-list noexcept function of
  parameter-type-list cv  (선택사항) ref   (선택사항) returning trailing "입니다.

• 그렇지 않으면 (C++17 이전) 그렇지 않으면 (C++17부터) 선언된 함수의 타입은
  "derived-declarator-type-list function of
  parameter-type-list cv  (선택사항) ref   (선택사항) returning trailing "입니다.

attr 이 있는 경우, 함수 타입에 적용됩니다.

• ref

• 후행 requires 절

• 함수가 후행 requires 절을 가진 비템플릿 friend 함수인 경우, 해당 시그니처는 바깥 네임스페이스 대신 바깥 클래스를 포함합니다. 시그니처는 또한 후행 requires 절도 포함합니다.

함수 정의에 virt-specs 가 포함된 경우, 이는 반드시 멤버 함수 를 정의해야 합니다.

함수 정의에 requires-clause 가 포함된 경우, 이는 반드시 템플릿 함수 를 정의해야 합니다.

디폴트 함수

함수 정의가 구문 ( 3 ) 인 경우, 해당 함수는 명시적으로 기본 정의됨 으로 정의됩니다.

명시적으로 기본 설정된 함수는 특수 멤버 함수 또는 비교 연산자 함수 (C++20부터) 여야 하며, 기본 인자 를 가져서는 안 됩니다.

명시적으로 기본 설정된 특수 멤버 함수 F1 은 암시적으로 선언되었을 해당 특수 멤버 함수 F2 와 다음과 같이 다를 수 있습니다:

• F1 와 F2 는 서로 다른 ref 및/또는 except 를 가질 수 있습니다.
• 만약 F2 가 const C & 타입의 비객체 매개변수를 갖는 경우, F1 의 해당 비객체 매개변수는 C& 타입일 수 있습니다.

F1 의 타입이 F2 의 타입과 선행 규칙에서 허용된 방식 이외의 방식으로 다른 경우:

• 만약 F1 이 대입 연산자이고, F1 의 반환 타입이 F2 의 반환 타입과 다르거나 F1 의 비객체 매개변수 타입이 참조가 아닌 경우, 프로그램의 형식이 올바르지 않습니다.
• 그렇지 않고 F1 이 첫 번째 선언에서 명시적으로 기본값으로 지정된 경우, 삭제된 것으로 정의됩니다.
• 그 외의 경우, 프로그램의 형식이 올바르지 않습니다.

첫 번째 선언에서 명시적으로 기본값으로 설정된 함수는 암시적으로 inline 이며, 가능한 경우 암시적으로 constexpr function 입니다.

struct S
{
    S(int a = 0) = default;             // 오류: 기본 인수
    void operator=(const S&) = default; // 오류: 일치하지 않는 반환 타입
    ~S() noexcept(false) = default;     // OK, 다른 예외 명세
private:
    int i;
    S(S&);          // OK, private 복사 생성자
};
S::S(S&) = default; // OK, 복사 생성자 정의

명시적으로 기본 설정된 함수와 암시적으로 선언된 함수를 통칭하여 기본 설정된 함수라고 합니다. 이들의 실제 정의는 암시적으로 제공되며, 자세한 내용은 해당 페이지를 참조하십시오.

삭제된 함수

함수 정의가 구문 ( 4 ) 또는 ( 5 ) (C++26부터) 인 경우, 해당 함수는 명시적으로 삭제된(explicitly deleted) 것으로 정의됩니다.

삭제된 함수의 모든 사용은 잘못된 형식입니다(프로그램이 컴파일되지 않습니다). 여기에는 명시적 호출(함수 호출 연산자 사용)과 암시적 호출(삭제된 오버로딩된 연산자, 특수 멤버 함수, 할당 함수 등에 대한 호출), 삭제된 함수에 대한 포인터 또는 멤버 포인터 생성, 그리고 잠재적으로 평가될 수 있는 표현식 이 아닌 표현식에서 삭제된 함수의 사용까지 포함됩니다.

순수하지 않은 가상 멤버 함수는 암묵적으로 odr-used 되더라도 삭제된(deleted) 함수로 정의될 수 있습니다. 삭제된 함수는 삭제된 함수로만 오버라이드할 수 있으며, 삭제되지 않은 함수는 삭제되지 않은 함수로만 오버라이드할 수 있습니다.

함수가 오버로드된 경우, 오버로드 해결 이 먼저 수행되며, 삭제된 함수가 선택된 경우에만 프로그램이 잘못된 형식입니다:

struct T
{
    void* operator new(std::size_t) = delete;
    void* operator new[](std::size_t) = delete("new[] is deleted"); // C++26부터
};
T* p = new T;    // 오류: 삭제된 T::operator new 호출 시도
T* p = new T[5]; // 오류: 삭제된 T::operator new[] 호출 시도,
                 //        "new[] is deleted" 진단 메시지 출력

삭제된 함수의 정의는 반드시 번역 단위에서 첫 번째 선언이어야 합니다: 이전에 선언된 함수를 삭제된 함수로 재선언할 수 없습니다:

struct T { T(); };
T::T() = delete; // 오류: 첫 번째 선언에서 삭제되어야 함

사용자 제공 함수

함수는 첫 번째 선언에서 명시적으로 기본 설정되거나 삭제되지 않은 사용자 선언 함수인 경우 사용자 제공(user-provided) 입니다. 사용자 제공 명시적 기본 함수(즉, 첫 번째 선언 이후 명시적으로 기본 설정된 함수)는 명시적으로 기본 설정된 지점에서 정의됩니다; 이러한 함수가 암시적으로 삭제된 것으로 정의되면 프로그램은 ill-formed입니다. 첫 번째 선언 이후 함수를 기본 설정으로 선언하면 진화하는 코드 베이스에 안정적인 바이너리 인터페이스를 제공하면서도 효율적인 실행과 간결한 정의를 제공할 수 있습니다.

// "trivial"의 모든 특수 멤버 함수들은
// 각각 첫 번째 선언에서 기본값으로 설정되었으며,
// 사용자 제공(user-provided)이 아닙니다
struct trivial
{
    trivial() = default;
    trivial(const trivial&) = default;
    trivial(trivial&&) = default;
    trivial& operator=(const trivial&) = default;
    trivial& operator=(trivial&&) = default;
    ~trivial() = default;
};
struct nontrivial
{
    nontrivial(); // 첫 번째 선언
};
// 첫 번째 선언에서 기본값으로 설정되지 않았으며,
// 사용자 제공(user-provided)이며 여기서 정의됩니다
nontrivial::nontrivial() = default;

모호성 해결

함수 본문과 initializer 가 { 또는 = (C++26부터) 로 시작하는 경우의 모호함이 있을 때, 이 모호함은 declarator identifier 의 타입을 확인하여 해결됩니다 noptr-declarator :

• 타입이 함수 타입인 경우, 모호한 토큰 시퀀스는 함수 본문으로 처리됩니다.
• 그렇지 않은 경우, 모호한 토큰 시퀀스는 초기화자로 처리됩니다.

using T = void(); // 함수 타입
using U = int;    // 비-함수 타입
T a{}; // 아무 작업도 하지 않는 함수를 정의
U b{}; // int 객체를 값 초기화
T c = delete("hello"); // 함수를 삭제된 것으로 정의
U d = delete("hello"); // int 객체를 delete 표현식의 결과로
                       // 복사 초기화 (잘못된 형식)

__func__

함수 본문 내에서, 함수-지역 사전 정의 변수 __func__ 는 다음과 같이 정의된 것처럼 정의됩니다

static const char __func__[] = "function-name";

이 변수는 블록 범위와 정적 저장 기간을 가집니다:

struct S
{
    S(): s(__func__) {} // OK: 초기화 목록은 함수 본문의 일부입니다
    const char* s;
};
void f(const char* s = __func__); // 오류: 매개변수 목록은 선언자의 일부입니다

#include <iostream>
void Foo() { std::cout << __func__ << ' '; }
struct Bar
{
    Bar() { std::cout << __func__ << ' '; }
    ~Bar() { std::cout << __func__ << ' '; }
    struct Pub { Pub() { std::cout << __func__ << ' '; } };
};
int main()
{
    Foo();
    Bar bar;
    Bar::Pub pub;
}

Foo Bar Pub ~Bar

함수 계약 지정자

함수 선언과 람다 표현식 은 일련의 함수 계약 지정자  를 포함할 수 있으며, 각 지정자는 다음 구문을 가집니다:

사전 조건 단언과 사후 조건 단언을 통칭하여 함수 계약 단언  이라고 합니다.

함수 계약 단언은 계약 단언 이 함수와 연관된 것입니다. 함수 계약 단언의 술어는 그 predicate contextually converted to bool 입니다.

다음 함수들은 함수 계약 지정자와 함께 선언될 수 없습니다:

• 가상 함수
• 삭제된 함수
• 첫 번째 선언에서 기본값으로 지정된 함수

사전 조건 어서션

사전 조건 어설션은 함수 진입과 연관되어 있습니다:

int divide(int dividend, int divisor) pre(divisor != 0)
{
    return dividend / divisor;
}
double square_root(double num) pre(num >= 0)
{
    return std::sqrt(num);
}

사후 조건 단언문

사후 조건 단언은 함수가 정상적으로 종료될 때와 연관됩니다.

사후 조건 단언문에 identifier 가 있는 경우, 함수 계약 지정자는 identifier 를 해당 함수의 결과 바인딩(result binding) 이름으로 도입합니다. 결과 바인딩은 해당 함수 호출로 반환된 객체나 참조를 나타냅니다. 결과 바인딩의 타입은 해당 함수의 반환 타입입니다.

int absolute_value(int num) post(r : r >= 0)
{
    return std::abs(num);
}
double sine(double num) post(r : r >= -1.0 && r <= 1.0)
{
    if (std::isnan(num) || std::isinf(num))
        // 예외를 통한 종료는 계약 위반을 야기하지 않음
        throw std::invalid_argument("잘못된 인수");
    return std::sin(num);
}

사후 조건 단언문에 식별자 가 있고, 관련 함수의 반환 타입이 (cv 한정자가 있을 수 있는) void 인 경우, 프로그램은 잘못된 형식입니다:

void f() post(r : r > 0); // 오류: "r"에 바인딩할 수 있는 값이 없음

비템플릿 함수의 선언된 반환 타입에 placeholder type 이 포함된 경우, identifier 를 가진 사후 조건 어설션은 함수 정의에서만 나타날 수 있습니다:

auto g(auto&) post(r : r >= 0); // OK, "g"는 템플릿입니다
auto h() post(r : r >= 0);      // 오류: 반환값을 명명할 수 없음
auto k() post(r : r >= 0)       // OK, "k"는 정의입니다
{
    return 0;
}

계약 일관성

함수 또는 함수 템플릿 func 의 재선언 D 은 contract-specs 를 전혀 가지지 않거나, D 에서 도달 가능한 첫 번째 선언 F 와 동일한 contract-specs 를 가져야 합니다. D 와 F 가 서로 다른 번역 단위에 있는 경우, D 가 명명된 모듈에 연결된 경우에만 진단이 필요합니다.

선언 F1 이 하나의 번역 단위에서 func 의 첫 번째 선언이고, 선언 F2 가 다른 번역 단위에서 func 의 첫 번째 선언인 경우, F1 과 F2 는 동일한 contract-specs 를 지정해야 하며, 진단은 요구되지 않습니다.

두 개의 contract-specs 는 동일한 순서로 동일한 함수 계약 지정자로 구성된 경우 동일합니다.

함수 계약 지정자 C1 이 함수 선언 D1 에 있을 때, 다음의 모든 조건이 충족되면 함수 계약 지정자 C2 가 함수 선언 D2 에 있는 것과 동일합니다:

• C1 과 C2 의 predicate 는 다음 재명명을 제외하고 선언 D1 과 D2 에 각각 위치한 함수 정의에 놓였을 때 one-definition rule 을 충족할 것입니다( D1 과 D2 가 서로 다른 번역 단위에 있는 경우, 각 predicate 내에 정의된 해당 개체들은 단일 정의를 가진 단일 개체인 것처럼 동작함):
  • 선언된 함수의 매개변수 재명명
  • 선언된 함수를 포함하는 템플릿의 템플릿 매개변수 재명명
  • 결과 바인딩(있는 경우)의 재명명
• C1 과 C2 모두 identifier 를 가지거나 둘 다 가지지 않습니다.

이 조건이 오직 두 개의 람다 표현식 비교로 인해 충족되지 않고, 이 람다 표현식들이 predicate s 내에 포함된 경우, 진단이 요구되지 않습니다.

bool b1, b2;
void f() pre (b1) pre([]{ return b2; }());
void f(); // OK, 함수 계약 지정자가 생략됨
void f() pre (b1) pre([]{ return b2; }()); // 오류: 클로저의 타입이 다름
void f() pre (b1); // 오류: 함수 계약 지정자가 다름
int g() post(r : b1);
int g() post(b1); // 오류: 결과 바인딩이 없음
namespace N
{
    void h() pre (b1);
    bool b1;
    void h() pre (b1); // 오류: 함수 계약 지정자가 일치하지 않음
                       //        (일 정의 규칙에 따라)
}