stl on yonmy

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

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

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의 출력결과가 어떻게 다른지 확인해 보면….

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

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

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

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

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

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

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

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

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

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 를 구성 하려면 당연하다.)