[후기] Optimized C++

이 책은 크게 '깊게' 들어가는 경향은 없지만

막 초급자를 탈피하여 중급자로 진입한 C++ 프로그래머 에게는 유용한 책이 될 것이다.

 

이 책을 읽고 나면 C++ 의 '미묘함' 을 다시한번 확인할 수 있는데,

'숙련되기 위해 수백가지 함정' 들이 무더기로 있다는것을 명확하게 깨달을 수 있다.

 

개인적으로 나는 이제 막 중급자 프로그래머로 진입하였다고 생각하는데.

내가 아는 많은 기교들이 정리되어 있었고, 특별히 못 알아먹을 내용이 없었기에

나는 이 책이 '초~중급자 프로그래머' (1년~5년차) 가 읽기에 적합한 책이라 생각된다.

 

해당 책에서 설명하는 최적화의 간단한 예시.

 

1. 우측값 복사가 유의미한 시간차이를 나타냄을 보여주는 예제.

 

#include <iostream>
#include <vector>
#include <windows.h>
 
void copyVector(std::vector<int> input_)
{
    std::vector<int> output_ = input_;
}
 
void copyVectorref(std::vector<int>&& input_) noexcept
{
    std::vector<int> output_ = input_;
}
 
 
int main()
{
    std::vector<int> a;
 
    for (int i = 0; i < 10000000; ++i)
    {
        a.push_back(i);
    }
 
 
    auto Start = GetTickCount64();
    copyVectorref(std::move(a));
    auto End = GetTickCount64();
 
    std::cout << End - Start << std::endl;
 
 
    Start = GetTickCount64();
    copyVector(a);
    End = GetTickCount64();
 
    std::cout << End - Start << std::endl;
}

 

 

 

2. 반복문의 종료값 캐싱의 중요성을 말해주는 예제

 

#include <iostream>
#include <string>
#include <chrono>
 
int main()
{
    std::chrono::system_clock::time_point start;
    std::chrono::system_clock::time_point end;
    std::chrono::nanoseconds result_non;
    std::chrono::nanoseconds result_ok;
    
    size_t result_non_win = 0;
    size_t result_ok_win = 0;
    size_t draw = 0;
 
    for (size_t i = 0; i < 1000000; ++i)
    {
        char s[] = "This string has many space (0x20) chars. ";
 
        start = std::chrono::system_clock::now();
        for (size_t i = 0; i < strlen(s); ++i)
        {
            if (s[i] == ' ')
            {
                s[i] = '*';
            }
        }
        end = std::chrono::system_clock::now();
        result_non = duration_cast<std::chrono::nanoseconds>(end - start);
 
        char k[] = "This string has many space (0x20) chars. ";
        start = std::chrono::system_clock::now();
        for (size_t i = 0, len = strlen(k); i < len; ++i)
        {
            if (k[i] == ' ')
            {
                k[i] = '*';
            }
        }
        end = std::chrono::system_clock::now();
        result_ok = duration_cast<std::chrono::nanoseconds>(end - start);
 
        if (result_non.count() < result_ok.count())
        {
            ++result_non_win;
            continue;
        }
        else if (result_non.count() > result_ok.count())
        {
            ++result_ok_win;
            continue;
        }
        else
        {
            ++draw;
            continue;
        }
    }
 
    std::cout << "result_non_win : " << result_non_win << std::endl;
    std::cout << "result_ok_win : " << result_ok_win << std::endl;
    std::cout << "draw : " << draw << std::endl;
 
}
 

string 내 .size() 함수에서도 효과는 낮지만,

동일한 증상을 볼 수있다.

 

결과값

 

char 형 strlen() 함수

 

string 형 size() 함수

 

 

 

3. 상수를 모아서 처리 (괄호, 왼쪽 몰아넣기) 하여야 컴파일 시간에 최대한 많은 작업 처리 가능.

#include <iostream>
#include <string>
#include <chrono>
 
int main()
{
    const double base = 10;
    std::chrono::system_clock::time_point start;
    std::chrono::system_clock::time_point end;
    std::chrono::nanoseconds result_1;
    std::chrono::nanoseconds result_2;
    size_t result_1_win = 0;
    size_t result_2_win = 0;
    size_t draw = 0;
    double temp;
 
    for (size_t i = 0; i < 1000000; ++i)
    {
        start = std::chrono::system_clock::now();
        temp = (12345 * 3.141592 * 654321 * 3.141592 * 5.123456 * 9.876543) * base * base;
        end = std::chrono::system_clock::now();
        result_1 = duration_cast<std::chrono::nanoseconds>(end - start);
 
        start = std::chrono::system_clock::now();
        temp = 12344 * 3.141591 * base * 9.876542 * 5.123455 * base * 3.141591 * 654320;
        end = std::chrono::system_clock::now();
        result_2 = duration_cast<std::chrono::nanoseconds>(end - start);
 
        if (result_1.count() < result_2.count())
        {
            ++result_1_win;
            continue;
        }
        else if (result_1.count() > result_2.count())
        {
            ++result_2_win;
            continue;
        }
        else
        {
            ++draw;
            continue;
        }
    }
    std::cout << "result_1_win : " << result_1_win << std::endl;
    std::cout << "result_2_win : " << result_2_win << std::endl;
    std::cout << "draw : " << draw << std::endl;
}
 

속도의 차이 유무보다는 Complie Time / Run Time 유무가 중요하다.

 

대표적으로 위와 같은 예제가 있고 책 내에서 다른 최적화 기법에 대한 예제를 정말 많이 다루고 있다.

이 책의 장점이라면 GCC 기반이 아닌 Windows Visual Studio 기반으로 코드가 작성 되어 있어서

Visual Studio 에서 예제 코드를 원할히 테스트 해 볼 수 있다는 점이다.

 

아쉬운 점이라면 어디까지나 중급자용 책으로서 지금의 나에게는 적합하지만,

메타 템플릿 프로그래밍 영역에 대해서 1쪽의 설명만 붙이고 넘어가기도 하는 둥 (템플릿 잘 배우세요~ 하고넘김..)

특정 영역에 대해서는 내용이 비어있는... 모습을 보여준다. 

 

세부설명으로

이 책의 분류를 크게 나누자면,

 

1. 시간 측정

2. std::string, std::vector 와 같은 동적 할당 배열에 관한 최적화.

3. 잡다한 내용

 

으로 나눌 수 있는데,

뭔가 2 번에 치중되어 설명한다는 느낌이 들었지만, 그것대로 유용하였다.

 

개인적으론 이 책을 읽으면서.

왜 프로그래머가 한번쯤은 Unmanaged Language 를 다뤄야

보다 성장할 수있는지를 뼈저리게 느끼게 되었다.

 

Managed 언어와 UnManaged 언어는 구현 결과물은 같을 수 있어도

프로그래머의 시야를 넓히는 데에 있어서는

하늘과 땅 차이이다.

 

자동차의 동작 원리를 아는 레이서와, 

자동차의 동작 원리를 모르는 레이서는

평상시에는 차이가 없을지 모르나,

다전제 상황에서는 원리를 '아는' 레이서가 보다 유연하게 대처할 수 밖에 없다.