CHIPMAKER

1. 카라츠바 알고리즘

다른 사람 C++ 코드를 보고 phython으로 옮겨 봤다.

알고리즘의 Insight는 아래 유투브 강의에 잘 나와 있다.

https://www.youtube.com/watch?v=7JvRFnxn3W0

def normalize(a): a.append(0) for i in range(len(a)-1): if a[i] < 0: borrow = (abs(a[i]) + 9) // 10 a[i+1] -= borrow a[i] += borrow*10 else: a[i+1] += (a[i] // 10) a[i] %= 10 while len(a) > 1 and a[-1] == 0: a.pop() def multiply(a, b): length = len(a) + len(b) + 1 c = [0] * length for i in range(len(a)): for j in range(len(b)): c[i+j] += (a[i] * b[j]) normalize(c) return c def addTo(a, b, k): newLength = max(len(a)+1, len(b)+k) #a = a + [0]*(newLength - len(a)) zeroFillNum = newLength - len(a) while zeroFillNum > 0: a.append(0) zeroFillNum -= 1 for i in range(len(b)): a[i+k] += b[i] normalize(a) def subFrom(a, b): newLength = max(len(a)+1, len(b)) +1 zeroFillNum = newLength - len(a) while zeroFillNum > 0: a.append(0) zeroFillNum -= 1 for i in range(len(b)): a[i] -= b[i] normalize(a) def karatsuba(a, b): if len(a) < len(b): return karatsuba(b, a) if len(a) == 0 or len(b) == 0: return [] if len(a) < 2: return multiply(a, b) half = len(a) // 2 a0 = a[:half] a1 = a[half:] b0 = b[:min(len(b), half)] b1 = b[min(len(b), half):] # z2= a1*b1 z2 = karatsuba(a1, b1) # z0= a0*b0 z0 = karatsuba(a0, b0) # a0 = a0 + a1 # b0 = b0 + b1 addTo(a0, a1, 0) addTo(b0, b1, 0) #z1 = (a0+a1)*(b0+b1)-z0-z2 z1 = karatsuba(a0, b0) subFrom(z1, z0) subFrom(z1, z2) result = [] addTo(result, z0, 0) addTo(result, z1, half) addTo(result, z2, half+half) return result if __name__ == '__main__': #a = [8, 2, 7] #b = [4, 4] a = [1, 2, 3, 4, 5, 6, 7, 8, 9] b = [9, 8, 6, 5, 4, 3] result = karatsuba(a[::-1], b[::-1]) #print(827*44) print(123456789*986543) print(result)

2. 팬미팅 소스

https://www.algospot.com/judge/problem/read/FANMEETING

Normalize 코드를 빼주고, fan의 순서를 뒤집어 주는 것이 원본 카라츠바 알고리즘과 차이점

def multiply(a, b): length = len(a) + len(b) + 1 c = [0] * length for i in range(len(a)): for j in range(len(b)): c[i+j] += (a[i] * b[j]) return c def addTo(a, b, k): newLength = max(len(a)+1, len(b)+k) zeroFillNum = newLength - len(a) while zeroFillNum > 0: a.append(0) zeroFillNum -= 1 for i in range(len(b)): a[i+k] += b[i] def subFrom(a, b): newLength = max(len(a)+1, len(b)) +1 zeroFillNum = newLength - len(a) while zeroFillNum > 0: a.append(0) zeroFillNum -= 1 for i in range(len(b)): a[i] -= b[i] def karatsuba(a, b): if len(a) < len(b): return karatsuba(b, a) if len(a) == 0 or len(b) == 0: return [] if len(a) <= 2: return multiply(a, b) half = len(a) // 2 a0 = a[:half] a1 = a[half:] b0 = b[:min(len(b), half)] b1 = b[min(len(b), half):] # z2= a1*b1 z2 = karatsuba(a1, b1) # z0= a0*b0 z0 = karatsuba(a0, b0) # a0 = a0 + a1 # b0 = b0 + b1 addTo(a0, a1, 0) addTo(b0, b1, 0) #z1 = (a0+a1)*(b0+b1)-z0-z2 z1 = karatsuba(a0, b0) subFrom(z1, z0) subFrom(z1, z2) result = [] addTo(result, z0, 0) addTo(result, z1, half) addTo(result, z2, half+half) return result def hugs(a, b): N = max(len(a), len(b)) M = min(len(a), len(b)) inta = [1 if v == 'M' else 0 for v in a] intb = [1 if v == 'M' else 0 for v in b] intb.reverse() C = karatsuba(inta[::-1], intb[::-1]) allHugs = 0 for i in range(M-1, N): if C[i] == 0: allHugs += 1 return allHugs if __name__ == '__main__': members = ['FFFMMM', 'FFFFF', 'FFFFM', 'MFMFMFFFMMMFMF'] fans = ['MMMFFF', 'FFFFFFFFFF', 'FFFFFMMMMF', 'MMFFFFFMFFFMFFFFFFMFFFMFFFFMFMMFFFFFFF'] for i in range(len(members)): result = hugs(members[i], fans[i]) print(result)

1. 소스 트리

tutorial2 핵심은 myhellow.cpp와 myhellow.hpp 파일을 이용해서 library라는 target을 만드는 것이다.

생성된 library를 실행파일에 최종적으로 연결까지 해 본다.

2. CMakeLists.txt 파일

앞 장의 basic 편에서 다루었던 부분에 추가된 부분만 설명한다.

add_library는 binary library를 생성하는 명령어이다.

• add_library
  
  • myhellow는 생성될 library의 이름이며, 뒤 이어지는 것은 소스 파일들이다.
  • option으로는 STATIC, MODULE, SHARED가 있으며, default는 STATIC 이다.
• target_link_libraries
  • 실행파일 (Target이라 한다)에 링크될 library를 지정하는 명령어이다.
  • ${PROJECT_NAME}은 실행파일인 target이름이며, 뒤 이어지는 것은 링크될 library 이름이다.
  • 옵션으로는 PRIVATE/PUBLIC/INTERFACE가 있다.
  • cmake.org/cmake/help/latest/command/target_link_libraries.html

cmake_minimum_required(VERSION 3.10) # set the project name project(tutorial2) # PROJECT_NAME is tutorial2 # set makefile verbose enable SET(CMAKE_VERBOSE_MAKEFILE ON) # add library (default static library) add_library( # myhellow STATIC # library name for executable myhellow # library name for executable myhellow.hpp myhellow.cpp ) # add the executable add_executable("${PROJECT_NAME}" tutorial2.cpp) # set path for libary target_link_libraries( "${PROJECT_NAME}" PRIVATE myhellow )

3. tutorial2.cpp 파일

테스트를 위한 기본적인 파일이다.

#include <iostream> #include <iostream> #include "myhellow.hpp" int main(int argc, char** argv) { //std::cout << "progect name : " << argv[0] << std::endl; Myhellow::hello(); return 0; }

4. cmake 실행 결과

Out 디렉토리에서 cmake .. 을 수행하면, static library가 생성될 것이다. 이 상태에서 shared library를 생성하고자 하면

Out 디렉토리에서 cmake -D BUILD_SHARED_LIBS=TRUE ../ 을 수행하면 된다.

5. git repository

아래 개인 git repository에 정리한다.

github.com/heesoon/cmake_tutorials/tree/main/tutorial2

1. 소스 트리

tutorial1 디렉토리 초기 구성은 아래 그림과 같다.

기본적으로 cmake를 위한 CMakeLists.txt 파일과 소스 파일인 tutorial1.cpp 파일이다.

Out 디렉토리는 임의적으로 제가 생성한 것이고, cmake의 모든 결과를 Out 디렉토리에 넣고자 한다.

현재 Out 디렉토리는 cmake 수행 전이라서 비어 있는 상태이다.

참고 : cmake.org/cmake/help/latest/manual/cmake-buildsystem.7.html

2. 기본 CMakeLists.txt 파일

CMakeLists.txt 파일의 가장 기본 구성요소는 아래와 같다.

• cmake_minimum_required(VERSION 3.10)
  • cmake 최소 버전. 나의 경우 ubuntu command 창에서 cmake --version 정보로 확인한 값을 적어주었다.
• project(tutorial1)
  • tutorial1 이라는 프로젝트명을 주었다
  • project( ) 명령어 지정한 프로젝트명은 PROJECT_NAME 변수에 저장된다.
• add_executable(tutorial tutorial1.cpp)
  • add_executable은 실행가능한 Target을 만들기 위한 명령어이다.
  • tutorial1 이라는 실행파일을 tutorial1.cpp을 빌드해서 만들겠다는 의미이다.
  • 실행파일에 포함될 소스 파일들은 공백으로 뒤에 쭉 적어주면 된다.

cmake_minimum_required(VERSION 3.10) # set the project name project(tutorial1) # add the executable #add_executable(tutorial1 tutorial1.cpp) add_executable(tutorial tutorial1.cpp)

3. tutorial1.cpp 파일

테스트를 위한 기본적인 파일이다.

#include <iostream> int main(int argc, char** argv) { std::cout << "progect name : " << argv[0] << std::endl; return 0; }

4. cmake 실행 결과

tutorial1 디렉토리에서 아래와 같은 순서로 명령어를 실행한다.

• cd Out
• cmake ..
• make

cmake의 모든 결과가 Out 디렉토리에 생성된 것을 확인할 수 있다. 이렇게 해야 관리가 편하다.

최종 실행 파일인 tutorial 파일도 Out 디렉토리에 생성된 것을 확인할 수 있다.

cmake 초기화하기 위해서는 Out 디렉토리 안의 내용을 모두 지우고 위의 명령어를 다시 수행하면 된다.

이를 기반으로 단계별로 정리하고자 한다.

5. git repository

아래 개인 git repository에 정리한다.

github.com/heesoon/cmake_tutorials/tree/main/tutorial1

1. unique_ptr 이란?

unique_ptr은 스마트포인터로 creational design pattern에서 많이 사용되는 포인터이다.

unique_ptr을 완벽히 이해하기 위해서는 move에 대한 고찰도 필요하다.

여기서는 복잡한 개념보다는 실제 사용법 위주로 정리하였다.

2. 사용예제

실제 개발을 진행하면서 명확한 사용법에서 해메는 경우가 종종있다. 이런 측면에서 보통 많이

적용되는 사용법 위주로 정리한 코드 예제들이다.

특히 unique_ptr을 함수의 파라미터로 사용할 때, 값/참조/rvalue의 선택지가 있는데

어떤 것을 사용해야 할지가 가장 햇갈리는 부분이였다.

간단히 사용법 측면에서 정리하면 다음과 같이 정리할 수 있을 것 같다.

• 받는쪽(함수)로 완전히 자원을 넘겨야 할 경우
  • 함수파라미터를 값이나 rvalue로 선언한다.
  • rvalue로 선언할 경우, 받는쪽에서 move를 통해서 자원을 가져가야 자원이동이 완료된다.
• 전달한 쪽에서도 계속 자원을 사용해야 할 경우
  • 함수파라미터를 참조로 선언해야 한다.

#include <iostream> #include <memory> #include <functional> class A { public: A(int v) : a(v) { std::cout << "A() called .. " << std::endl; } ~A() { std::cout << "~A() called .. " << std::endl; } int getValue() const { return a; } void setValue(int v) { a = v; } private: int a; }; void f1(std::unique_ptr<A> ua) { // 함수 매개변수로 value로 전달 경우 std::cout << "value : " << ua->getValue() << std::endl; } void f2(const std::unique_ptr<A> &ua) { // 함수 매개변수로 value로 전달 경우 std::cout << "in value : " << ua->getValue() << std::endl; } void f3(std::unique_ptr<A> &&ua) { // 함수 매개변수로 value로 전달 경우 std::cout << "in value : " << ua->getValue() << std::endl; } void f4(std::unique_ptr<A> &&ua) { // 함수 매개변수로 value로 전달 경우 std::unique_ptr<A> a = std::move(ua); std::cout << "in value : " << a->getValue() << std::endl; } int main() { // 1. nullptr { std::unique_ptr<A> ua1; // std::unique_ptr<A> ua1(nullptr)과 동일 } // 2. 일반적인 사용법 { std::unique_ptr<A> ua2{new A(10)}; // since c++11 std::unique_ptr<A> ua3 = std::make_unique<A>(10); // since c++14 // user defined deleter 사용 std::unique_ptr<A, std::function<void(A*)>> ua4(new A(10), [](A* ptr) { std::cout << "destroying from a custom deleter...\n"; delete ptr; }); } // 3. 호환성 측면에서 사용 예제 { // 기존에 raw pointer를 unique_ptr을 통해서 자원관리하고자 할 때 적용가능 A* pa1 = new A(20); std::unique_ptr<A> ua5(pa1); // 기존에 raw pointer를 unique_ptr을 통해서 자원관리하고자 할 때 적용가능 A* pa2 = new A(20); std::unique_ptr<A> ua6; ua5.reset(pa2); // get함수를 통한 raw pointer 획득 : raw pointer로 구현된 코드에 호환성을 위해 적용가능 A* pa3 = nullptr; std::unique_ptr<A> ua7(new A(10)); pa3 = ua7.get(); std::cout << "pa3 value : " << pa3->getValue() << std::endl; } // 4. 함수 파라미터와의 정합성 예제 // 4.1. 함수 파라미터가 unique_ptr<A>을 값으로 받을 때 { std::unique_ptr<A> ua8 = std::make_unique<A>(10); //f1(ua8); // error : unique_ptr(const unique_ptr&) = delete; // rvalue로 넘겨야 한다. f1(std::move(ua8)); // 이후부터 ua8 접근 시, 이미 ua8는 자원을 넘겼다. 따라서 segmentation fault; // std::cout << "value : " << ua8->getValue() << std::endl; } // 4.2. 함수 파라미터가 unique_ptr<A>을 참조로 받을 때 { std::unique_ptr<A> ua9 = std::make_unique<A>(10); // 참조로 unique_ptr을 넘길 시에는 자원은 이동되지 않고, 공유된다. f2(ua9); // 따라서 아래 코드는 ok std::cout << "out value : " << ua9->getValue() << std::endl; } // 4.3. 함수 파라미터가 unique_ptr<A>을 rvalue로 받을 때 { std::unique_ptr<A> ua10 = std::make_unique<A>(10); // rvalue function parameter에 넘긴다. // f3(ua10); // error : a6 is lvalue f3(std::move(ua10)); // 원칙적으로 ua10 아래에서 호출하면 segmentation fault가 발생해야 하는데, 발생하지 않는다. // 이 부분을 주의해야 한다. std::cout << "out value : " << ua10->getValue() << std::endl; } // 4.4. 함수 파라미터가 unique_ptr<A>을 rvalue로 받을 때 // f3함수에서 f4로 변경된 부분을 참고. 실제 f4처럼 함수파라미터로 넘어온 rvalue를 함수내에서 가져가야 // 완전한 자원 이동이 된다. { std::unique_ptr<A> ua11 = std::make_unique<A>(10); f4(std::move(ua11)); // f3을 f4로 고치면 이제 이후부터 ua11 접근 시, segmentation fault; //std::cout << "out value : " << ua11->getValue() << std::endl; } return 0; }

4. Pimpl Idiom with unique_ptr

unique_ptr과 함께 숙지해 놓으면 좋은 예가 c++ Idiom 중에서 Pimpl이다.

Pimpl은 컴파일 시간을 줄이기 위한 방법으로 Effective Modern C++ 22장에 정리되어 있다.

그 책을 예제로 정리해 놓는다.

아래 코드는 user define Gadget class가 widget.h에 포함되어 있다. widget.h 파일을 많은 cpp 파일에서

include 시킨다고 가정하면, 사용자가 개발 중에 Gadget을 빈번하게 수정한다면 widget.h를 include하는

모든 파일은 컴파일 대상이되어 빌드 시간이 오래걸린다. (컴파일러는 header 파일만 바라본다)

<컴파일 시간이 오래걸리는 코드 원본>

// in header "widget.h" class Widget { public: Widget(); private: std::string name; std::vector<double> data; Gadget g1, g2, g3; // Gadget is user defined type };

아래 코드는 위의 컴파일 시간 문제를 C++98 버전으로 Pimpl을 구현한 코드이다.

1. struct Impl에 사용자 변수를 package한다.
2. Impl *pImpl raw pointer로 할당받는다. Gadet의 변경은 이제 컴파일 시간에 영향을 주지 않는다.
3. 실제 코드는 cpp 구현부에 존재한다.
4. raw pointer의 사용으로 사용자 정의 생성자/소멸자를 만들어줘야 한다.

<C++ 98 Pimpl 구현 코드>

// Applying the Pimpl Idiom in C++98 class Widget { public: Widget(); ~Widget(); // raw pointer 사용으로 pImpl을 정리할 destructor 선언은 필수 private: struct Impl; // <-------------------------- 1) Impl *pImpl; // <-------------------------- 2) }; // Pimpl Idiom 개념상 // 즉 constructor와 destructor의 정의는 Widget.cpp 파일로 이동 // in Widget.cpp 파일 내부 #include "widget.h" #include "gadget.h" #include <string> #include <vector> // <-------------------------- 3) struct Widget::Impl { std::string name; std::vector<double> data; Gadget g1, g2, g3; }; // <-------------------------- 4) Widget::Widget() : pImpl(new Impl) { } // <-------------------------- 5) Widget::~Widget() { delete pImpl; }

이제 Pimpl에 c++11 unique_ptr 사용한다면 컴파일러가 자동으로 소멸자를 생성할 것으로 기대할 수 있다.

하지만 사용자가 생성자를 생성해야 한다. 그 이유는 책에 잘 설명되어 있다.

결론은 shared_ptr와 다르게 unique_ptr은 불완전 type(Impl)에 대해서 소멸자를 자동생성할 수 없다.

따라서 Pimpl처럼 불완전 타입을 unique_ptr에 적용하려면 사용자가 소멸자를 선언 및 정의해 줘야 한다.

소멸자를 사용자 재정의함에 따라서 move/copy 모든 생성자까지 사용자가 생성해줘야 한다.

special member function(https://chipmaker.tistory.com/entry/Modern-C-Summary-of-special-member-function-generation)을 참조하면 상세하게 정리되어 있다.

1. C++98과 동일하다.
2. raw pointer에서 smart pointer로 바꾸었다.
3. header 파일에는 생성자를 선언해야하고, 구현부(cpp)에는 정의가 필요
4. 생성자와 동일 (unique_ptr을 사용하는 효과가 전혀없다)
5. move 사용자 재정의로 copy operation(constructor, assignment operator)도 사용자 정의해야 한다.
6. 소멸자 사용자 재정의로 move operation(constructor, assignment operator)도 사용자 정의해야 한다.

C++98에서 unique_ptr을 사용하면 사용자가 해주어야 할 일이 줄어야 하는데, 차이가 없다.

raw pointer의 자원 관리 문제를 smart pointer를 통해서 Pimpl에서 확장하려면

결국 모든 생성자와 소멸자를 사용자가 해 주어야 한다점이 핵심이다.

물론 compiler가 생성하는 코드와 동일한 코드라면 모두 예제 코드처럼 default로 처리하면 된다.

<C++11 Pimpl 구현 코드>

// Applying the Pimpl Idiom in C++11 class Widget { public: Widget(); // <-------------------------- 3) ~Widget(); // <-------------------------- 4) // <-------------------------- 5) Widget(const Widget& rhs); Widget& operator=(const Widget& rhs); // <-------------------------- 6) Widget(Widget&& rhs); Widget& operator=(Widget&& rhs); private: struct Impl; // <-------------------------- 1) std::unique_ptr<Impl> pImpl; // <-------------------------- 2) }; // widget.cpp 파일 내부 #include "widget.h" #include "gadget.h" #include <string> #include <vector> // <-------------------------- 7) struct Widget::Impl { std::string name; std::vector<double> data; Gadget g1, g2, g3; }; // <-------------------------- 3) Widget::Widget() : pImpl( pImpl(std::make_unique<Impl>()) ) { } // <-------------------------- 4) Widget::~Widget() = default; // <-------------------------- 5) Widget::Widget(const Widget& rhs) // copy constructor : pImpl(std::make_unique<Impl>(*rhs.pImpl)) {} Widget& Widget::operator=(const Widget& rhs) // copy assignment operator { *pImpl = *rhs.pImpl; return *this; } // <-------------------------- 6) Widget::Widget(Widget&& rhs) = default; // move constructor Widget& Widget::operator=(Widget&& rhs) = default; // move assignment operator

5. 정리

cppreference에도 사용법은 잘 정리되어 있지만, 바로 보기 힘들어서 여기서 사용법만 재 정리하였다.

unique_ptr을 Pimpl Idiom에 적용할 때, 컴파일 에러상황과 고려해야 할 사항을 정리하였다.

물론 책에도 있지만 네가 다음에 보기 편하게 정리하였다.

Pimpl Idiom은 실제 unique_ptr과 연관성이 높으며, shared_ptr에 적용 예는 드물다.

shared resource에 대해서 Pimpl Idiom을 shared_ptr로 구현한다면, unique_ptr처럼 복잡하지 않다.

단순히 아래 코드처럼 생성자만 사용자가 생성해주면 된다.

소멸자를 사용자가 재정의하지 않아서 나머지 special member function은 컴파일러 모두 자동생성하기

때문이다.   

class Widget { public: Widget(); // <-------------------------- 3) private: struct Impl; // <-------------------------- 1) std::shared_ptr<Impl> pImpl; // <-------------------------- 2) }; // widget.cpp 파일 내부 #include "widget.h" #include "gadget.h" #include <string> #include <vector> // <-------------------------- 4) struct Widget::Impl { std::string name; std::vector<double> data; Gadget g1, g2, g3; }; // <-------------------------- 3) Widget::Widget() : pImpl( pImpl(std::make_shared<Impl>()) ) { }

1. special member function이란?

아래 6가지 member function에 대해서 컴파일러가 자동생성해주는 것을 말함. (by Scott Meyers)

아래 6가지 모든 함수를 사용자가 생성하지 않으면, 컴파일러가 자동으로 모두 생성해준다. 

하지만 경우에 따라서 사용자가 아래 6가지 함수 중에 하나 이상을 선언하는 경우가 발생할 수 있다.

특히 move는 성능과 직결되는 것으로 move관점에서 핵심만 정리한다.

• default constructor (기본생성자)
• copy constructor (복사생성자)
• copy assignment operator (복사대입연산자)
• move constructor (이동생성자)
• move assignment operator (이동대입연산자)
• destructor (소멸자)

2. move 자동생성 조건

move가 자동생성되기 위해서는 아래 세가지 조건이 모두 만족되어야 한다.

• No copy operations are declared in the class
• No move operations are declared in the class
• No destructor is declared in the class.

하지만 위의 세가지 조건을 모두 만족시키기 어려운 상황이 크게 두 가지 존재한다.

• class내에 raw pointer 기반 resource 관리 시
  • raw pointer는 모두 삭제하고, STL container 기반으로 코드 수정해야 한다.
• 클래스가 상속관계에 있을 경우
  • 해당 경우에 대해서 아래에서 상세하게 살펴본다.

3. move 자동생성이 안되는 경우 - class inherit condition

class 상속관계에서는 상위(부모) class의 desctructor는 virtual로 사용자가 선언해야 한다.

이런 제약 사항이 move의 자동생성 조건을 만족시킬 수 없어서 move가 자동생성되지 않는다. 

이로 인해 class 설계자가 고려해야 할 사항들에 대해서 정리하였다.

1. class 설계자는 move operation들을 생성해야한다.
   • 사용자 desctructor의 생성은 move operation이 자동생성되지 않기 때문
2. class 설계자는 copy operation들을 생성해야 한다
   • 사용자가 move operation들을 생성하면, copy operation들은 제거되거나 자동생성되지 않기 때문
   • copy operation 자동생성 조건은 따로 정리하지 않았지만, 이 정도만 기억하면 될 것으로 보인다.
3. class 설계자는 default 생성자를 사용해야 한다면, 생성해야 한다.
   • 사용자가 move operation를 생성하면 모든 생성자가 제거되거나 자동생성되지 않기 때문

결론적으로 class가 상속관계에 있는 경우, 6가지 special member function들에 대해서 잘 설계를 해야한다.

만약 단순히 virtual 때문에 destructor를 사용자가 선언해야하는 조건이라면, 컴파일러가 자동생성한 것과 동일하게 생성해 달라고 명시하면 된다.

만약 사용자가 컴파일러가 자동생성하는 코드와 다르다면 모두 사용자가 생성해줘야 한다.

class CBase { public: // 1. class 상속관계로 destructor를 virtual로 사용자가 생성해야 한다. // 사용자가 필요한 destructor가 컴파일러가 생성하는 코드와 차이가 없다면, // 컴파일러에게 생성해 줄 것을 default를 통해서 명시적으로 지시할 수 있다. virtual ~CBase() = default; // 2. 사용자의 destructor의 생성으로, move가 자동생성 안되니 // 사용자가 move operation들을 생성한다. CBase(CBase &&) = default; // default의 의미는 destrutor와 동일 CBase& operator=(CBase&&) = default; // 3. 사용자의 move 생성으로, copy가 자동생성 안되거나 제거된다. // 사용자가 copy operation들을 생성한다. CBase(const CBase &) = default; CBase& operator=(const CBase&) = default; // 4. move operation을 사용자가 생성하여, copy operation들은 모두 제거되었다. // 따라서 default constructor의 사용이 필요하다면, 아래처럼 생성해야 한다. CBase() = default; }; class CChild : public CBase { // CChild의 destructor는 컴파일러가 virtual destructor를 자동생성한다. // 따라서 나머지 special member function도 사용자가 생성하지 않는한 모두 자동생성된다. };

4. template 사용의 경우

Effective Modern C++ 책에서는 17장 마지막에 애매하게 설명하고 정리하였다.

아래 코드 테스트를 통해서, template라고 해서 특별히 위의 생성 규칙과 다른 점은 없었다.

move에 대해서 위의 규칙을 잘 이해하고 있다면, template에서도 동일하게 적용된다. 

#include <iostream> #include <memory> template<typename T> class A { public: // 4. 사용자가 move operation을 생성하여, default constructor도 // 자동생성되지 않아서, 사용자가 생성해줘야 한다. A() { std::cout << "Car() .. " << std::endl; } // copy operations // 3. 사용자가 move를 생성하여서, copy operation은 자동생성(implicity)되지 않는다. // 2. 사용자가 destructor를 생성하여 move는 자동생성되지 않아서 // 테스트를 위해서 move를 사용자가 default로 생성하였다. A(A &&) = default; A& operator=(A&&) = default; // 1. 사용자가 destructor를 생성하였다. ~A() { std::cout << "~A() .. " << std::endl; } void setCount(T a) { count = a; } T getCount() { return count; } private: T count; }; int main() { A<int> a1; a1.setCount(10); // 아래 코드는 copy constructor가 존재하지 않아서 다음과 같은 error를 발생시킨다. // error: use of deleted function 'constexpr A<int>::A(const A<int>&)' A<int> a2(a1); a2.getCount(); return 0; }

5. 정리

special member function은 컴파일러가 자동생성하는 함수들이다.

자동생성되는 함수들은 클래스의 public 영역에 inline으로 생성된다.

special member function들 중에 사용자 생성으로 자동생성되지 않는 규칙이 존재한다.

다른 규칙은 외우지 않아도 빌드 중에 모두 수정할 수 있다.

하지만 move의 특성상 move는 copy로 대체가 가능하여 move의 자동생성조건을

명확히 이해하지 않는다면, 원하지 않게 copy로 동작하여 성능저하의 문제를 겪을 수 있다.

이런 관점에서 move 관점에서 상세하게 살펴보았다.

1. reference collapsing 이란?

type deduction 과정에서 유도된 reference와 원본 expression이 가지고 있는 reference가 충돌하는 것을 말한다.

위의 문장으로는 어떤 의미인지 마음에 와 닿지 않는다. 예제를 하나 살펴보면

auto& rx = x;

예제가 이상하기는 하지만 x 가 int lvalue reference라고 한다면,

auto -> int&로 유도된다.

auto를 int&로 치환하면, 아래와 같고 결국 reference와 reference가 충돌하는 상황이 발생한다.

int& & rx = x;

2. reference collapsing 세가지 유형

reference collapsing이 발생하는 상황은 크게 아래 세가지 경우에 해당한다.

• template
• auto
• decltype

3. reference collaping 처리 규칙

"lvalue reference 이면 최종 결과는 lvalue reference, rvalue reference이면 최종 결과는 rvalue reference"

4. perfect forwarding

reference collapsing 규칙은 perfect forwarding 이해하는데 핵심 규칙으로 보인다.

perfect forward의 핵심인 forward 기술을 가지고 reference collasping 적용 규칙을 살펴본다.

// c++11 버전 std::forward<T> 개략적인 구현 코드 template<typename T> T&& forward(typename remove_reference<T>::type& param) { return static_cast<T&&>(param); } // c++14 버전 std::forward<T> 개략적인 구현 코드 template<typename T> T&& forward(remove_referenc_t<T>& param) { return static_cast<T&&>(param); } template<typename T> void f(T&& param) { // ... somefunction(std::forward<T>(param)); } class Widget{}; // 아래 결과는 ? int main() { // 1. lvalue Widget w; f(w); // 2. 임시객체 Widget(), rvalue 전달 f(Widget()); }

아래 표에 main함수에서 예시한 예제에 대해서 reference collapsing 과정을 기술하였다.

표를 통해서 reference collapsing 규칙을 이해하는데 어렵지 않을 것이다.

reference collasing설명에서 perfect forwarding이라는 머나먼 주제로 이동한 느낌이지만

reference collasping 주제를 통해서 perfect forwarding 기술이 무엇인지 알 수 있다.

perfect forwarding은 somefunction까지 매개변수가 전달되는 과정에서 원래 f 함수에 전달된

함수의 매개변수 reference 속성이 변경되지 않는 기술로 요약할 수 있다.

5. reference collasing 추가 고려 사항

아래 코드는 책에 존재하는 코드로

RvalueRefToT 변수는 Rvalue Reference로 사용을 위해서 typedef한 경우라고하면,

실제 type deduction 과정에서 reference collasping 과정을 거치고 나면

RvalueRefToT 변수는 lvalue reference로 정의되어진다.

reference collasping에 대한 정확한 이해를 바탕으로 구현이 필요함을 보여주는 예제이다. 

template<typename T> class Widget { public: typedef T&& RvalueRefToT; // ... }; // Case Widget<int&> w; // Case의 실제 type deduction // reference collasing : typedef int& && RvalueRefToT; // final result : typedef int& RvalueRefToT;

5. 정리

reference collasping은 perfect forwarding을 이해하는데 핵심 요소로 보여진다.

c++11을 정리하다보면 각자 다른 주제인 것 같지만, 결국 모두 상호 엮여있어서

다른 것을 이해하는데 각 요소의 정확한 이해가 필요해 보인다. 

1. decltype type deduction

decltype의 사용형식은 다음과 같다.

• decltype(expr) n

expr의 표현식의 따라서 type deduction은 크게 두가지로 분류될 수 있다.

• expr에 연산자가 존재하지 않을 경우의 type deduction
• expr에 연산자가 존재할 경우의 type deduction

2. expr에 연산자가 존재하지 않는 경우

expr에 연산자가 존재하지 않으면, expr과 동일한 type으로 변환된다.

const int i = 0; decltype(i) n; // const int 과 동일 bool f(const Widget& w); decltype(w) n; // const Widget& 과 동일 decltype(f) n; // bool(const Widget&) 과 동일

3. expr에 연산자가 포함되어 있는 경우

expr에 연산자가 존재하면, expr이 lvalue냐 또는 rvalue냐를 식별해야 한다.

lvalue일 경우, reference가 붙지만 rvalue이면 reference는 붙이지 않는다.

int n = 10; int *p = &n; decltype(p) a; // no operation in expr, decltype(p)는 int* decltype(*p) a; // *p : lvalue, decltype(*p)는 int& int x[3] = {1, 2, 3} decltype(x[0]) a; // x[0] : lvalue, lvalue, decltype(x[0])는 int& vector<int> v {1, 2, 3}; decltype(v[0]) a; // v[0] : lvalue, lvalue, decltype(v[0])는 int& // rvalue case decltype(n + n) a; // n + n 는 rvalue, decltype(n + n)는 int decltype(n++) a; // n++ 는 rvalue, decltype(n++)는 int

4. decltype(auto) 정리

c++14부터 지원하는 문법이다. 정확한 의미는 다음과 같다.

• auto
  • type deduction이 필요하다.
• decltype
  • type deduction rule은 decltype의 rule을 따른다.

결론적으로 type deduction을 수행해야 하는데, 이 때 decltype의 rule을 따른다의 의미이다.

이 형식이 어디에 사용되느냐는 함수의 return type과 관련이 있다.

Effective Modern C++의 추가 내용들은 perfact forwarding과 관련된 부분이 대부분이라서

간단히 왜 이런 구문이 나왔는지 측면에서 정리하고 넘어간다.

// c++11 코드 template<typename C, typename I> auto authAndAccess(C& c, I i) -> decltype(c[i]) { return c[i]; } // 위와 동일한 c++14 코드 template<typename C, typename I> auto authAndAccess(C& c, I i) { return c[i]; }

위의 코드에서 함수의 return을 auto로 받고 있다. auto의 type deduction에서 기술하였듯이

함수의 return type의 auto의 경우 template의 type deduction 규칙을 따른다.

이 경우 return되는 c[i]는 C&이지만 auto의 type deduction이 template 규칙을 따르기 때문에

최종적으로 return type은 C가 된다.

이 경우 문제는 다음과 같은 코드에서 문제가 발생할 수 있다.

std::deque<int> d;

authAndAccess(d, 5) = 10;

authAndAccess()의 return type은 rvalue를 return하고 있어서 대입 시 에러가 발생한다.

여기서 해결책은 무엇인가? c++11의 경우에는 perfact forwarding에 대한 지식이 필요하므로

c++14 기준으로 해결책은 decltype(auto)로 return type을 바꾸는 것이다.

decltype(auto)의 의미에 따라서 C&로 return type이 결정된다.

// authAndAccess의 return type을 C&로 받기 위한 해결책 template<typename C, typename I> decltype(auto) authAndAccess(C& c, I i) { return c[i]; }

5. 정리

decltype의 type deduction은 expr의 표현식의 연산자 유무에 따라서 그 동작에 차이가 있다.

이 부분을 주의해서 사용하는 것이 핵심이고, decltype(auto)는 양념정도로 알아두면 좋을 듯 하다.

1. auto type deduction

auto와 template의 type deduction 과정은 braced initalizer에 대한 type deduction을 제외하고는 동일하다.

braced initalizer에 대한 auto와 template의 기본 동작은 아래와 같다.

• auto
  • std::initializer_list로 type deduction 된다.
• template
  • std::initializer_list로 type deduction을 지원하지 않는다.

auto에 대한 위의 braced initalizer 기본 동작이 아래와 같은 경우에 또 예외 동작을 수행한다.

• auto가 함수의 return type으로 사용 시
  • template처럼 동작한다. 즉 std::initializer_list로 type deduction되지 않는다.
• lambda의 매개변수에 사용 시
  • template처럼 동작한다.

다음절에서 위에서 기술한 기본동작과 예외 동작에 대해서 상세하게 알아본다.

2. auto 기본동작 (template와 동일)

3. auto 와 template의 braced intializer와의 기본동작

서두에 기술한 auto와 template의 braced initializer에 대한 동작 차이점을 보여주는 예제이다.

// braced intializer가 아닌 경우, auto와 template type deduction은 동일 auto x1 = 27; // int x1 = 27; auto x2(27); // int x2 = 27; // braced intializer의 경우, auto는 std::initializer_list로 type deduction, template는 지원하지 않음. auto x3 = {27}; // std::initializer_list<int> x3 = {27}; auto x4{x27}; // std::initializer_list<int> x4 = {27}; template<typename T> void f(T param) f({11, 23, 9}); // compile error, template에서는 중괄호 초기화 리스트를 inializer_list로 변환하는 것을 지원하지 않는다 // compile error를 잡기 위해서는 template의 형태가 void f(std::initializer_list<T> param)로 바꿔야 한다. // 아래 경우는 auto의 std::intializer_list로 변환 과정과 관련이 있고, 변환 과정은 다음과 같은 순서로 진행 // 1. { } -> std::intializer_list<T> 로 변환 // 2. T를 결정, T는 { }안의 값을 기반으로 결정 // 아래는 int와 double이 썩어 있는 구조라서 T를 결정할 수 없어서 compile error 발생 auto x5 = {1, 2, 3.0}; // compile error

4. braced intializer와 auto의 기본동작의 예외 케이스

서두에 기술한 auto와 template의 braced initializer에 대한 동작 차이점을 보여주는 예제이다.

// Effective Modern C++ 코드 인용 // 1. auto 가 function return type으로 사용될 때 // auto 는 template type deduction처럼 동작한다. 따라서 std::initializer_list로 type deduction되지 않는다 auto createInitList() { return {1, 2, 3}; // compile error } // 1. auto 가 lambda parameter type으로 사용될 때 // auto 는 template type deduction처럼 동작한다. 따라서 std::initializer_list로 type deduction되지 않는다 std::vector<int> v; auto resetV = [&v](const auto& newValue) { v = newValue;}; resetV({1, 2, 3});

5. 정리

auto의 type deduction 동작은 template와 동일하다. 다만 braced initializer와의 동작에 대해서는

auto와 template간의 차이가 있고, 그 경우에 대해서 정리했다.

1. Type Deduction History

1) C++98

• Template Type Deduction

2) C++11

• Template Type Deduction 변경
• auto와 decltype 추가

3) C++ 14

• decltype(auto)가 가능

C++11에서 Template Type Deduction은 auto와 동일하다. 

2. Template Type Deduction

Effective Modern C++ 기준으로 정리하였으나, 내가 이해한 방식되로 정리하였다. 크게 세가지 관점에서 접근할 수 있다.

2.1. ParamType이 T인 경우 - pass by value

template<typename T> void f(T param); int x = 27; const int cx = x; const int& rx = x; const char* const ptr = "hellow";

f(expr)에서 expr로 전달되는 원본객체의 const, volatile, reference, pointer를 무시한다.

이 상태에서 T의 타입을 결정하고, expr의 pattern-matching 방식으로 최종 type을 결정한다.

2.2. ParamType이 참조 또는 포인터인 경우

아래 크게 세가지의 경우로 나누어서 정리하였지만, type을 최종 결정하는 방식은

동일한 방식으로 진행된다. 따라서 ParamType을 조금 변경하더라도 동일하게 유추가능하다.

1) T&인 경우

template<typename T> void f(T& param); int x = 27; const int cx = x; const int& rx = x;

f(expr)에서 expr로 전달되는 원본 객체의 참조를 무시한다.

이 상태에서 T type과 expr과의 pattern-matching 방식으로 최종 type을 결정한다.

2) const T&인 경우

template<typename T> void f(const T& param); int x = 27; const int cx = x; const int& rx = x;

f(expr)에서 expr로 전달되는 원본 객체의 상수성과 참조는 무시한다.

이 상태에서 T type과 expr과의 pattern-matching 방식으로 최종 type을 결정한다.

3) ParamType이 포인터인 경우

template<typename T> void f(const T*; param); int x = 27; const int *px = &x;

f(expr)에서 expr로 전달되는 원본 객체의 포인터는 무시한다.

이 상태에서 T type과 expr과의 pattern-matching 방식으로 최종 type을 결정한다.

2.3. ParamType이 foward reference 일 경우 (책에서는 universal reference)

template<typename T> void f(T&&; param); int x = 27; const int cx = x; const int& rx = x;

forward reference의 경우에는 expr로 전달되는 객체가 lvalue인지 rvalue인지를 통해서

T type을 결정하고 param type과는 reference collapsing(책, Item28)을 통해서 최종 타입이 결정된다.

3. 추가적인 Type Deduction

추가적으로 살펴보아야 할 type deduction은 배열과 함수이다. 이는 원래의 객체의 type이

type deduction 과정 중에 포인터로 바뀌는 현상이 존재하여 이를 잘 구분애서 사용해야 한다.

3.1.  배열 Type Deduction

배열 type을 갖는 함수 매개변수는 존재하지 않는다.

따라서 T를 통한 type deduction인 f(name)의 경우는 전통적인 C표준에 따라서

const char[13]은 const char*로 변환된다.

다만, 배열 type을 그대로 사용하기 위해서는 T&으로 함수템플릿을 정의해야 한다.

template<typename T> // name type : const char[13] const char name[] = "heesoon.kim"; // 1. T : pass by value template<typename T> void f(T param); f(name); // T : const char * // 2. T& : reference template<typename T> void g(T& param) g(name); // T : const char(&)[13]

3.2.  함수 Type Deduction

위의 배열에서 적용된 타입 변경 방식은 함수에도 동일하게 적용된다.

template<typename T> void function(int, double); // 1. T case template<typename T> void f(T param); f(function); // T : void(*)(int, double) // 2. T& case template<typename T> void g(T& param); g(function); // T : void(&)(int, double)

4. 정리

type deduction에서 pass by value는 expr로 넘겨오는 것은 값으로 복사한다는 측면에서 상수성과 참조성은 무시된다.

reference는 expr로 넘어오는 과정에서 원 객체의 reference를 무시하고 타입 유도를 진행한다.

다만 forward reference는 forward reference 특성을 반영하여 expr로 넘어오는 객체가 lvalue인지 rvalue인지가

타입 유도과정에 적용된다.

일반적인 타입 유도뿐만 아니라 전통적인 C에 뿌리를 두고 있는 타입 유도 과정도 같이 고민을 해야 하며,

expr로 넘겨지는 원 객체의 타입을 유지하려면 참조 정의해야 한다.

1. 목적

기본 http, url 모듈을 사용해서 로그인처리하는 서버를 만들어 보았다. login.html에 method 부분을 get과 post로 변경해서 아래 GET과 POST 테스트 코드를 수행해야 한다.

2. 코드

[ login.html ]

<!DOCTYPE html> <h2> Login Test </h2> <form action="/login" method="post"> name:<br> <input type="text" name="name" value="insert name"> <br> password:<br> <input type="text" name="passwd" value="insert password"> <br><br> <input type="submit" value="submit"> </form> <p> login test page ... </p>

[ app.js (GET method)]

var http = require('http'); var fs = require('fs'); var url = require('url'); var server = http.createServer(function (request, response) { let pathname = url.parse(request.url).pathname; let query = url.parse(request.url, true).query; console.log('url : ' + request.url); console.log('pathname : ' + pathname); console.log('query : ' + JSON.stringify(query)); if(pathname == '/') { console.log('in /'); fs.readFile('login.html', function(error, data) { //console.log('data : ' + data); response.writeHead(200, {'content-Type': 'text/html'}); response.end(data); }); } else if(pathname == '/login') { console.log('in login ... '); console.log('query : ' + query.firstname); console.log('query : ' + query.lastname); } else { console.log('else ... ' ); } }); server.listen(8000, function() { console.log('start server running ... '); });

[ app.js (POST method)]

const http = require('http'); const queryparse = require('querystring'); const fs = require('fs'); const server = http.createServer((req, res) => { if(req.method === 'POST') { console.log('post request ... '); if(req.headers['content-type'] === 'application/x-www-form-urlencoded') { let body = ''; req.on('data', function(chunk) { // req.on('data', chunk => { body += chunk.toString(); console.log(body); }); req.on('end', function() { console.log('end ... '); console.log(queryparse.parse(body)); res.writeHead(200, {'Content-Type': 'text/html'}); res.end('ok'); }); } } else { console.log('read login html ... '); fs.readFile('login.html', function(err, data) { res.writeHead(200, {'Content-Type': 'text/html'}); res.end(data); }); } }); server.listen(8000, function() { console.log('server running at 8000'); });

3. 설명

http://server_ipaddress:8000/ 으로 접속하면 login.html을 읽어 들이고, login.html에서 submit을 누르면, http://server_ipaddress:8000/login으로 submit 데이터를 보내게된다.

4. 실행결과

5. References

https://opentutorials.org/module/938/7369

https://itnext.io/how-to-handle-the-post-request-body-in-node-js-without-using-a-framework-cd2038b93190