* 마우스 드래그 방지 구현

원리

마우스 드래그 방지는 HTML/CSS/JavaScript 이벤트를 차단하는 원리입니다.

• CSS 방식: 텍스트 선택 자체를 비활성화합니다.
• JavaScript/HTML 이벤트 방식: 드래그 시작 이벤트(ondragstart)나 텍스트 선택 이벤트(onselectstart)를 return false로 처리합니다.

예시 코드

CSS로 구현

 HTML/JavaScript로 구현

또는 JavaScript 코드로 이벤트 차단을 설정할 수도 있습니다:

특정 요소만 텍스트 선택 허용

원리

• user-select: none으로 전체 페이지의 텍스트 선택을 비활성화합니다.
• 선택을 허용할 요소에는 user-select: text를 적용합니다.

예시 코드

마우스 우클릭 방지 구현

원리

마우스 오른쪽 클릭 시 발생하는 contextmenu 이벤트를 가로채서 preventDefault()를 호출하면, 브라우저의 기본 컨텍스트 메뉴가 표시되지 않습니다.

예시 코드

 HTML 속성 방식

JavaScript 방식

특정 요소만 우클릭 허용

원리

• contextmenu 이벤트를 전체 문서에 등록하여 우클릭을 차단합니다.
• 단, 특정 요소(event.target)가 허용 대상이면 preventDefault()를 호출하지 않습니다.​

예시 코드

이 코드는 event.target이 허용된 요소(또는 그 하위 자식)일 경우에만 우클릭이 작동하게 하며, 그 외 영역은 전부 차단됩니다.​

💡 참고: 개발자 도구(F12)에서 JavaScript를 비활성화하거나 코드 제거로 쉽게 우회할 수 있기에, 드래그/우클릭 방지는 사용자 경험 향상용 또는 간단한 안내 수준으로만 사용하는 것이 좋습니다.

원리를 요약하면,

• 드래그 방지: user-select:none; 또는 onselectstart/ondragstart 이벤트 차단.
• 우클릭 방지: contextmenu 이벤트를 막아 브라우저 메뉴가 뜨지 않게 함.

build.bat

@echo off
setlocal
echo DiskFilter Driver Build Script
echo =============================

call "C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Auxiliary\Build\vcvars64.bat" 2>nul
if %ERRORLEVEL% NEQ 0 (
    call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\Build\vcvars64.bat" 2>nul
    if %ERRORLEVEL% NEQ 0 (
        call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvars64.bat" 2>nul
        if %ERRORLEVEL% NEQ 0 (
            echo Error: Visual Studio not found. Please install Visual Studio or run from Developer Command Prompt.
            exit /b 1
        )
    )
)

set WDKPATH=C:\Program Files (x86)\Windows Kits\10

REM Check if we're in WDK environment
if not defined WDKPATH (
    echo Error: WDK environment not detected.
    echo Please run this script from WDK Developer Command Prompt.
    echo.
    echo To open WDK Developer Command Prompt:
    echo 1. Start Menu -> Windows Driver Kit -> WDK x64 x86 Cross-Tools Command Prompt
    echo 2. Navigate to this directory
    echo 3. Run this script again
    pause
    exit /b 1
)

echo WDK environment detected: %WDKPATH%
echo.

REM Clean previous build
echo Cleaning previous build...
del *.obj *.sys *.pdb *.ilk 2>nul

REM Compile
echo Compiling diskfilter.c...
cl /c /I"%WDKPATH%\Include\10.0.26100.0\km" /I"%WDKPATH%\Include\10.0.26100.0\shared" ^
 /I"C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\km\crt" ^
 /I"C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\include" ^
 /DDRIVER /DWIN32 /D_WIN32 /DNT /DNTDDI_VERSION=NTDDI_WIN10 /DWINVER=0x0A00 ^
 /D_WIN32_WINNT=0x0A00 /DUNICODE /D_UNICODE /DNDEBUG /Zi /Od /W3 /WX- /GS /Gy ^
 /Zc:wchar_t /Zc:forScope /Zc:inline /fp:precise /errorReport:prompt /kernel /D_AMD64_ /GS- diskfilter.c

if %errorLevel% neq 0 (
    echo Compilation failed!
    pause
    exit /b 1
)

REM Link
echo Linking diskfilter.sys...
link /DRIVER /SUBSYSTEM:NATIVE /ENTRY:DriverEntry ^
/NODEFAULTLIB /INCREMENTAL:NO /NOLOGO /DEBUG /PDB:diskfilter.pdb ^
/SUBSYSTEM:NATIVE /DRIVER:WDM /MACHINE:X64 /IGNORE:4099 /IGNORE:4210 /IGNORE:4049 /IGNORE:4103 /IGNORE:4098 ^
/LIBPATH:"%WDKPATH%\Lib\10.0.26100.0\km\x64" ^
/OUT:diskfilter.sys diskfilter.obj ntoskrnl.lib hal.lib bufferoverflowk.lib

if %errorLevel% neq 0 (
    echo Linking failed!
    pause
    exit /b 1
)

REM Check if build was successful
if exist diskfilter.sys (
    echo.
    echo Build completed successfully!
    echo Generated: diskfilter.sys
    echo.
    echo To install the driver, run: install.bat
    echo To test the driver, run: test.bat
) else (
    echo Build failed - diskfilter.sys not found!
)

echo.
echo Test completed.
endlocal
pause

윈도우에서 UTF-8 with BOM 파일을 찾아 모두   UTF-8 without BOM 형식으로 변환하기.

아래에서 첫 번째에 최상위 경로를 주고 powershell에서 실행하면 일괄로 변경한다. 

$targetFolder = "data"  # 변환할 최상위 폴더 경로

# UTF-8 BOM 3바이트 시퀀스
$utf8BOM = [byte[]](0xEF,0xBB,0xBF)

# 대상 폴더 내 모든 파일 재귀 탐색
Get-ChildItem -Path $targetFolder -File -Recurse | ForEach-Object {
    $file = $_.FullName

    # 파일을 바이트 단위로 읽기
    $bytes = [System.IO.File]::ReadAllBytes($file)

    # BOM 존재 여부 체크
    if ($bytes.Length -ge 3 -and $bytes[0] -eq $utf8BOM[0] -and $bytes[1] -eq $utf8BOM[1] -and $bytes[2] -eq $utf8BOM[2]) {
        Write-Host "BOM 발견 및 제거 중: $file"

        # BOM 제거한 바이트 배열 생성
        $bytesWithoutBOM = $bytes[3..($bytes.Length - 1)]

        # BOM 제거된 바이트를 임시 파일에 기록
        $tempFile = [System.IO.Path]::GetTempFileName()
        [System.IO.File]::WriteAllBytes($tempFile, $bytesWithoutBOM)

        # 임시 파일을 원본 파일로 덮어쓰기
        Move-Item -Path $tempFile -Destination $file -Force
    }
    else {
        Write-Host "BOM 없음: $file"
    }
}

이 시스템에서 스크립트를 실행할 수 없으므로 ~~~파일을 로드할 수 없습니다. 라고 에러가 나면.

관리자 모드 powershell에서

Set-ExecutionPolicy RemoteSigned

std::optional이 필요한가요?

C++에서는 전통적으로 "값이 없음을 나타내는" 방법이 마땅치 않았어요.

• 포인터일 경우는 nullptr로 표현할 수 있었지만,
• 값 타입(int, double, struct 등)에서는 특별한 값을 정하거나 별도 플래그를 둬야 했죠.

이런 문제를 해결하기 위해 optional이 등장했어요.

std::optional 이란?

std::optional<T>는 T 타입의 값을 가질 수도 있고, 안 가질 수도 있는 컨테이너입니다.

#include <optional>

std::optional<int> maybeGetValue(bool condition) {
    if (condition)
        return 42;
    else
        return std::nullopt;  // 아무 값도 없음
}

 주요 특징 정리

사용 예제

#include <iostream>
#include <optional>
#include <string>

std::optional<std::string> findNameById(int id) {
    if (id == 1)
        return "Alice";
    else
        return std::nullopt;
}

int main() {
    auto name = findNameById(2);

    if (name.has_value()) {
        std::cout << "이름: " << *name << "\n";
    } else {
        std::cout << "이름을 찾을 수 없습니다.\n";
    }

    return 0;
}

언제 쓰면 좋을까?

• 함수에서 값을 반환할 수도, 안 할 수도 있는 경우 (null 대신)
• 포인터를 쓰지 않고도 값 없음(null) 상태 표현 가능
• std::optional<T>는 T가 복사/이동 가능한 타입일 때 사용 가능

C++에서 Optional은 어떤 점이 좋을까?

• 명시적이고 타입 안정성 있음 (null pointer 같은 오류 줄임)
• 함수 인터페이스가 더 직관적이고 안전해짐
• null 체크나 특별한 에러코드를 리턴하는 방식보다 표현력이 풍부함

std::thread 사용법 정리 (C++17 기준)

1. 기본 개념

• C++11부터 도입된 std::thread는 병렬 실행을 위한 클래스입니다.
• 쓰레드를 생성하면 자동으로 시작되며, 작업이 끝날 때까지 join() 또는 detach() 호출로 관리해야 합니다.

2. 기본 예제

#include <iostream>
#include <thread>

void say_hello() {
    std::cout << "Hello from thread!" << std::endl;
}

int main() {
    std::thread t(say_hello); // 쓰레드 시작
    t.join();                 // 메인 쓰레드가 t를 기다림
}

• join()이 없으면 프로그램이 끝나기 전에 쓰레드가 종료되지 않을 수 있어 런타임 오류 발생.

3. 인자 전달

void print_sum(int a, int b) {
    std::cout << a + b << std::endl;
}

int main() {
    std::thread t(print_sum, 3, 4);
    t.join();
}

• 값은 복사되어 전달됩니다.
• 참조를 넘기려면 std::ref() 사용

void modify(int& x) {
    x += 10;
}

int main() {
    int value = 5;
    std::thread t(modify, std::ref(value));
    t.join();
    std::cout << value << std::endl; // 15
}

4. 람다 함수 사용

std::thread t([](){
    std::cout << "Running in a lambda thread!" << std::endl;
});
t.join();

5. 멤버 함수 호출

class Worker {
public:
    void run() {
        std::cout << "Worker running!" << std::endl;
    }
};

int main() {
    Worker w;
    std::thread t(&Worker::run, &w); // 객체 포인터 전달
    t.join();
}

6. join() vs detach()

• join(): 쓰레드가 끝날 때까지 기다림
• detach(): 쓰레드를 백그라운드에서 실행시키고 제어를 넘김

std::thread t([]() {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "Detached thread done" << std::endl;
});
t.detach(); // join하지 않아도 됨

주의: detach한 쓰레드는 더 이상 제어할 수 없으며, 메인 함수가 먼저 종료되면 문제가 생길 수 있음.

7. 쓰레드 ID 확인

8. 쓰레드 관련 함수들

• std::this_thread::sleep_for(duration): 일정 시간 동안 sleep
• std::this_thread::yield(): 다른 쓰레드에게 CPU 양보
• std::thread::hardware_concurrency(): 시스템의 논리 코어 수 반환

9. 예외 처리

std::thread 자체는 예외를 전달하지 않기 때문에, 예외는 쓰레드 내부에서 처리해야 합니다.

std::thread t([]() {
    try {
        throw std::runtime_error("error!");
    } catch (const std::exception& e) {
        std::cout << "Caught exception: " << e.what() << std::endl;
    }
});
t.join();

10. C++17에서 유용한 추가 기능

• std::scoped_lock을 쓰레드와 뮤텍스에 함께 사용 가능
• std::shared_mutex (읽기/쓰기 락)과 함께 사용 시 성능 최적화 가능
• 쓰레드 안전한 std::atomic 변수와 병행 사용

std::shared_mutex란?

• 동시에 여러 개의 쓰레드가 읽을 수 있도록 허용하지만,
• 쓰기(수정) 시에는 단 하나의 쓰레드만 접근 가능하게 만드는 락입니다.

읽기: 병렬 허용
쓰기: 단독만 허용

예: std::mutex와 std::shared_mutex의 차이

일반 std::mutex 사용 시

cpp

std::mutex mtx; void read() {
std::lock_guard<std::mutex> lock(mtx); // 읽기 작업
}

→ 읽기조차 직렬화됨 (읽기끼리도 동시에 접근 불가)


std::shared_mutex 사용 시

#include <shared_mutex>

std::shared_mutex shared_mtx;

void read() {
    std::shared_lock<std::shared_mutex> lock(shared_mtx); // 여러 쓰레드 동시에 가능
    // 읽기 작업
}

void write() {
    std::unique_lock<std::shared_mutex> lock(shared_mtx); // 단독 접근
    // 쓰기 작업
}

→ 여러 쓰레드가 동시에 읽기 가능
→ 쓰기 쓰레드는 단독 접근만 허용 (읽기 중인 쓰레드가 끝날 때까지 대기)

성능 최적화의 이유

쓰기보다 읽기가 많은 상황 (예: 캐시, 설정 조회 등)에서는:

• std::mutex: 모든 작업이 직렬 → 비효율적
• std::shared_mutex: 읽기 병렬화 가능 → 성능 향상

#include <iostream>
#include <thread>
#include <shared_mutex>
#include <vector>

std::shared_mutex shared_mtx;
int shared_data = 0;

void reader(int id) {
    std::shared_lock<std::shared_mutex> lock(shared_mtx);
    std::cout << "Reader " << id << " read value: " << shared_data << std::endl;
}

void writer(int value) {
    std::unique_lock<std::shared_mutex> lock(shared_mtx);
    shared_data = value;
    std::cout << "Writer wrote value: " << value << std::endl;
}

int main() {
    std::vector<std::thread> threads;

    // 읽기 쓰레드 여러 개
    for (int i = 0; i < 5; ++i)
        threads.emplace_back(reader, i);

    // 쓰기 쓰레드 하나
    threads.emplace_back(writer, 100);

    for (auto& t : threads) t.join();
}

std::atomic 개념과 사용법 (C++17 기준)

1. std::atomic이란?

• 동기화된 접근을 보장하는 데이터 타입 템플릿입니다.
• 멀티스레드에서 **뮤텍스 없이도 변수 접근의 원자성(atomicity)**을 보장합니다.
• std::atomic<int>, std::atomic<bool>, std::atomic<T> 등 다양한 타입으로 사용 가능.

2. 기본 사용법

#include <atomic>
#include <iostream>
#include <thread>

std::atomic<int> counter{0};

void increment() {
    for (int i = 0; i < 10000; ++i) {
        counter++;
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);

    t1.join();
    t2.join();

    std::cout << "Final counter: " << counter << std::endl;
}

• counter++는 원자적으로 수행됨 → 경쟁 조건(race condition) 없이 동작

3. 주요 연산

• store(val): 값 설정
• load(): 현재 값 반환
• exchange(val): 기존 값을 새로운 값으로 바꾸고, 이전 값을 반환
• compare_exchange_strong(expected, desired)
• compare_exchange_weak(expected, desired): CAS(compare-and-swap) 연산

std::atomic<int> value{5};
int expected = 5;
bool success = value.compare_exchange_strong(expected, 10);
// 성공 시 value는 10이 되고 true 반환

4. 메모리 순서 (memory ordering)

• 기본은 memory_order_seq_cst (가장 강력하고 안전한 순서)
• 필요에 따라 memory_order_relaxed, acquire, release 등 지정 가능

counter.fetch_add(1, std::memory_order_relaxed); // 약한 메모리 순서

하지만 대부분의 경우 기본 순서를 사용하는 것으로 충분하며, 성능 최적화가 필요한 경우만 조절합니다.

5. std::atomic_flag (가장 가벼운 락)

• 간단한 락 구현이나 spin lock 등에 사용
• 초기화는 반드시 ATOMIC_FLAG_INIT로

std::atomic_flag flag = ATOMIC_FLAG_INIT;

void work() {
    while (flag.test_and_set(std::memory_order_acquire)) {
        // busy-wait
    }
    // critical section
    flag.clear(std::memory_order_release);
}

6. 뮤텍스 vs atomic

7. C++17에서의 특징

• 템플릿 deduction을 사용할 수 없지만, std::atomic<T>의 인터페이스는 보다 풍부해졌습니다.
• std::atomic<std::shared_ptr<T>>도 제공되어, 참조 카운팅이 원자적으로 가능해졌습니다.

C++17에서의 mutex, lock

1. 기본 std::mutex 사용

std::mutex는 임계 구역(critical section)을 보호하기 위한 가장 기본적인 뮤텍스입니다.

#include <iostream>
#include <mutex>
#include <thread>

std::mutex mtx;

void print_message(const std::string& msg) {
    mtx.lock();
    std::cout << msg << std::endl;
    mtx.unlock();
}

int main() {
    std::thread t1(print_message, "Hello from thread 1");
    std::thread t2(print_message, "Hello from thread 2");

    t1.join();
    t2.join();
    return 0;
}

주의: lock()과 unlock()은 반드시 쌍으로 호출되어야 하며, 예외 발생 시 unlock이 호출되지 않아 데드락의 원인이 될 수 있음.

2. std::lock_guard 사용

std::lock_guard는 예외 안전성을 위해 사용되는 RAII 스타일의 뮤텍스 관리 도구입니다.

void print_message(const std::string& msg) {
    std::lock_guard<std::mutex> lock(mtx);
    std::cout << msg << std::endl;
}

스코프를 벗어나면 자동으로 unlock()이 호출됨.

3. std::unique_lock 사용

std::unique_lock은 lock_guard보다 더 유연한 뮤텍스 관리가 가능합니다. 예: 지연 잠금, 조건 변수와의 조합 등

void print_message(const std::string& msg) {
    std::unique_lock<std::mutex> lock(mtx);
    std::cout << msg << std::endl;
    // lock.unlock(); // 수동 해제도 가능
}

4. std::recursive_mutex

같은 쓰레드에서 여러 번 lock이 필요한 경우 사용합니다.

std::recursive_mutex rmtx;

void recursive_function(int count) {
    if (count <= 0) return;
    rmtx.lock();
    std::cout << "Depth: " << count << std::endl;
    recursive_function(count - 1);
    rmtx.unlock();
}

5. std::timed_mutex, std::recursive_timed_mutex

특정 시간 내에 lock을 얻지 못하면 포기하도록 설계된 뮤텍스입니다.

std::timed_mutex tmtx;

void try_lock_example() {
    if (tmtx.try_lock_for(std::chrono::milliseconds(100))) {
        std::cout << "Lock acquired" << std::endl;
        tmtx.unlock();
    } else {
        std::cout << "Timeout: failed to acquire lock" << std::endl;
    }
}

6. std::lock 함수

여러 뮤텍스를 동시에 안전하게 lock할 때 사용합니다. 데드락 방지를 위한 도구입니다.

데드락 케이스

// 쓰레드 A
m1.lock();
m2.lock(); // 잠금 대기 중

// 쓰레드 B
m2.lock();
m1.lock(); // 잠금 대기 중 → 데드락 발생!

쓰레드는 제 각각 돌기 때문에, 쓰레드A, B가 m1, m2를 lock을 한 다음 lock을 하게 되는 경우가 발생하게 되면 서로가 가진 뮤텍스를 기다리다가 영원히 대기 상태에 빠지게 됩니다.

#include <iostream>
#include <mutex>
#include <thread>

std::mutex m1, m2;

void threadA() {
    std::lock(m1, m2); // 안전하게 두 뮤텍스를 모두 잠금
    std::lock_guard<std::mutex> lk1(m1, std::adopt_lock);
    std::lock_guard<std::mutex> lk2(m2, std::adopt_lock);
    std::cout << "Thread A acquired both locks\n";
}

void threadB() {
    std::lock(m2, m1); // 순서를 바꿔도 안전하게 잠금
    std::lock_guard<std::mutex> lk1(m2, std::adopt_lock);
    std::lock_guard<std::mutex> lk2(m1, std::adopt_lock);
    std::cout << "Thread B acquired both locks\n";
}

int main() {
    std::thread t1(threadA);
    std::thread t2(threadB);

    t1.join();
    t2.join();
}

여기서 std::lock은 내부적으로 양쪽 쓰레드에서 같은 방식으로 동기화를 해주기 때문에 데드락 없이 둘 다 잠금에 성공할 수 있어요.

7. 주의사항 요약

• 뮤텍스는 가능한 한 짧은 영역에서만 잠그고 풀어야 함
• lock을 해제하지 않고 예외가 발생하면 데드락이 발생할 수 있음 → RAII 스타일 사용 권장
• 여러 뮤텍스를 동시에 잠글 경우 반드시 std::lock 사용
• 가능한 경우 std::scoped_lock (C++17부터 도입)을 사용하면 더 안전하게 여러 뮤텍스를 다룰 수 있음

std::mutex m1, m2;

void example() {
    std::scoped_lock lock(m1, m2);  // C++17: 데드락 방지 + RAII
    // 임계 구역
}

C++17에서 달라진 점 (C++14와 비교)

C++17은 C++14에 비해 여러 가지 새로운 기능과 개선점을 도입하여, 개발자 생산성, 코드 가독성, 그리고 언어의 표현력을 크게 향상시켰습니다. 아래 표와 목록에서 주요 변경 사항을 정리합니다.

주요 변경점 비교

C++17에서 추가된 주요 기능 및 개선 사항

• Inline 변수: 헤더 파일에서 변수 정의/초기화 가능, ODR(One Definition Rule) 위반 방지
• 구조적 바인딩 (Structured Bindings): 튜플, 구조체 등 복합 객체를 개별 변수로 분해할 수 있음
•  

  cpp

  auto [x, y] = std::make_pair(1, 2);
• constexpr if: 템플릿 코드에서 컴파일 타임 조건 분기 가능
•  

  cpp

  if constexpr (조건) { /* ... */ }
• Fold Expressions: 가변 인자 템플릿을 간결하게 연산할 수 있는 문법 도입
•  

  cpp

  template<typename... Args> auto sum(Args... args) { return (args + ...); }
• 파일 시스템 라이브러리(std::filesystem): 파일 및 디렉토리 작업을 표준화된 방식으로 지원
• 병렬/동시 STL 알고리즘: 표준 라이브러리 알고리즘에 병렬 실행 정책 지원
• if/switch 초기화자: if, switch문에서 변수 선언 및 초기화 가능
•  

  cpp

  if (int x = func(); x > 0) { /* ... */ }
• 중첩 네임스페이스: 여러 네임스페이스를 한 줄로 선언 가능
•  

  cpp

  namespace a::b::c { /* ... */ }
• std::optional: 값이 있을 수도 없을 수도 있는 상황을 명확하게 표현
• 클래스 템플릿 인자 추론(CTAD): 객체 생성 시 템플릿 인자를 명시하지 않아도 자동 추론
•  

  cpp

  std::pair p(1, 2); // std::pair<int, int>로 추론
• 기타: std::variant, std::any, std::string_view 등 유틸리티 타입 추가, lambdas 개선, 기타 표준 라이브러리 확장

요약

• C++14는 C++11의 기능을 다듬고 소폭 확장한 "마이너 업그레이드"였다면,
  C++17은 새로운 문법, 표준 라이브러리 확장, 컴파일 타임 프로그래밍 강화 등
  실질적인 "메이저 업그레이드"에 가까운 변화가 많습니다
• 대부분의 기능은 기존 코드와의 호환성을 유지하면서,
  새로운 코드 작성 시 코드의 간결성, 안전성, 효율성을 크게 높여줍니다.

C++17로의 전환은 최신 컴파일러(GCC, Clang, MSVC 등)에서 모두 지원되며,
현대적인 C++ 코드를 작성하고자 한다면 적극적으로 권장됩니다

C++14에서 달라진 점 (C++11과 비교)

C++14는 C++11의 기능을 다듬고 확장한 표준으로, 대규모 기능 추가보다는 기존 기능의 개선과 편의성 향상에 초점을 맞췄습니다. 아래는 C++11 대비 C++14에서 달라진 주요 내용을 정리한 것입니다.

1. 람다 함수의 확장

• 제네릭 람다(Generic Lambdas)
  • 람다 함수의 매개변수 타입에 auto 사용 가능
  •  

    cpp

    auto lambda = [](auto x, auto y) { return x + y; };
  • 템플릿 함수처럼 동작하는 람다 작성 가능

2. constexpr 기능 강화

• C++11의 constexpr 함수는 단순한 리턴만 가능했으나,
  C++14에서는 if문, 반복문, 지역 변수 선언 등 복잡한 로직을 지원
• 더 많은 함수와 상황에서 constexpr 사용 가능.

3. 함수 반환 타입 추론

• Return Type Deduction
  • 함수의 반환 타입을 auto로 지정하면, 구현부의 return문을 기반으로 타입이 자동 추론됨
  •  

    cpp

    auto func() { return 42; }

4. 표준 라이브러리 및 기타 개선

• Reader-Writer Locks
  • 다중 스레드 환경에서 읽기/쓰기 락 지원(std::shared_timed_mutex 등)
• std::exchange
  • 객체의 값을 새로운 값으로 교체하고, 이전 값을 반환하는 함수 템플릿(라이브러리 확장).
• 이진 리터럴 지원
  • 0b 또는 0B 접두사로 이진수 리터럴 사용 가능
  •  

    cpp

    int n = 0b101010;
• [[deprecated]] 속성
  • 함수, 변수 등에 deprecated 속성 부여 가능

5. 기타 언어 및 코드 스타일 관련 변화

• 변수 템플릿(Variable Templates)
  • 변수도 템플릿으로 선언 가능
• decltype(auto)
  • auto와 decltype의 타입 추론 결합
• 람다 캡처 초기화
  • 람다 캡처 시 임의의 표현식으로 멤버 초기화 가능
• 이종 탐색(Heterogeneous Lookup)
  • 연관 컨테이너에서 키 타입과 다른 타입으로 검색 가능

요약 표

C++14는 C++11의 기반 위에서 실질적인 코드 작성의 편의성과 성능, 타입 추론의 유연성을 크게 높였습니다