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

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 등도 만들 수 있다.