C++ 一條代碼打印vector內容以及random_shuffle函數

1. #include <iostream>  
2. #include <vector>   
3. #include <iterator>   
4. #include <algorithm>   
5.   
6. using namespace std;  
7.   
8. int main (int argc, char *argv[])  
9. {  
10.     int n = 10;  
11.     vector<int> v;  
12.   
13.     //append integers 0 to n-1 to v   
14.     for (int i = 0; i < n; ++i) {  
15.         v.push_back(i);  
16.     }  
17.   
18.     //random shuffle the values of v   
19.     random_shuffle (v.begin(), v.end());  
20.     //print all values of v to screen   
21.     copy (v.begin(), v.end(), ostream_iterator<int> (cout, "\n"));  
22.   
23.     return 0;  
24. }  

運行結果：

8
1
9
2
0
5
7
3
4
6
Press any key to continue . . .

     本實例簡單演示了vector的使用，實際上該演示代碼同時包含了迭代器（iterator）技術，如v.begin()和v.end(),

他們分別指示vector向量的初始化和末尾指針，同時該代碼還采用了STL技術中的算法技術，通過STL算法函數

random_shuffle吧容器類的元素順序搗亂，並通過算法函數copy實現數據的輸出。

    有關以上程序的運行過程如下圖所示，假設總共有100個元素，以上代碼首先定義了一個空的vector對象，然後

賦值如第二步所示，第三步顯示了賦值完畢後向量的存儲實例，通過random_shuffle函數把容器類的元素順序搗亂

後向量中存儲的元素如第四步所示：

                   

關於random_shuffle函數詳解如下：

1.其函數原型如下：

1. template <class RandomAccessIterator>   
2. void random_shuffle ( RandomAccessIterator first, RandomAccessIterator last );  
3.   
4. template <class RandomAccessIterator, class RandomNumberGenerator>   
5. void random_shuffle ( RandomAccessIterator first, RandomAccessIterator last,  
6.                       RandomNumberGenerator& rand );  

該函數的功能是重新隨機的排列first到last的間的所有元素。

Rearranges the elements in the range [first,last) randomly.

The function swaps the value of each element with that of some other randomly chosen element. When provided, the function rand chooses which element.

The behavior of this function template is equivalent to:

1. template <class RandomAccessIterator, class RandomNumberGenerator>  
2.   void random_shuffle ( RandomAccessIterator first, RandomAccessIterator last,  
3.                         RandomNumberGenerator& rand )  
4. {  
5.   iterator_traits<RandomAccessIterator>::difference_type i, n;  
6.   n = (last-first);  
7.   for (i=n-1; i>0; --i) swap (first[i],first[rand(i+1)]);  
8. }  

Parameters

first, last

Forward iterators to the initial and final positions of the sequence to be shuffled. The range used is [first,last), which contains all the elements between first andlast, including the element pointed by first but not the element pointed by last.

rand

Pointer to unary function taking one argument and returning a value, both of the appropriate difference type (generally ptrdiff_t). The function shall return a value between zero and its argument (lower than this).

Return value

none

Example

1. // random_shuffle example   
2. #include <iostream>   
3. #include <algorithm>   
4. #include <functional>   
5. #include <vector>   
6. #include <ctime>   
7. #include <cstdlib>   
8. using namespace std;  
9.   
10. // random generator function:   
11. ptrdiff_t myrandom (ptrdiff_t i) { return rand()%i;}  
12.   
13. // pointer object to it:   
14. ptrdiff_t (*p_myrandom)(ptrdiff_t) = myrandom;  
15.   
16. int main () {  
17.   srand ( unsigned ( time (NULL) ) );  
18.   vector<int> myvector;  
19.   vector<int>::iterator it;  
20.   
21.   // set some values:   
22.   for (int i=1; i<10; ++i) myvector.push_back(i); // 1 2 3 4 5 6 7 8 9   
23.   
24.   // using built-in random generator:   
25.   random_shuffle ( myvector.begin(), myvector.end() );  
26.   
27.   // using myrandom:   
28.   random_shuffle ( myvector.begin(), myvector.end(), p_myrandom);  
29.   
30.   // print out content:   
31.   cout << "myvector contains:";  
32.   for (it=myvector.begin(); it!=myvector.end(); ++it)  
33.     cout << " " << *it;  
34.   
35.   cout << endl;  
36.   
37.   return 0;  
38. }  

A possible output:

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

others：

ptrdiff_t

Result of pointer subtraction

This is the type returned by the subtraction operation between two pointers. This is a signed integral type, and as such can be casted to compatible fundamental data types.

A subtraction of two pointers is only granted to have a valid defined value for pointers to elements of the same array (or for the element just past the last in the array).

For other values, the behavior depends on the system characteristics and compiler implementation.