C++/문법/람다 표현식

  관련 문서: C++

#!if 문서명2 != null
, [[함수형 프로그래밍]]

#!if 문서명3 != null
, [[람다식]]

#!if 문서명4 != null
, [[]]

#!if 문서명5 != null
, [[]]

#!if 문서명6 != null
, [[]]

1. 개요

2. 매개변수와 반환 자료형

#!syntax cpp
int main()
{
    // (1) 정수를 반환하는 람다 표현식
    auto lambda0 = [] { return 1; };

    // `lambda0_result`는 1
    auto lambda0_result = lambda0();
}

#!syntax cpp
int main()
{
    // (2) 정수를 반환하는 람다 표현식
    auto lambda1 = [] -> unsigned long { return 10UL; };

    // `lambda1_result`는 10ul
    auto lambda1_result = lambda1();

    // (3) 실수를 반환하는 람다 표현식
    // 이 람다 표현식은 정수를 실수로 변환한다.
    auto lambda2 = [] -> double { return 10; };

    // `lambda2_result`는 10.0
    auto lambda2_result = lambda2();
}

#!syntax cpp
int main()
{
     std::string left{ "Left" };
     std::string right{ "Right" };

    // (4) auto로 인자를 받아서 더한 뒤 반환하는 람다 표현식
    auto lambda3 = [](auto lhs, auto rhs) -> auto { return lhs + rhs; };

    // const char[7]
    auto str = "Tail";

    // `lambda4_result_a`는 std::string
    // `lambda4_result_a`의 값은 "LeftTail"
    auto lambda3_result_a = lambda3(left, str);

    // `lambda4_result_b`는 std::string
    // `lambda4_result_b`의 값은 "HeadRight"
    auto lambda3_result_b = lambda3("Head", right);

    // (5) decltype으로 반환 자료형을 명시한 람다 표현식
    auto lambda4 = [](auto lhs, auto rhs) -> decltype(lhs + rhs) { return lhs + rhs; };

    // `lambda4_result`는 std::string{ "LeftRight" }
    auto lambda4_result = lambda4(left, right);
}

#!syntax cpp
int main()
{
    // (6) 반환형을 auto로 명시한 람다 표현식
    auto lambda5 = [](float lhs, auto rhs) -> auto { return lhs * rhs; };

    // `lambda5_result_a`는 float
    // `lambda5_result_a`의 값은 30.0f
    auto lambda5_result_a = lambda5(10.0f, 3.0f);

    // `lambda5_result_b`는 float
    // `lambda5_result_b`의 값은 50.0f
    auto lambda5_result_b = lambda5(0.5, 100);
}

#!syntax cpp
import <numeric>;

struct [[nodiscard]] Rational
{
    unsigned long long num = 0;
    unsigned long long den = 0;

    [[nodiscard]]
    friend constexpr Rational operator+(const Rational& lhs, const Rational& rhs)
    {
        const auto lcm = std::lcm(lhs.den, rhs.den);
        const auto ltm = lcm / lhs.den;
        const auto rtm = lcm / rhs.den;

        return Rational{ lhs.num * ltm + rhs.num * rtm, lcm };
    }

    friend constexpr Rational& operator+=(Rational& lhs, const Rational& rhs)
    {
        return (lhs = lhs + rhs);
    }

    [[nodiscard]]
    friend constexpr Rational operator*(const Rational& lhs, const Rational& rhs)
    {
        const auto num = lhs.num * rhs.num;
        const auto den = lhs.den * rhs.den;
        const auto gcd = std::gcd(num, den);

        return Rational{ num / gcd, den / gcd };
    }

    friend constexpr Rational& operator*=(Rational& lhs, const Rational& rhs)
    {
        return (lhs = lhs * rhs);
    }

    [[nodiscard]]
    constexpr operator double() const
    {
        return static_cast<double>(num) / static_cast<double>(den);
    }
};

int main()
{
    constexpr Rational left{ 1, 10 }; // 10분의 1
    constexpr Rational right{ 3, 7 }; // 7분의 3

    // (7) auto로 인자를 받아서 곱한 뒤 반환하는 람다 표현식
    constexpr auto lambda6 = [](auto lhs, auto rhs) -> auto { return lhs * rhs; };

    // `lambda6_result`는 Rational
    // `lambda6_result`의 값은 Rational{ 3, 70 };
    constexpr auto lambda6_result = lambda6(left, right);

    // (8) 완벽한 전달로 인자를 받아서 더한 뒤 반환하는 람다 표현식
    constexpr auto lambda7 = [](auto&& lhs, auto&& rhs) -> decltype(lhs += rhs) { return lhs += rhs; };
    // 상동
    constexpr auto lambda7_alt = [](auto&& lhs, auto&& rhs) -> decltype(auto) { return lhs += rhs; };

    Rational next{ 5, 9 };

    // `lambda7_result`는 Rational&
    // `lambda7_result`의 값은 Rational{ 62, 63 };
    auto&& lambda7_result = lambda7(next, right);
}

#!syntax cpp
int main()
{
    // (9) 정수를 매개변수로 받아서 출력하는 람다 표현식
    auto lambda8 = [](int value) -> void { std::println(value); };

    std::vector list{ 0, 1, 2, 3, 4 }; // std::vector<int>

    for (auto v : list)
    {
        lambda8(v);
    }
}

#!syntax cpp
int main()
{
    // (10) 실수를 반환하는 람다 표현식
    auto lambda0 = [] { return 1.0; };

    // 상태를 가지고 있지 않은 람다 표현식은 함수 포인터에 저장이 가능하다.
    // 후술하겠지만 decltype(lambda0)은 클로저의 자료형을 반환하므로 주의.
    using lambda0_t = double(*)();
    lambda0_t lambda0_v = lambda0;
}

3. 람다 캡처

#!syntax cpp
short GetPort() noexcept
{
    return 10008;
}

int main()
{
    int i{ 5 };
    const int j{ 10 };

    // (1) 외부의 변수 `i`를 포섭. 이제 람다 표현식 안에서 `i`의 이름을 사용할 수 있다.
    [i] { std::println("`i` is {}", i); };

    // (2) 외부의 변수 `j`를 포섭. 포섭한 객체와 포섭 필드의 이름은 같아도 된다.
    [j = j] {};

    // (3) 외부의 변수 `i`를 포섭, `j`를 참조 포섭
    [i = std::move(i), &j] {};

    // (4) 변수 `port`를 포섭란에서 즉시 정의
    [port = GetPort()](std::string_view ip_address) {};
}

#!syntax cpp
int main()
{
    int i{ 1 };

    // (1) `i`를 포섭
    auto lambda0 = [i] -> void {
        std::println("{}",i);

        // 포섭된 `i`는 상수이므로 수정할 수 없음.
    };
    lambda0();

    // (2) `i`를 이름 `integer_inside`로 포섭
    // `i = i` 처럼 람다 외부와 내부의 이름은 중복되어도 문제없음.
    auto lambda1 = [integer_inside = i, i = i] -> void {
        std::println("{}",i);

        // 포섭된 `integer_inside`와 `i`는 상수이므로 수정할 수 없음.
    };

    // (3) `i`를 참조 포섭
    auto lambda2 = [&i] {
        std::println(i);

        // 람다 내부에서 `i`의 값은 4가 됨.
        i = 4;
    };
    lambda2();
    // 마찬가지로 람다 외부의 `i`의 값도 4가 됨.

    // (4) `i`를 이름 `integer_inside`로 참조 포섭
    auto lambda3 = [&integer_inside = i] {
        std::println("{}", integer_inside);

        // 람다 내부에서 `integer_inside`의 값은 5가 됨.
        integer_inside = 5;
    };
    lambda3();
    // 람다에서 외부의 `i`를 `integer_inside`로 참조했으므로 람다 외부의 `i`의 값도 5가 됨.
}

#!syntax cpp
// 전역 변수
int globalInteger;

int main()
{
    // 정적 변수
    static staticInteger = 0;

    // (1) 전역 변수는 그대로 사용할 수 있다.
    auto lambda0 = [] { return globalInteger * 5 };

    // (2) 정적 변수는 그대로 사용할 수 있다.
    [staticInteger] {};

    // (3) 컴파일 오류! 정적인 지속 시간을 가진 객체는 캡처할 수 없습니다.
    [globalInteger] {};
}

#!syntax cpp
struct Squirrel
{
    int myAge;

    constexpr Squirrel(int age = 0) noexcept
        : myAge(age)
    {}
};

// `Squirrel` 벡터를 받아서 시작 나이부터 `Squirrel`들의 나이를 증분시키는 함수
void enumerate_squirrels(std::vector<Squirrel>& list, int age_begin) noexcept
{
    for (auto& squirrel : list)
    {
        squirrel.myAge = age_begin++;
    }
}

int main()
{
    // 10개의 `Squirrel` 인스턴스가 담긴 std::vector 지역 변수
    std::vector<Squirrel> everySquirrels { 10 };

    // (1) `everySquirrels`를 포섭
    auto lambda0 = [squirrels = everySquirrels](int age_begin) {
        // 컴파일 오류! `enumerate_squirrels`의 인자 `list`에서 형식 한정자가 삭제되었습니다.
        // 즉 `std::vector<Squirrel>&`를 받는 함수에 `const std::vector<Squirrel>&`가 전달되어서 실행할 수 없음.
        enumerate_squirrels(squirrels, age_begin);

        // 포섭된 `squirrels`는 상수이므로 수정할 수 없음.
    };
    lambda0(3);
    // 람다 외부에 정의된 `everySquirrels`는 변화 없음.

    // (2) `everySquirrels`를 참조 포섭
    // `everySquirrels`를 그대로 기입해도 문제없음.
    auto lambda1 = [&squirrels = everySquirrels, &everySquirrels](int age_begin) {
        enumerate_squirrels(squirrels, age_begin);
        // 람다 내부에서 `squirrels`에 들어있는 `Squirrel` 인스턴스들의 `myAge`가 수정됨.
    };
    lambda1(3);
    // 마찬가지로 람다 외부에 정의된 `everySquirrels`도 수정됨.
}

4. 전방위 환경 포섭

#!syntax cpp
int main()
{
    // 지역 변수
    int i{ 10 };
    std::vector list{ 0, 1, 2, 3, 4 };

    // (1) 벡터 `list`를 참조 포섭, 변수 `i`를 참조 포섭
    // 벡터 `list`의 세번째 원소의 참조형을 반환하는 람다 표현식
    auto lambda0 = [&] -> decltype(auto) {
        return list.at(2);
    };

    // int& lambda0_result == 2
    auto&& lambda0_result = lambda0();

    // (2) 원래 '2'가 들어있었던 벡터 `list`의 두번째 원소에 '10'이 대입된다.
    // 벡터 `list`가 수정된다.
    lambda0_result = 10;

    // (3) 벡터 `list`를 포섭, 변수 `i`를 포섭
    // 벡터 `list`의 네번째 원소를 반환하는 람다 표현식
    auto lambda1 = [=] -> decltype(auto) {
        return list.at(3);
    };

    // int lambda1_result == 3
    auto&& lambda1_result = lambda1();

    // (4) 벡터 `list`를 포섭, 변수 `i`를 참조 포섭
    auto lambda2 = [&, list] {
        // 포섭된 `list`는 상수이므로 수정할 수 없음.
        //list[1] = 60;

        // 람다 표현식 외부의 `i`에 '20'이 대입된다.
        i = 20;
    };
    lambda2();
    // 람다 표현식 외부의 벡터 `list`는 변화없음.
    // 람다 표현식 외부의 `i`가 수정됨.

    // (5) 벡터 `list`를 참조 포섭, 변수 `i`를 포섭
    auto lambda3 = [=, &list] {
        // 람다 표현식 외부의 `list`의 두번째 원소에 '100'이 대입된다.
        list[1] = 60;

        // 포섭된 `i`는 상수이므로 수정할 수 없음.
        //i = 10;
    };
    lambda3();
    // 람다 표현식 외부의 벡터 `list`가 수정됨.
    // 람다 표현식 외부의 `i`는 변화없음.
}

5. 클래스 인스턴스 포섭

#!syntax cpp
class Captured
{
public:
    float myRatio;
    float myCross;

    void Method1()
    {
        // (1) 데이터 멤버 `myRatio`를 참조형으로 포섭
        auto setter = [&myRatio = myRatio](float value) { myRatio = value; };

        setter(200.0f);
    }

    void Method2()
    {
        // (2) 현재 문맥은 클래스의 인스턴스이므로 현재 인스턴스와 모든 멤버를 참조 포섭
        auto setter0 = [this](float value) { myRatio = value; i = 0; };

        // (3) 인스턴스와 모든 멤버를 참조 포섭
        auto setter1 = [&](float value) { myRatio = value; };

        // (4) 현재 문맥은 클래스의 인스턴스이므로 인스턴스와 모든 멤버를 참조 포섭
        auto setter3 = [=](float value) { myRatio = value; };

        // (5) 현재 문맥은 클래스의 인스턴스이므로 인스턴스와 모든 멤버를 참조 포섭
        // `myCross`는 `&`에 의해 포섭되므로 오류는 없지만 의미없는 구문임.
        auto setter2 = [&, &myCross = myCross](float value) { myCross = value; };

        // (6) 현재 인스턴스를 불변 참조 포섭
        // setter4는 외부의 인스턴스를 수정할 수 없음.
        auto setter4 = [*this](float value) { /* myRatio = value; */ };

        // (7) 참조자를 써서 현재 인스턴스를 참조 포섭
        auto setter5 = [&self = *this](float value) { self.myRatio = value; };

        // (8) 현재 인스턴스를 불변 참조 포섭
        // `=`에 의해 참조 포섭되었다가, 나중에 쓰인 `*this`에 의하여 불변 참조 포섭됨.
        // 결과적으로 setter6는 외부의 인스턴스에 영향을 끼치지 못함.
        auto setter6 = [=, *this](float value) { /* myRatio = value; */ };

        setter1(200.0f);
    }

    void ConstMethod() const
    {}

    [[nodiscard]]
    constexpr auto GetCrossAdder() noexcept
    {
        // (9) 현재 인스턴스를 참조형으로 포섭하고, 람다 표현식을 바로 반환함.
        // 이 람다 표현식은 클래스 `Captured`의 인스턴스를 참조함.
        return ([this](float rhs) { myCross += rhs; });
    }

    [[nodiscard]]
    constexpr auto GetMutableRatioAdder() noexcept
    {
        // (10) 현재 인스턴스를 불변 참조형으로 포섭하고, 람다 표현식을 바로 반환함.
        // 이 람다 표현식은 클래스 `Captured`의 인스턴스를 참조함.
        // 그런데 'mutable'로 명시되어서 불변 인스턴스를 수정할 수 있음.
        return ([*this](float rhs) mutable { myRatio += rhs; });
    }

    [[nodiscard]]
    constexpr auto GetRatioAdder() noexcept
    {
        // (11) 데이터 멤버 `myRatio`를 참조형으로 포섭하고, 람다 표현식을 바로 반환함.
        // 이 람다 표현식은 클래스 `Captured`의 인스턴스의 `myRatio`를 참조함.
        return ([&myRatio = myRatio](float rhs) { myRatio += rhs; });
    }

    // (12)
    // C++23 부터는 static 람다 표현식을 사용할 수 있음.
    static inline constexpr auto static_lambda = [=]() { std::println("Hello, world!"); };
};

constexpr Captured globalInstance{};
Captured globalMutableInstance{};

int main()
{
    // (13) 클래스 `Captured`의 상수 인스턴스를 포섭
    [inst = globalInstance] { inst.ConstMethod(); };

    // (14) 클래스 `Captured`의 상수 인스턴스를 참조 포섭
    [&inst = globalInstance] { inst.ConstMethod(); };

    // (15) 클래스 `Captured`의 인스턴스를 참조 포섭
    [&globalMutableInstance] { globalMutableInstance.Method1(); };

    // (16) 클래스 `Captured`의 인스턴스를 참조 포섭
    [&inst = globalMutableInstance] { inst.Method2(); };

    // (17) 클래스 `Captured`의 인스턴스를 포섭
    // `inst`는 상수 인스턴스임.
    [inst = std::move(globalMutableInstance)] { inst.ConstMethod(); };

    // (18) `globalInstance`를 포섭한 람다 표현식
    // 하지만 `globalInstance`는 상수이므로 전부 실행하지 못함.
    /* auto globalInstAdder = globalInstance.GetRatioAdder(); */
    /* auto globalInstMutableAdder = globalInstance.GetMutableRatioAdder(); */

    // (19) `globalMutableInstAdder`는 `globalMutableInstance`를 포섭한 비상수 람다 표현식
    // `globalMutableInstance`는 상수가 아니므로 `globalMutableInstAdder`를 실행할 수 있음.
    // 람다 표현식 `globalMutableInstAdder`가 상수인지 아닌지는 상관없음.
    const auto globalMutableInstAdder = globalMutableInstance.GetCrossAdder();

    // (20) `globalMutableInstance`의 `myCross`는 `0.5f`가 됨.
    globalMutableInstAdder(0.5f);
}

5.1. 예제1: 스레드를 넘나드는 람다 표현식

<C++ 예제 보기>

#!syntax cpp
#include <print>
#include <vector>
#include <chrono>
#include <array>
#include <thread>
#include <latch>

constinit std::latch terminated_count{ 4 };

enum class [[nodiscard]] TaskCategory
{
	None = 0, Idle = 0, PrintID, EnumerateNumber, Terminate
};

void WorkerImplementation(class Worker* worker);

class Worker
{
public:
	explicit Worker() = default;

	explicit Worker(std::uintptr_t uid) noexcept
		: uid(uid), myHandle(std::jthread(::WorkerImplementation, this))
		, myTask(TaskCategory::None)
	{}

	// 클래스 `Worker`는 복사 생성 및 복사 대입을 할 수 없음.
	Worker(const Worker&) = delete;
	Worker& operator=(const Worker&) = delete;

	~Worker()
	{
		myTask = TaskCategory::Terminate;
	}

	int Execute()
	{
		using namespace std::chrono_literals;

		switch (myTask)
		{
		case TaskCategory::Idle:
		{
			std::println("{} idles", uid);

			myTask = TaskCategory::None;

			return 1;
		}

		case TaskCategory::PrintID:
		{
			std::println("{}'s id is {}", uid, std::this_thread::get_id());

			myTask = TaskCategory::None;

			return 2;
		}

		case TaskCategory::EnumerateNumber:
		{
			std::println("{} show number {}", uid, ::rand());

			myTask = TaskCategory::None;

			return 3;
		}

		case TaskCategory::Terminate:
		{
			return 0;
		}
		break;

		default: { return 4; } break;
		}
	}

	auto AcquireTaskSetter() noexcept
	{
		return [this](TaskCategory task) noexcept {
			if (TaskCategory::None == myTask)
			{
				myTask = task;
			}
		};
	}

	[[nodiscard]]
	constexpr auto GetID() const noexcept { return uid; }

	[[nodiscard]]
	constexpr const std::jthread& GetHandle() const& noexcept { return myHandle; }
	[[nodiscard]]
	constexpr std::jthread&& GetHandle() && noexcept { return std::move(myHandle); }

private:
	std::uintptr_t uid;
	std::jthread myHandle;
	TaskCategory myTask;
};

void WorkerImplementation(Worker* worker)
{
	using namespace std::chrono_literals;

	int result = 1;

	while (0 != result)
	{
		result = worker->Execute();

		std::this_thread::sleep_for(1s);
	}

	std::println("{} terminated", std::this_thread::get_id());

	terminated_count.arrive_and_wait();
}

int main()
{
    std::uintptr_t last_uid = 10000;

    // `Worker` 인스턴스들을 동적할당 하지 않는다.
    std::array<Worker, 4> workers
    {
        Worker{ last_uid++ },
        Worker{ last_uid++ },
        Worker{ last_uid++ },
        Worker{ last_uid++ }
    };

    std::array task_setters =
    {
            workers[0].AcquireTaskSetter(),
            workers[1].AcquireTaskSetter(),
            workers[2].AcquireTaskSetter(),
            workers[3].AcquireTaskSetter()
    };

    std::srand((unsigned) std::time(nullptr));

    using namespace std::chrono_literals;

    std::jthread worker_prompt
    {
        [task_setters] {
            while (true)
            {
                if (terminated_count.try_wait()) break;

                // 복사해서 써도 문제 없음.
                auto task_setter = task_setters[::rand() % 4];

                task_setter(static_cast<TaskCategory>(1 + ::rand() % 3));
                std::this_thread::sleep_for(1s);
            }
        }
    };

    terminated_count.wait();
}

6. 포섭의 제한 사항

#!syntax cpp
int main()
{
    int i;

    // (1) 컴파일 오류! 캡처 목록에서 하나의 이름이 여러번 표시될 수 없습니다.
    [i, i] {};

    // (2) 컴파일 오류! 캡처 목록에서 하나의 이름이 여러번 표시될 수 없습니다.
    [i, &i] {};

    // (3) 컴파일 오류! 캡처 목록에서 하나의 이름이 여러번 표시될 수 없습니다.
    [&i, &i] {};

    class Captured
    {
    public:
        void Method()
        {
            // (4) 컴파일 오류! 하나의 이름이 여러번 표시될 수 없습니다.
            [this, this] {};

            // (5) 컴파일 오류! 하나의 이름이 여러번 표시될 수 없습니다.
            [this, *this] {};
        }
    };
}

#!syntax cpp
int* value = new int{0};

// 참조 포섭
auto lambda = [&ref = *value] { ref = 30; };

// 참조 대상 소실
delete value;

// 런타임 오류! 메모리 참조 위반!
lambda();

7. 특성 적용

<C++ 예제 보기>

#!syntax cpp
int main()
{
    auto allocator = [][[nodiscard]] (std::size_t length) { return new int[length]; };

    // (1) int[10]
    auto array0 = allocator(10);

    // (2) 경고! 함수의 반환 값이 사용되지 않았습니다.
    allocator(100);
}

8. 상수 람다 표현식

<C++ 예제 보기>

#!syntax cpp
constexpr auto Absolute = [] (auto value) { return 0 <= value ? value : -value; };

9. 템플릿 람다 표현식

<C++ 예제 보기>

#!syntax cpp
// (1) 자료형의 크기에서 가까운 2의 배수를 구하는 람다 표현식
// 자료형만 쓰므로 consteval을 쓸 수 있다.
consteval auto lambda0 = []<typename T> [[nodiscard]](const T& v) noexcept -> std::size_t {
    constexpr std::size_t size = sizeof(T);
    constexpr std::size_t lower = size - (size % 2);
    constexpr std::size_t upper = lower + 2;
    return (size - lower < upper - size) ? lower : upper;
};

constexpr auto size_integer = lambda0(0);
constexpr auto size_squirrel = lambda0(Squirrel{});

// (2) 앞서 소개한 절대값을 구하는 람다 표현식을 엄밀하게 정의한 람다 표현식
constexpr auto Absolute = []<typename T> [[nodiscard]] (const T& value) noexcept(std::is_nothrow_copy_constructible_v<T>) - >T {
    return 0 <= value ? value : -value;
};

10. 함수의 매개변수로 전달

10.1. auto 매개변수

<C++ 예제 보기>

#!syntax cpp
// 참고사항: auto에는 또다른 auto 함수 또는 템플릿 함수를 전달할 수 없다.
auto GetMapper(auto& container, auto predicate)
{
	return [&] {
		for (auto& value : container)
		{
			value = predicate(value);
		}
	};
}

auto GetMapper(auto& container)
{
	return [&](auto predicate) {
		for (auto& value : container)
		{
			value = predicate(value);
		}
	};
}

[[nodiscard]]
constexpr int MultiplyFunction(int v) noexcept
{
	return v * 10;
}

int main()
{
	std::vector list{ 1, 2, 3, 4, 5 };

	// (1) 벡터 `list`를 참조형으로 받아서 수정하는 람다 표현식
	auto mapper0 = GetMapper(list, [](auto v) noexcept { return v * 10 });

	// `list`가 수정된다.
	// `list` == { 10, 20, 30, 40, 50 };
	mapper0();

	// (2) 상태가 없는 람다 표현식이므로 함수를 사용해도 같은 결과를 볼 수 있다.
	// 컴파일러가 릴리스 모드면 성능 상에 차이는 없다.
	auto mapper1 = GetMapper(list, MultiplyFunction);

	// (3) 수식 `predicate`를 복사로, 벡터 `list`를 참조형으로 받아서 수정하는 람다 표현식
	auto mapper2 = GetMapper(list);

	// `list`가 수정된다.
	// `list` == { 1, 2, 3, 4, 5 };
	mapper2([](auto v) noexcept { return v / 10; });
}

10.2. 템플릿 매개변수

<C++ 예제 보기>

#!syntax cpp
template<typename It, typename Predicate>
constexpr auto find_if(It first, It last, Predicate predicate)
{
    for(; first != last; ++first)
    {
        if (predicate(*first))
        {
            return first;
        }
    }

    return first;
}

11. 개념 (Concept) 매개변수

<C++ 예제 보기>

#!syntax cpp
import <type_traits>;
import <concepts>; // std::sentinel_for, std::invocable
import <iterator>; // std::forward_iterator, std::iter_value_t
import <functional>; // std::invoke
import <vector>; // std::vector
import <ranges>; // std::from_range_t, std::from_range, std::views::iota

template<std::forward_iterator It, std::sentinel_for<It> Sentinel>
constexpr It find_if(It first, const Sentinel last, std::invocable<std::iter_value_t<It>> auto predicate)
{
    for (; first != last; ++first)
    {
        if (std::invoke(predicate, *first))
        {
            return first;
        }
    }

    return first;
}

int main()
{
    const std::vector list{ std::from_range, std::ranges::views::iota(1, 10) };

    // 3으로 나누어 나머지가 0인 값이면 참을 반환
    const auto it = ::find_if(list.begin(), list.end(), [](const auto& value) noexcept -> bool { return value % 3 == 0; });

    // `what`의 값은 3
    auto what = *it;

    // `write_bytes`는 int, int, double& 매개변수를 받아 실행할 수 있는 실행가능한 객체 (invocable object)
    std::invocable<int, int, double&> auto write_bytes = [](int left, int right, double& dest) noexcept {
        *(reinterpret_cast<int*>(&dest) + 1) = left;
        *(reinterpret_cast<int*>(&dest)) = right;
    };

    double storage{};
    write_bytes(4000, 3000, storage);
}

12. 함수 포인터

<C++ 예제 보기>

#!syntax cpp
import <type_traits>;

// 함수
int Function0() { return 0; }
int Function1() noexcept { return 0; }
template<typename T>
T Function2(T value) { return T * T; }

// 함수 포인터 자료형 선언
using Function0_t = int(*)();
using Function1_t = int(*)();
using Function1_nothrow_t = int(*)() noexcept;
template<typename T>
using Function2_t = T(*)(T value);

// 람다 표현식
auto lambda0 = [] { return 0; };
auto lambda1 = [] { return 0; };
auto lambda1_nothrow = [] noexcept { return 0; };
auto lambda2 = []<typename T>(T value) -> T { return value * value; };

using lambda0_t = decltype(lambda0);
using lambda1_t = decltype(lambda1);
using lambda1_nothrow_t = decltype(lambda1_nothrow);
using lambda2_t = decltype(lambda2);

// (1) 컴파일 오류! 정적 어설션이 실패했습니다. [3]
static_assert(std::is_same_v<Function0_t, lambda0_t>);
static_assert(std::is_same_v<Function1_t, lambda1_t>);
static_assert(std::is_same_v<Function1_t, lambda1_nothrow_t>);
static_assert(std::is_same_v<Function2_t<int>, lambda2_t>);

// (2) 컴파일 오류 없음.
// 상태가 없는 람다 표현식은 동일 매개변수, 동일한 반환 자료형, 동일한 예외 상세(C++17 부터)를 갖고 있으면 함수 포인터로 변환이 가능함.
static_assert(std::is_convertible_v<lambda0_t, Function0_t>);
static_assert(std::is_convertible_v<lambda1_t, Function1_t>);
static_assert(std::is_convertible_v<lambda1_nothrow_t, Function1_nothrow_t>);
// `lambda2_t`는 템플릿 람다 표현식인데, 템플릿 매개변수를 명시할 수가 없어서 우회해서 원래의 멤버 함수를 가져와야 함.

// (3) C++17 부터는 동일한 예외 상세를 가져야 함수 포인터로 변환이 가능함.
// C++14 까지는 어설션이 성공함.
// C++17 부터는 컴파일 오류 발생함.
static_assert(std::is_convertible_v<lambda1_t, Function1_nothrow_t>);

// (4) 여담으로 예외가 없는(noexcept) 함수 포인터는 예외를 발생시킬 수 있는 함수 포인터로 변환할 수 있음.
static_assert(std::is_convertible_v<Function1_nothrow_t, Function1_t>);

int main()
{
    // (5) 상태가 없는 람다 표현식은 상수 시간에 초기화될 수 있음.
    constexpr lambda2_t lambda2_inst{};

    // (6) 람다 표현식의 멤버 연산자 함수
    // int에 대하여 특수화함.
    const auto lambda2_op_ptr = &(lambda2_t::operator()<int>);

    // (7) `lambda2_result`의 값은 400
    const auto lambda2_result = (lambda2_inst.operator())(20);
}

13. 정체

13.1. 상태가 없는 클로저

#!syntax cpp
class StatelessClosure
{
    using Fn = ReturnType(*)(parameters...);

public:
    constexpr StatelessClosure() = default;
    constexpr ~StatelessClosure() = default;

    /* 기본 복사/이동 생성자를 가짐 */
    constexpr StatelessClosure(const StatelessClosure&) = default;
    constexpr StatelessClosure(StatelessClosure&&) = default;

    /* 기본 복사/이동 대입 연산자를 가짐 */
    constexpr StatelessClosure& operator=(const StatelessClosure&) = default;
    constexpr StatelessClosure& operator=(StatelessClosure&&) = default;

    /* () 연산자 오버로딩 */
    constexpr ReturnType operator()(parameters...);

    /* 함수 포인터로 변환할 수 있음 */
    constexpr operator Fn() const noexcept;

private:
    // 포섭된 필드가 없음.
};

13.2. 상태가 없는 일반화 클로저

#!syntax cpp
class StatelessGenericClosure
{
    template<typename... Ts>
    using Fn = ReturnType(*)(Ts... parameters);

public:
    constexpr StatelessGenericClosure() = default;
    constexpr ~StatelessGenericClosure() = default;

    /* 기본 복사/이동 생성자를 가짐 */
    constexpr StatelessGenericClosure(const StatelessGenericClosure&) = default;
    constexpr StatelessGenericClosure(StatelessGenericClosure&&) = default;

    /* 기본 복사/이동 대입 연산자를 가짐 */
    constexpr StatelessGenericClosure& operator=(const StatelessGenericClosure&) = default;
    constexpr StatelessGenericClosure& operator=(StatelessGenericClosure&&) = default;

    /* () 연산자 오버로딩 */
    template<typename... Ts>
    constexpr ReturnType operator()(Ts... parameters);

    /* 함수 포인터로 변환할 수 있음 */
    template<typename... Ts>
    constexpr operator Fn<Ts...>() const noexcept;

private:
    // 포섭된 필드가 없음.
};

13.3. 상태를 가진 클로저

#!syntax cpp
class Closure
{
public:
    /* 기본 생성자를 가지고 있지 않음. 람다 표현식 인스턴스가 생성될 때 결합(Aggregate) 생성 방식으로 전달됨. */
    // constexpr Closure() = default;
    constexpr ~Closure() = default;

    /* 기본 복사/이동 생성자를 가짐 */
    constexpr Closure(const Closure&) = default;
    constexpr Closure(Closure&&) = default;

    /* 복사 대입 연산자는 삭제됨 */
    Closure& operator=(const Closure&) = delete;
    /* 이동 대입 연산자는 컴파일러에 의해 알아서 정의됨 */
    /* 참조 포섭을 했으면 좌측값 참조 데이터 멤버가 있으므로 이동 대입 연산자가 정의되지 않음 */
    //Closure& operator=(Closure&&) = default;

    /* () 연산자 오버로딩 */
    constexpr ReturnType operator()(parameters...);

    /* 함수 포인터로 변환은 불가능함 */
    //using Fn = ReturnType(*)(parameters...);
    //constexpr operator Fn() const noexcept;

private:
    // 포섭된 필드는 데이터 멤버임.
    T0 capture0;
    T1 capture2;
    // ...
};

13.4. 상태를 가진 일반화 클로저

#!syntax cpp
class GenericClosure
{
public:
    /* 기본 생성자를 가지고 있지 않음. 람다 표현식 인스턴스가 생성될 때 집결 초기화(Aggregate Initialization) 방식으로 전달됨. */
    // constexpr GenericClosure() = default;
    constexpr ~GenericClosure() = default;

    /* 기본 복사/이동 생성자를 가짐 */
    constexpr GenericClosure(const GenericClosure&) = default;
    constexpr GenericClosure(GenericClosure&&) = default;

    /* 복사 대입 연산자는 삭제됨 */
    GenericClosure& operator=(const GenericClosure&) = delete;
    /* 이동 대입 연산자는 컴파일러에 의해 알아서 정의됨 */
    /* 참조 포섭을 했으면 좌측값 참조 데이터 멤버가 있으므로 이동 대입 연산자가 정의되지 않음 */
    //GenericClosure& operator=(GenericClosure&&) = default;

    /* () 연산자 오버로딩 */
    template<typename... Ts>
    constexpr ReturnType operator()(Ts... parameters);

    /* 함수 포인터로 변환은 불가능함 */
    //template<typename... Ts> using Fn = ReturnType(*)(Ts... parameters);
    //template<typename... Ts> constexpr operator Fn<Ts...>() const noexcept;

private:
    // 포섭된 필드는 데이터 멤버임.
    T0 capture0;
    T1 capture2;
    // ...
};