boost.array源码整理和使用说明

Source

#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 */

Test code

template<typename T>

struct generator

{

       T operator()()

       {return static_cast<T>(::rand());}

};

 

template<typename T>

struct displayer

{

       void operator()(const T& t)

       {

              std::cout<<t<<std::endl;

       }

};

 

 

 

void array_test()

{

       using kimi_boost::array;

       array<int,10> ai;

       array<float,10> af;

       std::generate(ai.begin(),ai.end(),generator<int>());

       std::for_each(ai.begin(),ai.end(),displayer<int>());

 

       std::cout<<std::endl;

       std::generate(ai.rbegin(),ai.rend(),generator<int>());

       std::for_each(ai.rbegin(),ai.rend(),displayer<int>());

 

       ai.assign(10);

       af.assign( 3.14f );

       std::for_each(ai.begin(),ai.end(),displayer<int>());

       std::for_each(af.begin(),af.end(),displayer<float>());

 

       array<int,10> ai2;

       std::generate(ai2.begin(),ai2.end(),generator<int>());

       ai.swap(ai2);

       std::for_each(ai.begin(),ai.end(),displayer<int>());

       std::for_each(ai2.begin(),ai2.end(),displayer<int>());

}

Output

41

18467

6334

26500

19169

15724

11478

29358

26962

24464

 

5705

28145

23281

16827

9961

491

2995

11942

4827

5436

10

10

10

10

10

10

10

10

10

10

3.14

3.14

3.14

3.14

3.14

3.14

3.14

3.14

3.14

3.14

32391

14604

3902

153

292

12382

17421

18716

19718

19895

10

10

10

10

10

10

10

10

10

10