STL(14)变动型算法

template<class InputIterator, class
OutputIterator>

OutputIterator copy (InputIterator first, InputIterator
last, OutputIterator result)

{

while (first!=last) {

*result = *first;

++result; ++first;

}

return result;

}

-----------------------------------------------------------------------------------------------

// copy algorithm example

#include <iostream> // std::cout

#include <algorithm> // std::copy

#include <vector> // std::vector

int main () {

int myints[]={10,20,30,40,50,60,70};

std::vector<int> myvector (7);

std::copy ( myints, myints+7, myvector.begin() );

std::cout << "myvector contains:";

for (std::vector<int>::iterator it =
myvector.begin(); it!=myvector.end(); ++it)

std::cout << ‘ ‘ << *it;

std::cout << ‘\n‘;

return 0;

}??

--------------------------------------------------------------------------------------

Output:

myvector contains: 10 20 30 40 50 60 70

解释：遍历赋值

看核心代码，?while (first!=last) { *result = *first; ++result;
++first; } 必须有"operator="的支持。

思考：如果OutputIterator result此时没有分配空间，会调用operator=吗？

##最终会调用对象的operator=,那么，outputIterator result一定要分配了空间，会有对象。所以在copy之前，最好用resize()来分配空间，并产生对象：?std::vector<Demo> others;
others.resize(demos.size());

???

???????r

template<class InputIterator, class Size, class
OutputIterator>

OutputIterator copy_n (InputIterator first, Size n,
OutputIterator result)

{

while (n>0) {

*result = *first;

++result; ++first;

--n;

}

return result;

}

-------------------------------------------------------------------------------

??// copy_n algorithm example

#include <iostream> // std::cout

#include <algorithm> // std::copy

#include <vector> // std::vector

int main () {

int myints[]={10,20,30,40,50,60,70};

std::vector<int> myvector;

myvector.resize(7); // allocate space for 7 elements

std::copy_n ( myints, 7, myvector.begin() );

std::cout << "myvector contains:";

for (std::vector<int>::iterator it =
myvector.begin(); it!=myvector.end(); ++it)

std::cout << ‘ ‘ << *it;

std::cout << ‘\n‘;

return 0;

}

----------------------------------------------------------------------------------------------

Output:

myvector contains: 10 20 30 40 50 60 70

解释：

------------------------------------vs2015-----------------------------------

// TEMPLATE FUNCTION copy_n

template<class _InIt,class _Diff,class _OutIt>
inline

_OutIt _Copy_n_unchecked2(_InIt _First, _Diff _Count,

_OutIt _Dest, input_iterator_tag)

{ // copy [_First, _First + _Count) to [_Dest, ...),
input iterators

if (0 < _Count)

{

*_Dest = *_First;

while (0 < --_Count)

*++_Dest = *++_First;

return (++_Dest);

}

return (_Dest);

}?????

???

template <class InputIterator, class OutputIterator,
class UnaryPredicate>

OutputIterator copy_if (InputIterator first,
InputIterator last,

OutputIterator result, UnaryPredicate pred)

{

while (first!=last) {

if (pred(*first)) {

*result = *first;

++result;

}

++first;

}

return result;

}

-----------------------------------------------------------------------------------

??// copy_if example

#include <iostream> // std::cout

#include <algorithm> // std::copy_if, std::distance

#include <vector> // std::vector

int main () {

std::vector<int> foo = {25,15,5,-5,-15};

std::vector<int> bar (foo.size());

// copy only positive numbers:

auto it = std::copy_if (foo.begin(), foo.end(),
bar.begin(), [](int i){return !(i<0);} );

bar.resize(std::distance(bar.begin(),it)); // shrink
container to new size

std::cout << "bar contains:";

for (int& x: bar) std::cout << ‘ ‘ << x;

std::cout << ‘\n‘;

return 0;

}

-------------------------------------------------------------------------------------------

Output:

bar contains: 25 15 5

解释：copy_if算法很多应用场景：如在《学生信息管理系统》中查询功能，就能用copy_if简化写法。

-----------------------------------vs2015--------------------------------------------

// TEMPLATE FUNCTION copy_if

template<class _InIt,

class _OutIt,

class _Pr> inline

_OutIt _Copy_if_unchecked(_InIt _First, _InIt _Last,
_OutIt _Dest,

_Pr& _Pred)

{ // copy each satisfying _Pred

for (; _First != _Last; ++_First)

if (_Pred(*_First))

{ // validate _Dest and copy

_DEBUG_POINTER(_Dest);

*_Dest++ = *_First;

}

return (_Dest);

}???????

????

template<class BidirectionalIterator1, class
BidirectionalIterator2>

BidirectionalIterator2 copy_backward (
BidirectionalIterator1 first,

BidirectionalIterator1 last,

BidirectionalIterator2 result )

{

while (last!=first) *(--result) = *(--last);

return result;

}

-----------------------------------------------------------------------------

// copy_backward example

#include <iostream> // std::cout

#include <algorithm> // std::copy_backward

#include <vector> // std::vector

int main () {

std::vector<int> myvector;

// set some values:

for (int i=1; i<=5; i++)

myvector.push_back(i*10); // myvector: 10 20 30 40 50

myvector.resize(myvector.size()+3); // allocate space
for 3 more elements

std::copy_backward ( myvector.begin(),
myvector.begin()+5, myvector.end() );

std::cout << "myvector contains:";

for (std::vector<int>::iterator
it=myvector.begin(); it!=myvector.end(); ++it)

std::cout << ‘ ‘ << *it;

std::cout << ‘\n‘;

return 0;

}

----------------------------------------------------------------------------------------

??解释：result这里应该是end(),传参时要注意。

核心代码while (last!=first) *(--result) = *(--last); return
result;? 拿着result往前copy

------------------------------------vs2015--------------------------------

// TEMPLATE FUNCTION copy_backward

template<class _BidIt1,class _BidIt2> inline

_BidIt2 _Copy_backward_memmove(_BidIt1 _First, _BidIt1
_Last,

_BidIt2 _Dest)

{ // implement copy_backward-like function as memmove

const char * const _First_ch = reinterpret_cast<const
char *>(_First);

const char * const _Last_ch = reinterpret_cast<const
char *>(_Last);

char * const _Dest_ch = reinterpret_cast<char
*>(_Dest);

const size_t _Count = _Last_ch - _First_ch;

return (static_cast<_BidIt2>(

_CSTD memmove(_Dest_ch - _Count, _First_ch, _Count)));

}????

???

template <class T> void swap ( T& a, T& b
)

{

T c(a); a=b; b=c;

}

----------------------------------

??// swap algorithm example (C++98)

#include <iostream> // std::cout

#include <algorithm> // std::swap

#include <vector> // std::vector

int main () {

int x=10, y=20; // x:10 y:20

std::swap(x,y); // x:20 y:10

std::vector<int> foo (4,x), bar (6,y); // foo:4x20
bar:6x10

std::swap(foo,bar); // foo:6x10 bar:4x20

std::cout << "foo contains:";

for (std::vector<int>::iterator it=foo.begin();
it!=foo.end(); ++it)

std::cout << ‘ ‘ << *it;

std::cout << ‘\n‘;

return 0;

}

------------------------------------------------------------------------

??Output:

foo contains: 10 10 10 10 10 10

解释：

template <class T> void swap (T& a, T& b)

{

T c(std::move(a)); a=std::move(b); b=std::move(c);

}

template <class T, size_t N> void swap (T
(&a)[N], T (&b)[N])

{

for (size_t i = 0; i<N; ++i) swap (a[i],b[i]);

}

------------------------------------------------------------------

// swap algorithm example (C++98)

#include <iostream> // std::cout

#include <algorithm> // std::swap

#include <vector> // std::vector

int main () {

int x=10, y=20; // x:10 y:20

std::swap(x,y); // x:20 y:10

std::vector<int> foo (4,x), bar (6,y); // foo:4x20
bar:6x10

std::swap(foo,bar); // foo:6x10 bar:4x20

std::cout << "foo contains:";

for (std::vector<int>::iterator it=foo.begin();
it!=foo.end(); ++it)

std::cout << ‘ ‘ << *it;

std::cout << ‘\n‘;

return 0;

}

----------------------------------------------------------------------

Output:

foo contains: 10 10 10 10 10 10

解释 ： 交换数组

??

------------------------------------------vs2015--------------------------------------

???

???

???

template<class ForwardIterator1, class
ForwardIterator2>

ForwardIterator2 swap_ranges (ForwardIterator1 first1,
ForwardIterator1 last1,

ForwardIterator2 first2)

{

while (first1!=last1) {

swap (*first1, *first2);

++first1; ++first2;

}

return first2;

}

---------------------------------------------------------------------------------------------

// swap_ranges example

#include <iostream> // std::cout

#include <algorithm> // std::swap_ranges

#include <vector> // std::vector

int main () {

std::vector<int> foo (5,10); // foo: 10 10 10 10
10

std::vector<int> bar (5,33); // bar: 33 33 33 33
33

std::swap_ranges(foo.begin()+1, foo.end()-1,
bar.begin());

// print out results of swap:

std::cout << "foo contains:";

for (std::vector<int>::iterator it=foo.begin();
it!=foo.end(); ++it)

std::cout << ‘ ‘ << *it;

std::cout << ‘\n‘;

std::cout << "bar contains:";

for (std::vector<int>::iterator it=bar.begin();
it!=bar.end(); ++it)

std::cout << ‘ ‘ << *it;

std::cout << ‘\n‘;

return 0;

}

---------------------------------------------------------------------------------

Output:

foo contains: 10 33 33 33 10

bar contains: 10 10 10 33 33

解释：

-------------------------------vs2015--------------------------------------------

// TEMPLATE FUNCTION swap_ranges

template<class _FwdIt1,

class _FwdIt2> inline

_FwdIt2 _Swap_ranges_unchecked(_FwdIt1 _First1, _FwdIt1
_Last1,

_FwdIt2 _Dest)

{ // swap [_First1, _Last1) with [_Dest, ...)

for (; _First1 != _Last1; ++_First1, (void)++_Dest)

_STD iter_swap(_First1, _Dest);

return (_Dest);

}?????????????

template <class ForwardIterator1, class
ForwardIterator2>

void iter_swap (ForwardIterator1 a, ForwardIterator2 b)

{

swap (*a, *b);

}

------------------------------------------------------------------

??// iter_swap example

#include <iostream> // std::cout

#include <algorithm> // std::iter_swap

#include <vector> // std::vector

int main () {

int myints[]={10,20,30,40,50 }; // myints: 10 20 30 40
50

std::vector<int> myvector (4,99); // myvector: 99
99 99 99

std::iter_swap(myints,myvector.begin()); // myints: [99]
20 30 40 50

// myvector: [10] 99 99 99

std::iter_swap(myints+3,myvector.begin()+2); // myints:
99 20 30 [99] 50

// myvector: 10 99 [40] 99

std::cout << "myvector contains:";

for (std::vector<int>::iterator
it=myvector.begin(); it!=myvector.end(); ++it)

std::cout << ‘ ‘ << *it;

std::cout << ‘\n‘;

return 0;

}

----------------------------------------------------------------------------------

?

??Output:

myvector contains: 10 99 40 99

-------------------------------------vs2015------------------------------------------

?// TEMPLATE FUNCTION iter_swap (from <xutility>)

template<class _FwdIt1, class _FwdIt2> inline

void iter_swap(_FwdIt1 _Left, _FwdIt2 _Right)

{ // swap *_Left and *_Right

swap(*_Left, *_Right);

}????

template <class InputIterator, class OutputIterator,
class UnaryOperator>

OutputIterator transform (InputIterator first1,
InputIterator last1,

OutputIterator result, UnaryOperator op)

{

while (first1 != last1) {

*result = op(*first1); // or:
*result=binary_op(*first1,*first2++);

++result; ++first1;

}

return result;

}

---------------------------------------------------------------------------

// transform algorithm example

#include <iostream> // std::cout

#include <algorithm> // std::transform

#include <vector> // std::vector

#include <functional> // std::plus

int op_increase (int i) { return ++i; }

int main () {

std::vector<int> foo;

std::vector<int> bar;

// set some values:

for (int i=1; i<6; i++)

foo.push_back (i*10); // foo: 10 20 30 40 50

bar.resize(foo.size()); // allocate space

std::transform (foo.begin(), foo.end(), bar.begin(),
op_increase);

// bar: 11 21 31 41 51

// std::plus adds together its two arguments:

std::transform (foo.begin(), foo.end(), bar.begin(),
foo.begin(), std::plus<int>());

// foo: 21 41 61 81 101

std::cout << "foo contains:";

for (std::vector<int>::iterator it=foo.begin();
it!=foo.end(); ++it)

std::cout << ‘ ‘ << *it;

std::cout << ‘\n‘;

return 0;

}

-------------------------------------------------------------------------------------

Output:

foo contains: 21 41 61 81 101

------------------------------vs2015------------------------------------

// TEMPLATE FUNCTION transform WITH UNARY OP 一元运算

template<class _InIt,

class _OutIt,

class _Fn1> inline

_OutIt _Transform_unchecked(_InIt _First, _InIt _Last,

_OutIt _Dest, _Fn1& _Func)

{ // transform [_First, _Last) with _Func

for (; _First != _Last; ++_First, (void)++_Dest)

*_Dest = _Func(*_First);

return (_Dest);

}

---------------------------------------

// TEMPLATE FUNCTION transform WITH BINARY OP 二元运算

template<class _InIt1,

class _InIt2,

class _OutIt,

class _Fn2> inline

_OutIt _Transform_unchecked(_InIt1 _First1, _InIt1
_Last1,

_InIt2 _First2, _OutIt _Dest, _Fn2& _Func)

{ // transform [_First1, _Last1) and [_First2, ...) with
_Func

for (; _First1 != _Last1; ++_First1, (void)++_First2,
++_Dest)

*_Dest = _Func(*_First1, *_First2);

return (_Dest);

}??????????????

template <class ForwardIterator, class T>

void replace (ForwardIterator first, ForwardIterator
last,

const T& old_value, const T& new_value)

{

while (first!=last) {

if (*first == old_value) *first=new_value;

++first;

}

}

------------------------------------------------------------------

// replace algorithm example

#include <iostream> // std::cout

#include <algorithm> // std::replace

#include <vector> // std::vector

int main () {

int myints[] = { 10, 20, 30, 30, 20, 10, 10, 20 };

std::vector<int> myvector (myints, myints+8); //
10 20 30 30 20 10 10 20

std::replace (myvector.begin(), myvector.end(), 20, 99);
// 10 99 30 30 99 10 10 99

std::cout << "myvector contains:";

for (std::vector<int>::iterator
it=myvector.begin(); it!=myvector.end(); ++it)

std::cout << ‘ ‘ << *it;

std::cout << ‘\n‘;

return 0;

}

-------------------------------------------------------------

Output:

myvector contains: 10 99 30 30 99 10 10 99

解释：

-----------------------------------vs2015---------------------------------

??

// TEMPLATE FUNCTION replace

template<class _FwdIt,

class _Ty> inline

void _Replace_unchecked(_FwdIt _First, _FwdIt _Last,

const _Ty& _Oldval, const _Ty& _Newval)

{ // replace each matching _Oldval with _Newval

for (; _First != _Last; ++_First)

if (*_First == _Oldval)

*_First = _Newval;

}?????????

template < class ForwardIterator, class
UnaryPredicate, class T >

void replace_if (ForwardIterator first, ForwardIterator
last,

UnaryPredicate pred, const T& new_value)

{

while (first!=last) {

if (pred(*first)) *first=new_value;

++first;

}

}

------------------------------------------------------------------------

// replace_if example

#include <iostream> // std::cout

#include <algorithm> // std::replace_if

#include <vector> // std::vector

bool IsOdd (int i) { return ((i%2)==1); }

int main () {

std::vector<int> myvector;

// set some values:

for (int i=1; i<10; i++) myvector.push_back(i); // 1
2 3 4 5 6 7 8 9

std::replace_if (myvector.begin(), myvector.end(),
IsOdd, 0); // 0 2 0 4 0 6 0 8 0

std::cout << "myvector contains:";

for (std::vector<int>::iterator
it=myvector.begin(); it!=myvector.end(); ++it)

std::cout << ‘ ‘ << *it;

std::cout << ‘\n‘;

return 0;

}

--------------------------------------------------------------------------------

Output:

myvector contains: 0 2 0 4 0 6 0 8 0

解释： 1 需要operator=的支持 2 里面的判断函数必须返回bool值 3 里面的判断函数接收的是一个指针

----------------------------------------------vs2015-----------------------------------------

// TEMPLATE FUNCTION replace_if

template<class _FwdIt,

class _Pr,

class _Ty> inline

void _Replace_if_unchecked(_FwdIt _First, _FwdIt _Last,
_Pr& _Pred, const _Ty& _Val)

{ // replace each satisfying _Pred with _Val

for (; _First != _Last; ++_First)

if (_Pred(*_First))

*_First = _Val;

}

??????????

???

template <class InputIterator, class OutputIterator,
class T>

OutputIterator replace_copy (InputIterator first,
InputIterator last,

OutputIterator result, const T& old_value, const
T& new_value)

{

while (first!=last) {

*result = (*first==old_value)? new_value: *first;

++first; ++result;

}

return result;

}

---------------------------------------------------------------------------------

// replace_copy example

#include <iostream> // std::cout

#include <algorithm> // std::replace_copy

#include <vector> // std::vector

int main () {

int myints[] = { 10, 20, 30, 30, 20, 10, 10, 20 };

std::vector<int> myvector (8);

std::replace_copy (myints, myints+8, myvector.begin(),
20, 99);

std::cout << "myvector contains:";

for (std::vector<int>::iterator
it=myvector.begin(); it!=myvector.end(); ++it)

std::cout << ‘ ‘ << *it;

std::cout << ‘\n‘;

return 0;

}

------------------------------------------------------------------------------------------

Output:

myvector contains: 10 99 30 30 99 10 10 99

解释：不改变原序列的值，会产生新的序列来接收

核心代码 while (first!=last) { *result = (*first==old_value)?
new_value: *first; ++first; ++result; }?

三目运算赋值，当第1 区间有旧值，则接收新值，否则不变。

??

-------------------------------------vs2015--------------------------------------------------

// TEMPLATE FUNCTION replace_copy

template<class _InIt,class _OutIt,class _Ty> inline

_OutIt _Replace_copy_unchecked(_InIt _First, _InIt
_Last,

_OutIt _Dest, const _Ty& _Oldval, const _Ty&
_Newval)

{ // copy replacing each matching _Oldval with _Newval 与_newval更换每个匹配_oldval复制

for (; _First != _Last; ++_First, (void)++_Dest)

*_Dest = *_First == _Oldval ? _Newval : *_First;

return (_Dest);

}????????????

template <class InputIterator, class OutputIterator,
class UnaryPredicate, class T>

OutputIterator replace_copy_if (InputIterator first,
InputIterator last,

OutputIterator result, UnaryPredicate pred,

const T& new_value)

{

while (first!=last) {

*result = (pred(*first))? new_value: *first;

++first; ++result;

}

return result;

}

--------------------------------------------------------------------------------------------------

// replace_copy_if example

#include <iostream> // std::cout

#include <algorithm> // std::replace_copy_if

#include <vector> // std::vector

bool IsOdd (int i) { return ((i%2)==1); }

int main () {

std::vector<int> foo,bar;

// set some values:

for (int i=1; i<10; i++) foo.push_back(i); // 1 2 3 4
5 6 7 8 9

bar.resize(foo.size()); // allocate space

std::replace_copy_if (foo.begin(), foo.end(),
bar.begin(), IsOdd, 0);

// 0 2 0 4 0 6 0 8 0

std::cout << "bar contains:";

for (std::vector<int>::iterator it=bar.begin();
it!=bar.end(); ++it)

std::cout << ‘ ‘ << *it;

std::cout << ‘\n‘;

return 0;

}

---------------------------------------------------------------------------------

Output:

second contains: 0 2 0 4 0 6 0 8 0

解释：

??核心代码：while (first!=last) { *result = (pred(*first))? new_value:
*first; ++first; ++result; }

三目运算赋值，符合条件则赋新，否则保持不变。

-------------------------------vs2015----------------------------------------

// TEMPLATE FUNCTION replace_copy_if

template<class _InIt,

class _OutIt,

class _Pr,

class _Ty> inline

_OutIt _Replace_copy_if_unchecked(_InIt _First, _InIt
_Last,

_OutIt _Dest, _Pr& _Pred, const _Ty& _Val)

{ // copy replacing each satisfying _Pred with _Val

for (; _First != _Last; ++_First, (void)++_Dest)

*_Dest = _Pred(*_First) ? _Val : *_First;

return (_Dest);

}

??????????????

template <class ForwardIterator, class T>

void fill (ForwardIterator first, ForwardIterator last,
const T& val)

{

while (first != last) {

*first = val;

++first;

}

}

---------------------------------------------------------------------------------

// fill algorithm example

#include <iostream> // std::cout

#include <algorithm> // std::fill

#include <vector> // std::vector

int main () {

std::vector<int> myvector (8); // myvector: 0 0 0
0 0 0 0 0

std::fill (myvector.begin(),myvector.begin()+4,5); //
myvector: 5 5 5 5 0 0 0 0

std::fill (myvector.begin()+3,myvector.end()-2,8); //
myvector: 5 5 5 8 8 8 0 0

std::cout << "myvector contains:";

for (std::vector<int>::iterator
it=myvector.begin(); it!=myvector.end(); ++it)

std::cout << ‘ ‘ << *it;

std::cout << ‘\n‘;

return 0;

}

--------------------------------------------------------------------------------------

Output:

myvector contains: 5 5 5 8 8 8 0 0

解释：

核心代码：while (first != last) { *first = val; ++first; }

????

??????---------------------------------------vs2015---------------------------------------

template<class _FwdIt,

class _Ty> inline

void _Fill_unchecked1(_FwdIt _First, _FwdIt _Last, const
_Ty& _Val, false_type)

{ // copy _Val through [_First, _Last), no special
optimization

for (; _First != _Last; ++_First)

*_First = _Val;

}???

template <class OutputIterator, class Size, class
T>

OutputIterator fill_n (OutputIterator first, Size n,
const T& val)

{

while (n>0) {

*first = val;

++first; --n;

}

return first; // since C++11

}

---------------------------------------------------------------------------------

// fill_n example

#include <iostream> // std::cout

#include <algorithm> // std::fill_n

#include <vector> // std::vector

int main () {

std::vector<int> myvector (8,10); // myvector: 10
10 10 10 10 10 10 10

std::fill_n (myvector.begin(),4,20); // myvector: 20 20
20 20 10 10 10 10

std::fill_n (myvector.begin()+3,3,33); // myvector: 20
20 20 33 33 33 10 10

std::cout << "myvector contains:";

for (std::vector<int>::iterator
it=myvector.begin(); it!=myvector.end(); ++it)

std::cout << ‘ ‘ << *it;

std::cout << ‘\n‘;

return 0;

}

----------------------------------------------------------------------------------------

Output:

myvector contains: 20 20 20 33 33 33 10 10

解释：特别注意空间不够用时，会产生未知错误。

核心代码：while (n>0) { *first = val; ++first; --n; }??? return
first; 返回时，first位置已经改变。

-------------------------------vs2015-------------------------------------------

// TEMPLATE FUNCTION fill_n

template<class _OutIt, class _Diff, class _Ty>
inline

_OutIt _Fill_n_unchecked1(_OutIt _Dest, _Diff _Count,
const _Ty& _Val, false_type)

{ // copy _Val _Count times through [_Dest, ...), no
special optimization

for (; 0 < _Count; --_Count, (void)++_Dest)

*_Dest = _Val;

return (_Dest);

}

template<class _OutIt,

class _Diff, class _Ty> inline

? _OutIt _Fill_n_unchecked1(_OutIt _Dest, _Diff _Count,
const _Ty& _Val, true_type)

{ // copy _Val _Count times through [_Dest, ...), memset
optimization

if (0 < _Count)

{

_CSTD memset(_Dest, _Val, _Count);

return (_Dest + _Count);

}

return (_Dest);

}?????

??

template <class ForwardIterator, class Generator>

void generate ( ForwardIterator first, ForwardIterator
last, Generator gen )

{

while (first != last) {

*first = gen();

++first;

}

}

------------------------------------------------------------------------------------

// generate algorithm example

#include <iostream> // std::cout

#include <algorithm> // std::generate

#include <vector> // std::vector

#include <ctime> // std::time

#include <cstdlib> // std::rand, std::srand

// function generator:

int RandomNumber () { return (std::rand()%100); }

// class generator:

struct c_unique {

int current;

c_unique() {current=0;}

int operator()() {return ++current;}

} UniqueNumber;

int main () {

std::srand ( unsigned ( std::time(0) ) );

std::vector<int> myvector (8);

std::generate (myvector.begin(), myvector.end(),
RandomNumber);

std::cout << "myvector contains:";

for (std::vector<int>::iterator
it=myvector.begin(); it!=myvector.end(); ++it)

std::cout << ‘ ‘ << *it;

std::cout << ‘\n‘;

std::generate (myvector.begin(), myvector.end(),
UniqueNumber);

std::cout << "myvector contains:";

for (std::vector<int>::iterator
it=myvector.begin(); it!=myvector.end(); ++it)

std::cout << ‘ ‘ << *it;

std::cout << ‘\n‘;

return 0;

}

----------------------------------------------------------------------------------

A possible output:

myvector contains: 57 87 76 66 85 54 17 15

myvector contains: 1 2 3 4 5 6 7 8

解释：

??????---------------------------------vs2015-------------------------------------------

??????

template <class OutputIterator, class Size, class
Generator>

void generate_n ( OutputIterator first, Size n,
Generator gen )

{

while (n>0) {

*first = gen();

++first; --n;

}

}

-----------------------------------------------------------------------

// generate_n example

#include <iostream> // std::cout

#include <algorithm> // std::generate_n

int current = 0;

int UniqueNumber () { return ++current; }

int main () {

int myarray[9];

std::generate_n (myarray, 9, UniqueNumber);

std::cout << "myarray contains:";

for (int i=0; i<9; ++i)

std::cout << ‘ ‘ << myarray[i];

std::cout << ‘\n‘;

return 0;

}

---------------------------------------------------------------------------------

A possible output:

myarray contains: 1 2 3 4 5 6 7 8 9

解释：

核心代码：while (n>0) { *first = gen(); ++first; --n; }?

---------------------------------vs2015-----------------------------

// TEMPLATE FUNCTION generate_n

template<class _OutIt, class _Diff, class _Fn0>
inline

_OutIt _Generate_n_unchecked(_OutIt _Dest, _Diff _Count,
_Fn0& _Func)

{ // replace [_Dest, _Dest + _Count) with _Func()

for (; 0 < _Count; --_Count, (void)++_Dest)

*_Dest = _Func();

return (_Dest);

}??????

?????

template <class ForwardIterator, class T>

ForwardIterator remove (ForwardIterator first,
ForwardIterator last, const T& val)

{

ForwardIterator result = first;

while (first!=last) {

if (!(*first == val)) {

*result = *first;

++result;

}

++first;

}

return result;

}

------------------------------------------------------------------------------------------

// remove algorithm example

#include <iostream> // std::cout

#include <algorithm> // std::remove

int main () {

int myints[] = {10,20,30,30,20,10,10,20}; // 10 20 30 30
20 10 10 20

// bounds of range:

int* pbegin = myints; // ^

int* pend = myints+sizeof(myints)/sizeof(int); // ^ ^

pend = std::remove (pbegin, pend, 20); // 10 30 30 10 10
? ? ?

// ^ ^

std::cout << "range contains:";

for (int* p=pbegin; p!=pend; ++p)

std::cout << ‘ ‘ << *p;

std::cout << ‘\n‘;

return 0;

}

---------------------------------------------------------------------------------------

Output:

range contains: 10 30 30 10 10

解释：注意返回值，返回值是移除后最后的end()??

----------------------------------------vs2015-------------------------------------

// TEMPLATE FUNCTION remove

template<class _FwdIt,

class _Ty> inline

_FwdIt _Remove_unchecked(_FwdIt _First, _FwdIt _Last,
const _Ty& _Val)

{ // remove each matching _Val

_First = _Find_unchecked(_First, _Last, _Val);

_FwdIt _Next = _First;

if (_First != _Last)

{

for (++_First; _First != _Last; ++_First)

if (!(*_First == _Val))

*_Next++ = _STD move(*_First);

}

return (_Next);

}?????????

?????

template <class ForwardIterator, class T>

ForwardIterator remove (ForwardIterator first,
ForwardIterator last, const T& val)

{

ForwardIterator result = first;

while (first!=last) {

if (!(*first == val)) {

*result = move(*first);

++result;

}

++first;

}

return result;

}

--------------------------------------------------------------------------------------------

// remove algorithm example

#include <iostream> // std::cout

#include <algorithm> // std::remove

int main () {

int myints[] = {10,20,30,30,20,10,10,20}; // 10 20 30 30
20 10 10 20

// bounds of range:

int* pbegin = myints; // ^

int* pend = myints+sizeof(myints)/sizeof(int); // ^ ^

pend = std::remove (pbegin, pend, 20); // 10 30 30 10 10
? ? ?

// ^ ^

std::cout << "range contains:";

for (int* p=pbegin; p!=pend; ++p)

std::cout << ‘ ‘ << *p;

std::cout << ‘\n‘;

return 0;

}

-------------------------------------------------------------------------------------------

Output:

range contains: 10 30 30 10 10

?

解释 ：

核心代码

? ?ForwardIterator result = first;

while (first!=last) {

if (!(*first == val)) {

*result = *first;

++result;

}

++first;

}

------------------------------vs2015-------------------------------------------

// TEMPLATE FUNCTION remove

template<class _FwdIt,

class _Ty> inline

_FwdIt _Remove_unchecked(_FwdIt _First, _FwdIt _Last,
const _Ty& _Val)

{ // remove each matching _Val

_First = _Find_unchecked(_First, _Last, _Val);

_FwdIt _Next = _First;

if (_First != _Last)

{

for (++_First; _First != _Last; ++_First)

if (!(*_First == _Val))

*_Next++ = _STD move(*_First);

}

return (_Next);

}????????

template <class ForwardIterator, class
UnaryPredicate>

ForwardIterator remove_if (ForwardIterator first,
ForwardIterator last,

UnaryPredicate pred)

{

ForwardIterator result = first;

while (first!=last) {

if (!pred(*first)) {

*result = *first;

++result;

}

++first;

}

return result;

}

---------------------------------------------------------------------------------

// remove_if example

#include <iostream> // std::cout

#include <algorithm> // std::remove_if

bool IsOdd (int i) { return ((i%2)==1); }

int main () {

int myints[] = {1,2,3,4,5,6,7,8,9}; // 1 2 3 4 5 6 7 8 9

// bounds of range:

int* pbegin = myints; // ^

int* pend = myints+sizeof(myints)/sizeof(int); // ^ ^

pend = std::remove_if (pbegin, pend, IsOdd); // 2 4 6 8
? ? ? ? ?

// ^ ^

std::cout << "the range contains:";

for (int* p=pbegin; p!=pend; ++p)

std::cout << ‘ ‘ << *p;

std::cout << ‘\n‘;

return 0;

}

------------------------------------------------------------------------------

Output:

the range contains: 2 4 6 8

?

------------------------vs2015--------------------------------

// TEMPLATE FUNCTION remove_if

template<class _FwdIt,

class _Pr> inline

_FwdIt _Remove_if_unchecked(_FwdIt _First, _FwdIt _Last,
_Pr& _Pred)

{ // remove each satisfying _Pred

_First = _Find_if_unchecked(_First, _Last, _Pred);

_FwdIt _Next = _First;

if (_First != _Last)

{

for (++_First; _First != _Last; ++_First)

if (!_Pred(*_First))

*_Next++ = _STD move(*_First);

}

return (_Next);

}????????

template <class InputIterator, class OutputIterator,
class T>

OutputIterator remove_copy (InputIterator first,
InputIterator last,

OutputIterator result, const T& val)

{

while (first!=last) {

if (!(*first == val)) {

*result = *first;

++result;

}

++first;

}

return result;

}

---------------------------------------------------------------------------------

// remove_copy example

#include <iostream> // std::cout

#include <algorithm> // std::remove_copy

#include <vector> // std::vector

int main () {

int myints[] = {10,20,30,30,20,10,10,20}; // 10 20 30 30
20 10 10 20

std::vector<int> myvector (8);

std::remove_copy (myints,myints+8,myvector.begin(),20);
// 10 30 30 10 10 0 0 0

std::cout << "myvector contains:";

for (std::vector<int>::iterator it=myvector.begin();
it!=myvector.end(); ++it)

std::cout << ‘ ‘ << *it;

std::cout << ‘\n‘;

return 0;

}

----------------------------------------------------------------------------------------

Output:

myvector contains: 10 30 30 10 10 0 0 0

----------------------------------------------vs2015------------------------------------

// TEMPLATE FUNCTION remove_copy

template<class _InIt,

class _OutIt,

class _Ty> inline

_OutIt _Remove_copy_unchecked(_InIt _First, _InIt _Last,

_OutIt _Dest, const _Ty& _Val)

{ // copy omitting each matching _Val

for (; _First != _Last; ++_First)

if (!(*_First == _Val))

{ // validate _Dest and store

_DEBUG_POINTER(_Dest);

*_Dest++ = *_First;

}

return (_Dest);

}

????????????

template <class InputIterator, class OutputIterator,
class UnaryPredicate>

OutputIterator remove_copy_if (InputIterator first,
InputIterator last,

OutputIterator result, UnaryPredicate pred)

{

while (first!=last) {

if (!pred(*first)) {

*result = *first;

++result;

}

++first;

}

return result;

}

------------------------------------------------------------------------------------

// remove_copy_if example

#include <iostream> // std::cout

#include <algorithm> // std::remove_copy_if

#include <vector> // std::vector

bool IsOdd (int i) { return ((i%2)==1); }

int main () {

int myints[] = {1,2,3,4,5,6,7,8,9};

std::vector<int> myvector (9);

std::remove_copy_if
(myints,myints+9,myvector.begin(),IsOdd);

std::cout << "myvector contains:";

for (std::vector<int>::iterator
it=myvector.begin(); it!=myvector.end(); ++it)

std::cout << ‘ ‘ << *it;

std::cout << ‘\n‘;

return 0;

}

-----------------------------------------------------------------------------------------

Output:

myvector contains: 2 4 6 8 0 0 0 0 0

--------------------------------------vs2015--------------------------------------------??????????

// TEMPLATE FUNCTION remove_copy_if

template<class _InIt,

class _OutIt,

class _Pr> inline

_OutIt _Remove_copy_if_unchecked(_InIt _First, _InIt
_Last,

_OutIt _Dest, _Pr& _Pred)

{ // copy omitting each element satisfying _Pred

for (; _First != _Last; ++_First)

if (!_Pred(*_First))

{ // validate _Dest and store

_DEBUG_POINTER(_Dest);

*_Dest++ = *_First;

}

return (_Dest);

}??

template <class ForwardIterator>

ForwardIterator unique (ForwardIterator first,
ForwardIterator last)

{

if (first==last) return last;

ForwardIterator result = first;

while (++first != last)

{

if (!(*result == *first)) // or: if
(!pred(*result,*first)) for version (2)

*(++result)=*first;

}

return ++result;

}

--------------------------------------------------------------------------------------

// unique algorithm example

#include <iostream> // std::cout

#include <algorithm> // std::unique, std::distance

#include <vector> // std::vector

bool myfunction (int i, int j) {

return (i==j);

}

int main () {

int myints[] = {10,20,20,20,30,30,20,20,10}; // 10 20 20
20 30 30 20 20 10

std::vector<int> myvector (myints,myints+9);

// using default comparison:

std::vector<int>::iterator it;

it = std::unique (myvector.begin(), myvector.end()); //
10 20 30 20 10 ? ? ? ?

// ^

myvector.resize( std::distance(myvector.begin(),it) );
// 10 20 30 20 10

// using predicate comparison:

std::unique (myvector.begin(), myvector.end(),
myfunction); // (no changes)

// print out content:

std::cout << "myvector contains:";

for (it=myvector.begin(); it!=myvector.end(); ++it)

std::cout << ‘ ‘ << *it;

std::cout << ‘\n‘;

return 0;

}

---------------------------------------------------------------------------------------------------

Output:

myvector contains: 10 20 30 20 10

解释：

???核心代码 while (++first != last)

{ if (!(*result == *first)) // or: if
(!pred(*result,*first)) for version (2)

*(++result)=*first;

}

相邻两个值不相等的时候，返回++first

----------------------------------------vs2015--------------------------------------------------

// TEMPLATE FUNCTION unique

template<class _FwdIt> inline

_FwdIt unique(_FwdIt _First, _FwdIt _Last)

{ // remove each matching previous

return (_STD unique(_First, _Last, equal_to<>()));

}

?

// TEMPLATE FUNCTION unique WITH PRED

template<class _FwdIt, class _Pr> inline

_FwdIt _Unique_unchecked(_FwdIt _First, _FwdIt _Last,
_Pr& _Pred)

{ // remove each satisfying _Pred with previous

if (_First != _Last)

for (_FwdIt _Firstb; (void)(_Firstb = _First), ++_First
!= _Last; )

if (_Pred(*_Firstb, *_First))

{ // copy down

for (; ++_First != _Last; )

if (!_Pred(*_Firstb, *_First))

*++_Firstb = _STD move(*_First);

return (++_Firstb);

}

return (_Last);

}???????????????????

template <class InputIterator, class
OutputIterator>

OutputIterator unique_copy (InputIterator first,
InputIterator last,

OutputIterator result)

{

if (first==last) return result;

*result = *first;

while (++first != last) {

typename
iterator_traits<InputIterator>::value_type val = *first;

if (!(*result == val)) // or: if (!pred(*result,val))
for version (2)

*(++result)=val;

}

return ++result;

}

-------------------------------------------------------------------------

// unique_copy example

#include <iostream> // std::cout

#include <algorithm> // std::unique_copy, std::sort,
std::distance

#include <vector> // std::vector

bool myfunction (int i, int j) {

return (i==j);

}

int main () {

int myints[] = {10,20,20,20,30,30,20,20,10};

std::vector<int> myvector (9); // 0 0 0 0 0 0 0 0
0

// using default comparison:

std::vector<int>::iterator it;

it=std::unique_copy (myints,myints+9,myvector.begin());
// 10 20 30 20 10 0 0 0 0

// ^

std::sort (myvector.begin(),it); // 10 10 20 20 30 0 0 0
0

// ^

// using predicate comparison:

it=std::unique_copy (myvector.begin(), it,
myvector.begin(), myfunction);

// 10 20 30 20 30 0 0 0 0

// ^

myvector.resize( std::distance(myvector.begin(),it) );
// 10 20 30

// print out content:

std::cout << "myvector contains:";

for (it=myvector.begin(); it!=myvector.end(); ++it)

std::cout << ‘ ‘ << *it;

std::cout << ‘\n‘;

return 0;

}

------------------------------------------------------------------------------

????Output:

myvector contains: 10 20 30

解释：

-------------------------------vs2015-----------------?????

// TEMPLATE FUNCTION unique_copy WITH PRED

template<class _InIt,

class _OutIt,

class _Pr> inline

_OutIt _Unique_copy_unchecked(_InIt _First, _InIt _Last,

_OutIt _Dest, _Pr& _Pred, input_iterator_tag)

{ // copy compressing pairs satisfying _Pred, input
iterators

if (_First != _Last)

{

_Iter_value_t<_InIt> _Val = *_First;

for (*_Dest++ = _Val; ++_First != _Last; )

if (!_Pred(_Val, *_First))

{ // copy unmatched

_Val = *_First;

*_Dest++ = _Val;

}

}

return (_Dest);

}

template<class _FwdIt,

class _OutIt,

class _Pr> inline

_OutIt _Unique_copy_unchecked(_FwdIt _First, _FwdIt
_Last,

_OutIt _Dest, _Pr& _Pred, forward_iterator_tag)

{ // copy compressing pairs satisfying _Pred, forward
iterators

if (_First != _Last)

{

_FwdIt _Firstb = _First;

for (*_Dest++ = *_Firstb; ++_First != _Last; )

if (!_Pred(*_Firstb, *_First))

{ // copy unmatched

_Firstb = _First;

*_Dest++ = *_Firstb;

}

}

return (_Dest);

}?

template <class BidirectionalIterator>

void reverse (BidirectionalIterator first,
BidirectionalIterator last)

{

while ((first!=last)&&(first!=--last)) {

std::iter_swap (first,last);

++first;

}

}

----------------------------------------------------------------------------

// reverse algorithm example

#include <iostream> // std::cout

#include <algorithm> // std::reverse

#include <vector> // std::vector

int main () {

std::vector<int> myvector;

// set some values:

for (int i=1; i<10; ++i) myvector.push_back(i); // 1
2 3 4 5 6 7 8 9

std::reverse(myvector.begin(),myvector.end()); // 9 8 7
6 5 4 3 2 1

// print out content:

std::cout << "myvector contains:";

for (std::vector<int>::iterator
it=myvector.begin(); it!=myvector.end(); ++it)

std::cout << ‘ ‘ << *it;

std::cout << ‘\n‘;

return 0;

}

-------------------------------------------------------------------------------------

Output:

myvector contains: 9 8 7 6 5 4 3 2 1

解释：

核心代码 while ((first!=last)&&(first!=--last)) {
std::iter_swap (first,last); ++first; }?

-----------------------------------------------------vs2015--------------------------------

// TEMPLATE FUNCTION reverse

?template<class _BidIt> inline

void _Reverse_unchecked(_BidIt _First, _BidIt _Last)

{ // reverse elements in [_First, _Last), bidirectional
iterators

for (; _First != _Last && _First != --_Last;
++_First)

_STD iter_swap(_First, _Last);

}??????????????????

template <class BidirectionalIterator, class
OutputIterator>

OutputIterator reverse_copy (BidirectionalIterator
first,

BidirectionalIterator last, OutputIterator result)

{

while (first!=last) {

--last;

*result = *last;

++result;

}

return result;

}

--------------------------------------------------------------------------------

// reverse_copy example

#include <iostream> // std::cout

#include <algorithm> // std::reverse_copy

#include <vector> // std::vector

int main () {

int myints[] ={1,2,3,4,5,6,7,8,9};

std::vector<int> myvector;

myvector.resize(9); // allocate space

std::reverse_copy (myints, myints+9, myvector.begin());

// print out content:

std::cout << "myvector contains:";

for (std::vector<int>::iterator
it=myvector.begin(); it!=myvector.end(); ++it)

std::cout << ‘ ‘ << *it;

std::cout << ‘\n‘;

return 0;

}

------------------------------------------------------------------------------------

Output:

myvector contains: 9 8 7 6 5 4 3 2 1

---------------------------vs2015---------------------------------------

// TEMPLATE FUNCTION reverse_copy

template<class _BidIt,

class _OutIt> inline

_OutIt _Reverse_copy_unchecked(_BidIt _First, _BidIt
_Last,

_OutIt _Dest)

{ // copy reversing elements in [_First, _Last)

for (; _First != _Last; ++_Dest)

*_Dest = *--_Last;

return (_Dest);

}??????????

template <class ForwardIterator>

void rotate (ForwardIterator first, ForwardIterator
middle,

ForwardIterator last)

{

ForwardIterator next = middle;

while (first!=next)

{

swap (*first++,*next++);

if (next==last) next=middle;

else if (first==middle) middle=next;

}

}

---------------------------------------------------------------------

// rotate algorithm example

#include <iostream> // std::cout

#include <algorithm> // std::rotate

#include <vector> // std::vector

int main () {

std::vector<int> myvector;

// set some values:

for (int i=1; i<10; ++i) myvector.push_back(i); // 1
2 3 4 5 6 7 8 9

std::rotate(myvector.begin(),myvector.begin()+3,myvector.end());

// 4 5 6 7 8 9 1 2 3

// print out content:

std::cout << "myvector contains:";

for (std::vector<int>::iterator
it=myvector.begin(); it!=myvector.end(); ++it)

std::cout << ‘ ‘ << *it;

std::cout << ‘\n‘;

return 0;

}????

-----------------------------------------------------------------------------

???Output:

myvector contains: 4 5 6 7 8 9 1 2 3

------------------------------------------vs2015----------------------------------

// TEMPLATE FUNCTION rotate

template<class _FwdIt> inline

_FwdIt _Rotate_unchecked1(_FwdIt _First, _FwdIt _Mid,
_FwdIt _Last,

forward_iterator_tag)

{ // rotate [_First, _Last), forward iterators

for (_FwdIt _Next = _Mid, _Res = _Last; ; )

{ // swap [_First, ...) into place

_STD iter_swap(_First, _Next);

if (++_First == _Mid)

{ // quit if done, else define next interval

if (++_Next == _Last)

return (_Res == _Last ? _Mid : _Res);

else

_Mid = _Next; // mark end of next interval

}

else if (++_Next == _Last)

{ // wrap to last end

if (_Res == _Last)

_Res = _First;

_Next = _Mid;

}

}

}

????

template <class ForwardIterator, class
OutputIterator>

OutputIterator rotate_copy (ForwardIterator first,
ForwardIterator middle,

ForwardIterator last, OutputIterator result)

{

result=std::copy (middle,last,result);

return std::copy (first,middle,result);

}

------------------------------------------------------------------------------

// rotate_copy algorithm example

#include <iostream> // std::cout

#include <algorithm> // std::rotate_copy

#include <vector> // std::vector

int main () {

int myints[] = {10,20,30,40,50,60,70};

std::vector<int> myvector (7);

std::rotate_copy(myints,myints+3,myints+7,myvector.begin());

// print out content:

std::cout << "myvector contains:";

for (std::vector<int>::iterator
it=myvector.begin(); it!=myvector.end(); ++it)

std::cout << ‘ ‘ << *it;

std::cout << ‘\n‘;

return 0;

}

-----------------------------------------------------------------------------------------

Output:

myvector contains: 40 50 60 70 10 20 30

----------------------------vs2015--------------------------------------------------

// TEMPLATE FUNCTION rotate_copy

template<class _FwdIt,

class _OutIt> inline

_OutIt _Rotate_copy_unchecked(_FwdIt _First, _FwdIt
_Mid, _FwdIt _Last,

_OutIt _Dest)

{ // copy rotating [_First, _Last)

_Dest = _Copy_unchecked(_Mid, _Last, _Dest);

return (_Copy_unchecked(_First, _Mid, _Dest));

}????????

template <class RandomAccessIterator, class
RandomNumberGenerator>

void random_shuffle (RandomAccessIterator first,
RandomAccessIterator last,

RandomNumberGenerator& gen)

{

iterator_traits<RandomAccessIterator>::difference_type
i, n;

n = (last-first);

for (i=n-1; i>0; --i) {

swap (first[i],first[gen(i+1)]);

}

}

------------------------------------------------------------------------------------

// random_shuffle example

#include <iostream> // std::cout

#include <algorithm> // std::random_shuffle

#include <vector> // std::vector

#include <ctime> // std::time

#include <cstdlib> // std::rand, std::srand

// random generator function:

int myrandom (int i) { return std::rand()%i;}

int main () {

std::srand ( unsigned ( std::time(0) ) );

std::vector<int> myvector;

// set some values:

for (int i=1; i<10; ++i) myvector.push_back(i); // 1
2 3 4 5 6 7 8 9

// using built-in random generator:

std::random_shuffle ( myvector.begin(), myvector.end()
);

// using myrandom:

std::random_shuffle ( myvector.begin(), myvector.end(),
myrandom);

// print out content:

std::cout << "myvector contains:";

for (std::vector<int>::iterator
it=myvector.begin(); it!=myvector.end(); ++it)

std::cout << ‘ ‘ << *it;

std::cout << ‘\n‘;

return 0;

}

---------------------------------------------------------------------------------------

Possible output:

myvector contains: 3 4 1 6 8 9 2 7 5

-----------------------------------------vs2015-----------------------------------------

// TEMPLATE FUNCTION shuffle WITH URNG

template<class _RanIt,

class _Fn1> inline

void _Random_shuffle_unchecked(_RanIt _First, _RanIt
_Last, _Fn1& _Func)

{ // shuffle nonempty [_First, _Last) using random
function _Func

if (_Last - _First < 2)

return;

_RanIt _Next = _First;

for (_Iter_diff_t<_RanIt> _Index = 2; ++_Next !=
_Last; ++_Index)

{ // randomly swap element with self or earlier element

_Iter_diff_t<_RanIt> _Off = _Func(_Index);

#if _ITERATOR_DEBUG_LEVEL == 2

if (_Off < 0 || _Index <= _Off)

{ // report error

_DEBUG_ERROR("random value out of range");

_SCL_SECURE_OUT_OF_RANGE;

}

#elif _ITERATOR_DEBUG_LEVEL == 1

_SCL_SECURE_VALIDATE_RANGE(0 <= _Off && _Off
< _Index);

#endif /* _ITERATOR_DEBUG_LEVEL */

_STD iter_swap(_Next, _First + _Off);

}

}????????

template <class RandomAccessIterator, class URNG>

void shuffle (RandomAccessIterator first,
RandomAccessIterator last, URNG&& g)

{

for (auto i=(last-first)-1; i>0; --i) {

std::uniform_int_distribution<decltype(i)> d(0,i);

swap (first[i], first[d(g)]);

}

}

------------------------------------------------------------------------------------------

// shuffle algorithm example

#include <iostream> // std::cout

#include <algorithm> // std::shuffle

#include <array> // std::array

#include <random> // std::default_random_engine

#include <chrono> // std::chrono::system_clock

int main () {

std::array<int,5> foo {1,2,3,4,5};

// obtain a time-based seed:

unsigned seed =
std::chrono::system_clock::now().time_since_epoch().count();

shuffle (foo.begin(), foo.end(),
std::default_random_engine(seed));

std::cout << "shuffled elements:";

for (int& x: foo) std::cout << ‘ ‘ << x;

std::cout << ‘\n‘;

return 0;

}

---------------------------------------------------------------------------------------

Possible output:

shuffled elements: 3 1 4 2 5

--------------------------------------vs2015----------------------------------

// TEMPLATE FUNCTION shuffle WITH URNG

template<class _RanIt,

class _Fn1> inline

void _Random_shuffle_unchecked(_RanIt _First, _RanIt
_Last, _Fn1& _Func)

{ // shuffle nonempty [_First, _Last) using random
function _Func

if (_Last - _First < 2)

return;

_RanIt _Next = _First;

for (_Iter_diff_t<_RanIt> _Index = 2; ++_Next !=
_Last; ++_Index)

{ // randomly swap element with self or earlier element

_Iter_diff_t<_RanIt> _Off = _Func(_Index);

#if _ITERATOR_DEBUG_LEVEL == 2

if (_Off < 0 || _Index <= _Off)

{ // report error

_DEBUG_ERROR("random value out of range");

_SCL_SECURE_OUT_OF_RANGE;

}

#elif _ITERATOR_DEBUG_LEVEL == 1

_SCL_SECURE_VALIDATE_RANGE(0 <= _Off && _Off
< _Index);

#endif /* _ITERATOR_DEBUG_LEVEL */

_STD iter_swap(_Next, _First + _Off);

}

}

????????????