gloomycoder

. std::tr1::array 이란?

. 내부 구조는 기존 배열과 동일하지만 std::algorithm 에 적용하기 쉽게 랩핑되어 있습니다.

   1: // TEMPLATE CLASS array

   2: template<class _Ty,

   3:    size_t _Size>

   4:    class array

   5:    {   // fixed size array of values

   6: public:

   7:    enum {_EEN_SIZE = _Size};   // helper for expression evaluator

   8:  

   9:    typedef array<_Ty, _Size> _Myt;

  10:    typedef _Ty value_type;

  11:    typedef size_t size_type;

  12:    typedef ptrdiff_t difference_type;

  13:    typedef _Ty *pointer;

  14:    typedef const _Ty *const_pointer;

  15:    typedef _Ty& reference;

  16:    typedef const _Ty& const_reference;

  17:  

  18:    typedef _Array_iterator<_Ty, _Size> iterator;

  19:    typedef _Array_const_iterator<_Ty, _Size> const_iterator;

  20:  

  21:    typedef std::reverse_iterator<iterator> reverse_iterator;

  22:    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

  23:  

  24:    void assign(const _Ty& _Value)

  25:       {   // assign value to all elements

  26:       std::fill_n(_Elems, _Size, _Value);

  27:       }

  28:  

  29:    void swap(_Myt& _Other)

  30:       {   // swap contents with _Other

  31:       std::swap_ranges(_Other.begin(), _Other.end(), begin());

  32:       }

  33:  

  34:    iterator begin()

  35:       {   // return iterator for beginning of mutable sequence

  36:       return (iterator(&_Elems[0], 0));

  37:       }

  38:  

  39:    const_iterator begin() const

  40:       {   // return iterator for beginning of nonmutable sequence

  41:       return (const_iterator((pointer)&_Elems[0], 0));

  42:       }

  43:  

  44:    iterator end()

  45:       {   // return iterator for end of mutable sequence

  46:       return (iterator(&_Elems[0], _Size));

  47:       }

  48:  

  49:    const_iterator end() const

  50:       {   // return iterator for beginning of nonmutable sequence

  51:       return (const_iterator((pointer)&_Elems[0], _Size));

  52:       }

  53:  

  54:    reverse_iterator rbegin()

  55:       {   // return iterator for beginning of reversed mutable sequence

  56:       return (reverse_iterator(end()));

  57:       }

  58:  

  59:    const_reverse_iterator rbegin() const

  60:       {   // return iterator for beginning of reversed nonmutable sequence

  61:       return (const_reverse_iterator(end()));

  62:       }

  63:  

  64:    reverse_iterator rend()

  65:       {   // return iterator for end of reversed mutable sequence

  66:       return (reverse_iterator(begin()));

  67:       }

  68:  

  69:    const_reverse_iterator rend() const

  70:       {   // return iterator for end of reversed nonmutable sequence

  71:       return (const_reverse_iterator(begin()));

  72:       }

  73:  

  74:    size_type size() const

  75:       {   // return length of sequence

  76:       return (_Size);

  77:       }

  78:  

  79:    size_type max_size() const

  80:       {   // return maximum possible length of sequence

  81:       return (_Size);

  82:       }

  83:  

  84:    bool empty() const

  85:       {   // test if sequence is empty

  86:       return (_Size == 0);

  87:       }

  88:  

  89:    reference at(size_type _Pos)

  90:       {   // subscript mutable sequence with checking

  91:       if (_Size <= _Pos)

  92:          _Xoutrange();

  93:       return (_Elems[_Pos]);

  94:       }

  95:  

  96:    const_reference at(size_type _Pos) const

  97:       {   // subscript nonmutable sequence with checking

  98:       if (_Size <= _Pos)

  99:          _Xoutrange();

 100:       return (_Elems[_Pos]);

 101:       }

 102:  

 103:    reference operator[](size_type _Pos)

 104:       {   // subscript mutable sequence

 105:  #if _HAS_ITERATOR_DEBUGGING

 106:       if (_Size <= _Pos)

 107:          _DEBUG_ERROR("array subscript out of range");

 108:  #endif /* _HAS_ITERATOR_DEBUGGING */

 109:  

 110:       _SCL_SECURE_VALIDATE_RANGE(_Pos < _Size);

 111:  

 112:       return (_Elems[_Pos]);

 113:       }

 114:  

 115:    const_reference operator[](size_type _Pos) const

 116:       {   // subscript nonmutable sequence

 117:  #if _HAS_ITERATOR_DEBUGGING

 118:       if (_Size <= _Pos)

 119:          _DEBUG_ERROR("array subscript out of range");

 120:  #endif /* _HAS_ITERATOR_DEBUGGING */

 121:  

 122:       _SCL_SECURE_VALIDATE_RANGE(_Pos < _Size);

 123:  

 124:       return (_Elems[_Pos]);

 125:       }

 126:  

 127:    reference front()

 128:       {   // return first element of mutable sequence

 129:  #if _HAS_ITERATOR_DEBUGGING

 130:       if (_Size == 0)

 131:          _DEBUG_ERROR("array<T, 0>::front() invalid");

 132:  #endif /* _HAS_ITERATOR_DEBUGGING */

 133:  

 134:       _SCL_SECURE_VALIDATE_RANGE(0 < _Size);

 135:  

 136:       return (_Elems[0]);

 137:       }

 138:  

 139:    const_reference front() const

 140:       {   // return first element of nonmutable sequence

 141:  #if _HAS_ITERATOR_DEBUGGING

 142:       if (_Size == 0)

 143:          _DEBUG_ERROR("array<T, 0>::front() invalid");

 144:  #endif /* _HAS_ITERATOR_DEBUGGING */

 145:  

 146:       _SCL_SECURE_VALIDATE_RANGE(0 < _Size);

 147:  

 148:       return (_Elems[0]);

 149:       }

 150:  

 151:    reference back()

 152:       {   // return last element of mutable sequence

 153:  #if _HAS_ITERATOR_DEBUGGING

 154:       if (_Size == 0)

 155:          _DEBUG_ERROR("array<T, 0>::back() invalid");

 156:  #endif /* _HAS_ITERATOR_DEBUGGING */

 157:  

 158:       _SCL_SECURE_VALIDATE_RANGE(0 < _Size);

 159:  

 160:       return (_Elems[_Size - 1]);

 161:       }

 162:  

 163:    const_reference back() const

 164:       {   // return last element of nonmutable sequence

 165:  #if _HAS_ITERATOR_DEBUGGING

 166:       if (_Size == 0)

 167:          _DEBUG_ERROR("array<T, 0>::back() invalid");

 168:  #endif /* _HAS_ITERATOR_DEBUGGING */

 169:  

 170:       _SCL_SECURE_VALIDATE_RANGE(0 < _Size);

 171:  

 172:       return (_Elems[_Size - 1]);

 173:       }

 174:  

 175:    _Ty *data()

 176:       {   // return pointer to mutable data array

 177:       return (_Elems);

 178:       }

 179:  

 180:    const _Ty *data() const

 181:       {   // return pointer to nonmutable data array

 182:       return (_Elems);

 183:       }

 184:  

 185:    _Ty _Elems[_Size == 0 ? 1 : _Size];

 186:    };

. 실제 구현 코드이며 소스 젤 아래 부분을 보시면 _Ty 에 대해 _Size 만큼 배열을 잡는걸 볼 수 있습니다. (0 이면 크기를 1로 잡는군요 –_-ㅋ)

. 실제 배열을 가지고 있으며 인터페이스는 size() 와 max_size() 가 동일하게 _Size 를 돌려주는 애매한 상황만 말고는 다들 이름만 보고도 이해가 갈만합니다.

. 요즘 배열보다는 array 를 더 자주 사용하고있습니다. 보기도 좋군요 @_@ㅋ (개인적인 취향입니다)

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.