외부 라이브러리 사용, 프로젝트 템플릿

git clone

• git clone --recursive 명령어를 통해, 깃허브 내부적으로 링크된 레포지토리들까지 전부 받아올 수 있다.

CMake

• Makefile을 좀 더 추상화하여 직관적으로 빌드할 수 있다.

• 소스 코드 폴더 내에 CMakeLists.txt이 Makefile과 같은 역할을 한다.

• 참고 : https://www.tuwlab.com/ece/27234

nanoGUI 예시

• 링크 : https://github.com/wjakob/nanogui

• git clone으로 소스 코드를 받아서, CMake로 빌드하고나면 솔루션 파일이 생긴다.

  • 해당 솔루션 파일을 열면 예제들을 실행시켜 볼 수 있다.

• 다른 프로젝트에서 라이브러리를 사용하려면 따로 설정을 해야한다.

  • 예제 프로젝트를 우클릭하면 나오는 Properties를 통해 다음 항목들을 참고하면 된다.

    • C/C++ - General의 Additional include Directories

    • C/C++ - Preprocess의 Preprocessor Definitions

    • Linker의 Additional Dependencies

    • Linker - General의 Additional Library Directories

• dll 파일이 프로그램이 존재하는 경로에 없으면 런타임 에러가 발생한다.

  • 디버그, 릴리즈 모드에 따라 해당 폴더에 dll 라이브러리 파일을 복사하면 해결된다.

  • 복사하는 대신에 dll 파일이 존재하는 위치를 프로젝트 설정의 환경변수로 추가하는 방법도 있다.

    • 프로젝트를 우클릭하면 나오는 Properties의 Debugging - Environment에 다음처럼 입력하면 된다.

      PATH=dll파일이 존재하는 폴더 경로

프로젝트 템플릿

• 현재 프로젝트의 설정을 템플릿으로 내보낼 수 있다.

  • 내보낸 템플릿으로 프로젝트를 만들면, 내보낸 상태 그대로 프로젝트가 생성된다.

• 메뉴의 Project - Export Template...을 클릭하면 템플릿 이름 등을 설정할 수 있다.

TCP/IP 네트워킹 (TCP/IP Networking)

• boost/asio 라이브러리를 이용하여 통신을 할 수 있다.

예제

• 원래 서버 프로그램 하나, 클라이언트 프로그램 하나 이렇게 두 개의 파일을 만드는게 정석이지만, 한번에 보기 편하도록 프로그램 하나로 작성했다.

• 로컬호스트의 13번 포트를 사용하는 예제이다.

  #include <iostream>
  #include <ctime>
  #include <string>
  #include <boost/asio.hpp>
  #include <thread>
  
  using boost::asio::ip::tcp;
  
  void        virtual_server()
  {
    try
    {
      boost::asio::io_service io_service;
  
      tcp::endpoint endpoint(tcp::v4(), 13);
      tcp::acceptor acceptor(io_service, endpoint);
  
      std::cout << "Server - Server started\n";
  
      while (true)
      {
        const std::string message_to_send = "Hello From Server";
  
        tcp::iostream stream;
        boost::system::error_code ec;
  
        std::cout << "Server - Waiting client...\n";
  
        acceptor.accept(*stream.rdbuf(), ec);
  
        std::cout << "Server - Accepted a client\n";
  
        if (!ec)
        {
          std::string line;
          std::getline(stream, line);
          std::cout << "Server - " << line << std::endl;
  
          stream << message_to_send;
          stream << std::endl;
        }
      }
    }
    catch (std::exception& e)
    {
      std::cerr << e.what() << std::endl;
    }
  }
  
  void        virtual_client()
  {
    try
    {
      tcp::iostream stream("127.0.0.1", std::to_string(int(13)));
  
      if (!stream)
      {
        std::cerr << "Client - Fail to connect : " << \
          stream.error().message() << std::endl;
        return ;
      }
  
      std::cout << "Client - Connected to the server\n";
  
      stream << "Hello From Client";
      stream << std::endl;
  
      std::string line;
      std::getline(stream, line);
      std::cout << "Client - " << line << std::endl;
    }
    catch (std::exception& e)
    {
      std::cerr << e.what() << std::endl;
    }
  }
  
  int            main()
  {
    auto t1 = std::thread(virtual_server);
  
    Sleep(1000);
    auto t2 = std::thread(virtual_client);
    t2.join();
  
    Sleep(1000);
    auto t3 = std::thread(virtual_client);
    t3.join();
  
    t1.join();
  }
  
  /* stdout
  Server - Server started
  Server - Waiting client...
  Client - Connected to the server
  Server - Accepted a client
  Server - Hello From Client
  Client - Hello From Server
  Server - Waiting client...
  Client - Connected to the server
  Server - Accepted a client
  Server - Hello From Client
  Client - Hello From Server
  Server - Waiting client...
  */

참고

• https://www.boost.org/doc/libs/1_68_0/doc/html/boost_asio/overview/networking/iostreams.html

따라하며 배우는 C++ 20장

비주얼 스튜디오 프로파일링 (Visual Studio Profiling)

vcpkg

TCP/IP 네트워킹 (TCP/IP Networking)

외부 라이브러리 사용, 프로젝트 템플릿

• 따라하며 배우는 C++

멀티쓰레딩 예제 (벡터 내적)

• 병렬로 처리할 때, 정확한 계산을 위해 레이스 컨디션을 고려해주는 것은 필수이다.

  • mutex, atomic, future 등을 사용할 수 있다.

• 시간적인 요소 또한 중요하므로, 쓰레드의 개수 등을 조절하여 최적화를 해야 한다.

코드

• Release모드, x64 환경에서 컴파일해야 빠르다. Debug모드는 기다리다가 속터져서 죽는다.

  #include <iostream>
  #include <vector>
  #include <random>
  #include <chrono>
  #include <numeric>
  #include <thread>
  #include <mutex>
  #include <atomic>
  #include <future>
  #include <execution>
  
  std::mutex mtx;
  
  auto    dotProductFuture(const std::vector<int>& v0, const std::vector<int>& v1, \
      const unsigned i_start, const unsigned i_end)
  {
      unsigned long long sum = 0;
  
      for (unsigned i = i_start; i < i_end; ++i)
          sum += v0[i] * v1[i];
      return sum;
  }
  
  void    dotProductAtomic(const std::vector<int>& v0, const std::vector<int>& v1, \
      const unsigned i_start, const unsigned i_end, \
      std::atomic<unsigned long long>& sum)
  {
      unsigned long long tmp = 0;
      for (unsigned i = i_start; i < i_end; ++i)
          tmp += v0[i] * v1[i];
      sum += tmp;
  }
  
  void    dotProductLock(const std::vector<int>& v0, const std::vector<int>& v1, \
      const unsigned i_start, const unsigned i_end, unsigned long long& sum)
  {
      unsigned long long tmp = 0;
  
      for (unsigned i = i_start; i < i_end; ++i)
          tmp += v0[i] * v1[i];
  
      {
          std::scoped_lock lock(mtx);
          sum += tmp;
      }
  }
  
  void    dotProductNaive(const std::vector<int>& v0, const std::vector<int>& v1, \
      const unsigned i_start, const unsigned i_end, unsigned long long& sum)
  {
      for (unsigned i = i_start; i < i_end; ++i)
          sum += v0[i] * v1[i];
  }
  
  int        main()
  {
      using namespace std;
  
      const long long n_data = 100'000'000;
      const unsigned  n_threads = 4;
  
      vector<int> v0, v1;
      v0.reserve(n_data);
      v1.reserve(n_data);
  
      random_device seed;
      mt19937 engine(seed());
  
      uniform_int_distribution<> uniformDist(1, 10);
  
      for (long long i = 0; i < n_data; ++i)
      {
          v0.push_back(uniformDist(engine));
          v1.push_back(uniformDist(engine));
      }
  
      {
          cout << "std::inner_product (Not parallel computing)\n";
  
          const auto sta = chrono::steady_clock::now();
          const auto sum = std::inner_product(v0.begin(), v0.end(), v1.begin(), 0ull);
          const chrono::duration<double> dur = chrono::steady_clock::now() - sta;
  
          cout << "Elapsed time : " << dur.count() << 's' << endl;
          cout << "Sum : " << sum << endl;
          cout << endl;
      }
  
      {
          cout << "Naive (Race Condition)\n";
  
          const auto sta = chrono::steady_clock::now();
          unsigned long long sum = 0;
  
          vector<thread> threads;
          threads.resize(n_threads);
  
          const unsigned n_per_thread = n_data / n_threads;
          for (unsigned t = 0; t < n_threads; ++t)
              threads[t] = thread(dotProductNaive, ref(v0), ref(v1), \
                  t * n_per_thread, (t + 1) * n_per_thread, ref(sum));
          for (unsigned t = 0; t < n_threads; ++t)
              threads[t].join();
  
          const chrono::duration<double> dur = chrono::steady_clock::now() - sta;
  
          cout << "Elapsed time : " << dur.count() << 's' << endl;
          cout << "Sum : " << sum << endl;
          cout << endl;
      }
  
      {
          cout << "Lockguard\n";
  
          const auto sta = chrono::steady_clock::now();
          unsigned long long sum = 0;
  
          vector<thread> threads;
          threads.resize(n_threads);
  
          const unsigned n_per_thread = n_data / n_threads;
          for (unsigned t = 0; t < n_threads; ++t)
              threads[t] = thread(dotProductLock, ref(v0), ref(v1), \
                  t * n_per_thread, (t + 1) * n_per_thread, ref(sum));
          for (unsigned t = 0; t < n_threads; ++t)
              threads[t].join();
  
          const chrono::duration<double> dur = chrono::steady_clock::now() - sta;
  
          cout << "Elapsed time : " << dur.count() << 's' << endl;
          cout << "Sum : " << sum << endl;
          cout << endl;
      }
  
      {
          cout << "Atomic\n";
  
          const auto sta = chrono::steady_clock::now();
          atomic<unsigned long long> sum = 0;
  
          vector<thread> threads;
          threads.resize(n_threads);
  
          const unsigned n_per_thread = n_data / n_threads;
          for (unsigned t = 0; t < n_threads; ++t)
              threads[t] = thread(dotProductAtomic, ref(v0), ref(v1), \
                  t * n_per_thread, (t + 1) * n_per_thread, ref(sum));
          for (unsigned t = 0; t < n_threads; ++t)
              threads[t].join();
  
          const chrono::duration<double> dur = chrono::steady_clock::now() - sta;
  
          cout << "Elapsed time : " << dur.count() << 's' << endl;
          cout << "Sum : " << sum << endl;
          cout << endl;
      }
  
      {
          cout << "Future\n";
  
          const auto sta = chrono::steady_clock::now();
          unsigned long long sum = 0;
  
          vector<future<unsigned long long>> futures;
          futures.resize(n_threads);
  
          const unsigned n_per_thread = n_data / n_threads;
          for (unsigned t = 0; t < n_threads; ++t)
              futures[t] = async(dotProductFuture, ref(v0), ref(v1), \
                  t * n_per_thread, (t + 1) * n_per_thread);
          for (unsigned t = 0; t < n_threads; ++t)
              sum += futures[t].get();
  
          const chrono::duration<double> dur = chrono::steady_clock::now() - sta;
  
          cout << "Elapsed time : " << dur.count() << 's' << endl;
          cout << "Sum : " << sum << endl;
          cout << endl;
      }
  
      {
          cout << "std::transform_reduce (Parallel)\n";
  
          const auto sta = chrono::steady_clock::now();
          const auto sum = transform_reduce(execution::par, v0.begin(), v0.end(), \
              v1.begin(), 0ull);
  
          const chrono::duration<double> dur = chrono::steady_clock::now() - sta;
  
          cout << "Elapsed time : " << dur.count() << 's' << endl;
          cout << "Sum : " << sum << endl;
          cout << endl;
      }
  }
  
  /* stdout
  std::inner_product (Not parallel computing)
  Elapsed time : 0.0370022s
  Sum : 3024919192
  
  Naive (Race Condition)
  Elapsed time : 0.302984s
  Sum : 877824373
  
  Lockguard
  Elapsed time : 0.0200525s
  Sum : 3024919192
  
  Atomic
  Elapsed time : 0.0201991s
  Sum : 3024919192
  
  Future
  Elapsed time : 0.020037s
  Sum : 3024919192
  
  std::transform_reduce (Parallel)
  Elapsed time : 0.0214739s
  Sum : 3024919192
  */

따라하며 배우는 C++ 19장

람다 함수 (Lambda Function)

함수에서 여러 개의 리턴 값 반환(C++17)

멀티쓰레딩 (Multithreading)

경쟁 상태 (Race Condition)

작업 기반 비동기 프로그래밍 (Task-based Parallelism)

멀티쓰레딩 예제 (벡터 내적)

완벽한 전달 (Perfect Forwarding)

자료형 추론 (auto, decltype)

• 따라하며 배우는 C++

따라하며 배우는 C++ 18장

istream

ostream

sstream

흐름 상태 (Stream States)

정규 표현식 (Regular Expressions)

파일 입출력

파일 임의 위치 접근

• 따라하며 배우는 C++

따라하며 배우는 C++ 17장

string

sstream

• 따라하며 배우는 C++

따라하며 배우는 C++ 16장

표준 템플릿 라이브러리 (Standard Template Libraries)

• 따라하며 배우는 C++

따라하며 배우는 C++ 15장

스마트 포인터 (Smart Pointer)

R-value Reference

이동 생성자와 이동 대입

std::move

unique_ptr

shared_ptr

순환 의존성 문제 (Circular Dependency Issues)

• 따라하며 배우는 C++

따라하며 배우는 C++ 14장

예외 처리 (Exception Handling)

• 따라하며 배우는 C++

따라하며 배우는 C++ 13장

템플릿 (Templates)

참고

• 따라하며 배우는 C++

따라하며 배우는 C++ 12장

다형성 (Polymorphism)

참고

• 따라하며 배우는 C++

따라하며 배우는 C++ 11장

상속 (Inheritance)

참고

• 따라하며 배우는 C++

따라하며 배우는 C++ 10장

객체들의 관계 (Object Relationship)

IntArray 컨테이너 만들어보기

참고

• 따라하며 배우는 C++

따라하며 배우는 C++ 9장

오버로딩 (Overloading)

복사 생성자 (Copy Constructor)

변환 생성자 (Converting Constructor)

delete

얕은 복사 (Shallow Copy)

깊은 복사 (Deep Copy)

이니셜라이저 리스트 (Initializer List)

참고

• 따라하며 배우는 C++

따라하며 배우는 C++ 8장

Class

참고

• 따라하며 배우는 C++

따라하며 배우는 C++ 7장

Call by Reference

std::tuple

인라인 함수 (Inline Function)

함수 포인터 (Function Pointer)

std::vector

assert

참고

• 따라하며 배우는 C++

배열 (Array)

nullptr_t

문자열 (string)

Stack Size

레퍼런스 (Reference, 참조)

float vs double

const 값 변경

참고

• 따라하며 배우는 C++

제어 흐름 (Control Flow)

switch

반복문 (Loop)

난수 생성 (Random Number Generation)

cin

참고

• 따라하며 배우는 C++

extern

메모리 절약 팁 (extern)

using

auto

데이터 타입 확인

형 변환(Type Conversion)

입력 버퍼 무시하기

열거형 (Enumerate Type)

Type Alias

참고

• 따라하며 배우는 C++

연산자

산술 연산자 (Arithmetic Operator)

쉼표 연산자 (Comma Operator)

비트 연산자 (Bitwise Operator)

범위 지정 연산자 (Scope Resolution Operator)

참고

• 따라하며 배우는 C++

변수 선언 시점

• 예전 c컴파일러의 경우 모든 변수 선언은 코드의 맨 위에 있었어야 했다.

  • 메모리를 미리 다 잡아놓고 사용하는 방식이다.

• 요즘은 변수 사용 직전에 선언하는걸 선호한다고 한다.

  • 디버깅, 리팩토링에 용이하다.

자료형 (Data Type)

소수점 (Decimal Point)

Boolean

형변환 (Type Conversion)

출력 버퍼 비우기 (fflush)

상수 (Contant)

참고

• 따라하며 배우는 C++

언어

• 컴파일러 언어

  • 코드를 컴파일하여 실행파일을 생성하고 실행시킨다.

• 인터프리터 언어

  • 실행파일 없이 바로 실행시킨다.

  • 상대적으로 느리다.

    • 실행파일을 만들고 반복해서 사용하는게 더 빠르다.

주석

• 당연한건 적지 말자

초기화 (Initialization)

헤더 가드 (Header Guard)

namespace

전처리기 (PreProcessor)

참고

• 따라하며 배우는 C++