C++/문법

1. 개요

2. 자료형 (Data Types)

3. 함수 (Function)

3.1. 반환 자료형

3.2. return

3.3. 매개변수

3.3.1. 값으로 전달

<C++ 예제 보기>

#!syntax cpp
import <print>;

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

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

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

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

    increment1(a); // (1) 아무것도 안 함
    increment1(7124820); // (2)

    increment2(a); // (3)
    increment2(a + b); // (4)

    increment3(a, 9058142); // (5)
    increment3(a, b); // (6)

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

3.3.2. 좌측값 참조로 전달

<C++ 예제 보기>

#!syntax cpp
import <print>;

void increment(int& value)
{ 
    ++value; // 여기서 value는 복사본이 아님
}

int* addressof(int& value)
{
    return &value;
}

double& increment(double& target, const double& plus)
{ 
    return target += plus;
}

int main()
{
    // (1)
    int a = 0;
    increment(a); // a의 값 증가

    // (2)
    const auto& b = addressof(a); // int* const&
    increment(*b); // a의 값 증가

    // (3)
    const int* c = addressof(a);
    //increment(*c); 오류! const int&는 수정할 수 없음

    std::println("a의 값: {}", a) // 2를 출력함

    // (4)
    int d = 400;
    //b = addressof(d); 오류! const& 포인터는 수정할 수 없음
    c = addressof(d); // 문제없음

    // (5)
    double f = 10000.0;
    auto& e = increment(f, 30000.0); // const double&에 숫자 리터럴 전달, e는 f의 참조형으로 f의 값은 40000.0
}

3.3.3. 우측값 참조로 전달

<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);

3.4. inline

3.5. noexcept

3.6. 함수 오버로딩

4. 클래스 (Class)

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

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

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

5. 이름공간 (Namespace)

6. 언어 연결성 (Language Linkage)

6.1. 내부 연결

<C++ 예제 보기>

#!syntax cpp
// 이름없는 이름공간 안에 있으면 무조건 내부 연결이 된다.
// 설령 extern 이라도.
namespace
{
    namespace InternalLinkage
    {
        class MyTablet
        {
        public:
            static std::string hwVender;
            static std::string hwIdentifier;
        };

        class MyPhone : public ::Device
        {
        public:
            // constinit 사용
            static inline constinit std::string hwVender = "Google";
            static inline constinit std::string hwIdentifier = "Pixel 5";

        protected:
            std::string callNumber;
            std::size_t callCounts;
            std::string IMEI;
        };
    }

    class MyDesktop : public Device
    {
    public:
        static std::string hwVender;
        static std::string hwIdentifier;
    };

    // extern이지만 내부 연결 함수
    extern std::string_view GetMyDeviceID(std::string_view simple_name) noexcept;
}

std::string InternalLinkage::MyTablet::hwIdentifier = "IPad 6th Gen";

std::string MyDesktop::hwVender = "TG삼보";
std::string MyDesktop::hwVender = "TG-DT281-GA51B-011";

6.2. 외부 연결

6.3. 모듈 연결

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

7.1. static

7.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;

7.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();
}

7.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";

7.2. extern

<C++ 예제 보기>

#!syntax cpp
extern class GameObject;

7.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();
    }
}

7.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;
}

8. 상수 표현식 (Constant expression)

9. 템플릿 (Template)

9.1. 변수

9.2. 함수

#!syntax cpp
template<typename... 템플릿 매개변수>
자료형 또는 auto
함수의 이름(매개 변수...)
{
    ...;
}

#!syntax cpp
template<typename... 템플릿 매개변수> // (선택)
[[특성1, 특성2, ...]] // (선택)
static // (선택)
inline // (선택)
constexpr 또는 consteval // (선택)
자료형 또는 auto
[[특성1, 특성2, ...]] // (선택)
함수의 이름(매개 변수...)
noexcept 또는 noexcept(조건) // (선택)
-> 후속 반환형 // (선택)
{
    실행문...; // (선택)
}

<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 적용
}

9.2.1. 템플릿 인자 추론

<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;
}

9.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;
}

#!syntax cpp
// 템플릿, 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;
}

9.3. 클래스

9.3.1. 템플릿 데이터 멤버

9.3.2. 템플릿 멤버 함수

9.3.2.1. Deducing this

9.3.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;
};

9.4. 제약조건

<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);
}

10. 이름 탐색 (Name Lookup)

<C++ 예제 보기>

#!syntax cpp
import <iostream>;
import <complex>;

int main()
{
    std::complex left{ 30, 5 };
    std::complex right{ 60, 2 };

    // (1-1)
    // `*` 연산자는 `std` 이름공간안에 있는데 실행할 수 있다
    // result_1: std::complex<int> == std::complex{ 1700, 360 }
    auto result_1 = left * right;

    // (1-2)
    // std::cout은 이름공간 `std` 안의 클래스 `std::iostream<char, std::char_traits<char>>`의 extern 인스턴스다
    // std::endl은 이름공간 `std` 안의 endl(std::ostream&) 함수다
    // << 연산자는 이름공간 `std` 안에 있다
    // std::operator<<(std::ostream&, const std::complex&)을 실행한다
    std::cout << "result_1 = " << result_1 << std::endl;

    // (2)
    // `std::complex`에 대한 `cos`의 오버로딩은 C언어의 `cos`와 다르게 `std` 이름공간 안에 있는데 실행할 수 있다
    // result_2: std::complex<int> == std::complex{ 11, 73 }
    auto result_2 = cos(left);

    // (2-2)
    // << 연산자는 이름공간 `std` 안에 있다
    // std::operator<<(std::ostream&, const int&)을 실행한다
    std::cout << "imaginary number of result_2 = " << result_2.img() << std::endl;
}

10.1. 인자 의존성 탐색

<C++ 예제 보기>

#!syntax cpp
namespace NamuWiki
{
    struct Vector2
    {
        // Vector2는 float 필드 두개 뿐이므로 복사와 이동이 가능하다

        // 이항 양의 부호 연산자 (덧셈 연산자)
        Vector2 operator+(Vector2& rhs) noexcept
        {
            Vector2 result = *this; // *복사
            result.x += rhs.x;
            result.y += rhs.y;

            return result; // *RVO
        }

        // 이항 음의 부호 연산자 (뺄셈 연산자)
        // 매개변수가 꼭 const lvalue일 필요는 없으나 성능 때문에 하는 게 좋다
        // 이때 `operator+`는 구조체 Vector2 내부가 아니라 이름공간 NamuWiki에 정의된다
        friend Vector2 operator-(const Vector2& lhs, const Vector2& rhs) noexcept
        {
            // C++의 결집 구조체 초기화 (Aggregate initialization)
            return Vector2{ lhs.x - rhs.x, lhs.y - rhs.y };
        }

        // 곱셈 연산자
        // 매개변수가 꼭 const lvalue일 필요는 없으나 성능 때문에 하는 게 좋다
        // 이때 `operator+`는 구조체 Vector2 내부에 정의된다
        // inline이 아니라서 정의를 늦게 해줘도 된다
        Vector2 operator*(const Vector2& lhs, const Vector2& rhs) noexcept;

        // 곱셈 연산자
        // 매개변수가 꼭 const lvalue일 필요는 없으나 성능 때문에 하는 게 좋다
        // 이때 `operator/`는 구조체 Vector2 내부에 정의된다
        // 그러나 inline이기 때문에 반드시 클래스 정의와 함께 같은 헤더 어딘가에 정의해줘야 한다
        inline Vector2 operator/(const Vector2& rhs) noexcept;

        // 단항 양의 부호 연산자
        // 이때 `operator+`는 구조체 Vector2 내부가 아니라 이름공간 NamuWiki에 정의된다
        static friend Vector2& operator+(Vector2& vector) noexcept
        {
            vector.x = std::abs(vector.x);
            vector.y = std::abs(vector.y);
            return vector;
        }

        // 단항 음의 부호 연산자
        // 단항 음의 부호 연산자는 friend가 아니면 static일 수 없다.
        // 이때 `operator-`는 구조체 Vector2 내부에 정의된다
        Vector2& operator-() noexcept
        {
            x = -std::abs(x);
            y = -std::abs(y);
            return *this;
        }

        // 단항 비트 반전 연산자
        // 단항 비트 반전 연산자는 friend가 아니면 static일 수 없다
        // 이때 `operator~`는 구조체 Vector2 내부가 아니라 이름공간 NamuWiki에 정의된다
        static friend Vector2& operator~(Vector2& vector) noexcept
        {
            vector.x = std::abs(vector.x);
            vector.y = std::abs(vector.y);
            return vector;
        }

        float x, y;
    };

    Vector2 Vector2::operator/(const Vector2& rhs) noexcept
    {
        // C의 지정 초기화 (Designated initialization)
         return Vector2
         {
             .x = this->x / rhs.x,
             .y = this->y / rhs.y
         };
    }

    Vector2 Add(const Vector2& lhs, const Vector2& rhs) noexcept
    {
        return lhs.operator+(rhs);
    }

    Vector2 Subtract(const Vector2& lhs, const Vector2& rhs) noexcept
    {
        return lhs.operator-(rhs);
    }

    struct Vector3 : public Vector2
    {
        float z;
    }

    Vector3 Add(const Vector3& lhs, const Vector2& rhs) noexcept
    {
        return Vector3{ lhs.x + rhs.x, lhs.y + rhs.y, lhs.z };
    }
}

NamuWiki::Vector2 NamuWiki::operator*(const NamuWiki::Vector2& lhs, NamuWiki::const Vector2& rhs) noexcept
{
    return Vector2{ lhs.x * rhs.x, lhs.y * rhs.y };
}

int main()
{
    NamuWiki::Vector2 vec1{ 50, 100 };
    NamuWiki::Vector2 vec2{ 400, 70 };
    NamuWiki::Vector3 vec3{ 200, 910, 30 };

    // (1)
    // NamuWiki::Vector2 내부의 (this const Vector2&, const Vector2&)를 이항 +연산자 호출
    vec1 += vec2;

    // (2)
    // result_2 == NamuWiki::Vector2{ 540, 170 }
    // NamuWiki 내부의 (const Vector2&, const Vector2&)를 받는 이항 +연산자 호출
    auto result_2 = vec1 + vec2;

    // 3)
    // result_3 == NamuWiki::Vector2{ 50, 100 }
    // NamuWiki 내부의 (const Vector2&, const Vector2&)를 받는 이항 -연산자 호출
    auto result_3 = vec1 -= vec2;

    // (4)
    // result_4 == NamuWiki::Vector2{ -400, -70 }
    // NamuWiki::Vector2 내부의 단항 -연산자 호출
    auto result_4 = vec2.operator-();

    // (5)
    // result_5 == NamuWiki::Vector2{ -2000, -7000 }
    // NamuWiki 내부의 (const Vector2&, const Vector2&)를 받는 이항 *연산자 호출
    auto result_5 = NamuWiki::operator*(vec1, vec2);

    // (6)
    // result_6 == NamuWiki::Vector2{ -350, -30 }
    // NamuWiki 내부의 (const Vector2&, const Vector2&)를 받는 함수 Add 호출
    auto result_6 = Add(vec1, vec2);

    // (7)
    // result_7 == NamuWiki::Vector3{ 250, 1010, 30 }
    // NamuWiki 내부의 (const Vector3&, const Vector2&)를 받는 함수 Add 호출
    auto result_7 = Add(vec1, vec3);
}

10.2. 모호한 함수 후보 문제 & 이름공간 무시

<C++ 예제 보기>

#!syntax cpp

int main()
{
}

10.3. 잘못된 함수 후보 문제

<C++ 예제 보기>

#!syntax cpp

int main()
{
}

10.4. 해결 방법

<C++ 예제 보기>

#!syntax cpp
namespace NamuWiki
{
    long long Add(int lhs, int rhs);

    class Calculator
    {
    public:
        long long operator()(long long value) const noexcept;
    };

    Calculator Calculator{};
}
long long Calculator(long long a);

int Add(int a, int b);

int main()
{
    // (1)
    auto result_1 = Calculator(254906214713);

    // (2)
    // NamuWiki::Calculator의 인스턴스 Calculator에서 () 연산자 호출
    auto result_2 = NamuWiki::Calculator(254906214713);

    // (3)
    // 전역 범위의 ::Add 호출
    auto result_3 = Add(1000, 6000);

    // (4)
    // 오류! 클래스 Calculator는 () 연산자로 실행할 수 없습니다
    // C++23 부터는 static operator()가 가능하다
    using namespace NamuWiki;
    auto result_4 = NamuWiki::Calculator(254906214713);

    // (5)
    // 오류! 모호한 함수 후보
    using namespace NamuWiki;
    auto result_5 = Add(1000, 6000);
}

<C++ 예제 보기>

#!syntax cpp
class Functor
{
public:
    int operator()() const noexcept
    {
        return 500;
    }

    double operator()(double add) const noexcept
    {
        return myDouble + add;
    }

    double myDouble;
};

class Adder
{
public:
    int operator()(const int& lhs, const int& rhs) const noexcept
    {
        return multiplier * (lhs + rhs);
    }

    float operator()(const float& lhs, const float& rhs) const noexcept
    {
        return static_cast<float>(multiplier) * (lhs + rhs);
    }

    int multiplier = 1;
};

int main()
{
    // (1) test1.myDouble == 0
    Functor test1;

    // test1_result: int == 500
    auto test1_result = test1();

    // (2) test2.myDouble == 200.0
    // ()로 객체 생성
    Functor test2( 200.0 );

    // test2_result: double == 1200.0
    auto test2_result = test2(1000);

    // (3) test3.multiplier == 1
    Adder test3{};

    // test3_result: int == 17000
    auto test3_result = test3(8000, 9000);

    // (4) test4.multiplier == 7
    Adder test4{ 7 };

    // test4_result: float == 4200.0f
    auto test4_result = test3(300, 300.0f);
}

11. 특성 (Attribute)