emhash는 C++용 고성능 헤더 전용 해시맵/해시셋 라이브러리입니다.

• 프로젝트 홈페이지: https://github.com/ktprime/emhash

std::unordered_map 보다 빠르고 메모리 효율적인 대안을 제공하며, 다양한 최적화 구현체가 포함되어 있어 성능 및 용도에 따라 선택할 수 있습니다.

주요 특징:

• 헤더 전용 (header-only)
• 고속 삽입/탐색/삭제
• 낮은 메모리 사용량
• 높은 부하 계수 (load factor) 지원
• 다양한 환경(Windows/Linux/Mac, GCC/Clang/MSVC)에서의 호환성

아래는 emhash8::HashMap을 사용하는 간단한 예제입니다:

cpp

  // 헤더 파일 포함
  #include "emhash8.h" // 또는 "emhash7.h" 등 다른 버전 사용 가능
  #include <iostream>
  
  int main() {
      emhash8::HashMap<int, std::string> map;
  
      // 값 삽입
      map[1] = "apple";
      map[2] = "banana";
      map[3] = "cherry";
  
      // 값 접근
      std::cout << "map[2] = " << map[2] << std::endl;
  
      // 반복문을 통한 전체 출력
      for (const auto& kv : map) {
          std::cout << kv.first << ": " << kv.second << std::endl;
      }
  
      // 요소 존재 확인
      if (map.find(3) != map.end()) {
          std::cout << "키 3은 존재합니다." << std::endl;
      }
  
      // 요소 삭제
      map.erase(1);
  
      // 전체 요소 수 출력
      std::cout << "남은 요소 수: " << map.size() << std::endl;
  
      return 0;
  }

외부 벤치마크에 따르면 emhash는 Google의 dense_hash_map, absl::flat_hash_map, robin_hood::unordered_flat_map 등과 비교해 삽입/탐색/삭제 성능에서 우수한 결과 를 보였습니다.

특히 반복(iteration) 속도와 부하 계수(load factor) 면에서 탁월한 성능을 자랑합니다.

참고: 공식 벤치마크 결과

• https://github.com/ktprime/emhash

• 예: #include "emhash8.h"

• -O2, -O3, -march=native 등

• Node.js 설치
  • https://nodejs.org/
• Visual Studio Code 설치
  • https://code.visualstudio.com
• 확장 개발 도구 설치:

  • bash

      npm install -g yo generator-code @vscode/vsce
    

  • ⚠️ 오류 발생 시 --force 옵션을 사용할 수 있습니다:

      npm install -g typescript --force
    

bash

  npm install -g typescript

• bash

  tsc --version

bash

  npm install --save-dev typescript

bash

  npx tsc --init

json

  {
    "compilerOptions": {
      "target": "ES2020",
      "module": "commonjs",
      "outDir": "dist",
      "rootDir": "src",
      "strict": true
    }
  }

bash

  npx yo code

• bash

    npm install
  

dir

  my-extension/
  ├── package.json
  ├── tsconfig.json
  ├── src/
  │   └── extension.ts

json

  {
    "name": "my-extension",
    "displayName": "My Extension",
    "publisher": "your-name",
    "version": "0.0.1",
    "engines": {
      "vscode": "^1.70.0"
    },
    "activationEvents": ["onCommand:my-extension.hello"],
    "main": "./dist/extension.js",
    "contributes": {
      "commands": [
        {
          "command": "my-extension.hello",
          "title": "Hello World"
        }
      ]
    },
    "scripts": {
      "vscode:prepublish": "npm run compile",
      "compile": "tsc -p ./",
      "watch": "tsc -w -p ./"
    },
    "devDependencies": {
      "@types/vscode": "^1.70.0",
      "typescript": "^4.7.4",
      "vscode-test": "^1.6.2"
    }
  }

ts

  import * as vscode from 'vscode';
  
  function sayHello() {
    vscode.window.showInformationMessage('👋 안녕하세요!');
  }
  
  function sayBye() {
    vscode.window.showInformationMessage('👋 안녕히 가세요!');
  }
  
  export function activate(context: vscode.ExtensionContext) {
    const helloCmd = vscode.commands.registerCommand('my-extension.hello', sayHello);
    const byeCmd = vscode.commands.registerCommand('my-extension.bye', sayBye);
    context.subscriptions.push(helloCmd, byeCmd);
  
    return {
      greet: sayHello,
      farewell: sayBye
    };
  }
  
  export function deactivate() {
    console.log("🛑 확장이 비활성화되었습니다.");
  }

⚠️ main 항목은 반드시 컴파일된 JS 경로(dist/extension.js) 를 가리켜야 합니다.
.ts 파일을 직접 실행할 수는 없습니다.

bash

  npm run compile

src/extension.ts → dist/extension.js로 변환됩니다.

bash

  vsce package

→ my-extension-0.0.1.vsix 파일 생성

bash

  code --install-extension my-extension-0.0.1.vsix

또는 VS Code에서 Extensions: Install from VSIX... 명령을 사용하여 설치합니다.

activate() 함수에서 객체를 반환하면, 다른 확장에서 다음과 같이 사용할 수 있습니다:

ts

  const ext = vscode.extensions.getExtension('your-name.my-extension');
  const api = await ext.activate();
  
  api.greet();    // sayHello() 호출
  api.farewell(); // sayBye() 호출

• 1.1. Winget 사용 (추천)
  • 명령 프롬프트(cmd)나 PowerShell에서 다음 명령어 실행:

  • bash

      winget install --id GitHub.cli
    

• 1.2. Scoop 사용

  • bash

      scoop install gh
    

• 1.3. 설치 파일 수동 다운로드
  • GitHub 공식 릴리즈 페이지에서 MSI 설치 파일 다운로드:
    • https://github.com/cli/cli/releases

• 2.1. Homebrew 사용 (추천)

  • bash

      brew install gh
    

• 2.2. MacPorts 사용

  • bash

      sudo port install gh
    

• 3.1. Ubuntu / Debian 계열

  • bash

      sudo apt update  
      sudo apt install gh
    

• 3.2. Fedora

  • bash

      sudo dnf install gh
    

• 3.3. CentOS / RHEL

  • bash

      sudo dnf install 'https://github.com/cli/cli/releases/download/v2.0.0/gh_2.0.0_linux_amd64.rpm'
    

  • ※ 위 URL은 예시이며, 실제 버전은 최신 릴리즈 페이지에서 확인하여 교체해 주세요.

• 설치가 완료되면 터미널에서 다음 명령어로 정상 설치 여부를 확인할 수 있습니다:

• bash

    gh --version
  

cpp

  #include <string>
  #include <iostream>
  
  template<typename T>
  class Holder {
  public:
      Holder(T value) {
          std::cout << "Generic Holder: " << value << std::endl;
      }
  };
  
  template<>
  class Holder<std::string> {
  public:
      Holder(const char* value) {
          std::cout << "Specialized Holder<std::string>: " << value << std::endl;
      }
  };
  
  int main() {
      Holder<int> h1(42);
      Holder<std::string> h2("hello");  // 직접 타입 명시 필요
  }

cpp

  #include <string>
  #include <iostream>
  
  template<typename T>
  class Holder {
  public:
      Holder(T value) {
          std::cout << "Generic Holder: " << value << std::endl;
      }
  };
  
  // 헬퍼 함수 제작
  
  template<typename T>
  Holder<T> make_holder(T value) {
      return Holder<T>(value);
  }
  
  Holder<std::string> make_holder(const char* value) {
      return Holder<std::string>(std::string(value));
  }
  
  int main() {
      auto h1 = make_holder(42);         // Holder<int>
      auto h2 = make_holder("hello");    // Holder<std::string>
  }

cpp

  #include <string>
  #include <iostream>
  
  template<typename T>
  class Holder {
  public:
      Holder(T value) {
          std::cout << "Holder<" << typeid(T).name() << ">: " << value << std::endl;
      }
  };
  
  Holder(const char*) -> Holder<std::string>; // Deduction Guide 
  
  int main() {
      Holder h1(42);         // Holder<int>
      Holder h2("hello");    // Holder<std::string>
  }

cpp

  #include <string>
  #include <iostream>
  #include <concepts>
  
  template<typename T>
  class Holder {
  public:
      Holder(T value) {
          std::cout << "Holder<" << typeid(T).name() << ">: " << value << std::endl;
      }
  };
  
  Holder(const char*) -> Holder<std::string>;
  
  template<std::integral T>
  Holder(T) -> Holder<int>;
  
  template<std::floating_point T>
  Holder(T) -> Holder<double>;
  
  int main() {
      Holder h1("hello");   // Holder<std::string>
      Holder h2(10);        // Holder<int>
      Holder h3(3.14f);     // Holder<double>
  }

C++ 버전 별로 타입 유추 기능은 계속 진화 중입니다. 😕 😵 🤔 🚀 👽

cpp

  consteval int square(int x) { // 컴파일 타임 함수
      return x * x;
  }
  
  constexpr int value = square(5); // ✅ 가능: 컴파일 타임 평가
  int runtime = square(5);         // ❌ 오류: 런타임 호출 불가

constinit은 **정적 저장 기간(static storage duration)**을 가진 변수에 대해, 컴파일 타임에 초기화가 반드시 일어나야 함을 보장합니다.

런타임 초기화를 막아 **정적 초기화 순서 문제(static initialization order fiasco)**를 방지할 수 있습니다.

cpp

  constinit int global_value = 42; // ✅ 컴파일 타임 초기화됨
  
  // 아래는 오류
  // constinit int another = std::rand(); // ❌ rand()는 런타임 평가

템플릿 인자 대체 시 오류가 발생하면, 컴파일러는 해당 함수 템플릿을 무시하고 다른 후보를 계속 찾는다.

이 규칙 덕분에 다양한 조건부 템플릿 코드 작성이 가능해졌습니다.

cpp

  #include <type_traits>
  #include <iostream>
  
  template<typename T>
  typename std::enable_if<std::is_integral<T>::value, void>::type
  func(T t) {
      std::cout << "정수 타입입니다: " << t << "\n";
  }
  
  template<typename T>
  typename std::enable_if<std::is_floating_point<T>::value, void>::type
  func(T t) {
      std::cout << "실수 타입입니다: " << t << "\n";
  }

cpp

  func(42);      // 정수 타입입니다
  func(3.14);    // 실수 타입입니다
  // func("hello"); → 컴파일 에러 (문자열에 대한 적절한 템플릿 없음)

cpp

  template<typename T>
  requires std::integral<T>
  void func(T t) {
      std::cout << "정수 타입입니다: " << t << "\n";
  }

bash

  git clone https://github.com/Palm1r/QodeAssist.git

Qt Creator로 QodeAssist 프로젝트를 엽니다.

프로젝트를 빌드한 후, 생성된 플러그인 파일(.so, .dll 등)을 Qt Creator의 플러그인 디렉토리에 복사합니다.

Qt Creator를 재시작합니다.

QodeAssist는 Qt Creator의 버전에 따라 호환되는 플러그인 버전이 다릅니다:

• 👉 https://github.com/Palm1r/QodeAssist

cpp

  std::vector<int> data = {1, 2, 3};  // data가 메모리의 소유권을 가짐

cpp

  #include <string_view>
  #include <iostream>

  void print(std::string_view sv) {
     // std::string_view는 std::string이나 char*로부터 
     // 문자열을 얕게 참조하고, 소유하지 않습니다.
  
      std::cout << sv << '\n';
  }

  int main() {
      std::string str = "Hello, World!";
      print(str);                    // std::string
      print("Temporary literal");    // const char*
  }

• 이런 기능을 분기 예측(branch prediction) 이라고 합니다.

• 이를 파이프라인 플러시(pipeline flush) 라고 하며, 성능 저하의 원인이 됩니다.

cpp

  int a = 10;

  if ([[likely]] a > 0) {
       // 자주 실행되는 경로
  } else {
      // 거의 실행되지 않는 경로
  }

C++20 이전에는 GCC와 Clang 같은 컴파일러에서 다음과 같은 비표준 방식 을 사용했습니다:

cpp

  if (__builtin_expect(condition, 1)) {
      // likely
  }

rust

  if likely(x > 0) {
      // 빠른 경로
  }

zig

  if (likely(x > 0)) {
      // ...
  }

이를 지원하는 주요 프레임워크는 다음과 같습니다:

cpp

  #include <doctest/doctest.h>
  
  TEST_CASE("예제") {
      double halfpi = 1.5707963;
      REQUIRE(halfpi == doctest::Approx(1.5707963));
  }

• cpp

    std::fabs(lhs - rhs) <= epsilon × max(|lhs|, |rhs|)
  

cpp

  REQUIRE(1.57079631 == doctest::Approx(1.5707963).epsilon(1e-9));  // 허용
  REQUIRE(1.57079631 == doctest::Approx(1.5707963).epsilon(1e-13)); // 실패 가능

cpp

  #include <catch2/catch.hpp>

  TEST_CASE("Catch2 근사 비교") {
      double val = 1.5707963;
      REQUIRE(val == Catch::Approx(1.5707963));
  }

cpp

  #include <gtest/gtest.h>

  TEST(FloatingPointTest, NearTest) {
      double val = 1.5707963;
      EXPECT_NEAR(val, 1.5707963, 1e-9);  // 절대 오차
  }

cpp

  #include <boost/test/unit_test.hpp>
  
  BOOST_AUTO_TEST_CASE(test_close) {
      double val = 1.5707963;
      BOOST_CHECK_CLOSE(val, 1.5707963, 0.0001);  // 0.0001% 허용 오차
  }

cpp

  #include <Eigen/Dense>
  
  Eigen::VectorXd a(2), b(2);
  a << 1.0, 2.0;
  b << 1.0, 2.000000001;
  
  bool is_close = a.isApprox(b, 1e-9);

cpp

  #include <cmath>
  
  double a = 1.5707963;
  double b = 1.57079631;
  double epsilon = 1e-9;
  
  if (std::fabs(a - b) < epsilon) {
      // 근사적으로 같다
  }

= default는 컴파일러에게 기본 구현을 자동으로 생성하라고 지시 하는 문법입니다.

사용자가 별도로 구현하지 않아도, 기본 생성자나 소멸자, 복사 생성자 등을 자동으로 만들어 줍니다.

cpp

  class Mat3x3 {
  public:
      Mat3x3() = default; // 기본 생성자의 구현 코드를 컴파일러가 자동으로 생성
  };
   
  // Mat3x3::Mat3x3() {
  // } // 직접 구현하는 코드를 생략하여도 됨

cpp

  class MyClass {
  public:
      MyClass() = default;
      
      MyClass(const MyClass&) = delete; // 복사 생성자 연산자 금지
      MyClass& operator=(const MyClass&) = delete; // 복사 대입 연산자 금지
  
      void sayHello() const {
          std::cout << "안녕하세요!\n";
      }
  }; 
  
  int main() {
      MyClass a;
      a.sayHello();
  
      // MyClass b = a;      // ❌ 복사 생성자 금지
      // MyClass c;
      // c = a;              // ❌ 복사 대입 금지
  }

cpp

  void func(int) {
      std::cout << "정수 버전 함수입니다.\n";
  }
  
  void func(double) = delete;  // 실수 타입 금지
  
  int main() {
      func(42);      // ✅ 정상
      // func(3.14); // ❌ 컴파일 에러 (double 금지)

이처럼 = delete는 특정 타입이나 동작을 명확하게 차단 하고자 할 때 유용하게 쓰입니다.

• cpp

    char c = 'A';
    float f = 3.5f;
    bool b = false;
    short s = 42;
    
    enum Color { RED, GREEN, BLUE };
    Color color = GREEN;
    
    func(c);       // char → int
    func(f);       // float → int
    func(b);       // bool → int
    func(s);       // short → int		 
    func(color);   // enum → int
  

C++11 이후부터는 이 두 문법을 적극적으로 활용하면, 보다 명확하고 안전한 클래스 설계 가 가능합니다.

코드를 짧고 명확하게 유지하면서, 의도하지 않은 사용을 방지하는 데 큰 도움이 됩니다.

cpp

  #include <iostream>
  #include <stdexcept>
  
  struct A {
      ~A() { std::cout << "A 소멸자\n"; }
  };
  
  struct B {
      ~B() { throw std::runtime_error("B의 소멸자에서 예외!"); }
  };
  
  int main() {
      try {
          A a;
          B b;
          throw std::runtime_error("기본 예외 발생!");
      } catch (...) {
          std::cout << "예외 잡힘\n";
      }
  }

스택 풀림(Stack Unwinding) 과정에서 두 번째 예외가 발생하면, 표준은 std::terminate()를 호출하도록 규정하고 있습니다.

어떤 객체의 소멸자가 먼저 호출될지 명확하지 않아 결과가 플랫폼이나 최적화 수준에 따라 달라질 수 있습니다.

cpp

  #include <iostream>
  #include <thread>
  
  void worker(bool shouldThrow) {
      if (shouldThrow) {
          throw std::runtime_error("스레드 내 예외 발생!");
      }
  }
  
  int main() {
      try {
          std::thread t(worker, true);
          t.join();
      } catch (const std::exception& e) {
          std::cout << "메인 스레드에서 예외 잡힘: " << e.what() << '\n';
      }
  }

• 예외는 서브 스레드(sub thread)에서 발생했기 때문입니다.

cpp

  #include <iostream>
  #include <stdexcept>
  
  inline void throw_inline() {
      throw std::runtime_error("인라인 예외");
  }
  
  void throw_noninline() {
      throw std::runtime_error("비인라인 예외");
  }
  
  int main() {
      try {
          throw_inline();  // 또는 throw_noninline();
      } catch (const std::exception& e) {
          std::cout << "예외: " << e.what() << '\n';
      }
  }

인라인 함수 (inline function)는 예외 발생 시 디버거에서 함수 이름이 스택 트레이스에 보이지 않거나, 최적화에 의해 예외 경로가 사라질 수도 있습니다.

• 인라인 함수는 호출 오버헤드가 없지만, 예외가 발생할 경우 오히려 복잡한 인라인 코드 흐름 때문에 예외 전파 비용이 증가할 수도 있습니다.
• 비인라인 함수는 함수 경계를 기준으로 예외 전파가 더 단순함.

컴파일러와 최적화 옵션에 따라 인라인 함수의 예외 경로가 달라져 비결정성이 발생 할 수 있습니다.

• GCC, Clang, MSVC 등은 인라인 최적화 방식이 다릅니다.
• 동일한 소스 코드라도, 인라인 예외 처리 방식이 달라 예외 발생 여부, 메시지, 스택 구조가 플랫폼마다 다르게 보일 수 있음 → 완벽한 비결정성

cpp

  #include <iostream>
  #include <vector>
  
  int main() {
      std::vector<int> v = {1, 2, 3};
  
      try {
          int x = v.at(10);  // 예외 발생 (범위 초과)
          std::cout << "x: " << x << '\n';
      } catch (const std::out_of_range& e) {
          std::cout << "예외 발생: " << e.what() << '\n';
      }
  
      // operator[]는 예외를 던지지 않고, 정의되지 않은 동작 발생 가능
      int y = v[10];  // 런타임에 따라 충돌할 수도 있고, 아닐 수도 있음
      std::cout << "y: " << y << '\n';  // 비결정적 결과 가능
  }

cpp

  #include <vector>
  #include <type_traits>
  
  int main() {
      std::vector<int> v;
  
      static_assert(noexcept(v.size()), "예외 발생 가능!");
      bool b1 = noexcept(v.size());         // true
      bool b2 = noexcept(v.at(10));         // false
      bool b3 = noexcept(v.push_back(5));   // false
  }

C++ 표준 라이브러리 함수는 cppreference.com 에서 예외 명세 를 확인할 수 있습니다.

• 예: std::vector::at()은 "Throws: std::out_of_range"로 명시됨.

noexcept 여부도 문서에 명확히 표시되어 있습니다.

cpp

  #include <vector>
  #include <utility>
  
  struct MyType {
      MyType(MyType&&) noexcept {}  // 예외 없음
  };
  
  int main() {
      std::vector<MyType> v;
      static_assert(noexcept(std::vector<MyType>(std::move(v))), "예외 발생 가능!");
  }