C++/문법

1. 개요

2. Hello, world!

#!syntax cpp
import <print>;

int main()
{
    std::println("Hello, world!");
    std::println("{}, {} {}!", "Hello", "world", "again");
}

3. 프로그램 진입점

4. 원시 자료형 (Primitives)

4.1. Truthy / Falsy

5. 함수 (Function)

5.1. 반환 자료형 (Return Type)

5.1.1. return

5.2. 매개변수 (Parameter)

<C++ 예제 보기>

#!syntax cpp
import <print>;

void increment1(int x)
{
    ++x;
}

void increment2(int x)
{
    ++x;
}

void increment3(int x, int y)
{
    x += y;
}

int main()
{
    int a = 100;
    int b = 500;

    // (1)
    increment1(a);
    // (2)
    increment1(7124820);
    // (3)
    increment2(a);
    // (4)
    increment2(b);
    // (5)
    increment3(a, 9058142);
    // (6)
    increment3(a, b);

    std::println("a의 값: {}", a) // 100을 출력함
    std::println("b의 값: {}", b) // 500을 출력함
}

5.3. 오버로딩 (Overloading)

5.4. inline

5.5. noexcept

6. 구조체 (Struct)

<C++ 예제 보기>

#!syntax cpp
import <filesystem>;

struct [[nodiscard]] Sprite
{
    std::filesystem::path imagePath;
    int imageIndex;
};

struct Player
{
    Sprite mySprite;

    float myHealth;
    float myPosition[2];
};

Player player_instance;

void PlayerMoveX(float dist)
{
    player_instance.myPosition[0] += dist;
}

void PlayerMoveY(float dist)
{
    player_instance.myPosition[1] += dist;
}

[[nodiscard]]
float PlayerGetHealth()
{
   return player_instance.myHealth;
}

[[nodiscard]]
std::filesystem::path SpriteGetImagePath(Sprite sprite)
{
   return sprite.imagePath;
}

int main()
{
    Sprite player_sprite
    {
        .imagePath = L"/res/img/Player/Idle.png",
        .imageIndex = 0
    };

    player_instance = Player{ player_sprite, 100.0f, 0, 0 };
}

7. 자료형 (Data Types)

8. 자료형 한정자 (Type Qualifier)

8.1. const

8.2. volatile

8.3. & 참조

<C++ 예제 보기>

#!syntax cpp
int original_v1 = 1'000'000;
int original_v2 = 7'000'000;
int original_v3 = 9'000'000;

int& ref_v1 = original_v1;
int& ref_v2 = original_v2;
int& ref_v3 = original_v3;

ref_v1 = 1000; // original_v1의 값이 1000이 된다.
int* handle_v1 = &ref_v1; // original_v1의 주소를 가져온다.

ref_v1 = original_v2; // 참조 변수 ref_v1을 통해 original_v1의 값이 7000000이 된다.
ref_v1 = ref_v2; // 참조 변수 ref_v2를 통해 original_v2의 값을 가져오고, ref_v1을 통해 original_v1의 값이 7000000이 된다.
*handle_v1 = original_v3;// handle_v1의 주소가 바뀌지 않는다. original_v1의 값이 9000000이 된다.

<C++ 예제 보기>

#!syntax cpp
// 생략

Player player_instance;

void PlayerMoveX(float dist)
{
    player_instance.myPosition[0] += dist;
}

void PlayerMoveY(float dist)
{
    player_instance.myPosition[1] += dist;
}

[[nodiscard]]
float PlayerGetHealth()
{
   return player_instance.myHealth;
}

8.3.1. 함수에 좌측값 참조로 전달

<C++ 예제 보기>

#!syntax cpp
// 생략

Player playerInstances[4];
int localPlayerIndex = 0;

void PlayerMoveX(Player& player, float dist)
{
    player.myPosition[0] += dist;
}

void PlayerMoveY(Player& player, float dist)
{
    player.myPosition[1] += dist;
}

[[nodiscard]]
float PlayerGetHealth(Player& player)
{
   return player.myHealth;
}

int main()
{
    Sprite player_sprite
    {
        .imagePath = L"/res/img/Player/Idle.png",
        .imageIndex = 0
    };

    playerInstances[localPlayerIndex] = Player{ player_sprite, 100.0f, 20, 180 };
    playerInstances[localPlayerIndex + 1] = Player{ player_sprite, 100.0f, 180, 180 };
    playerInstances[localPlayerIndex + 2] = Player{ player_sprite, 100.0f, 20, 20 };
    playerInstances[localPlayerIndex + 3] = Player{ player_sprite, 100.0f, 180, 20 };

    PlayerMoveY(playerInstances[localPlayerIndex + 2], 30);

    // 오류!
    PlayerMoveX(Player{ player_sprite, 100.0f, 100, 100 }, 50);
}

8.4. && 참조

8.4.1. 함수에 우측값 참조로 전달

<C++ 예제 보기>

#!syntax cpp
import <string>;

struct Position { float x, y, z; };

Position MakePosition_Copy(const Position& pos)
{
    return Position{ pos };
}

Position MakePosition_Move(Position&& pos)
{
    // 매개변수 pos를 그대로 전이
    return std::move(pos);
    // 또는 이동 생성자 사용
    return Position{ std::move(pos) };
    // 또는 수동으로 rvalue 변환
    return Position{ static_cast<Position&&>(pos) };
}

struct Squirrel
{
    std::string myName;
    Position myPosition;
};

void SetPosition_Copy(Squirrel& squirrel, const Position& pos)
{
    squirrel.myPosition = pos;
}

void SetPosition_Move(Squirrel& squirrel, Position&& pos)
{
    squirrel.myPosition = std::move(pos);
    // 또는 수동으로 rvalue 변환
    squirrel.myPosition = static_cast<Position&&>(pos);
}

void Function3_pos_copy(Squirrel& squirrel, const float& x, const float& y, const float& z);
void Function3_pos_move(Squirrel& squirrel, float&& x, float&& y, float&& z);

9. 클래스 (Class)

#!syntax cpp
import <string>;
import <print>;

class GreetingWorld
{
public:
    GreetingWorld() noexcept
    {
        std::println(myGreet);
    }

protected:
    std::string myGreet = "Hello, world!";
};

10. 이름공간 (Namespace)

11. 메모리 할당

이 문단의 내용 중 전체 또는 일부는

C++/명세

C++/명세

문서의 r20 판

, 4번 문단

에서 가져왔습니다. 이전 역사 보러 가기

이 문단의 내용 중 전체 또는 일부는 다른 문서에서 가져왔습니다.

[ 펼치기 · 접기 ]

C++/명세

C++/명세

문서의 r20 판

, 4번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

문서의 r 판

, 번 문단

(이전 역사)

11.1. 자동 할당

<C++ 예제 보기>

#!syntax cpp
#include <utility>
#include <iostream>
int main()
{
    int x = 0;

    // 0을 출력
    std::cout << x << '\n';
    // x의 주소를 출력
    std::cout << std::addressof(x) << '\n';

    return 0;
}

11.2. 정적 할당

<C++ 예제 보기>

#!syntax cpp
#include <cstdint>
#include <utility>
#include <string_view>

// 전역 변수
float my_float;
/*static*/ int my_st_integer;

// static이어도 문제 없다.
/*static*/ std::int64_t my_i64;
/*static*/ std::int64_t* my_ptr_i64 = &my_i64;

constexpr std::int32_t my_ct_i32 = 40;
constexpr const std::int32_t* my_ct_ptr_i32 = &my_ct_i32;

class MyClass
public:
    static constexpr std::string_view Name = "MyClass";
    static std::string_view NotCtName1;
    static inline std::string_view NotCtName2 = "MyClass";
    constinit static inline std::string_view NotCtName3 = "MyClass";
};
int main()
{
    /*constexpr*/ MyClass instance1, instance2;
    // constexpr 객체가 아니라도 constexpr 정적 필드는 컴파일 시간에 값을 검증할 수 있다.
    static_assert(std::addressof(instance1.NotCtName1) == std::addressof(instance2.NotCtName1));
    // 정적 필드는 constexpr가 아니더라도 컴파일 시간에 주소를 검증할 수 있다.
    static_assert(std::addressof(instance1.NotCtName2) == std::addressof(instance2.NotCtName2));
    static_assert(std::addressof(instance1.NotCtName3) == std::addressof(instance2.NotCtName3));
    static_assert(sizeof(MyClass) == 1);
    // 그런데 소멸자는 호출 가능하다.
    // 다만 이렇게 명시적으로 호출하면 소멸자에 정의된 동작이 실행되며 실제로 메모리가 해제되는 시점은 함수의 범위가 끝나는 시점이다.
    instance1.~MyClass();
}

11.3. 동적 할당

#!syntax cpp
#include <utility>

int* DanglingMemory()
{
    int x = 0;
    int *ptr = std::addressof(x); // 참조 대상 소실 (Dangling Pointer/Reference)

    return ptr; // 접근 위반 오류 또는 경고. 보안 문제가 발생할 수 있다.

<C++ 예제 보기>

#!syntax cpp
#include <iostream>
int* CreateMemory()
{
    int *ptr = new int; // 동적 할당
    *ptr = 0;
    return ptr;
}
int main()
{
    int *ptr = CreateMemory();
    // "0" 출력
    std::cout << *ptr << '\n'; 
    delete ptr; // ptr이 가리키는 메모리를 해제한다. 이제 ptr은 사용할 수 없다.
}

<C++ 예제 보기>

#!syntax cpp
#include <new>
#include <memory>
#include <span>
struct MyData
{
    void ExecuteData() const {}
    int a;
    int b;
    int c;
};
struct MyData_Copy
{
    void ExecuteData() const {}

    int a;
    int b;
    int c;
};

struct Packet
{
    [[nodiscard]]
    std::span<const char> Serialize() const noexcept
    {
        return std::span{ reinterpret_cast<const char*>(myData), mySize };
    }

    void* myData;
    size_t mySize;
};

int main()
{
    MyData data{};

    Packet packet1
    {
        .myData = new (std::addressof(data)) MyData{},
        .mySize = sizeof(MyData)
    };

    // acq_data1_packet1는 data를 가리키는 포인터이다.
    MyData* acq_data1_packet1 = std::launder(reinterpret_cast<MyData*>(packet1.myData));
    acq_data1_packet1->ExecuteData();

    Packet packet2
    {
        .myData = new MyData_Copy{}, // MyData과 똑같은 구성
        .mySize = sizeof(MyData_Copy)
    };

    // packet2.myData에는 MyData가 아닌 MyData_Copy가 들어있으므로 std::launder는 정의되지 않은 동작에 돌입한다.
    // 따라서 acq_data1_packet2의 값은 알 수 없다.
    MyData* acq_data1_packet2 = std::launder(reinterpret_cast<MyData*>(packet2.myData));

    Packet packet3
    {
        .myData = new MyData{},
        .mySize = sizeof(MyData)
    };
    delete packet3.myData;

    // packet3.myData는 해제된 메모리 이므로 std::launder는 정의되지 않은 동작에 돌입한다.
    // 따라서 acq_data1_packet3의 값은 알 수 없다.
    MyData* acq_data1_packet3 = std::launder(reinterpret_cast<MyData*>(packet3.myData));
}

12. 언어 연결성 (Language Linkage)

13. 저장소 지속요건 (Storage Duration)

13.1. static

13.1.1. static 변수

<C++ 예제 보기>

#!syntax cpp
namespace NamuWiki
{
    class Squirrel
    {
    public:
        Squirrel(float x, float y, float z);

        float mx, my, mz;
    };

    // (1)
    // NamuWiki::liveEverywhere로 언제든지 사용할 수 있다
    static int liveEverywhere;

    // (2)
    // 오류! 기본 생성자를 호출할 수 없습니다
    static Squirrel allIsNotWell;
}

// 이름 공간과 클래스 안에 있는 정적 변수의 정의는 스코프 밖에, 그리고 헤더라면 별도의 소스 파일에 작성해야 한다.
// 그러나 liveEverywhere이 정말 이때 초기화될지는 확실하지 않다.
int NamuWiki::liveEverywhere = 40;

13.1.2. static 함수

<C++ 예제 보기>

#!syntax cpp
import <string_view>;

// 구현 내용이 없으면 링크 오류가 발생한다.
static char GetFirstCharacter(std::string_view str);

// 헤더를 여러번 삽입하더라도 GetFirstCharacter는 언제나 동일한 함수임이 보장된다.
// 내부 연결 객체는 현재 이름공간에 유일한 존재로 남으므로 식별자의 중복 선언 문제가 발생하지 않는다.
static char GetFirstCharacter(std::string_view str)
{
    return str.front();
}

13.1.3. 클래스 멤버

<C++ 예제 보기>

#!syntax cpp
class GameObject
{
public:
    static inline const int firstId = 1000;
    static const std::string DefaultName;

    static GameObject* CreateObject()
    {
        // objectId는 단 한번 할당된다
        static int objectId = firstId;

        return new GameObject{ .myID = objectId++, .myName = DefaultName };
    }

    int myID;
    std::string myName;
};

template<typename crtp>
class ISingleton
{
public:
    static void SetInstance(crtp* inst)
    {
        if (Instance == nullptr)
        {
            crtp = inst;
        }
        else
        {
            throw "Singleton error!";
        }
    }

    [[nodiscard]]
    static crtp* GetInstance() noexcept
    {
        return Instance;
    }

protected:
    static crtp* Instance = nullptr;
}

std::string GameObject::DefaultName = "GameObject";

13.2. extern

<C++ 예제 보기>

#!syntax cpp
extern class GameObject;

13.3. thread_local

<C++ 예제 보기>

#!syntax cpp
import <vector>;
import <thread>;
import <chrono>;
import <print>;

// 전역 범위에 선언되어 있지만, 실제로는 스레드 단위 지역 변수다.
thread_local size_t threadID;
thread_local size_t threadCount = 0;

void Watcher(size_t id)
{
    // 보이지 않는 threadID, threadCount 지역 변수가 선언되어 있다.
    threadID = id;

    using namespace std::chrono_literals;

    while (true)
    {
        if (::rand() % 10 == 0)
        {
            std::println("스레드 ID {}에서 {}번째 보고", threadID, ++threadCount);
        }

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

int main()
{
    std::vector<std::jthread> myThreads{};
    myThreads.reserve(4);

    for (size_t i = 0; i < 4; ++i)
    {
        myThreads.emplace_back(Watcher, i);
    }

    while (true)
    {
        std::this_thread::yield();
    }
}

13.4. mutable

<C++ 예제 보기>

#!syntax cpp
import <atomic>;
import <vector>;
import <thread>;
import <print>;

class SpinLock
{
public:
    constexpr SpinLock() noexcept = default;
    ~SpinLock() noexcept = default;

    // const 메서드이지만 myState를 수정하고 있다.
    void Lock(std::memory_order model = std::memory_order::memory_order_acquire) const volatile noexcept
    {
        while (!TryLock(model));
    }

    bool TryLock(std::memory_order model = std::memory_order::memory_order_relaxed) const volatile noexcept
    {
        return !mySwitch.test_and_set(model);
    }

    void Unlock(std::memory_order model = std::memory_order::memory_order_release) const volatile noexcept
    {
        mySwitch.clear(model);
    }

    [[nodiscard]] bool IsLocked() const noexcept
    {
        return mySwitch.test(std::memory_order::memory_order_relaxed);
    }

    SpinLock(const SpinLock&) = delete;
    SpinLock& operator=(const SpinLock&) = delete;

private:
    mutable volatile std::atomic_flag mySwitch;
};

// const여도 아무 문제 없다.
const SpinLock globalLock{};
size_t globalCounter = 0;

void Incrementor(size_t max) noexcept
{
    for (size_t i = 0; i < max; ++i)
    {
        globalLock.Lock();
        globalCounter++;
        globalLock.Unlock();
    }
}

int main()
{
    constexpr size_t target = 1000'0000'0000'0000;
    constexpr size_t thrd_count = 10;
    constexpr size_t thrd_workout = target / thrd_count;

    std::vector<std::thread> myThreads{};
    myThreads.reserve(thrd_count);

    for (size_t i = 0; i < thrd_count; ++i)
    {
        myThreads.emplace(Incrementor, thrd_workout);
    }

    for (auto& th : myThreads)
    {
        th.join();
    }

    std::println("결과: {}", globalCounter); // 1000000000000000

    return 0;
}

14. 상수 표현식 (Constant expression)

15. 제약조건

16. 값 범주론 (Value Category)

17. 템플릿 (Template)

17.1. auto

<C++ 예제 보기>

#!syntax cpp
class Counter
{
public:
    constexpr Counter() noexcept = default;
    constexpr ~Counter() noexcept = default;

    constexpr Counter(const size_t& number) noexcept
        : myNumber(number)
     {}

     constexpr size_t& GetNumber() noexcept { return myNumber; }
     constexpr const size_t& GetNumber() const noexcept { return myNumber; }
     constexpr auto GetNumber2() noexcept { return myNumber; } // 한정자 없는 size_t 반환
     constexpr auto GetNumber2() const noexcept { return myNumber; } // 한정자 없는 size_t 반환

protected:
    size_t myNumber = 0;
}

int main()
{
    Counter counter_v{ 300 };
    constexpr Counter counter_c{ 500 };

    auto cnt1 = counter_v.GetNumber(); // size_t
    const auto cnt2 = counter_v.GetNumber(); // const size_t
    const auto& cnt3 = counter_v.GetNumber(); // counter_v.myNumber 필드의 불변 참조 변수다. 

    size_t cnt4 = counter_v.GetNumber();
    size_t& cnt5 = counter_v.GetNumber(); // cnt5를 통해 counter_v.myNumber 필드를 수정할 수 있다.
    const size_t& cnt6 = counter_v.GetNumber(); // counter_v.myNumber 필드의 불변 참조 변수다. 
    
    auto cnt7 = counter_c.GetNumber(); // size_t
    auto& cnt8 = Counter{ 700 }.GetNumber(); // 형식 한정자 오류!
    const auto& cnt8 = counter_c.GetNumber(); // const size_t& 이며 counter_c.myNumber 필드의 참조 변수다.
}

17.2. 템플릿 인자 추론

<C++ 예제 보기>

#!syntax cpp
import <string>;
import <print>;

template<typename T>
void increment1(T x)
{
    // 전위 증가 연산자를 사용할 수 없으면 예외 발생
    ++x;
}

void increment2(auto x)
{
    // 전위 증가 연산자를 사용할 수 없으면 예외 발생
    ++x;
}

template<typename T>
void increment3(T lhs, T rhs)
{
    lhs += rhs;
}

template<typename T>
void increment4(T lhs, const T* rhs)
{
    lhs += *rhs;
}

void increment5(auto lhs, auto rhs)
{
    lhs += rhs;
}

int main()
{
    int a = 100;
    long long b = 500;
    const int c = 900;
    int& d = a;

    increment1(a); // 아무것도 안 함 (1)
    increment1(510942633); // (2)
    increment1(b); // (3)
    increment1(d); // (4) d는 a의 참조 변수이지만 &가 부패해서 사라진다
    increment1('B'); // (5)
    increment1("namu"); // 오류! 문자열은 더할 수 없습니다

    increment2(a); // (4)
    increment2(a + b); // (5) 값에 의한 전달은 prvalue도 전달할 수 있다
    increment2('B'); // (6)
    increment2("wiki"); // 오류! 문자열은 더할 수 없습니다

    increment3(a, 1058142); // (7)
    increment3(a, c); // (8) 인자의 const는 매개변수의 auto에 영향을 끼치지 못한다
    increment3(a, b); // 오류! 전달된 두 매개변수 T의 자료형이 서로 다릅니다

    increment4(a, &c); // (9) 포인터(주소)는 glvalue만이 가질 수 있다. glvalue는 lvalue라서 모든 한정자를 반드시 유지한다
    increment4(a, &b); // 오류! 전달된 두 매개변수 T의 자료형이 서로 다릅니다
    increment4(a, &d); // 오류! 포인터와 인자의 const 한정자가 일치하지 않습니다

    increment5(a, b); // (10)
    increment5(d, c); // (11) d는 참조형이지만 auto에서 &가 부패해서 사라진다
    increment5(c, d); // (12)
    increment5(d, b); // (13)
    increment5(std::string{ "Namu" }, std::string{ "Wiki" }); // (14)

    std::println("a의 값: {}", a) // 100
    std::println("b의 값: {}", b) // 500
    std::println("c의 값: {}", c) // 900
    std::println("d의 값: {}", d) // 100 (a의 참조형)

    return 0;
}

17.2.1. decltype

17.2.1.1. decltype(auto)

<C++ 예제 보기>

#!syntax cpp
int main()
{
    Counter counter_v{ 300 };
    constexpr Counter counter_c{ 500 };

    decltype(auto) cnt1 = counter_v.GetNumber(); // size_t& counter_v.myNumber 필드의 참조 변수다. 
    decltype(auto) cnt2 = counter_c.GetNumber(); // const size_t& counter_c.myNumber 필드의 참조 변수다. 

    const decltype(auto)& cnt3 = counter_v.GetNumber(); // 오류! decltype(auto)는 한정자를 붙일 수 없다.
}

17.2.1.2. decltype(expression)

17.2.1.3. 함수 응용 예제

17.2.2. 완벽한 매개변수 전달

<C++ 예제 보기>

#!syntax cpp
import <type_traits>;

void ValueFunction(auto value);
void LvalueFunction(auto& value);
void RvalueFunction(auto&& value);

auto&& Function4_forwarding(auto&& value)
{
    // 복사, &, &&, []가 모두 사라짐 (Decay)
    // 복사할 수 없는 값이라면 오류 발생함
    return value;

    // std::move는 lvalue를 보존하지 않기 때문에 문제가 생긴다.
    // value가 glvalue
    //  T&: T&&
    //  const T&: lvalue는 const T&, xvalue는 const T&&
    // value가 rvalue
    //  T&& - T&&
    //  const T&& - const T&&
    return std::move(value);
}

int main()
{
    const long A = 132435;

    ValueFunction(A); // value는 long
    ValueFunction(std::move(A)); // value는 long
    ValueFunction(8000); // 리터럴 value는 int

    LvalueFunction(A); // value&는 const long&
    LvalueFunction(std::move(A)); // value&는 const long&
    LvalueFunction(8000); // 오류! 리터럴은 lvalue에 대입할 수 없음

    RvalueFunction(A); // value&&는 const long&
    RvalueFunction(std::move(A)); // value&&는 const long&&
    RvalueFunction(8000); // 리터럴 value&&는 int&&
}

<C++ 예제 보기>

#!syntax cpp
import <utility>;

template<typename T>
T&& Function5_forwarding_by_template(T&& value) noexcept(noexcept(std::declval<T&&>()))
// 원본 자료형을 유지한채 value의 객체가 생성될 때 예외가 없음을 확인한다
{
    // lvalue, xvalue, prvalue 모두가 원래 값 범주(Value Category)를 유지한채, 아무 비용없이 전달된다
    // lvalue는 lvalue 그대로 전달된다
    // xvalue를 감싸 이름없이 전달한다
    // prvalue를 감싸 이름없이 전달한다
    return std::forward<T>(value);
}

template<typename T, typename V>
auto&& Function5_modified_forwarding_by_template(V&& value) noexcept(noexcept(std::forward_like<const volatile T>(std::declval<V&&>())))
// 원본 자료형을 바꾼 value의 객체가 생성될 때 예외가 없음을 확인한다
{
    // 원래 값 범주를 유지한채로, 다른 자료형으로 바꿔 전달할 수 있다.
    return std::forward_like<const volatile T>(value);
}

// C++23부터 사용할 수 있는 Function5_forwarding_by_template과 같은 코드
auto&& Function5_forwarding_by_deduction(auto&& value) noexcept(noexcept(std::declval<decltype(value)>()))
// 원본 자료형 그대로 value의 객체가 생성될 때 예외가 없음을 확인한다
{
    // C++23부터 가능한 완벽한 전달 수단
    return auto{ value };
    // 또는 
    return auto(value);
}

Position Function6_forwarding_by_copy(const Position& pos) noexcept(std::is_nothrow_copy_constructible<Position>)
{
    // pos를 복사해서 전달한다
    return pos;
}

Position&& Function6_forwarding_by_move(Position&& pos) noexcept(std::is_nothrow_move_constructible<Position>)
{
    // pos를 아무 성능 오버헤드 없이 그대로 전달한다
    return std::move(pos);

    // 이동 연산에 써도 문제 없다. 그러나 lvalue가 아님을 유의해야 한다
    return std::forward<Position>(pos);

    // 경고! 이 경우 복사가 되어 참조 Dangling이 일어난다
    return pos;
}

<C++ 예제 보기>

#!syntax cpp
// 매개 변수가 있고 반환값은 없는 함수
template<typename T>
void SetID(const T& obj, unsigned long long id)
{
    obj.id = id;
}

// 사용자 정의 noexcept 명세를 사용하는 함수
inline constexpr size_t MySize = 10;
int MyBuffer[MySize]{};

template<size_t Index>
constexpr int& Set(const int& value) noexcept(Index < MySize) // Index가 MySize보다 작으면 오류가 없다.
{
    // 그러나 예외를 잡아내는 코드를 생성하지 않는다는 거지, 예외가 발생하지 않도록 하는 건 아니다.
    // 여전히 Index가 MySize 이상이면 오류가 발생한다.
    // 그냥 noexcept로 지정하면, 메모리 접근 위반이 발생했을때 예외 알림 대신 프로그램이 종료된다.
    return MyBuffer[Index] = value;
}

// 후속 반환형을 사용하는 함수
// 제약조건, noexcept 명세, 후속 반환형 사용
template<typename T, size_t Size>
    requires std::copyable<T> // <concept>
constexpr auto CreateArray(const T& value)
    noexcept(std::is_nothrow_copy_constructible_v<T>) // <type_traits>
    -> std::array<T, Size>
{
    // <array>
    std::array<T, size> result{};
    // <ranges>
    std::ranges::fill(result, value);

    return result; // Return Value Optimization 적용
}

// 템플릿, constexpr, 조건부 noexcept 사용
template<typename T>
constexpr T Instantiate(T&& obj, const float x, const float y, const float z) noexcept(std::is_nothrow_constructible_v<T, std::add_rvalue_reference_t<T>>)
{
    // 완벽한 전달(Perfect Forwarding) 사용
    return T(std::forward<T>(obj), x, y, z);
}

// 가변 템플릿, constexpr, 조건부 noexcept, 후속 반환형 사용
template<typename... Ts>
constexpr auto ForwardAsTuple(Ts&&... args) noexcept(std::conjunction_v<std::is_nothrow_constructible<Ts, Ts&&>...>)
    -> std::tuple<Ts&&...>
{
    // 완벽한 전달(Perfect Forwarding) 사용
    return std::tuple<Ts&&...>{ std::forward<Ts>(args)... };
}

int main()
{
    const long A = 0; // 0
    unsigned long long B = 93140583732; // 1
    bool C = false; // 2
    bool& D = C; // 3
    Squirrel E{}; // 4
    const Squirrel& F = E; // 5
    constexpr unsigned G = 34275860428; // 6

    auto tuple1 = std::make_tuple(A, B, C, D, E, F, G);
    std::get<2>(tuple1) = true; // 복사본은 원본 C, D에 영향을 주지 못함

    auto tuple2 = ForwardAsTuple(A, std::move(B), C, D, E, F, Squirrel{}, std::move(G));
    std::get<2>(tuple2) = true; // C, D가 true가 됨
    std::get<4>(tuple2).myName = "new name"; // E, F의 myName이 "new name"이 됨

    return 0;
}

17.3. 문자열 리터럴

#!syntax cpp
void Function1(const char* string);

void Function2(const char* const& string);

template<size_t Length>
void Function3(const char (&string)[Length]);

void Function4(auto string);

int main()
{
    auto str1 = "wasd"; // 문자열 리터럴은 반드시 const char*
    const auto str2 = "ijkl"; // const char* const
    constexpr auto str3 = "zxcv"; // const char* const&

    Function1("Hello, world! (1)"); // string은 null로 끝나는 문자열
    Function2("Hello, world! (2)"); // string은 null로 끝나는 문자열
    Function3("Hello, world! (3)"); // string은 char의 크기가 18인 문자열
    Function4("Hello, world! (4)"); // string은 null로 끝나는 문자열, const char*

    return 0;
}

17.4. 클래스

17.4.1. 템플릿 데이터 멤버

17.4.2. 템플릿 멤버 함수

17.4.2.1. Deducing this

17.4.3. 템플릿 자료형 멤버

#!syntax cpp
template<typename T>
class Trait
{
public:
    using type = T;
    using value_type = T;
    using const_type = const T;
    using reference = T&;
    using const_reference = const T&;
    using rvalue_reference = T&&;
    using const_rvalue_reference = const T&&;
    using pointer = T*;
    using const_pointer = const T*;
    using difference_type = std::ptrdiff_t;
};

template<typename _Ty, typename _Trait = Trait<_Ty>>
class MyVector
{
public:
    using value_type = _Trait<_Ty>::value_type;
    using const_type = _Trait<_Ty>::const_type;
    using reference = _Trait<_Ty>::reference;
    using const_reference = _Trait<_Ty>::const_reference;
    using rvalue_reference = _Trait<_Ty>::rvalue_reference;
    using const_rvalue_reference = _Trait<_Ty>::const_rvalue_reference;
    using pointer = _Trait<_Ty>::pointer;
    using const_pointer = _Trait<_Ty>::const_pointer;
    using difference_type = _Trait<_Ty>::difference_type;

    constexpr void Push(const_reference element);
    constexpr void Push(rvalue_reference element);

private:
    value_type* myBuffer;
};

18. 개념 (Concept)

<C++ 예제 보기>

#!syntax cpp
import <print>;
import <type_traits>;

template<typename T>
concept integrals = std::is_integral_v<T>;

template<typename T>
void Print(T&& value)
{
    std::println("정수가 아닌 값 {} 출력", std::forward<T>(value));
}

// 후방에 선언되어 있어도 정수인 경우를 잘 걸러낼 수 있다.
template<integrals T>
void Print(T&& value)
{
    std::println("정수 값 {} 출력", std::forward<T>(value));
}

int main()
{
    // (1)
    // C++11의 메타 함수를 사용한 static_assert
    static_assert(std::is_integral_v<bool>);
    static_assert(std::is_integral_v<int>);
    static_assert(std::is_integral_v<unsigned int>);
    static_assert(std::is_integral_v<long long>);
    static_assert(std::is_integral_v<float>); // 컴파일 오류!
    static_assert(std::is_integral_v<double>); // 컴파일 오류!

    // (2)
    // C++20의 제약 조건을 사용한 static_assert
    static_assert(integrals<bool>);
    static_assert(integrals<char>);
    static_assert(integrals<int>);
    static_assert(integrals<unsigned int>);
    static_assert(integrals<long long>);
    static_assert(integrals<float>); // 컴파일 오류!
    static_assert(integrals<double>); // 컴파일 오류!

    // (3)
    // 템플릿에서 제약 조건 사용

    // (3-1)
    // "정수 값 10000 출력"
    Print(10'000);

    // (3-2)
    // "정수 값 10000000 출력"
    Print(10'000'000ULL);

    // (3-3)
    // "정수가 아닌 값 Hello, world! 출력"
    Print("Hello, world!");

    // (3-4)
    // "정수가 아닌 값 nullptr 출력"
    Print(nullptr);
}

19. 특성 (Attribute)