declval

std::function은 단순 함수뿐만 아니라 operator(), 람다, 멤버 함수, std::bind 등을 포함한 모든 callable 객체를 저장하고 호출할 수 있는 다형적인 함수 래퍼 클래스입니다.

일반적인 함수

int some_function(const std::string& s)
{
    std::cout << s << "함수 호출!" << std::endl;
    return 0;
}

struct S
{
    void operator()(const std::string& s)
    {
        std::cout << "구조체 오퍼레이터 함수 호출!" << std::endl;
    }
};

int main() 
{


    std::function<int(const std::string& s)> f1 = some_function;
    std::function<void(const std::string& s)> f2 = [](const std::string& s) -> void { std::cout << "람다 함수 호출" << s << std::endl;};
    std::function<void(const std::string& s)> f3 = S();

    f1("sss");
    f2("sss");
    f3("sss");

    return 0;

}

템플릿 인자로 함수의 타입(반환, 인자)를 받아 함수 객체를 보관하는 역할

멤버함수

멤버함수의 경우엔?

class A {
    int c;
public:
    A(int c) : c(c) {}
    int some_func() { std::cout << "내부데이터: " << c << std::endl; }
};


int main() {
    A a(5);
    std::function<int()> f1 = a.some_func;
}

내부 함수의 c가 어떤 객체의 c를 참조하는지 알 수 없기에 오류가 발생한다. 즉, 멤버 함수는 객체 없이 단독 호출이 불가능하기 때문에, std::function에 넣을 때는 객체 참조를 인자로 받는 형식으로 감싸야 합니다.

그렇기에

class A {
    int c;
public:
    A(int c) : c(c) {}
    int some_func() { std::cout << "내부데이터: " << c << std::endl; }

    int some_const_function() const { std::cout << "내부데이터, const: " << c << std::endl; }
};


int main() {
    A a(5);
        // 비-const 멤버 함수 포인터
    std::function<int(A&)> f1 = &A::some_func;
    f1(a);

    // const 멤버 함수 포인터
    std::function<int(const A&)> f2 = &A::some_const_func;
    f2(a);

}

함수 이름만으로는 멤버 함수 포인터로 암시적 변환되지 않기 때문에 &A::some_func처럼 명시적 주소 연산자가 필요합니다.

std::mem_fn

멤버 함수 포인터를 함수 객체로 변환해주는 도우미 함수입니다. 객체를 인자로 넘기기만 하면 됩니다.

#include <iostream>
#include <functional>
#include <vector>

class A {
public:
    void print() const { std::cout << "mem_fn 예제" << std::endl; }
};

int main() {
    A a;
    auto f = std::mem_fn(&A::print);
    f(a); // mem_fn을 이용한 멤버 함수 호출

    std::vector<A> vec(3);
    for (const auto& item : vec) f(item); // STL 컨테이너에도 적용 가능
}

std::Bind

std::bind는 기존 함수나 멤버 함수에 인자를 고정(bind) 시켜서 새로운 호출 가능한 객체를 만듭니다.

#include <iostream>
#include <functional>

void greet(const std::string& name, int times) {
    for (int i = 0; i < times; ++i)
        std::cout << "Hello, " << name << "!\n";
}

int main() {
    auto say_hello = std::bind(greet, "Alice", 3);
    say_hello(); // Hello, Alice! x3

    auto say_n_times = std::bind(greet, std::placeholders::_1, 2);
    say_n_times("Bob"); // Hello, Bob! x2
}

std::placeholders::_1 여러 숫자가 있는데 인자의 순서를 나타낸다.

auto g = std::bind(show, std::placeholders::_2, std::placeholders::_1, 300);

이런식으로 할 경우 g(2,3)이라고 할 경우 -> (3,2)의 순서로 나타난다.

레퍼런스의 경우 명시적으로 std::ref(s1) 전달해주지 않으면 데이터가 변경되지 않을 수 있는데 인자가 복사되어 전달되기 때문이다.

#include <iostream>
#include <functional>

void modify(std::string& s) {
    s += " world";
}

int main() {
    std::string s = "hello";

    // 값 복사 - 원본 변경 안 됨
    auto f1 = std::bind(modify, s);
    f1();
    std::cout << s << std::endl; // 출력: hello

    // 참조로 전달
    auto f2 = std::bind(modify, std::ref(s));
    f2();
    std::cout << s << std::endl; // 출력: hello world
}

std::bind는 인자를 기본적으로 값으로 복사하므로, 원본 객체를 수정하고 싶다면 반드시 std::ref()로 참조 전달해야 합니다.

멤버 함수 바인딩의 경우에도

class A {
public:
    void hello(const std::string& msg) {
        std::cout << "A says: " << msg << "\n";
    }
};

A a;
auto f = std::bind(&A::hello, &a, "Hi");
f(); // A says: Hi

void A::hello(A* this, const std::string& msg);

내부적으론 이런형태이기 때문에 꼭 주소를 명시를 해주어야 한다.

MS functional 헤더에 대한 자세한 참고자료

예외처리 과정에서 delete 해야 했던 것을 못하고 넘어가게 되는 경우가 발생 → 메모리 누수(memory leak)

하지만 C++에서는, 예외가 발생해 함수에서 빠져나가더라도, 그 함수의 스택에 정의된 모든 객체는 자동으로 소멸자 호출됨 → 이 과정을 stack unwinding(스택 풀기)이라고 한다

이 아이디어를 차용하여, 포인터를 객체로 감싸고, 그 객체의 소멸자에서 delete를 자동으로 호출하도록 설계했다.

RAII (Resource Acquisition Is Initialization)

자원(포인터, 파일, 락 등)을 생성자에서 획득 해당 객체가 scope을 벗어나면 소멸자에서 자원 자동 해제

즉, 자원을 객체의 생명주기(lifetime)에 묶어버린 것.

✅Unique Ptr

특정객체에 유일한 소유권을 부여하는 것이다. 여러 객체가 참조하지 못한다.

소유권이란? 이 객체가 더 이상 필요 없을 때, "누가 메모리에서 해제(delete)할 책임이 있는가?" 에 대한 권한을 의미한다. unique ptr에선 그 소유권을 특정 객체에게 명확히 한다.

소유권이 중요한 이유

1. Dangling Pointer (허공을 가리키는 포인터): A가 객체를 지웠는데, B가 그 객체에 접근하려 할 때

2. Double Free (중복 해제): A도 지우고, B도 똑같은 객체를 지우려 할 때 발생

3. Memory Leak (메모리 누수)

따라서

std::unique_ptr<Class> ptr(new int(35));

일 경우

std::unique_ptr<Class> ptr2 = ptr; //불가능

이 불가능한데 기본적으로 복사 연산자가 없기 때문이다. 그렇기에 소유권을 넘겨주기 위해서는

std::unique_ptr<Class> ptr2 = std::move(ptr); 

의 rvalue 형태로 이동시켜줘야 한다.

함수 인자로 전달할 때는 포인터의 형태로 전달해야한다. unique_ptr형태로 전달할 경우 더 이상 유일한 소유권이 아니게 되기 때문이다.

void func(int *a);

int main()
{
    std::unique_ptr<int> ptr(new int(35));
    func(ptr.get()) //실제 주소값 전달
}

make_unique

템플릿인자로 전달된 클래스의 생성자 인자들에 직접 완벽한 전달을 한다.

 auto ptr = std::make_unique<Class>(1);

컨테이너에 사용

vector에 사용할 경우 그래도 유니크 포인터로 전달할 경우 컴파일 에러가 발생한다. -> 벡터에 push_back할 때 복사하여 전달하는데 복사 연산자가 없기 때문이다. 역시 rvalue 형태로 만들어 넣어줘야 한다.

vec.push_back(std::move(ptr));
//or
vec.emplace_back(new Class(1));

✅shared_ptr

유니크 포인터와는 다르게 여러 공유 포인터가 하나의 객체를 가리킬 수 있다.

그럼 delete는 어떻게 할까? ->그 객체를 참고 하고 있는 개수(참조 카운트)가 0이 될 경우 소멸

개수를 저장할때 각각의 포인터 객체에 넣으면 업데이트를 어떻게 시키지? -> 처음에 제어 블록(control block)을 동적으로 할당하고 각 포인터 객체들이 이를 공유하며 필요한 정보를 얻거나 업데이트 시킴.

std::shared_ptr<int> ptr(new int(10));//
std::shared_ptr<int> ptr2 = ptr;

복사 연산자가 있기 때문에 = 사용 가능하며 위 경우엔 한 객체를 2개가 가리키게 된다.

[ 제어 블록 (ref count 포함) ] ← 여러 shared_ptr이 이걸 공유 ↑ [shared_ptr 객체] ↓ [실제 데이터 (int)]

제어 블록(control block)에는 다음이 포함됨: 참조 카운트 (use_count) 삭제자 (deleter) weak reference count (shared_ptr + weak_ptr 관리용)

make_shared

일반적으로 공유 포인터를 만들경우 객체 그리고 제어블록에 대한 동적할당 2번이 일어난다. make_shared을 쓸 경우 두 크기를 합친만큼의 동적할당 1번이 일어나므로 속도가 더 빠르다.

std::shared_ptr<A> p1 = std::make_shared<A>();
### ```
#### 주의할 점
인자로 주소값을 전달할 경우 첫 번째 객체로 갖는다고 인식하여 여러 개가 같은 주소값을 가리켜도 각각 1개씩 가리킨다고 생각한다.
-> 즉, 서로 다른 제어블록을 계속 생성함.
```cpp
 A* a = new A();
 std::shared_ptr<A> ptr1(a);
 std::shared_ptr<A> ptr2(a);

-> 참조카운트에 대한 오해로 이미 소멸시킨 객체를 또 소멸시켜 오류가 발생한다.

enable_shared_from_this

shared_ptr는 T*만 가지고 있다고 해서 내부적으로 그걸 관리할 수 없음

객체 안에서 자신을 shared_ptr로 다시 만들려면 자신이 어느 제어 블록에 소속돼 있는지 알아야 함

class ex
{
     std::shared_ptr<ex> get_shared_ptr() { return std::shared_ptr<ex>(this); }
}

int main() {
 std::shared_ptr<ex> pa1 = std::make_shared<ex>();
 std::shared_ptr<ex> pa2 = pa1->get_shared_ptr(); //오류 발생

 }

->이럴 경우 오류가 발생하는데 이때 enable_shared_from_this 클래스를 상속받아서 사용하면 된다.

class ex: public std::enable_shared_from_this<ex> 
{
     std::shared_ptr<ex> get_shared_ptr() { return shared_from_this();  }
}

int main() {
 std::shared_ptr<ex> pa1 = std::make_shared<ex>();
 std::shared_ptr<ex> pa2 = pa1->get_shared_ptr(); 

 }

enable_shared_from_this를 상속하면, std::weak_ptr를 내부에 저장해두고, shared_from_this() 호출 시 그걸 shared_ptr로 승격해서 반환함.

✅weak_ptr

std::weak_ptr

weak_ptr는 shared_ptr와 함께 사용하는 보조 스마트 포인터로,

객체를 소유하지 않고 참조만 하기 위한 목적으로 사용된다. 순환 참조 문제를 회피할 수 있는 유일한 안전한 방법 주로 부모-자식 관계, 콜백, 이벤트 리스너, 캐시 등에서 사용

🔄 순환 참조 문제 (Circular Reference)

shared_ptr는 참조 카운트를 기반으로 객체를 소멸시킴. 그런데 아래와 같은 경우가 생기면 문제가 생김: A → (shared_ptr) → B
B → (shared_ptr) → A 서로가 서로를 shared_ptr로 참조하면 참조 카운트가 0이 될 수 없어, 객체가 소멸되지 않는 메모리 누수가 발생한다. ➡ 이걸 해결하려고 나온 게 바로 weak_ptr이다.

#include <iostream>
#include <memory>

struct B;
struct A {
    std::shared_ptr<B> b_ptr;
};

struct B {
    std::weak_ptr<A> a_ptr; //  
  };

int main() {
    std::shared_ptr<A> a = std::make_shared<A>();
    std::shared_ptr<B> b = std::make_shared<B>();

    a->b_ptr = b;
    b->a_ptr = a; // shared_ptr이었다면 순환 참조 발생

    // 둘 다 scope 벗어나면 자동으로 소멸
}

lock() 함수

weak_ptr은 객체가 이미 소멸되었을 수도 있기 때문에, 바로 접근하지 못하고 lock() 함수를 통해 접근해야 한다.

std::weak_ptr<A> weak;
if (auto shared = weak.lock()) {
    // shared는 유효한 shared_ptr → 객체가 살아 있음
    shared->doSomething();
} else {
    // 객체는 이미 소멸됨
}

제어 블록 (Control Block)

shared_ptr, weak_ptr 모두 내부적으로 제어 블록을 공유함 제어 블록에는 다음 정보가 있음:

use count == 현재 shared_ptr 참조 수 weak count == 현재 weak_ptr 참조 수 deleter 삭제자 정보 객체는 use count == 0일 때 소멸됨 제어 블록 자체는 shared_ptr + weak_ptr 모두 0일 때 메모리에서 해제됨

그렇기에 lvalue 레퍼런스를 하듯 rvalue 레퍼런스를 사용할 경우 오류가 발생할 수 있다. 따라서 &&라는 기호를 사용하여 rvalue 레퍼런스를 사용할 수 있다. ** 왜 사용하는 것일까?**

불필요한 복사를 피해서 성능(메모리, 속도...)을 크게 향상시키기 위해서이다.

복사를 할 경우 깊은 복사는 비용이 매우 크다. (메모리 할당, 데이터 복제 등) 이동은 그냥 포인터만 옮기면 되기 때문이다. (자원 뺏기)

관련 함수 및 추가 정보..

std::move함수

lvalue를 rvalue로 형 변환 해주는 역할 -> 이동 연산자 (&& a)를 사용하는데 쓰임. 우측값 레퍼런스를 할 때 쓰인다.

#include <utility>  // for std::move
#include <iostream>

template<typename T>
class tt
{
    int a;

public:
    // 기본 생성자
    tt() : a(0) {}

    // 복사 생성자
    tt(const tt& t)
    {
        a = t.a;
        std::cout << "복사 생성자" << std::endl;
    }

    // 이동 생성자
    tt(tt&& t)
    {
        a = t.a; // int는 move 의미 없지만 일단 값 복사
        std::cout << "이동 생성자" << std::endl;
    }
};

int main()
{
    tt<int> t;                      // 기본 생성자
    tt<int> t2(std::move(t));       // 이동 생성자
}

std::forward<>

✅ std::forward란? "넘겨받은 값을 원래의 속성(lvalue인지 rvalue인지) 그대로 다음 함수에 전달하는 것"

이걸 perfect forwarding (완벽 전달)이라고 한다.

🔍 왜 필요한가? 📦 일반적인 템플릿 함수에서

template <typename T>
void wrapper(T arg) {
    callee(arg); // 문제 발생 가능
}

여기서 arg는 항상 좌측값(lvalue)로 취급됨 원래 rvalue였던 값도 lvalue로 바뀜! 즉, 원래 이렇게 부르면:

wrapper(std::string("hi")); // <- 이건 rvalue! 그런데 callee(arg)로 넘기면 arg는 이름 있는 변수 → lvalue → 그래서 callee는 복사 생성자를 호출하게 됨 ❌

✅ 해결법: std::forward

template <typename T>
void wrapper(T&& arg) {
    callee(std::forward<T>(arg)); // 💥 여기서 원래 성질 유지됨!
}

여기서 T&&는 universal reference (또는 forwarding reference) std::forward(arg)는 T가 lvalue면 → lvalue로 전달 T가 rvalue면 → rvalue로 전달 즉, 전달받은 값의 원래 성격(lvalue/rvalue)을 그대로 전달하는 게 핵심!

rvalue 레퍼런스 관련 MS 문서

C++에서 예외(Exception)는 프로그램 실행 중 오류 또는 비정상적인 상황이 발생했을 때 이를 감지하고 적절히 처리하는 메커니즘이다. 예외 처리를 사용하면 프로그램이 비정상적으로 종료되는 것을 방지하고, 오류를 보다 체계적으로 관리할 수 있다.

✅ 2. throw, try, catch 기본 개념

C++ 예외 처리는 세 가지 주요 키워드로 구성된다.

throw 예외를 발생시킬 때 사용 try 예외 발생 가능성이 있는 코드를 감싸는 블록 catch 예외가 발생했을 때 실행할 코드 블록

✅ 3. 예외 처리 기본 구조

try {
    // 예외가 발생할 가능성이 있는 코드
    throw 42;  // 예외 발생
} 
catch (int e) {  
    // 예외 처리 코드
    std::cout << "Caught exception: " << e << std::endl;
}

✔ throw → 예외 발생 시, 예외 객체를 전달함 ✔ try → 예외 발생 가능성이 있는 코드 블록을 감싸줌 ✔ catch → 발생한 예외를 받아 처리

✅ 4. 예제 코드: 예외 발생 및 처리

#include <iostream>

void testFunction() {
    std::cout << "Throwing an exception..." << std::endl;
    throw std::runtime_error("Something went wrong!");  // 예외 발생
}

int main() {
    try {
        testFunction();
    } 
    catch (const std::runtime_error& e) {
        std::cout << "Caught exception: " << e.what() << std::endl;
    }

    std::cout << "Program continues..." << std::endl;
    return 0;
}

🔹 실행 결과: Throwing an exception...(예외 발생) Caught exception: Something went wrong!(해당 예외 타입에 대한 정보를 받아 실행) Program continues... ✔ 예외가 발생하면 즉시 catch 블록으로 이동하여 처리됨 ✔ 예외 처리 후에도 프로그램이 정상적으로 실행됨

✅ 5. 여러 개의 catch 블록 사용

예외 타입에 따라 다른 방식으로 처리 가능

try {
    throw 42;  // 예외 발생
} 
catch (int e) {
    std::cout << "Caught an integer: " << e << std::endl;
} 
catch (const std::runtime_error& e) {
    std::cout << "Caught a runtime_error: " << e.what() << std::endl;
} 
catch (...) {  // 모든 예외를 처리하는 블록 switch의 default처럼
    std::cout << "Caught an unknown exception" << std::endl;
}

✔ 특정 예외 타입에 맞는 catch 블록이 실행됨 ✔ catch (...)는 모든 예외를 처리하는 블록 (예외 종류를 모를 때 사용)

✅ 6. 예외 전파(Exception Propagation)

예외는 함수를 넘어서 상위 함수로 전파될 수 있다.

#include <iostream>

void functionA() {
    throw std::runtime_error("Error in functionA");
}

void functionB() {
    functionA();  // functionA에서 예외 발생
}

int main() {
    try {
        functionB();  // functionB가 호출됨
    } 
    catch (const std::runtime_error& e) {
        std::cout << "Caught exception: " << e.what() << std::endl;
    }
}

🔹 실행 결과: Caught exception: Error in functionA ✔ 예외가 발생하면 functionA → functionB → main으로 전파됨 ✔ main에서 예외가 처리되지 않으면 프로그램이 비정상 종료됨 ** 만약 부모,자식 클래스에 대해서 받을 경우 catch순서에 부모 클래스를 먼저 둘 경우 Parent& p = Child()✅ Child& p = Parent()❌ 도 가능하므로 자식클래스 예외타입에 대해서도 부모 클래스에 대한 catch가 실행되므로 자식 클래스를 앞에 두는 것이 좋다.**

✅ 7. 스택 풀기 (Stack Unwinding)

스택 풀기(Stack Unwinding)란 예외가 발생하여 함수가 종료될 때, 지역 변수들이 자동으로 소멸되는 과정을 의미한다.

📌 스택 풀기의 원리: 예외 발생 시, 현재 함수가 즉시 종료됨. 지역 변수들의 소멸자가 자동으로 호출됨. 예외가 상위 함수로 전파되면서, 그 과정에서 할당된 모든 지역 변수들이 해제됨. catch 블록에서 예외를 처리하면 예외 전파가 멈춤. 📌 예제 (소멸자 호출 확인)

#include <iostream>

struct Test {
    std::string name;
    Test(std::string n) : name(n) { std::cout << name << " created\n"; }
    ~Test() { std::cout << name << " destroyed\n"; }
};

void functionA() {
    Test a("A");
    throw std::runtime_error("Exception in functionA");
}

void functionB() {
    Test b("B");
    functionA();
}

int main() {
    try {
        functionB();
    } 
    catch (const std::runtime_error& e) {
        std::cout << "Caught exception: " << e.what() << std::endl;
    }
}

🔹 실행 결과: B created A created A destroyed B destroyed Caught exception: Exception in functionA ✔ 예외가 발생하면 지역 변수들이 역순으로 소멸됨. ✔ 스택 풀기가 동작하여 자원 누수가 방지됨. 유의할 점 -> 생성자에서 예외 발생 시 소멸자가 호출되지 않음!@

✅ 8. 사용자 정의 예외 클래스

C++에서는 std::exception을 상속받아 사용자 정의 예외 클래스를 만들 수 있다.

#include <iostream>
#include <stdexcept>

class MyException : public std::exception {
public:
    const char* what() const noexcept override {
        return "Custom exception occurred!";
    }
};

void test() {
    throw MyException();
}

int main() {
    try {
        test();
    } 
    catch (const MyException& e) {
        std::cout << "Caught: " << e.what() << std::endl;
    }
}

✔ std::exception을 상속받아 what()을 오버라이드하여 예외 메시지를 정의 가능. ✔ 사용자 정의 예외를 통해 더 세밀한 예외 처리가 가능.

what()->예외 발생 시 해당 예외에 대한 설명 메시지(문자열)를 반환하는 역할

✅ 9. noexcept와 예외 처리

noexcept 키워드를 사용하면 함수에서 예외가 발생하지 않음을 명시할 수 있다.

void safeFunction() noexcept {
    std::cout << "This function never throws exceptions.\n";
}

✔ noexcept가 붙은 함수에서 예외가 발생하면 프로그램이 강제 종료됨.

✔ noexcept가 붙었다고 해서 절대 예외를 발생시키지 않는 것은 아니다. -> 컴파일러가 예외를 발생시키지 않는다고 생각하고 컴파일 하는 것임.

-✔ 예외를 절대 발생시키지 않는 함수에 사용하면 최적화에 도움이 됨. ✔ C++11 부터 소멸자는 기본적으로 noexcept임.

추가자료 <stdexcept.h>

MS <stdexcept.h>에 대한 자세한 자료들 클래스들 등등...

람다 함수는 익명 함수(anonymous function)로, 간결하게 정의하여 코드의 가독성을 높이고, 함수 객체(functor) 없이도 간편하게 사용할 수 있다.

✅ 람다 함수 기본 문법

Copy code
[capture](parameter_list) -> return_type { function_body };

✅ 예제

#include <iostream>

int main() {
    auto add = [](int a, int b) { return a + b; };
    std::cout << add(3, 5) << std::endl;  // 8
}

[] : 캡처 리스트 (외부 변수를 사용할 수 있게 함) -> 클래스처럼 객체에 대한 변수를 사용할 경우엔 [this]를 통해 인스턴스에 대한 변수임을 알려야 함. [&] -> 모든 외부 변수를 레퍼런스로 [=] -> 모든 외부 변수를 복사본으로 [&a ,b] -> 반반

(int a, int b) : 매개변수 리스트 { return a + b; } : 함수 본문

2️⃣ std::remove

std::remove는 특정 값을 배열 또는 컨테이너에서 삭제하는 것처럼 보이게 한다. 실제로 원소를 삭제하는 것이 아니라, 제거된 요소들을 컨테이너의 끝으로 이동시키고, 새로운 끝을 가리키는 반복자를 반환한다.

✅ 사용법

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5, 3, 6};

    vec.erase(std::remove(vec.begin(), vec.end(), 3), vec.end());

    for (int v : vec) std::cout << v << " ";  // 1 2 4 5 6
}

💡 주의: std::remove는 원소를 삭제하는 것이 아니라, 새로운 위치로 이동시키므로 erase와 함께 사용해야 한다.

3️⃣ std::remove_if

std::remove_if는 조건을 만족하는 요소들을 제거하는 버전이다.

✅ 사용법

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5, 6};

    vec.erase(std::remove_if(vec.begin(), vec.end(), [](int x) { return x % 2 == 0; }), vec.end());

    for (int v : vec) std::cout << v << " ";  // 1 3 5
}

💡 람다 함수 사용 가능하여 더욱 유연하게 조건을 설정할 수 있다.

4️⃣ std::sort

std::sort는 빠른 정렬(QuickSort, HeapSort, IntroSort를 혼합한 최적화된 정렬 알고리즘)을 사용하여 컨테이너를 정렬한다.

✅ 기본 사용법 (오름차순 정렬)

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = {5, 2, 9, 1, 5, 6};

    std::sort(vec.begin(), vec.end());

    for (int v : vec) std::cout << v << " ";  // 1 2 5 5 6 9
}

✅ 내림차순 정렬 (람다 사용)

std::sort(vec.begin(), vec.end(), [](int a, int b) { return a > b; });

5️⃣ std::stable_sort

std::stable_sort는 안정적인 정렬 알고리즘으로, 같은 값에 대한 상대적인 순서를 유지한다.

✅ 예제

#include <iostream>
#include <vector>
#include <algorithm>

struct Person {
    std::string name;
    int age;
};

int main() {
    std::vector<Person> people = {{"Alice", 30}, {"Bob", 25}, {"Charlie", 30}};

    std::stable_sort(people.begin(), people.end(), [](const Person &a, const Person &b) {
        return a.age < b.age;
    });

    for (const auto &p : people) std::cout << p.name << " ";  // Bob Alice Charlie
}

💡 정렬 후에도 Alice와 Charlie의 순서가 유지됨 (stable)

6️⃣ std::partial_sort

std::partial_sort는 컨테이너의 일부만 정렬하는 알고리즘으로, 상위 N개의 요소만 정렬할 때 유용하다.

✅ 예제

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = {10, 5, 8, 1, 7, 9};

    std::partial_sort(vec.begin(), vec.begin() + 3, vec.end());

    for (int v : vec) std::cout << v << " ";  // 1 5 7 10 8 9
}

💡 처음 3개의 요소만 정렬됨, 나머지는 정렬되지 않음.

7️⃣ std::transform

std::transform은 컨테이너의 각 요소를 변환하여 새로운 컨테이너에 저장할 때 사용한다.

✅ 예제 (각 요소를 2배로 변환)

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    std::vector<int> result(vec.size());

    std::transform(vec.begin(), vec.end(), result.begin(), [](int x) { return x * 2; });

    for (int v : result) std::cout << v << " ";  // 2 4 6 8 10
}

💡 원본 컨테이너는 유지하면서 변환된 결과를 다른 컨테이너에 저장할 수 있음.

8️⃣ std::find

std::find는 컨테이너에서 특정 값을 찾아 첫 번째 위치를 반환하는 알고리즘이다.

✅ 사용법

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = {10, 20, 30, 40, 50};

    auto it = std::find(vec.begin(), vec.end(), 30);

    if (it != vec.end()) {
        std::cout << "Found: " << *it << std::endl;  // Found: 30
    } else {
        std::cout << "Not Found" << std::endl;
    }
}

첫 번째 30을 찾으면 반복자를 반환하며, 없으면 vec.end()를 반환한다.

9️⃣ std::find_if

std::find_if는 특정 조건을 만족하는 첫 번째 요소를 찾는 알고리즘이다.

✅ 사용법

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = {10, 21, 33, 40, 50};

    auto it = std::find_if(vec.begin(), vec.end(), [](int x) { return x % 2 == 1; });

    if (it != vec.end()) {
        std::cout << "First odd number: " << *it << std::endl;  // First odd number: 21
    } else {
        std::cout << "No odd numbers found" << std::endl;
    }
}

람다 함수를 사용해 홀수(x % 2 == 1)인 첫 번째 요소를 찾는다.

set,map과 같은 컨테이너는 이미 내부 구조를 알고 있어 해당 컨테이너의 find함수를 쓰는 것이 더 빠르(효율적)이다. 내부적으로 find함수가 없을 경우 사용하면 유용하다.

🔟 std::all_of

std::all_of는 컨테이너의 모든 요소가 특정 조건을 만족하는지 확인하는 알고리즘이다.

✅ 사용법

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = {2, 4, 6, 8, 10};

    bool allEven = std::all_of(vec.begin(), vec.end(), [](int x) { return x % 2 == 0; });

    if (allEven) {
        std::cout << "All elements are even." << std::endl;  // 출력됨
    } else {
        std::cout << "Not all elements are even." << std::endl;
    }
}

✔️ 모든 요소가 짝수(x % 2 == 0)인지 검사 ✔️ 모든 요소가 조건을 만족하면 true, 그렇지 않으면 false 반환

1️⃣1️⃣ std::any_of

std::any_of는 컨테이너의 하나 이상의 요소가 특정 조건을 만족하는지 확인하는 알고리즘이다.

✅ 사용법

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = {2, 4, 6, 9, 10};

    bool hasOdd = std::any_of(vec.begin(), vec.end(), [](int x) { return x % 2 == 1; });

    if (hasOdd) {
        std::cout << "There is at least one odd number." << std::endl;  // 출력됨
    } else {
        std::cout << "No odd numbers found." << std::endl;
    }
}

✔️ 하나라도 홀수(x % 2 == 1)인 요소가 있으면 true 반환 ✔️ 모든 요소가 조건을 만족하지 않으면 false 반환

문자열을 탐색할 때 사용하는 알고리즘이다.

핵심 아이디어는 찾고자 하는 문자열의 접두사(prefix)와 접미사(suffix)에 대하여 일치하는 개수(길이)를 배열로 저장한 후에 탐색할 때 사용하는 것이다.

예를 들어 찾고자 하는 문자열 p가 ababc 일 경우 i = 0, 0 i = 1, 0 i = 2, aba 에서 a, a이므로 1 i = 3, abab에서 ab와 ab이므로 2 i = 4, 접미사가 c로 시작하므로 일치하는 것이 없다 0

이렇게 배열을 만든 후 찾고자하는 문자열 s가 ababdababcababc일 경우

j = 0(p에서 쓰이는 인덱스), i = 0 (s에서 쓰이는 인덱스)

처음에 ababd에 대하여 abab까지 같으므로 j = 4 , i = 4이고 다음 상황에 c != d이므로 j를 옮겨 줘야 한다 이때 미리 구해둔 pi배열을 쓰는데 위에서 보든 pi[3]일때 즉 abab였을 때 접두사 == 접미사 중 가장 긴 것의 길이가 2인 ab를 저장해두었으므로 j = 2인데 [2]또한 다르기 때문에 한 번더 옮겨주면 j = 0으로 다시 시작하게 된다.

쉽게 얘기해서 굳이 처음부터 다시 비교하는 것이 아닌 미리 저장해둔 위치로 이동해서 더 효율적으로 탐색하는 것이다.

이후 계속 보면 ababc가 겹치므로 정답을 추가하고 j = 0이 되어 다시 진행 하면 ababc가 또 나오므로 총 2개의 문자열이 탐색된다.

백준 1786번 문제

백준 1786번

#include <iostream>
#include <queue>
#include <algorithm>
#include <vector>
#include <cstring>
#include <cmath>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <string>
#include <functional>


using namespace std;

int dx[4] = { 0,0,-1,1 };
int dy[4] = { -1,1,0,0 };




vector<int> getPi(string p)
{
    int m = p.size();
    int j = 0;

    vector<int> pi(m, 0);

    for (int i = 1; i < m; i++)
    {
        while (j > 0 && p[i] != p[j])
            j = pi[j - 1];

        if (p[i] == p[j])
            pi[i] = ++j;
    }

    return pi;
}

vector<int> kmp(string s, string p)
{
    vector<int>ans;

    auto pi = getPi(p);

    int n = s.size(); int m = p.size(); int j = 0;

    for (int i = 0; i < n; i++)
    {
        while (j > 0 && s[i] != p[j])
            j = pi[j - 1];

        if (s[i] == p[j])
        {
            if (j == m - 1)
            {
                ans.push_back(i - m + 1);
                j = pi[j];
            }
            else
            {
                j++;
            }
        }
    }

    return ans;
}


int main()
{
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);


    string T, P;

    getline(cin, T);

    getline(cin, P);


    vector<int> a = kmp(T, P);

    cout << a.size() << "\n";

    for (int i = 0; i < a.size(); i++)
    {
        cout << a[i] + 1 << " ";
    }

    return 0;
}

접근 방식

주어진 inorder과 postorder를 고려해 봤을 때 postorder을 통해서 루트를 얻어올 수 있고 inorder를 통하여 미리 구한 루트를 기준으로 왼쪽 서브트리 오른쪽 서브트리를 구할 수 있다는 것을 알아냈다.

1. 이를 구현하기 위해 postorder의 가장 마지막 값은 무조건 root의 값이므로 이를 기점으로 시작하여 root의 왼쪽 subroot 오른쪽 subroot를 구하는 방식으로 접근한다.

2. subroot를 구하기 위하여 처음에 쓴 방식은 루트를 구했다면 이를 기준으로 inorder에서 해당 루트 인덱스 왼쪽은 왼쪽 서브트리 set ,오른쪽은 오른쪽 서브트리 set에 넣어 postorder을 맨뒤에서 부터 순회할 때 오른쪽 왼쪽 각각 가장 먼저 set안에 해당하는 값이면 이것이 그 subtree의 root임을 이용하였다.

3. 자료구조의 트리처럼 왼쪽, 오른쪽 포인터를 이용한 구조체를 만들어서 하였는데 시간초과도 나고 불필요하다는 생각이 들어 재귀를 통해 함수에 접근할때 바로 출력하면 그것이 preorder이기 때문에 구조체 방법을 없애고 바로바로 출력하는 방법으로 바꾸었다.

4. 여전히 시간초과가 나서 subroot를 찾을때 오른쪽 subroot는 postorder배열에서 현재 root의 바로 옆에있는 것이기에 왼쪽 subroot를 구할때 오른쪽 개수만큼 뺀후에 시작하도록 하였는데 이래도 여전히 시간초과가 발생했다.

5. 마지막으로 시도한 방법은 오른쪽은 현재 root바로 옆 인덱스의 값을 반환하도록 하고 왼쪽은 아까 시도한 방식에서 for문을 없애고 현재 인덱스에서 오른쪽 서브트리의 개수 + 1의 값을 뺴서 이 역시도 해당 인덱스에 위치한 배열 값을 출력하도록 했고 문제가 해결이 됐다.

처음 접근 방식은 좋았는데 이를 효율적으로 구현하지 못하여 좀 헤맸던 것 같다.

해당 코드

#include <iostream>
#include <queue>
#include <algorithm>
#include <vector>
#include <cstring>
#include <cmath>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <string>


using namespace std;

int dx[4] = { 0,0,-1,1 };
int dy[4] = { -1,1,0,0 };

int N;

int InOrder[100001] = { 0 };
int PostOrder[100001] = { 0 };

unordered_map<int,int>InOrderIdx;
unordered_map<int,int>PostOrderIdx;


int FindLeftTreeRoot(int rootIdx, int postRootIdx, int end) {

    int rightNums = end - rootIdx;  
    int leftRootIdx = postRootIdx - rightNums - 1;  

    if (leftRootIdx >= 1) {
        return PostOrder[leftRootIdx];
    }
    return -999;
}

int FindRightTreeRoot(int rootIdx, int postRootIdx) {

    int rightRootIdx = postRootIdx - 1;  

    if (rightRootIdx >= 1) {
        return PostOrder[rightRootIdx];
    }
    return -999;
}

void MakeTree(int start, int end, int rootVal, int rootIdx)
{

    if (start > end)
    {
        return;
    }

    int rootV = -999;
    int postRootIdx = PostOrderIdx[rootVal];

    cout << rootVal << " ";

    if ((rootV = FindLeftTreeRoot(rootIdx, postRootIdx, end)) != -999)
    {
        MakeTree(start, rootIdx - 1, rootV, InOrderIdx[rootV]);
    }

    if ((rootV = FindRightTreeRoot(rootIdx, postRootIdx)) != -999)
    {

        MakeTree(rootIdx + 1, end, rootV, InOrderIdx[rootV]);
    }

;

}



int main()
{
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);

    cin >> N;

    for (int i = 1; i <= N; i++)
    {
        cin >> InOrder[i];
        InOrderIdx[InOrder[i]] = i;    
    }

    for (int i = 1; i <= N; i++)
    {
        cin >> PostOrder[i];
        PostOrderIdx[PostOrder[i]] = i;
    }

    int rootVal = PostOrder[N];

    MakeTree(1, N, rootVal,InOrderIdx[rootVal]);


    int a = 0;

    return 0;
}

개발자가 함수 반환값을 반드시 사용해야 하는 상황에서 실수를 방지하도록 돕는 도구이다.

[[nodiscard]] int GetID(const std::wstring& userName)
{
    return DB.Get(userName);
}

int main()
{

    GetID(L"Kim");//반환값이 사용되지 않음
    int my_ID = GetID(L"Lee"); // 반환값이 사용됨

}

이런 경우일 때 사용되고 추가로

[[nodiscard("사용자에 대한 ID를 사용하지 않고 있습니다!")]] 
int GetID(const std::wstring& userName)
{
    return DB.Get(userName);
}

위와 같이 메시지를 추가하여 경고문으로 사용할 수 있다.

noreturn

함수가 반환하지 않을 것임을 컴파일러에 명시적으로 알리는 데 사용됩니다. 주로 프로그램 실행을 종료하거나, 무한 루프를 실행하거나, 예외를 던지는 함수에 적용된다.

1.프로그램 종료함수

#include <cstdlib>
#include <stdexcept>

[[noreturn]] void TerminateProgram() {
    std::exit(1); // 프로그램 종료
}

int main() {
    TerminateProgram();
    // 이 이후 코드는 절대 실행되지 않음
    return 0;
}

2. 예외를 던지는 함수

   [[noreturn]] void ThrowError() {
    throw std::runtime_error("Error occurred!");
   }
   

void Process() { ThrowError(); // 이 이후 코드는 절대 실행되지 않음 }

### string_view
✅ 1. std::string_view의 특징
1️⃣ 문자열을 복사하지 않음 → 기존 문자열 데이터를 참조하여 빠름
2️⃣ 읽기 전용 → 문자열을 수정할 수 없음 (std::string과 다름)
3️⃣ 자동으로 C-스타일 문자열(const char*)과 std::string을 참조 가능
4️⃣ 길이를 저장하고 있음 → strlen()보다 size() 호출이 빠름

✅ 2. 기본 사용법

```cpp
#include <iostream>
#include <string_view>

int main() {
    std::string_view sv = "Hello, World!";  // 문자열 리터럴 참조
    std::cout << sv << std::endl;           // Hello, World!
    std::cout << "Length: " << sv.size() << std::endl;  // 13
}

✔ 문자열을 복사하지 않고 참조만 수행 ✔ .size()는 O(1) 연산 (C-스타일 문자열의 strlen()은 O(n))

std::string_view는 std::string과 유사한 인터페이스를 제공하지만, 읽기 전용 함수만 사용 가능합니다.

함수 설명 예제 size() 문자열 길이 반환 sv.size() empty() 문자열이 비어 있는지 확인 sv.empty() substr(pos, len) 부분 문자열 반환 (std::string_view) sv.substr(7, 5) front() 첫 번째 문자 반환 sv.front() back() 마지막 문자 반환 sv.back() remove_prefix(n) 앞에서 n개 문자 제거 sv.remove_prefix(7) remove_suffix(n) 뒤에서 n개 문자 제거 sv.remove_suffix(6)

유의 -> 원본 문자열이 사라질 시 오류 발생

사용자가 원하는 타입을 넣어주면 그에 맞게 짜여지는 틀과 같은 역할을 한다.

template <typename T>
void print(T w)
{
    cout << w << endl;
}

int main()
{
    string s;
    cin >> s;

    print(s);

    int a;
    cin >> a;

    print(a);
}

template <typename T>
class Print
{

public:

    Print()
    {
    }

    void pt()
    {
        std::cout << typeid(T).name() << std::endl;
    }



};

int main()
{

    Print<std::string> print_s;
    print_s.pt();
    Print<int> print_i;
    print_i.pt();


    return 0;
}

위 코드처럼 들어가는 변수의 타입에 맞게 코드가 실행된다.

위 경우들 처럼 클래스 템플릿에 인자를 전달해서 실제 코드를 생성하는 것을 클래스 템플릿 인스턴스화 (class template instantiation)라고 한다.

템플릿 특수화(template specializtion)

템플릿을 할 때 일부 경우에 대해선 따로 처리해주는 것이다.

template <typename T, typename A>
class Print
{

public:

    Print()
    {
    }

    void pt()
    {
        std::cout << typeid(T).name() << std::endl;
    }



};

template <>
class Print<int, float>
{

public:

    Print()
    {
        std::cout << "float or int~~" << std::endl;
    }


};

template <typename B>
class Print<std::string,B>
{

public:

    Print()
    {
        std::cout << "string~~" << std::endl;
    }


};

int main()
{

    Print<std::string, double> print_s;
    Print<int, float> print_i;


    return 0;
}

이런식으로 원래 선언한 템플릿의 개수에 맞추어 자신이 따로 처리하고 싶은 경우에 대하여 템플릿 특수화를 진행할 수 있다.

함수 객체(Function object / Functor)

template<typename T, typename Comp>
void bubble_sort(T& cont, Comp& comp)
{
    for (int i = 0; i < cont.size(); i++) 
    {
        for (int j = i + 1; j < cont.size(); j++)
        {
            if (!comp(cont[i], cont[j])) 
            {
                int temp = cont[i];
                cont[i] = cont[j];
                cont[j] = temp;
            }
        }
    }
}

bool comp1(int a, int b)
{
    return (a > b);
}

bool comp2(int a, int b)
{
    return (a < b);
}


int main()
{
    std::vector<int> v;

    v.push_back(1);
    v.push_back(4);
    v.push_back(2);
    v.push_back(6);
    v.push_back(3);

    bubble_sort(v, comp1);

    for (int i = 0; i < v.size(); i++)
    {
        std::cout << v[i] << std::endl;
    }

코드를 입력하세요

    bubble_sort(v, comp2);

    for (int i = 0; i < v.size(); i++)
    {
        std::cout << v[i] << std::endl;
    }

    return 0;
}

함수 객체가 없었다면 오름차순, 내림차순 정렬에 대하여 만들어줘야 하지만(함수포인터를 쓸 필요없이) 사용자가 원하는 조건에 대한 클래스를 만들어 주어서 실행할 수 있다는 점에서 더 간편하고 효율적이다.

타입이 아닌 템플릿 인자 (non-type template arguments)

template<typename T, int num>
void print(T s)
{
    std::cout << s << " " << num << std::endl;
}

int main()
{
    std::string s;
    std::cin >> s;

    print<std::string, 5>(s);

    return 0;
}

이와 같이 템플릿에 전달하는 인자가 타입이 아닌 정수와 같은 변수도 가능하다. 정수 이외에도(c++ 20부터) 밑에 있는 여러 자료형들도 사용이 가능해졌다. ->컴파일 타임에 값들이 정해져야 하는 것에 많이 사용 ex)STL의 array 경우 std::array<int, 2> arr 이런 식으로 미리 크기를 알려줄 수 있다.

1. 정수 타입들 (bool, char, int, long 등등). 당연히 float 과 double 은 제외

2. 포인터 타입

3. enum 타입

4. std::nullptr_t (널 포인터)

만약 아무 값도 전달해주지 않으면 컴파일 오류가 생긴다.

이를 방지하기 위해

디폴트 템플릿 인자

미리 디폴트 값을 정해두어 아무 값도 전달하지 않아도 실행될 수 있게 할 수 있다.

template<typename T, int num = 5>
void print(T s)
{
    std::cout << s << " " << num << std::endl;
}

int main()
{
    std::string s;
    std::cin >> s;

    print<std::string>(s);

    return 0;
}

타입 또한 디폴트로 전달이 가능하다. 최소값을 구하는 함수를 만들 때

template<typename T>
struct Compare
{
    bool operator()(const T& a, const  T& b) const { return a < b; }
};

template<typename T, typename Comp = Compare<T>>//디폴트로 설정해준 타입에 따라서 클래스가 실행됨
T Min(T a, T b) {
    Comp comp;
    if (comp(a, b)) {
        return a;
    }
    return b;
}



int main()
{
    int a = 3, b = 5;
    std::cout << "Min " << a << " , " << b << " :: " << Min(a, b) << std::endl;

    std::string s1 = "abc", s2 = "def";
    std::cout << "Min " << s1 << " , " << s2 << " :: " << Min(s1, s2)
        << std::endl;

    return 0;
}

<출처>

모두의 코드 c++

레스터라이져 Desc

//  래스터라이저 스테이트 오브젝트 생성

D3D11_RASTERIZER_DESC RSDesc;
RSDesc.FillMode = D3D11_FILL_SOLID;           // 평범하게 렌더링
RSDesc.CullMode = D3D11_CULL_NONE;         // 컬모드 하지 않음
RSDesc.FrontCounterClockwise = FALSE;        // 시계방향이 뒷면임 CCW
RSDesc.DepthBias             = 0;                      //깊이 바이어스 값 0
RSDesc.DepthBiasClamp        = 0;
RSDesc.SlopeScaledDepthBias  = 0;
RSDesc.DepthClipEnable       = FALSE;            // 깊이 클리핑 없음
RSDesc.ScissorEnable         = FALSE;             // 시저 테스트 하지 않음
RSDesc.MultisampleEnable     = FALSE;          // 멀티 샘플링 하지 않음
RSDesc.AntialiasedLineEnable = FALSE;         // 라인 안티앨리어싱 없음

hr = g_pD3DDevice->CreateRasterizerState(&RSDesc, &g_pRasterizerState);

Desc와 모드에 관한 더 상세한 설명

Blend

output merger에 대한 설명(깊이,스텐실,블렌딩)

Blend Desc

        D3D11_BLEND_DESC bsDesc = {};
        bsDesc.AlphaToCoverageEnable = false; //멀티 샘플링에서 알파값 사용 유무
        bsDesc.IndependentBlendEnable = false; // False -> 렌더타겟의 0번쨰만 사용 (1~7 번째는 무시)

        // 0번 렌더타겟에 대한 블렌드 상태 설정 (0~7 번까지 설정 가능하다)
        bsDesc.RenderTarget[0].BlendEnable = true; 
        bsDesc.RenderTarget[0].SrcBlend = D3D11_BLEND::D3D11_BLEND_SRC_ALPHA;
        bsDesc.RenderTarget[0].DestBlend = D3D11_BLEND::D3D11_BLEND_INV_SRC_ALPHA;
        bsDesc.RenderTarget[0].BlendOp = D3D11_BLEND_OP::D3D11_BLEND_OP_ADD;
        bsDesc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND::D3D11_BLEND_ONE;
        bsDesc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND::D3D11_BLEND_ZERO;
        bsDesc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP::D3D11_BLEND_OP_ADD;
        bsDesc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE::D3D11_COLOR_WRITE_ENABLE_ALL;
        GetDevice()->CreateBlendState(&bsDesc, blendStates[(UINT)eBlendState::AlphaBlend].GetAddressOf());

Blend Desc에 관한 상세한 설명

Depth/Stencil Desc

ID3D11DepthStencilState* g_pDepthStencilState = NULL;

D3D11_DEPTH_STENCIL_DESC DepthStencilDesc;

DepthStencilDesc.DepthEnable = TRUE;                                    //깊이 테스트 활성화
DepthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;            //쓰기
DepthStencilDesc.DepthFunc  = D3D11_COMPARISON_LESS;                     // 앞쪽물체를 렌더링
DepthStencilDesc.StencilEnable = FALSE;                                  //스텐실 테스트 비활성화
DepthStencilDesc.StencilReadMask = D3D11_DEFAULT_STENCIL_READ_MASK;      //스텐실 읽기 마스크
DepthStencilDesc.StencilWriteMask = D3D11_DEFAULT_STENCIL_WRITE_MASK;   //스텐실 쓰기 마스크

// 면이 앞을 보고 있을 경우 스텐실 테스트 설정
DepthStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;        //유지
DepthStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP;   //유지
DepthStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;        //유지
DepthStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;        //항상 성공

//면이 뒤를 보고 있을경우 스텐실 테스트 설정
DepthStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;         //유지
DepthStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP;    //유지
DepthStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;         //유지
DepthStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;         //항상 성공

g_pd3dDevice->CreateDepthStencilState(&DepthStencilDesc,&g_pDepthStencilState);

Depth/Stencil Desc 상세 설명

<참고자료> 얌얌 코딩 수업노트