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

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

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值