• 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))), "예외 발생 가능!");
  }

cpp

  for (const auto& kv : my_map) {
      std::cout << "key=" << kv.first << " value=" << kv.second << "\n";
  }

cpp

  for (const auto& [key, value] : my_map) {
    std::cout << "key=" << key << " value=" << value << "\n";
  }

cpp

  std::pair<std::string, int> p{"apple", 3};
  
  // 구조 분해 방식
  auto [key, value] = p;

순회 시에는 C++11 스타일(.first, .second)과 C++17 스타일(구조 분해) 모두 가능하므로, 자신의 프로젝트 환경에 맞는 문법을 선택 하여 사용하면 됩니다.

C++17 이상을 사용 중이라면 구조 분해를 적극 활용하는 것이 코드 가독성 측면에서 큰 도움이 됩니다.

c

  #define PI 3.14159265358979323846

  const double pi = 3.14159265358979323846;

일부 구현체(GNU libc, MSVC 등)에서는 math.h에서 M_PI 매크로를 제공하지만, 이는 표준이 아니며, 사용 전 활성화가 필요할 수 있습니다.

c

  #define _USE_MATH_DEFINES  // MSVC
  #include <math.h>
  
  double area = M_PI * r * r;

수학적으로 π는 2 * acos(0.0)으로도 정의할 수 있습니다.

c

  #include <math.h>

  double pi = 2.0 * acos(0.0);

C++도 초기에는 C처럼 π 상수를 제공하지 않았기 때문에, 아래와 같이 수학 계산으로 정의하는 방식이 일반적이었습니다.

cpp

  #include <cmath>
  
  constexpr double pi = 2. * std::acos(0.);

cpp

  #include <numbers>
  
  constexpr double pi = std::numbers::pi;