array

固定長配列クラス

元ネタはboost::array

#include <algorithm>

namespace shand {

template <class Type, size_t Size>
class array {
public:
    Type element_[Size];

public:
    typedef Type&                                       reference;
    typedef Type                                        difference_type;
    typedef Type                                        value_type;
    typedef Type*                                       iterator;
    typedef const Type*                                 const_iterator;

#if defined(_MSC_VER) && _MSC_VER <= 1201
    typedef std::reverse_iterator<iterator, Type>       reverse_iterator;
    typedef std::reverse_iterator<const_iterator, Type> const_reverse_iterator;
#else
    typedef std::reverse_iterator<iterator>             reverse_iterator;
    typedef std::reverse_iterator<const_iterator>       const_reverse_iterator;
#endif

public:
    // 添字での要素参照
    Type& operator[](int index)
    {
        return element_[index];
    }

    const Type& operator[](int index) const
    {
        return element_[index];
    }

    // 配列サイズ取得
    int size() const { return Size; }

    // 先頭要素へのイテレータ取得
    iterator        begin()         { return element_; }
    const_iterator  begin() const   { return element_; }

    // 最後尾要素へのイテレータ取得
    iterator        end()           { return element_ + Size; }
    const_iterator  end() const     { return element_ + Size; }

    reverse_iterator        rbegin()        { return reverse_iterator(end()); }
    const_reverse_iterator  rbegin() const  { return const_reverse_iterator(end()); }

    reverse_iterator        rend()          { return reverse_iterator(begin()); }
    const_reverse_iterator  rend() const    { return const_reverse_iterator(begin()); }
};

// 比較演算子
template <typename Type, size_t Size>
bool operator== (const shand::array<Type, Size> &lhs, const shand::array<Type, Size> &rhs)
{
    return std::equal(lhs.begin(), lhs.end(), rhs.begin());
}

template <typename Type, size_t Size>
bool operator!= (const shand::array<Type, Size> &lhs, const shand::array<Type, Size> &rhs)
{
    return !(lhs == rhs);
}

template <typename Type, size_t Size>
bool operator< (const shand::array<Type, Size> &lhs, const shand::array<Type, Size> &rhs)
{
    return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
}

template <typename Type, size_t Size>
bool operator> (const shand::array<Type, Size> &lhs, const shand::array<Type, Size> &rhs)
{
    return rhs < lhs;
}

template <typename Type, size_t Size>
bool operator<= (const shand::array<Type, Size> &lhs, const shand::array<Type, Size> &rhs)
{
    return !(rhs < lhs);
}

template <typename Type, size_t Size>
bool operator>= (const shand::array<Type, Size> &lhs, const shand::array<Type, Size> &rhs)
{
    return !(lhs < rhs);
}

} // namespace shand

#include <iostream>
#include <shand/array.hpp>

using namespace std;
using namespace shand;

int main()
{
    array<int, 3> ar = { 3, 1, 4 }; // 配列と同様の初期化

    // 添字での参照
    ar[1] = 2;

    // 要素数取得
    const int size = ar.size();

    // イテレータでループ
    for (array<int, 3>::iterator it = ar.begin(); it != ar.end(); ++it)
        cout << *it << endl;

    return 0;
}

地味に便利

※
2007/10/04 更新...reference型, difference_type型, value_type型追加

ライブラリまとめ