// 피보나치 수열을 컴파일 타임에 계산!
constexpr int fibonacci(int n) {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
}

int main() {
    // 이 계산은 런타임에 일어나지 않아!
    // 컴파일러가 이미 55라는 값을 계산해서 넣어줌
    constexpr int result = fibonacci(10);
    
    // 어셈블리를 보면 그냥 "mov eax, 55" 한 줄이야
    return result;
}

// consteval: 반드시 컴파일 타임에만 실행되어야 함
consteval int square(int n) {
    return n * n;
}

// constexpr if: 컴파일 타임 분기
template<typename T>
auto process(T value) {
    if constexpr (std::is_integral_v<T>) {
        return value * 2;  // 정수 타입일 때
    } else {
        return value * 2.0;  // 부동소수점 타입일 때
    }
    // 사용되지 않는 분기는 컴파일러가 완전히 제거!
}

// 원시 포인터 방식 (C 스타일)
void raw_pointer_example() {
    int* p = new int(42);
    // ... 뭔가 작업 ...
    delete p;  // 까먹으면 메모리 누수!
}

// unique_ptr 방식 (C++ 스타일)
void smart_pointer_example() {
    auto p = std::make_unique<int>(42);
    // ... 뭔가 작업 ...
    // 함수 끝나면 자동으로 delete 호출!
    // 예외가 발생해도 안전하게 해제됨
}

// 컴파일된 어셈블리는 거의 동일해!
// unique_ptr의 소멸자는 완전히 인라이닝됨

// RAII 기반 파일 핸들러
class FileGuard {
    FILE* file_;
public:
    explicit FileGuard(const char* path, const char* mode)
        : file_(fopen(path, mode)) {}
    
    ~FileGuard() {
        if (file_) fclose(file_);  // 자동으로 닫힘!
    }
    
    // 복사 금지, 이동만 허용
    FileGuard(const FileGuard&) = delete;
    FileGuard& operator=(const FileGuard&) = delete;
    
    FILE* get() const { return file_; }
};

void process_file(const char* path) {
    FileGuard f(path, "r");
    // 예외가 발생해도, 함수가 어떻게 끝나도
    // 파일은 반드시 닫힌다!
    // 컴파일러는 이 소멸자를 인라이닝해서
    // fclose() 직접 호출과 동일한 코드 생성
}

#include <algorithm>
#include <vector>

std::vector<int> data = {5, 3, 8, 1, 9, 2, 7};

// 람다를 사용한 정렬
std::sort(data.begin(), data.end(), 
    [](const int& a, const int& b) {
        return a < b;
    }
);

// 이 람다는 컴파일 타임에 완전히 인라이닝됨
// std::sort의 비교 함수 포인터 오버헤드 없음!
// 함수 포인터 버전보다 오히려 더 빠를 수 있음

// 왜냐면 람다는 타입이 고유해서 템플릿 인스턴스화 시
// 컴파일러가 비교 로직을 완전히 인라이닝할 수 있거든

// ❌ 가상 함수 방식 (런타임 오버헤드 있음)
class Sorter {
public:
    virtual void sort(std::vector<int>& v) = 0;
    virtual ~Sorter() = default;
};

class QuickSorter : public Sorter {
public:
    void sort(std::vector<int>& v) override {
        // 퀵소트 구현
    }
};

// 가상 함수 테이블(vtable) 조회 비용 발생!
// 캐시 미스 가능성 있음
void process(Sorter* s, std::vector<int>& v) {
    s->sort(v);  // 간접 호출
}

// ✅ 정책 기반 설계 (제로 비용!)
template<typename SortPolicy>
class DataProcessor {
    SortPolicy sorter_;
public:
    void process(std::vector<int>& v) {
        sorter_.sort(v);  // 컴파일 타임에 결정, 인라이닝됨!
    }
};

struct QuickSort {
    void sort(std::vector<int>& v) {
        // 퀵소트 구현
        std::sort(v.begin(), v.end());
    }
};

struct StableSort {
    void sort(std::vector<int>& v) {
        std::stable_sort(v.begin(), v.end());
    }
};

// 사용 예시
DataProcessor<QuickSort> fast_processor;
DataProcessor<StableSort> stable_processor;
// 각각 완전히 다른 최적화된 코드가 생성됨!

// CRTP 기반 클래스
template<typename Derived>
class Shape {
public:
    // 가상 함수 없이 다형성 구현!
    double area() const {
        return static_cast<const Derived*>(this)->area_impl();
    }
    
    void print_area() const {
        std::cout << "Area: " << area() << "\n";
    }
};

class Circle : public Shape<Circle> {
    double radius_;
public:
    explicit Circle(double r) : radius_(r) {}
    
    double area_impl() const {
        return 3.14159 * radius_ * radius_;
    }
};

class Rectangle : public Shape<Rectangle> {
    double w_, h_;
public:
    Rectangle(double w, double h) : w_(w), h_(h) {}
    
    double area_impl() const {
        return w_ * h_;
    }
};

// 사용 시 vtable 조회 없음!
// 컴파일러가 area_impl()을 완전히 인라이닝
Circle c(5.0);
c.print_area();  // 완전히 인라이닝된 코드 실행

#include <variant>
#include <string>

// C 스타일 unsafe union
union UnsafeValue {
    int i;
    double d;
    // 어떤 타입이 활성화됐는지 추적 안 됨!
};

// C++ std::variant (타입 안전!)
using SafeValue = std::variant<int, double, std::string>;

SafeValue v = 42;
v = 3.14;
v = "hello";

// std::visit으로 처리
std::visit([](auto&& val) {
    using T = std::decay_t<decltype(val)>;
    if constexpr (std::is_same_v<T, int>) {
        std::cout << "int: " << val << "\n";
    } else if constexpr (std::is_same_v<T, double>) {
        std::cout << "double: " << val << "\n";
    } else {
        std::cout << "string: " << val << "\n";
    }
}, v);

// if constexpr 덕분에 사용되지 않는 분기는
// 컴파일러가 완전히 제거!
// 런타임에는 딱 필요한 코드만 실행됨

#include <optional>

// 실패할 수 있는 함수
std::optional<int> safe_divide(int a, int b) {
    if (b == 0) return std::nullopt;
    return a / b;
}

auto result = safe_divide(10, 2);
if (result.has_value()) {
    std::cout << *result << "\n";  // 5
}

// std::optional<T>의 크기는 T + bool 정도
// 포인터 기반 null 체크와 거의 동일한 성능
// 하지만 타입 안전성과 명확한 의도 표현!

#include <vector>
#include <string>

// 이동 의미론 없이 (C++03 스타일)
std::vector<int> create_large_vector_old() {
    std::vector<int> v(1000000, 42);
    return v;  // 100만 개 원소 복사! 비쌈
}

// 이동 의미론 활용 (C++11+)
std::vector<int> create_large_vector() {
    std::vector<int> v(1000000, 42);
    return v;  // RVO/NRVO 또는 이동 생성자 적용
    // 실제로는 포인터 3개만 복사됨! (begin, end, capacity)
}

// 명시적 이동
std::string s1 = "Hello, World! This is a long string...";
std::string s2 = std::move(s1);  // 포인터만 이전, 복사 없음
// s1은 이제 비어있음 (moved-from state)

// 이동 생성자 구현 예시
class BigData {
    int* data_;
    size_t size_;
public:
    // 이동 생성자: noexcept 필수!
    BigData(BigData&& other) noexcept
        : data_(other.data_), size_(other.size_) {
        other.data_ = nullptr;  // 소유권 이전
        other.size_ = 0;
    }
};

// 완벽한 인수 전달 패턴
template<typename T, typename... Args>
std::unique_ptr<T> make_unique_impl(Args&&... args) {
    return std::unique_ptr<T>(
        new T(std::forward<Args>(args)...)
    );
}

// std::forward는 컴파일 타임에 완전히 해결됨
// 런타임 오버헤드 없이 lvalue/rvalue를 완벽하게 전달
// 이것이 std::make_unique, std::make_shared의 내부 구현 방식

#include <concepts>

// C++20 이전: SFINAE 지옥
template<typename T>
typename std::enable_if<std::is_integral_v<T>, T>::type
old_double(T x) { return x * 2; }

// C++20 Concepts: 읽기 쉽고 오류 메시지도 명확!
template<std::integral T>
T new_double(T x) { return x * 2; }

// 또는 requires 절 사용
template<typename T>
requires std::is_floating_point_v<T>
T precise_double(T x) { return x * 2.0; }

// 사용자 정의 Concept
template<typename T>
concept Printable = requires(T t) {
    { std::cout << t } -> std::same_as<std::ostream&>;
};

template<Printable T>
void print(const T& value) {
    std::cout << value << "\n";
}

// Concepts는 컴파일 타임에 완전히 해결됨
// 런타임 오버헤드 없음!

#include <ranges>
#include <vector>

std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

// 전통적인 방식 (중간 벡터 생성)
std::vector<int> evens, doubled;
for (auto n : numbers) {
    if (n % 2 == 0) evens.push_back(n);
}
for (auto n : evens) {
    doubled.push_back(n * 2);
}

// C++20 Ranges (지연 평가, 중간 컨테이너 없음!)
auto result = numbers
    | std::views::filter([](int n) { return n % 2 == 0; })
    | std::views::transform([](int n) { return n * 2; });

// result는 뷰(view)야 - 실제 계산은 순회할 때만 발생
// 중간 벡터 할당 없음 = 메모리 효율 + 성능 향상
for (auto n : result) {
    std::cout << n << " ";  // 4 8 12 16 20
}

// 컴파일러는 이 파이프라인을 단일 루프로 최적화!

// 해결책 1: extern template (명시적 인스턴스화 선언)
// header.h
extern template class std::vector<MyClass>;  // 다른 곳에서 인스턴스화됨

// source.cpp
template class std::vector<MyClass>;  // 여기서만 인스턴스화

// 해결책 2: C++20 모듈 (Modules)
// mymodule.ixx
export module mymodule;
export template<typename T>
T my_function(T x) { return x * 2; }
// 모듈은 한 번만 컴파일되고 캐시됨!

// 코드 팽창 예시
template<typename T>
void process(std::vector<T>& v) {
    // 이 함수는 T가 다를 때마다 별도 코드 생성
    // int, double, string, MyClass... 모두 별도 인스턴스
}

// 해결책: 타입 독립적인 부분을 비템플릿으로 분리
class ProcessorBase {
protected:
    void do_common_work(void* data, size_t size);  // 공통 로직
};

template<typename T>
class Processor : public ProcessorBase {
public:
    void process(std::vector<T>& v) {
        do_common_work(v.data(), v.size());  // 공통 코드 재사용
        // T에 특화된 부분만 여기서
    }
};

// noexcept는 이동 의미론 최적화에 중요!
class MyVector {
    int* data_;
    size_t size_;
public:
    // noexcept가 없으면 std::vector 재할당 시
    // 이동 대신 복사를 사용할 수 있음!
    MyVector(MyVector&& other) noexcept  // ← 이게 중요!
        : data_(other.data_), size_(other.size_) {
        other.data_ = nullptr;
        other.size_ = 0;
    }
};

// std::vector는 재할당 시 이동 생성자가 noexcept인 경우에만
// 이동을 사용하고, 그렇지 않으면 안전을 위해 복사를 사용해
// noexcept를 빠뜨리면 성능이 크게 저하될 수 있어!

// godbolt.org에서 이 코드를 -O2 옵션으로 컴파일해봐!
#include <vector>
#include <algorithm>

// 버전 1: 범위 기반 for
int sum_range(const std::vector<int>& v) {
    int sum = 0;
    for (const auto& x : v) sum += x;
    return sum;
}

// 버전 2: 인덱스 기반 for
int sum_index(const std::vector<int>& v) {
    int sum = 0;
    for (size_t i = 0; i < v.size(); ++i) sum += v[i];
    return sum;
}

// 두 함수의 어셈블리를 비교해봐
// 거의 동일하거나 완전히 동일한 코드가 생성될 거야!
// 심지어 SIMD 벡터화까지 동일하게 적용됨

#include <benchmark/benchmark.h>
#include <vector>
#include <algorithm>
#include <functional>

// 람다 vs 함수 포인터 성능 비교
static void BM_LambdaSort(benchmark::State& state) {
    std::vector<int> v(1000);
    std::iota(v.begin(), v.end(), 0);
    
    for (auto _ : state) {
        std::shuffle(v.begin(), v.end(), std::mt19937{});
        std::sort(v.begin(), v.end(), 
            [](int a, int b) { return a < b; });  // 람다
    }
}

static void BM_FuncPtrSort(benchmark::State& state) {
    std::vector<int> v(1000);
    std::iota(v.begin(), v.end(), 0);
    
    for (auto _ : state) {
        std::shuffle(v.begin(), v.end(), std::mt19937{});
        std::sort(v.begin(), v.end(), 
            std::less<int>{});  // 함수 객체 (인라이닝됨)
    }
}

BENCHMARK(BM_LambdaSort);
BENCHMARK(BM_FuncPtrSort);
BENCHMARK_MAIN();

// 결과: 두 버전의 성능이 거의 동일하거나
// 람다 버전이 약간 더 빠를 수 있음!

#include <vector>
#include <numeric>
#include <execution>  // C++17 병렬 알고리즘

// 제로 비용 추상화를 활용한 고성능 벡터 연산
template<typename T>
class MathVector {
    std::vector<T> data_;
    
public:
    explicit MathVector(size_t n, T val = T{}) 
        : data_(n, val) {}
    
    // 이동 생성자 (noexcept 필수!)
    MathVector(MathVector&&) noexcept = default;
    MathVector& operator=(MathVector&&) noexcept = default;
    
    // 원소별 덧셈 (SIMD 벡터화 친화적)
    MathVector& operator+=(const MathVector& other) {
        // std::transform은 SIMD 자동 벡터화 잘 됨
        std::transform(
            data_.begin(), data_.end(),
            other.data_.begin(),
            data_.begin(),
            std::plus<T>{}
        );
        return *this;
    }
    
    // 내적 (dot product) - 병렬 실행 정책 활용
    T dot(const MathVector& other) const {
        return std::transform_reduce(
            std::execution::par_unseq,  // 병렬 + SIMD
            data_.begin(), data_.end(),
            other.data_.begin(),
            T{},
            std::plus<T>{},
            std::multiplies<T>{}
        );
    }
    
    size_t size() const noexcept { return data_.size(); }
    T& operator[](size_t i) noexcept { return data_[i]; }
    const T& operator[](size_t i) const noexcept { return data_[i]; }
};

// 사용 예시
MathVector<float> a(1000000, 1.0f);
MathVector<float> b(1000000, 2.0f);
float result = a.dot(b);  // 병렬 SIMD 실행!
// 추상화 비용 없이 최대 성능 달성

// C++23: std::expected - 예외 없는 오류 처리
#include <expected>

std::expected<int, std::string> safe_sqrt(int x) {
    if (x < 0) return std::unexpected("음수는 안 돼!");
    return static_cast<int>(std::sqrt(x));
}

auto result = safe_sqrt(16);
if (result) {
    std::cout << *result << "\n";  // 4
} else {
    std::cout << result.error() << "\n";
}
// 예외 오버헤드 없이 오류 처리!
// std::optional과 유사하지만 오류 정보 포함

// C++23: std::mdspan - 다차원 배열 뷰
#include <mdspan>

std::vector<int> data(6);
auto matrix = std::mdspan(data.data(), 2, 3);  // 2x3 행렬
matrix[0, 1] = 42;  // (0,1) 원소 접근
// 추가 메모리 할당 없이 다차원 뷰 제공!

// C++26 예정: std::execution (비동기 실행 프레임워크)
// 제로 비용 비동기 추상화를 목표로 개발 중

// C++20 모듈: 헤더 파일의 대안
// math_utils.ixx (모듈 인터페이스 파일)
export module math_utils;

export template<typename T>
constexpr T square(T x) { return x * x; }

export template<typename T>
constexpr T cube(T x) { return x * x * x; }

// main.cpp
import math_utils;  // 헤더 포함 대신 모듈 임포트

int main() {
    constexpr auto s = square(5);  // 컴파일 타임: 25
    constexpr auto c = cube(3);    // 컴파일 타임: 27
    return s + c;  // 어셈블리: mov eax, 52
}

// 모듈의 장점:
// 1. 한 번만 컴파일되고 캐시됨 → 빌드 시간 대폭 감소
// 2. 매크로 오염 없음
// 3. 순환 의존성 문제 해결
// 4. 제로 비용 추상화는 그대로 유지!