#include <cstddef>

#include <stdexcept>

#include <boost/assert.hpp>

 

// Handles broken standard libraries better than <iterator>

#include <boost/detail/iterator.hpp>

#include <boost/throw_exception.hpp>

#include <algorithm>

 

// FIXES for broken compilers

#include <boost/config.hpp>

 

 

namespace kimi_boost {

 

       // 固定大小的数组

    template<class T, std::size_t N>

    class array {

      public:

        T elems[N];    // fixed-size array of elements of type T

 

      public:

        //与std:vector完全相同的类型定义

        typedef T              value_type;

        typedef T*             iterator;

        typedef const T*       const_iterator;

        typedef T&             reference;

        typedef const T&       const_reference;

        typedef std::size_t    size_type;

        typedef std::ptrdiff_t difference_type;

        typedef std::reverse_iterator<iterator> reverse_iterator;

        typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

 

        // iterator support

        iterator begin() { return elems; }

        const_iterator begin() const { return elems; }

        iterator end() { return elems+N; }

        const_iterator end() const { return elems+N; }

 

        // reverse iterator support

        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());}

 

        // operator[]

        reference operator[](size_type i)

        {

            BOOST_ASSERT( i < N && "out of range" );

            return elems[i];

        }

       

        const_reference operator[](size_type i) const

        {    

            BOOST_ASSERT( i < N && "out of range" );

            return elems[i];

        }

 

        // at() with range check

        reference at(size_type i) { rangecheck(i); return elems[i]; }

        const_reference at(size_type i) const { rangecheck(i); return elems[i]; }

        // front() and back()

        reference front() { return elems[0]; }  

        const_reference front() const {return elems[0];}

        reference back() { return elems[N-1]; }

        const_reference back() const { return elems[N-1]; }

        // size is constant

        static size_type size() { return N; }

              static size_type capacity() { return N; }

        static bool empty() { return false; }

        static size_type max_size() { return N; }

        //enum { static_size = N };

 

        // swap (note: linear complexity)

        void swap (array<T,N>& y) {std::swap_ranges(begin(),end(),y.begin());}

 

        // direct access to data (read-only)

        const T* data() const { return elems; }

        T* data() { return elems; }

 

        // use array as C array (direct read/write access to data)

        T* c_array() { return elems; }

 

        //类型安全吗?T2一定能转换为T吗?

        template <typename T2>

        array<T,N>& operator= (const array<T2,N>& rhs) {

            std::copy(rhs.begin(),rhs.end(), begin());

            return *this;

        }

 

        // assign one value to all elements

        void assign (const T& value){std::fill_n(begin(),N,value);}

 

        // check range (may be private because it is static)

        static void rangecheck (size_type i) {

            if (i >= size()) {

                throw std::range_error("array<>: index out of range");

            }

        }

 

    };

 

 

 

 

    // comparisons

    template<class T, std::size_t N>

    bool operator== (const array<T,N>& x, const array<T,N>& y) {

        return std::equal(x.begin(), x.end(), y.begin());

    }

    template<class T, std::size_t N>

    bool operator< (const array<T,N>& x, const array<T,N>& y) {

        return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end());

    }

    template<class T, std::size_t N>

    bool operator!= (const array<T,N>& x, const array<T,N>& y) {

        return !(x==y);

    }

    template<class T, std::size_t N>

    bool operator> (const array<T,N>& x, const array<T,N>& y) {

        return y<x;

    }

    template<class T, std::size_t N>

    bool operator<= (const array<T,N>& x, const array<T,N>& y) {

        return !(y<x);

    }

    template<class T, std::size_t N>

    bool operator>= (const array<T,N>& x, const array<T,N>& y) {

        return !(x<y);

    }

 

    // global swap()

    template<class T, std::size_t N>

    inline void swap (array<T,N>& x, array<T,N>& y) {

        x.swap(y);

    }

 

} /* namespace kimi_boost */

 

 


本文来源：http://blog.csdn.net/laibach0304/archive/2007/08/24/1758078.aspx