boost::array库的使用

namespace boost {
template<typename T, std::size_t N> class array;
template<typename T, std::size_t N> void swap(array<T, N>&, array<T, N>&);
template<typename T, std::size_t N>
bool operator==(const array<T, N>&, const array<T, N>&);
template<typename T, std::size_t N>
bool operator!=(const array<T, N>&, const array<T, N>&);
template<typename T, std::size_t N>
bool operator<(const array<T, N>&, const array<T, N>&);
template<typename T, std::size_t N>
bool operator>(const array<T, N>&, const array<T, N>&);
template<typename T, std::size_t N>
bool operator<=(const array<T, N>&, const array<T, N>&);
template<typename T, std::size_t N>
bool operator>=(const array<T, N>&, const array<T, N>&);
}

// In header: <boost/array.hpp>

template<typename T, std::size_t N>
class array {
public:
// types
typedef T                                     value_type;
typedef T*                                    iterator;
typedef const T*                              const_iterator;
typedef std::reverse_iterator<iterator>       reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
typedef T&                                    reference;
typedef const T&                              const_reference;
typedef std::size_t                           size_type;
typedef std::ptrdiff_t                        difference_type;

// static constants
static const size_type static_size = N;

// construct/copy/destruct
template<typename U> array& operator=(const array<U, N>&);

// iterator support
iterator begin();
const_iterator begin() const;
iterator end();
const_iterator end() const;

// reverse iterator support
reverse_iterator rbegin();
const_reverse_iterator rbegin() const;
reverse_iterator rend();
const_reverse_iterator rend() const;

// capacity
size_type size();
bool empty();
size_type max_size();

// element access
reference operator[](size_type);
const_reference operator[](size_type) const;
reference at(size_type);
const_reference at(size_type) const;
reference front();
const_reference front() const;
reference back();
const_reference back() const;
const T* data() const;
T* c_array();

// modifiers
void swap(array<T, N>&);
void assign(const T&);

// public data members
T elems
;
};

// specialized algorithms
template<typename T, std::size_t N> void swap(array<T, N>&, array<T, N>&);

// comparisons
template<typename T, std::size_t N>
bool operator==(const array<T, N>&, const array<T, N>&);
template<typename T, std::size_t N>
bool operator!=(const array<T, N>&, const array<T, N>&);
template<typename T, std::size_t N>
bool operator<(const array<T, N>&, const array<T, N>&);
template<typename T, std::size_t N>
bool operator>(const array<T, N>&, const array<T, N>&);
template<typename T, std::size_t N>
bool operator<=(const array<T, N>&, const array<T, N>&);
template<typename T, std::size_t N>
bool operator>=(const array<T, N>&, const array<T, N>&);

/**
@author	Amiber
@date 2012-12-14
@brief boost::array
**/

#include <iostream>
#include <cstring>
#include <algorithm>
#include <functional>
#include <iterator>

#include <boost/array.hpp>
#include <boost/typeof/typeof.hpp>
#include <boost/foreach.hpp>

int main(int argc,char* argv[])
{
boost::array<int,4> arrf={1,2,3,4};//=operator

boost::array<int,4> arrs={4,3,2,1};//=operator

arrs = arrf ;//=operator(const &)

/**
begin();
end():
iterator
**/
boost::array<int,4>::iterator iter;

for(iter= arrs.begin();iter!=arrs.end();iter++)
{
std::cout<<*iter<<' ';
}

std::cout<<std::endl;

/**
BOOST_FROEACH
BOOST_TYPEOF
**/
BOOST_FOREACH(BOOST_TYPEOF(*arrs.begin()) elem,arrs)
{
std::cout<<elem<<' ';
}

std::cout<<std::endl;

/**
rbegin()
rend();
reverse_iterator
**/
boost::array<int,4>::reverse_iterator rIter;

for(rIter = arrs.rbegin();rIter!=arrs.rend();rIter++)
{
std::cout<<*rIter<<' ';
}

std::cout<<std::endl;
/**
BOOST_FOREACH
BOOST_TYPEOF
**/
BOOST_FOREACH(BOOST_TYPEOF(*arrs.rbegin()) elem,arrs)
{
std::cout<<elem<<' ';
}
std::cout<<std::endl;

/**
size()
operator []
at()
**/
for(std::size_t i =0;i<arrs.size();i++)
{
std::cout<<arrs[i]<<' ';
std::cout<<arrs.at(i)<<' ';
}

std::cout<<std::endl;
/**
back()
front()
**/

std::cout<<arrs.back()<<std::endl;
std::cout<<arrs.front()<<std::endl;

/**
data()
c_array()
**/

const int* dt = arrs.data();
/*dt[0] = -1;

std::copy(arrs.begin(),arrs.end(),std::ostream_iterator<int>(std::cout," "));
std::cout<<std::endl;
*/
int* dtN = arrs.c_array();

dtN[0] = 1;
std::copy(arrs.begin(),arrs.end(),std::ostream_iterator<int>(std::cout," "));

/**
assign
**/

arrs.assign(10);

std::cout<<std::endl;
std::copy(arrs.begin(),arrs.end(),std::ostream_iterator<int>(std::cout," "));
std::cout<<std::endl;

/**
swap
**/

arrs.swap(arrf);

BOOST_FOREACH(BOOST_TYPEOF(*arrs.begin()) elem , arrs)
{
std::cout<<elem<<' ';
}
return 0;
}