programming on yonmy

std::unique_ptr을 사용하자

Tue, 03 Jul 2018 21:15:39 +0900

최신의 c++에서 동적메모리 할당에 raw pointer를 사용하는 것보다는 std::unique_ptr을 사용해야 할 이유는 충분히 많이 있다.

std::unique_ptr의 사용해야 할 이유가 생소한 사람은 “스콧 마이어스의 Effective Modern C++” 부터 읽어보길 추천한다.

여기서는 생각해볼 문제로 2가지 관점에서 std::unique_ptr을 써야 하는 이유를 이야기해보고자 한다.

1. 예외로 부터 보호하기

c++에서는 RAII를 활용하는 것이 정말 좋다. 즉, raw pointer보다 std::unique_ptr이 더 좋다.

class CQueue
{
public:
 bool Add(CTask* task);
};

CQueue g_queue;

void UseRawPointer()
{
 auto task = new CTask();
 if (g_queue.Add(task) == false)
 {
 // Add 실패시에는 메모리를 해제해주어야 한다.
 delete task;
 }
}

void UseUniquePointer()
{
 auto task = std::make_unique<CTask>();
 if (g_queue.Add(task.get()) == true)
 {
 // Add 성공시에 release를 해준다.(제어권은 g_queue로 넘어갔다)
 task.release();
 }
}

void DoSomething()
{
 try
 {
 UseRawPointer();
 UseUniquePointer();
 }
 catch (...)
 {
 }
}

만약 CQueue::Add 함수가 예외를 던진다면 어떻게 될까?

Spin-Loop

Thu, 31 May 2018 00:00:49 +0900

멀티쓰레딩 프로그래밍에서 락을 잡는 타이밍이 짧다면 이론적으로 spin lock을 사용하여 busy waiting을 하는 것이 성능에 좋다고 알고 있다.

하지만, 실제로 spin lock으로 효과를 보기 쉽지 않은데, CPU에 이를 위해 pause라는 명령어가 존재한다.

spin lock이라는게 결국 변수의 값이 원하는 값이 될때까지 계속 loop를 돌리는 것인데, pause라는 명령어를 통해 CPU에게 지금 spin loop를 돌고 있다는 힌트를 주고, CPU가 메모리버스 속도 등을 감안해서 변수가 바뀌는데 필요한 최소한의 시간만큼 다음 명령어를 실행하지 않는 것이다.

std::vector로 배우는 레벨업 #2

Thu, 18 Jan 2018 15:39:17 +0900

std::vector로 배우는 레벨업 #1에 이어서…

resize를 구현해 보자

void resize(size_t newSize)
 {
 // 공간을 확보
 reserve(newSize);

 // 늘어난 사이즈만큼 생성자를 호출
 for (size_t i = _size; i < newSize; ++i)
 {
 auto p = _data + i;
 new(p) T();
 }

 // 줄어든 사이즈만큼 소멸자를 호출
 for (size_t i = newSize; i < _size; ++i)
 {
 auto p = _data + i;
 p->~T();
 }

 _size = newSize;
 }

아래 테스트 코드를 통해 동작을 확인해보자.

std::cout << "std::vector<Foo> :" << std::endl;
std::vector<Foo> stdVec;
stdVec.resize(3);
stdVec.resize(1);

std::cout << std::endl;
std::cout << "MyVector<Foo> :" << std::endl;

MyVector<Foo> myVec;
myVec.resize(3);
myVec.resize(1);

std::vector로 배우는 레벨업 #1

Wed, 17 Jan 2018 17:29:36 +0900

선행학습: std::vector의 size와 capacity에 대해서 제대로 알고있자

std::vector의 push_back과 reserve를 한번 직접 구현해보자..

언뜻 생각해보면 template에 대해서 조금만 알고 있으면 다음과 같이 쉽게 구현 할 수 있을 거라는 생각이 들 것이다.

template<class T>
class MyVector
{
public:
 MyVector()
 : _data(nullptr)
 , _size(0)
 , _capacity(0)
 {
 }

 ~MyVector()
 {
 delete[] _data;
 }

 size_t size() const noexcept { return _size; }
 size_t capacity() const noexcept { return _capacity; }

 T& operator[](size_t idx)
 {
 return _data[idx];
 }

 void reserve(size_t newCapacity)
 {
 if (_capacity < newCapacity)
 {
 // 더 큰 공간을 할당 하고
 T* newData = new T[newCapacity];

 // 기존의 _data를 복사한다.
 for (size_t i = 0; i < _size; ++i)
 {
 newData[i] = _data[i];
 }

 // 기존의 _data는 메모리 해제
 delete[] _data;
 _data = newData;
 _capacity = newCapacity;
 }
 }

 void push_back(const T& value)
 {
 if (_capacity <= _size)
 {
 reserve(calculate_growth(_capacity + 1));
 }

 _data[_size++] = value; // 복사 및 사이즈 증가
 }

private:
 size_t calculate_growth(const size_t new_size) const
 {
 if (_capacity > std::numeric_limits<size_t>::max() - _capacity / 2)
 {
 return (new_size);	// geometric growth would overflow
 }

 const size_t geometric = _capacity + _capacity / 2;
 if (geometric < new_size)
 {
 return (new_size);	// geometric growth would be insufficient
 }

 return (geometric);	// geometric growth is sufficient
 }

private:
 T* _data;
 size_t _size;
 size_t _capacity;
};

한번 다음의 테스트 코드로 std::vector과 MyVector의 출력결과가 어떻게 다른지 확인해 보면….

c++에서 malloc과 new의 차이점

Wed, 17 Jan 2018 17:28:12 +0900

제일 중요한 포인트는 생성자의 호출 유무이다.

malloc
- 동적 메모리를 할당한다.
new
- 동적 메모리를 할당한다.
- 생성자를 호출한다.

마찬가지로, free와 delete의 핵심 차이점은 소멸자의 호출 여부

기타 차이점으로는

호출 하는 방법이 다르다.
new 의 경우에 메모리 할당에 실패하면 예외(std::bad_alloc)가 발생한다.

참고

https://msdn.microsoft.com/library/kftdy56f.aspx

http://en.cppreference.com/w/cpp/memory/new/operator_new

std::vector의 size와 capacity에 대해서 제대로 알고있자

Sun, 11 Dec 2016 13:58:16 +0900

std::vector를 제대로 알고, 제대로 쓰고 있는가를 파악할 때 내가 자주 하는 질문은

reserve와 resize에 대해 설명해 보세요.

의외로 많은 프로그래머가 제대로 대답하지 못한다.

저 질문을 대답하기 위해서는 size와 capacity에 대해서 잘 알고 있어야 하는데..

사실, std::vector을 사용하기에 앞서 어떻게 구현이 되어있을까? 라고 고민을 해보면 추측할 수 있는 문제가 아닌가 하는 안타까움이 들때가 많다.

이제 막 입문하는 사람은 그렇다 치고, 어느정도 사용하다보면, 당연히 가지게 되는 의문과 고민, 추측이 아닌가?

그것은 나만 기대하는 욕심인 것인가?

가상 소멸자(virtual destructor)에 대한 정확한 이해

Sun, 11 Dec 2016 12:48:08 +0900

C++입문자들이 가상 소멸자에대해서 잘 모르는 것을 많이 봤다.

또, 어느정도 했다는 프로그래머중에서도 정확히는 모르는 사람들이 꽤 있드라…

“Effective C++ 항목7” 에 이 부분에 대한 설명이 있지만, 초보자들이 이해하기에는 다소 어려움이 있어 보여, 이부분에 대해 이해도를 높여 보고자 한다.

(다형성을 가진 virtual class에서) 가상 소멸자(virtual destructor)를 사용하지 않으면 문제는 무엇인가?

라는 질문을 했을때 다음과 같은 대답을 한다면 70점을 줄 것이다.

메모리 릭이 발생합니다

소멸자의 호출여부를 제대로 알고 있어야 100점이라고 할 수 있다. 대략

tuple의 모든 타입이 arithmetic type 인지 알아내는 템플릿 클래스

Tue, 13 Sep 2016 12:04:23 +0900

최근에 C#으로 코딩좀 하고 있는데…

역시 c++의 강력한 template이 그립다..

개인적으로 OOP형태의 언어에서는 c++의 template 때문에 c++을 버릴 수 없을 것 같다. ㅠ

필요할 것 같아서 작성했는데…

std::is_arithmetic 은 integral type(short, int, __int64 …) 이나 floating-point type(float, double) 이면 true이다.

이걸 tuple의 모든 항목이 true인지 검사하는 템플릿 클래스를 만들어 보았다.

참고로, std::is_arithmetic< std::tuple<…> >::value = false 이다.

template<class Tuple>
struct IsTupleAllArithmetic;

template<class... Args>
struct IsTupleAllArithmetic< std::tuple<Args...> >
{
 template<class Tuple>
 struct IsInternal;

 template<class... Args>
 struct IsInternal< std::tuple<Args...> >
 {
 constexpr bool operator()() const noexcept
 {
 return operator()(std::integral_constant<size_t, 0>());
 }

 template<size_t INDEX>
 constexpr bool operator()(std::integral_constant<size_t, INDEX>) const noexcept
 {
 return std::is_arithmetic< std::tuple_element<INDEX, std::tuple<Args...> >::type >::value
 && operator()(std::integral_constant<size_t, INDEX + 1>());
 }

 template<>
 constexpr bool operator()(std::integral_constant<size_t, std::tuple_size< std::tuple<Args...> >::value>) const noexcept
 {
 return true;
 }
 };

 static constexpr bool value = IsInternal< std::tuple<Args...> >()();
};

assert(std::is_arithmetic< std::tuple<int, __int64, float, double> >::value == false);
assert(IsTupleAllArithmetic< std::tuple<int, __int64, float, double> >::value == true);
assert(IsTupleAllArithmetic< std::tuple<int, __int64*, float, double> >::value == false);
assert(IsTupleAllArithmetic< std::tuple<int, __int64, std::string, double> >::value == false);

응용하면 std::is_integral, std::is_floating_point, std::is_same 등도 만들 수 있다.

swap을 사용하면 최적화 할 수 있다.

Thu, 05 May 2016 00:59:14 +0900

Lock을 잡는 scope는 최소화 해야 하는 것은 잘 알고 있을 것이다.

swap을 활용하면 더 좋다는 것에 대해서 이야기 해보려고 한다.

개발을 하다보면 map을 만들어 놓고 객체를 등록하고, 찾고, 제거하는 일을 많이 하게 된다.

예를 들어 다음과 같은 Manager class를 만들어 사용한다고 하자

class Manager
{
private:
 std::map< int, std::unique_ptr<Foo> > _cont;

public:
 bool Register(int id, std::unique_ptr<Foo>& ptr)
 {
 return _cont.insert({ id, std::move(ptr) }).second;
 }

 bool Remove(int id)
 {
 return (_cont.erase(id) > 0);
 }
};

만약 Manager가 멀티쓰레드 환경에서 thread safe해져야 한다면,

lock free container를 도입하거나,

std::map(set) insert 정확하게 사용하기

Sun, 17 Apr 2016 11:53:21 +0900

꽤나 많은 프로그래머들이 std::map insert 의 사용을 잘 못 하고 있는 경우가 있어서, 오늘은 그것에 대해 이야기 하려고 한다.

우선 std::map의 insert의 기본형을 보면 다음과 같다.

pair<iterator,bool> insert (const pair<const Key, Type>& val);

여기서 중요한점은 리턴값으로 pair를 돌려주고 있는데, 이 리턴값의 의미를 정확히 이해 하고 있어야 한다.

insert 결과	첫번째(iterator)	두번째(bool)	언제 발생
성공	insert되어진 element의 iterator	true	중복된 Key가 존재 하지 않을때
실패	중복된 Key의 element의 iterator	false	중복된 Key가 존재 할때

insert를 한다는 것도 내부적으로 insert할 위치를 찾아가며, (이는 Red-black tree 를 구성 하려면 당연하다.)