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(<chmetcnv w:st="on" tcsc="0" numbertype="1" negative="False" hasspace="False" sourcevalue="3.14" unitname="F">3.14f</chmetcnv>);

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

18467

6334

26500

19169

15724

11478

29358

26962

24464

5705

28145

23281

16827

9961

491

2995

11942

4827

5436

3.14

32391

14604

3902

153

292

12382

17421

18716

19718

19895