与Non-mutating Algorithms相比，变易算法能修改容器元素数据，可进行序列数据的复制、交换、替换、填充、移除、旋转、随机抖动、分割。还是参考叶至军的那本书以及网站Cplusplus.com
元素复制。该函数用于容器间元素拷贝，将迭代器区间[first, last)的元素复制到由复制目标迭代器result给定的区间[result, result + (last - first))。
template <class InputIterator, class OutputIterator>
OutputIterator copy (InputIterator first, InputIterator last, OutputIterator result);
Copies the elements in the range [first,last) into the range beginning at result.
The function returns an iterator to the end of the destination range (which points to the element following the last element copied).
template<class InputIterator, class OutputIterator>
OutputIterator copy (InputIterator first, InputIterator last, OutputIterator result)
{
while (first!=last) {
*result = *first;
++result; ++first;
}
return result;
}
#include<iostream>
#include<algorithm>
#include<list>
#include<vector>
using namespace std;
void print(int x)
{
cout<<x<<" ";
}
int main()
{
vector<int> v;
v.push_back(2);
v.push_back(4);
v.push_back(3);
list<int> l(3);
copy(v.begin(), v.end(), l.begin());
for_each(l.begin(), l.end(), print);//2 4 3
return 0;
}
反向复制。将一个迭代器区间的内容复制到另一迭代器区间，与copy()相似，不同的是复制过程从最后的元素开始。
template <class BidirectionalIterator1, class BidirectionalIterator2>
BidirectionalIterator2 copy_backward (BidirectionalIterator1 first,
BidirectionalIterator1 last,
BidirectionalIterator2 result);
Copies the elements in the range [first,last) starting from the end into the range terminating at result.
The function returns an iterator to the first element in the destination range.
template<class BidirectionalIterator1, class BidirectionalIterator2>
BidirectionalIterator2 copy_backward ( BidirectionalIterator1 first,
BidirectionalIterator1 last,
BidirectionalIterator2 result )
{
while (last!=first) *(--result) = *(--last);
return result;
}
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
void print(int x)
{
cout<<x<<" ";
}
int main()
{
vector<int> v(4);
for(int i=0;i<v.size();i++)
{
v[i]=i+1;
}
vector<int> v2(8);
copy_backward(v.begin(), v.end(), v2.end());
for_each(v2.begin(), v2.end(), print);//0 0 0 0 1 2 3 4
return 0;
}
该函数的功能是实现两个元素的交换。虽然大多数容器内部都提供了swap函数，这里提供了更一般的迭代器形式。
C++98中，函数原型为：
template <class T> void swap (T& a, T& b);
C++11中，函数原型为：
template <class T> void swap (T& a, T& b)noexcept
(is_nothrow_move_constructible<T>::value && is_nothrow_move_assignable<T>::value);
template <class T, size_t N> void swap(T (&a)[N], T (&b)[N])
noexcept (noexcept(swap(*a,*b)));
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]);
}
//交换a,b的值
#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;
return 0;
}
迭代器交换。iter_swap函数是swap函数的迭代器形式，使交换算法更易用于一般的容器。
template <class ForwardIterator1, class ForwardIterator2>
void iter_swap (ForwardIterator1 a, ForwardIterator2 b);
Swaps the elements pointed to by a and b.
The function calls swap (unqualified) to exchange the elements.
template <class ForwardIterator1, class ForwardIterator2>
void iter_swap (ForwardIterator1 a, ForwardIterator2 b)
{
swap (*a, *b);
}
#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;
return 0;
}
区间元素交换。
函数原型如下：
template<class ForwardIterator1, class ForwardIterator2>
ForwardIterator2 swap_ranges (ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2)
Exchanges the values of each of the elements in the range [first1,last1) with those of their respective elements in the range beginning at first2.
The function calls swap (unqualified) to exchange the elements.
template<class ForwardIterator1, class ForwardIterator2>
ForwardIterator2 swap_ranges (ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2)
{
while (first1!=last1) {
swap (*first1, *first2);
++first1; ++first2;
}
return first2;
}
#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 (6,33); // bar: 33 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<<std::endl;
std::cout << "bar contains:";
for (std::vector<int>::iterator it=bar.begin(); it!=bar.end(); ++it)
std::cout << ' ' << *it;
std::cout <<std::endl;
return 0;
}
元素变换。该函数用于容器元素的变换操作。有两个使用原型，分别用于一元函数对象和二元函数操作。
template <class InputIterator, class OutputIterator, class UnaryOperation>
OutputIterator transform (InputIterator first1, InputIterator last1,
OutputIterator result, UnaryOperation op)
template <class InputIterator1, class InputIterator2,
class OutputIterator, class BinaryOperation>
OutputIterator transform (InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, OutputIterator result,
BinaryOperation binary_op)
Applies an operation sequentially to the elements of one (1) or two (2) ranges and stores the result in the range that begins at result.
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;
}
#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;
}
替换。
template <class ForwardIterator, class T>
void replace (ForwardIterator first, ForwardIterator last,
const T& old_value, const T& new_value)
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;
}
}
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {
cout << x << " ";
}
int main(void) {
vector<int> v;
v.push_back(3);
v.push_back(5);
v.push_back(8);
v.push_back(5);
replace(v.begin(), v.end(), 5, 6);
for_each(v.begin(), v.end(), print);//3 6 8 6
return 0;
}
条件替换。该函数是replace函数的谓词判断版本，将满足谓词条件的元素替换为新值。
template <class ForwardIterator, class UnaryPredicate, class T>
void replace_if (ForwardIterator first, ForwardIterator last,
UnaryPredicate pred, const T& new_value );
#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;
}
替换和复制。该函数先进行元素替换，再将元素复制到新容器。
template <class BidirectionalIterator, class OutputIterator>
OutputIterator reverse_copy (BidirectionalIterator first,
BidirectionalIterator last, OutputIterator result);
//将容器v中值为5的元素的值替换为6，并复制到容器v2。
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {
cout << x << " ";
}
int main(void) {
vector<int> v;
v.push_back(3);
v.push_back(5);
v.push_back(8);
vector<int> v2(v.size());
replace_copy(v.begin(), v.end(), v2.begin(), 5, 6);
for_each(v2.begin(), v2.end(), print);
return 0;
}
条件替换和复制。该函数是replace_copy的一元谓词判断版本，用法相似。
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)
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {
cout << x << " ";
}
int odd(int x) {
return !(x % 2);
}
int main(void) {
vector<int> v;
v.push_back(3);
v.push_back(5);
v.push_back(8);
vector<int> v2(v.size());
replace_copy_if(v.begin(), v.end(), v2.begin(), odd, 2);
for_each(v2.begin(), v2.end(), print);
return 0;
}
填充。该函数将同一个值填充到迭代器区间内。
template <class ForwardIterator, class T>
void fill (ForwardIterator first, ForwardIterator last, const T& val)
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {
cout << x << " ";
}
int main(void) {
vector<int> v(5);
fill(v.begin(), v.end(), 9);
for_each(v.begin(), v.end(), print);
return 0;
}
n次填充。与fill函数相似，但可指定填充的元素的个数。
template <class OutputIterator, class Size, class T>
void fill_n (OutputIterator first, Size n, const T& val)
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
void print(int x)
{
cout<<x<<" ";
}
int main()
{
vector<int> v(4);
for(int i=0;i<v.size();i++)
v[i]=i+1;
fill_n(v.begin()+1,2,10);
for_each(v.begin(),v.end(),print);//1 10 10 4
return 0;
}
随机生成元素。该函数用于随机生成函数，将迭代器区间内的元素填充为生成的元素。
template <class ForwardIterator, class Generator>
void generate (ForwardIterator first, ForwardIterator last, Generator gen)
//生成公比为3的等比数列
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {
cout << x << " ";
}
int next(int x) {
return 2;
}
class Seq {
public:
int a;
Seq() {
a = 1;
}
inline int operator()() {
a *= 3;
return a;
}
};
int main(void) {
vector<int> v(5);
Seq seq;
generate(v.begin(), v.end(), seq);
for_each(v.begin(), v.end(), print);
return 0;
}
随机生成n个元素。该函数与generate相似，只是限定了填入容器的数值个数。函数原型：
template <class OutputIterator, class Size, class Generator>
void generate_n (OutputIterator first, Size n, Generator gen)
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
void print(int x)
{
cout<<x<<" ";
}
int main()
{
vector<int> v(6);
generate_n(v.begin(),3, rand);
for_each(v.begin(),v.end(),print);
return 0;
}
移除。该函数用于将容器中等于某个给定值的元素全部移除掉，并返回表示容器结束位置的迭代器。函数原型：
template <class ForwardIterator, class T>
ForwardIterator remove (ForwardIterator first, ForwardIterator last, const T& val)
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;
}
//移除数组中的元素20
#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;
}
条件移除。该函数是remove函数的一个带谓词判断的版本，将满足一元谓词判断条件的元素移除掉。
template <class ForwardIterator, class UnaryPredicate>
ForwardIterator remove_if (ForwardIterator first, ForwardIterator last,
UnaryPredicate pred)
//将容器v中值为偶数的元素移除掉
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int isOdd(int x) {
return !(x % 2);
}
void print(int x) {
cout << x << " ";
}
int main(void) {
vector<int> v;
v.push_back(3);
v.push_back(7);
v.push_back(8);
vector<int>::iterator result = remove_if(v.begin(), v.end(), isOdd);
for_each(v.begin(), result, print);
return 0;
}
移除复制。该函数先进行元素移除，再将元素复制到新容器，实质上是一个条件复制。
template <class InputIterator, class OutputIterator, class T>
OutputIterator remove_copy (InputIterator first, InputIterator last,
OutputIterator result, const T& val)
Copies the elements in the range [first,last) to the range beginning at result, except those elements that compare equal to val.
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;
}
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int isOdd(int x) {
return !(x % 2);
}
void print(int x) {
cout << x << " ";
}
int main(void) {
vector<int> v;
v.push_back(3);
v.push_back(7);
v.push_back(8);
vector<int>::iterator result = remove_if(v.begin(), v.end(), isOdd);
for_each(v.begin(), result, print);
return 0;
}
条件移除复制。该函数是remove_copy的一个带谓词判断版本，将不满足一元谓词判断条件的元素复制到新容器。
template <class InputIterator, class OutputIterator, class UnaryPredicate>
OutputIterator remove_copy_if (InputIterator first, InputIterator last,
OutputIterator result, UnaryPredicate pred)
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int isOdd(int x) {
return !(x % 2);
}
void print(int x) {
cout << x << " ";
}
int main(void) {
vector<int> v;
v.push_back(3);
v.push_back(7);
v.push_back(8);
vector<int> v2(5);
remove_copy_if(v.begin(), v.end(), v2.begin(), isOdd);
for_each(v2.begin(), v2.end(), print);
return 0;
}
剔除连续重复元素。该函数用于剔除容器中连续重复的元素，只保留一个。有两个使用原型，可以使连续重复的原型，或不连续但满足二元谓词判断条件的元素。
template <class ForwardIterator>
ForwardIterator unique (ForwardIterator first, ForwardIterator last)
template <class ForwardIterator, class BinaryPredicate>
ForwardIterator unique (ForwardIterator first, ForwardIterator last,
BinaryPredicate pred)
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {
cout << x << " ";
}
int main(void) {
vector<int> v;
v.push_back(2);
v.push_back(2);
v.push_back(3);
v.push_back(2);
v.push_back(5);
vector<int>::iterator result = unique(v.begin(), v.end());
for_each(v.begin(), result, print);//2 3 2 5
return 0;
}
不连续重复元素复制。该函数用于复制不连续重复的元素。同样有两个使用原型。
template <class InputIterator, class OutputIterator>
OutputIterator unique_copy (InputIterator first, InputIterator last,
OutputIterator result)
template <class InputIterator, class OutputIterator, class BinaryPredicate>
OutputIterator unique_copy (InputIterator first, InputIterator last,
OutputIterator result, BinaryPredicate pred)
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {
cout << x << " ";
}
int main(void) {
vector<int> v;
v.push_back(2);
v.push_back(3);
v.push_back(3);
v.push_back(5);
v.push_back(3);
vector<int> v2(4);
unique_copy(v.begin(), v.end(), v2.begin());
for_each(v2.begin(), v2.end(), print);//2 3 5 3
return 0;
}
元素反向。该函数用于容器元素的反向排列。
template <class BidirectionalIterator>
void reverse (BidirectionalIterator first, BidirectionalIterator last)
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {
cout << x << " ";
}
int main(void) {
vector<int> v;
v.push_back(2);
v.push_back(3);
v.push_back(5);
reverse(v.begin(), v.end());
for_each(v.begin(), v.end(), print);
return 0;
}
反向复制。该函数用于反向复制容器元素。
template <class BidirectionalIterator, class OutputIterator>
OutputIterator reverse_copy (BidirectionalIterator first,
BidirectionalIterator last, OutputIterator result)
//将容器v中的元素反向复制到新容器v2中
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {
cout << x << " ";
}
int main(void) {
vector<int> v;
v.push_back(2);
v.push_back(3);
v.push_back(5);
vector<int> v2(v.size());
reverse_copy(v.begin(), v.end(), v2.begin());
for_each(v2.begin(), v2.end(), print);
return 0;
}
该函数用于旋转某个迭代器区间的元素。假设区间元素为{a0, a1, ..., ak, ..., an}，ak为middle位置，则旋转复制后，新区间元素为{ak, ak+1, ..., an, a0, a1, ..., ak-1}
函数原型：
template <class ForwardIterator>
void rotate (ForwardIterator first, ForwardIterator middle,
ForwardIterator last)
//将容器v以值为7的元素为支点旋转
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {
cout << x << " ";
}
int main(void) {
vector<int> v;
for(int i = 0; i < 10; i++) {
v.push_back(i + 1);
}
rotate(v.begin(), find(v.begin(), v.end(), 7), v.end());
for_each(v.begin(), v.end(), print);
return 0;
}
旋转复制。该函数通过复制的方法实现旋转，比rotate函数更简单高效，但需要占用较多的内存空间。
template <class ForwardIterator, class OutputIterator>
OutputIterator rotate_copy (ForwardIterator first, ForwardIterator middle,
ForwardIterator last, OutputIterator result)
//将以容器v中值为7的元素为支点旋转，将结果存储在容器v2中
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {
cout << x << " ";
}
int main(void) {
vector<int> v;
for(int i = 0; i < 10; i++) {
v.push_back(i + 1);
}
vector<int> v2(v.size());
rotate_copy(v.begin(), find(v.begin(), v.end(), 7), v.end(), v2.begin());
for_each(v2.begin(), v2.end(), print);
return 0;
}
随机抖动。该函数用于对容器元素进行随机的排列，有两个使用原型，使用C标准的伪随机函数rand或自定义的随机数发生器函数对象。
template <class RandomAccessIterator>
void random_shuffle (RandomAccessIterator first, RandomAccessIterator last)
template <class RandomAccessIterator, class RandomNumberGenerator>
void random_shuffle (RandomAccessIterator first, RandomAccessIterator last,
RandomNumberGenerator& gen)
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {
cout << x << " ";
}
int main(void) {
vector<int> v;
for(int i = 0; i < 10; i++) {
v.push_back(i);
}
random_shuffle(v.begin(), v.end());
for_each(v.begin(), v.end(), print);
cout << endl;
random_shuffle(v.begin(), v.end());
for_each(v.begin(), v.end(), print);
return 0;
}
随机采样。SGI C++可能不支持。
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
void print(int x)
{
cout<<x<<" ";
}
int main()
{
vector<int> v(10);
for(int i=0;i<v.size();i++)
{
v[i]=i%8;
}
int n=6;
int iArray[n];
random_sample(v.begin(),v.end(),iArray,iArray+n);
cout<<"采样元素为：";
for_each(iArray,iArray+n,print);
cout<<endl;
return 0;
}
容器分割。该函数用于重新分割排列容器的元素，按照医院谓词判断条件，分割成满足和不满足条件的两部分，返回的迭代器指向首个不满足条件的元素。
template <class BidirectionalIterator, class UnaryPredicate>
BidirectionalIterator partition (BidirectionalIterator first,
BidirectionalIterator last, UnaryPredicate pred)
//将容器v中的元素分为小于5和大于等于5的两部分，并分别将元素打印出来
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {
cout << x << " ";
}
int less5(int x) {
if(x < 5) {
return 1;
} else {
return 0;
}
}
int main(void) {
vector<int> v;
for(int i = 10; i > 0; i--) {
v.push_back(i);
}
vector<int>::iterator iv = partition(v.begin(), v.end(), less5);
cout << "less than 5: ";
for_each(v.begin(), iv, print);
cout << endl;
cout << "no less than 5: ";
for_each(iv, v.end(), print);
return 0;
}
容器稳定分割。该函数与parition类似，重新分割排列容器的元素，但可以保持原有元素的先后顺序。
template <class BidirectionalIterator, class UnaryPredicate>
BidirectionalIterator stable_partition (BidirectionalIterator first,
BidirectionalIterator last,
UnaryPredicate pred)
Rearranges the elements in the range [first,last), in such a way that all the elements for which pred returns true precede all those for which it returns false, and, unlike function partition, the relative order of elements within each group is preserved.
//将容器v中的元素分为小于5和大于等于5的两部分，但保持元素的稳定性
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void print(int x) {
cout << x << " ";
}
int less5(int x) {
if(x < 5) {
return 1;
} else {
return 0;
}
}
int main(void) {
vector<int> v;
for(int i = 10; i > 0; i--) {
v.push_back(i);
}
vector<int>::iterator iv = stable_partition(v.begin(), v.end(), less5);
cout << "less than 5: ";
for_each(v.begin(), iv, print);
cout << endl;
cout << "no less than 5: ";
for_each(iv, v.end(), print);
return 0;
}
版权声明：本文为博主原创文章，未经博主允许不得转载。
原文地址：http://blog.csdn.net/u011000290/article/details/47837601
