akof1314

C++ 算法库(2) 修改内容的序列操作

修改内容的序列操作：

`copy`	将一个范围中的元素拷贝到新的位置处
`copy_backward`	将一个范围中的元素按逆序拷贝到新的位置处
`copy_if` C++11	将一个范围中满足给定条件的元素拷贝到新的位置处
`copy_n` C++11	拷贝 n 个元素到新的位置处
`fill`	将一个范围的元素赋值为给定值
`fill_n`	将某个位置开始的 n 个元素赋值为给定值
`generate`	将一个函数的执行结果保存到指定范围的元素中，用于批量赋值范围中的元素
`generate_n`	将一个函数的执行结果保存到指定位置开始的 n 个元素中
`iter_swap`	交换两个迭代器指向的元素
`move` C++11	将一个范围中的元素移动到新的位置处
`move_backward` C++11	将一个范围中的元素按逆序移动到新的位置处
`random_shuffle`	随机打乱指定范围中的元素的位置
`remove`	将一个范围中值等价于给定值的元素删除
`remove_if`	将一个范围中值满足给定条件的元素删除
`remove_copy`	拷贝一个范围的元素，将其中值等价于给定值的元素删除
`remove_copy_if`	拷贝一个范围的元素，将其中值满足给定条件的元素删除
`replace`	将一个范围中值等价于给定值的元素赋值为新的值
`replace_copy`	拷贝一个范围的元素，将其中值等价于给定值的元素赋值为新的值
`replace_copy_if`	拷贝一个范围的元素，将其中值满足给定条件的元素赋值为新的值
`replace_if`	将一个范围中值满足给定条件的元素赋值为新的值
`reverse`	反转排序指定范围中的元素
`reverse_copy`	拷贝指定范围的反转排序结果
`rotate`	循环移动指定范围中的元素
`rotate_copy`	拷贝指定范围的循环移动结果
`shuffle` C++11	用指定的随机数引擎随机打乱指定范围中的元素的位置
`swap`	交换两个对象的值
`swap_ranges`	交换两个范围的元素
`transform`	对指定范围中的每个元素调用某个函数以改变元素的值
`unique`	删除指定范围中的所有连续重复元素，仅仅留下每组等值元素中的第一个元素
`unique_copy`	拷贝指定范围的唯一化（参考上述的 unique）结果

copy

将一个范围中的元素拷贝到新的位置处

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// 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;
}

输出：

myvector contains: 10 20 30 40 50 60 70

copy_backward

将一个范围中的元素按逆序拷贝到新的位置处

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// 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;
}

输出：

myvector contains: 10 20 30 10 20 30 40 50

copy_if

将一个范围中满足给定条件的元素拷贝到新的位置处

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// 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;
}

输出：

bar contains: 25 15 5

copy_n

拷贝 n 个元素到新的位置处

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

// 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;
}

输出：

myvector contains: 10 20 30 40 50 60 70

fill

将一个范围的元素赋值为给定值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// 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;
}

输出：

myvector contains: 5 5 5 8 8 8 0 0

fill_n

将某个位置开始的 n 个元素赋值为给定值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// 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;
}

输出：

myvector contains: 20 20 20 33 33 33 10 10

generate

将一个函数的执行结果保存到指定范围的元素中，用于批量赋值范围中的元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

// 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);

  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;
}

输出：

1
2

myvector contains: 57 87 76 66 85 54 17 15
myvector contains: 1 2 3 4 5 6 7 8

generate_n

将一个函数的执行结果保存到指定位置开始的 n 个元素中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// 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;
}

输出：

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

iter_swap

交换两个迭代器指向的元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// 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]
                                                // 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;
}

输出：

myvector contains: 10 99 40 99

move

将一个范围中的元素移动到新的位置处

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

// move algorithm example
#include <iostream>      // std::cout
#include <algorithm>     // std::move (ranges)
#include <utility>       // std::move (objects)
#include <vector>        // std::vector
#include <string>        // std::string

int main () {
  std::vector<std::string> foo = { "air", "water", "fire", "earth"};
  std::vector<std::string> bar ( 4);

   // moving ranges:
  std::cout << "Moving ranges...\n";
  std::move ( foo.begin(), foo.begin()+ 4, bar.begin() );

  std::cout << "foo contains " << foo.size() << " elements:";
  std::cout << " (each in an unspecified but valid state)";
  std::cout << '\n';

  std::cout << "bar contains " << bar.size() << " elements:";
   for (std::string& x: bar) std::cout << " [" << x << "]";
  std::cout << '\n';

   // moving container:
  std::cout << "Moving container...\n";
  foo = std::move (bar);

  std::cout << "foo contains " << foo.size() << " elements:";
   for (std::string& x: foo) std::cout << " [" << x << "]";
  std::cout << '\n';

  std::cout << "bar is in an unspecified but valid state";
  std::cout << '\n';

   return 0;
}

输出：

1
2
3
4
5
6

Moving ranges...
foo contains 4 elements: (each in an unspecified but valid state)
bar contains 4 elements: [air] [water] [fire] [earth]
Moving container...
foo contains 4 elements: [air] [water] [fire] [earth]
bar is in an unspecified but valid state

move_backward

将一个范围中的元素按逆序移动到新的位置处

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// move_backward example
#include <iostream>      // std::cout
#include <algorithm>     // std::move_backward
#include <string>        // std::string

int main () {
  std::string elems[ 10] = { "air", "water", "fire", "earth"};

   // insert new element at the beginning:
  std::move_backward (elems,elems+ 4,elems+ 5);
  elems[ 0]= "ether";

  std::cout << "elems contains:";
   for ( int i= 0; i< 10; ++i)
    std::cout << " [" << elems[i] << "]";
  std::cout << '\n';

   return 0;
}

输出：

elems contains: [ether] [air] [water] [fire] [earth] [] [] [] [] []

random_shuffle

随机打乱指定范围中的元素的位置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

// 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;
}

输出：

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

remove

将一个范围中值等价于给定值的元素删除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// 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;
}

输出：

range contains: 10 30 30 10 10

remove_if

将一个范围中值满足给定条件的元素删除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// 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;
}

输出：

the range contains: 2 4 6 8

remove_copy

拷贝一个范围的元素，将其中值等价于给定值的元素删除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// 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;
}

输出：

myvector contains: 10 30 30 10 10 0 0 0

remove_copy_if

拷贝一个范围的元素，将其中值满足给定条件的元素删除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// 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;
}

输出：

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

replace

将一个范围中值等价于给定值的元素赋值为新的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// 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;
}

输出：

myvector contains: 10 99 30 30 99 10 10 99

replace_copy

拷贝一个范围的元素，将其中值等价于给定值的元素赋值为新的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// 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;
}

输出：

myvector contains: 10 99 30 30 99 10 10 99

replace_copy_if

拷贝一个范围的元素，将其中值满足给定条件的元素删除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// 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;
}

输出：

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

replace_if

将一个范围中值满足给定条件的元素赋值为新的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// 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;
}

输出：

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

reverse

反转排序指定范围中的元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

// 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;
}

输出：

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

reverse_copy

拷贝指定范围的反转排序结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// 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;
}

输出：

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

rotate

循环移动指定范围中的元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

// 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;
}

输出：

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

rotate_copy

拷贝指定范围的循环移动结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// 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;
}

输出：

myvector contains: 40 50 60 70 10 20 30

shuffle

用指定的随机数引擎随机打乱指定范围中的元素的位置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

// shuffle algorithm example
#include <iostream>      // std::cout
#include <algorithm>     // std::move_backward
#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;
}

输出：

shuffled elements: 3 1 4 2 5

swap

交换两个对象的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// 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;
}

输出：

foo contains: 10 10 10 10 10 10

swap_ranges

交换两个范围的元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// 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;
}

输出：

1
2

foo contains: 10 33 33 33 10
bar contains: 10 10 10 33 33

transform

对指定范围中的每个元素调用某个函数以改变元素的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

// 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;
}

输出：

foo contains: 21 41 61 81 101

unique

删除指定范围中的所有连续重复元素，仅仅留下每组等值元素中的第一个元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

// 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;
}

输出：

myvector contains: 10 20 30 20 10

unique_copy

拷贝指定范围的唯一化（参考上述的 unique）结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

// 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;
}

输出：

myvector contains: 10 20 30

特别说明：函数的中文释义来自：http://classfoo.cn/cpp/head/76573_319/，例子来自：http://www.cplusplus.com/reference/algorithm/

你可能感兴趣的:(C++11)

C++11新特性之连续右尖括号（＞＞）改进画个逗号给明天" c++开发语言
1.介绍在C++11之前的泛型编程中，模版实例化有个很繁琐的地方，那就是连续右尖括号（>>）会被编译器解释为右移操作符，而不是模版参数表的结束。例如：templatestructFun{typedefTtype;};templateclassA{...};intmain(void){Fun>::typexx;//编译出错return0;}这种嵌套模版在编译过程中会出现错误，因为不支持Fun>这种写
cpp智能指针 xianwu543 c++mysql 网络开发语言数据库
普通指针的不足new和new[]的内存需要用delete和deletel]释放。程序员的主观失误，忘了或漏了释放。程序员也不确定何时释放。普通指针的释放类内的指针，在析构函数中释放。C++内置数据类型，如何释放?new出来的类，本身如何释放?C++11新增三个智能指针类型unique_ptrshared_ptrweak_ptr一、智能指针unique_ptrunique_ptr独享它指向的对象，也
gcc 编译 java_编译GCC4.9 刘俊海 gcc 编译 java
从svncheckoutsvn://gcc.gnu.org/svn/gcc/trunk拿了GCC的最新代码，打算编译了学东西习学习C++11的东西，结果在configure的时候出现如下问题：BuildingGCCrequiresGMP4.2+,MPFR2.3.1+andMPC0.8.0+http://www.multiprecision.org/mpc下载mpc-1.0.2.tar.gzftp:
C++11线程安全队列实现小贤2016 C++c++c++11 阻塞队列面试线程安全
实现了一个C++11线程安全队列，可以作为模板使用。#include#include#include#include#include#include#includetemplateclassthreadsafe_queue{private:structnode{//存储了数据和下一个节点指针的节点std::shared_ptrdata;std::unique_ptrnext;};std::mute
C++11新特性之可调用对象包装器和绑定器 is-zq C++c++开发语言算法
一、可调用对象C++中可调用对象有六种.1.普通函数普通函数类型可以声明函数,定义函数指针和引用,但是不能定义函数的实体.usingFun=void(int,conststring&);//普通函数类型的别名。Funshow;//声明普通函数。intmain(){show(1,"我是一只傻傻鸟。");//直接调用普通函数。void(*fp1)(int,conststring&)=show;//声明
11 C++11线程使用 Snow__Sunny #C++11 c++开发语言
声明：该文章转载自此篇文章，欢迎大家支持关注原作者！C++11之前，C++语言没有对并发编程提供语言级别的支持，这使得我们在编写可移植的并发程序时，存在诸多的不便。现在C++11中增加了线程以及线程相关的类，很方便地支持了并发编程，使得编写的多线程程序的可移植性得到了很大的提高。C++11中提供的线程类叫做std::thread，基于这个类创建一个新的线程非常的简单，只需要提供线程函数或者函数对象
C++11线程使用 Jason_Lee155 车联网程序算法 c++多线程
线程概念C++11引入了thread类，大大降低了多线程使用的复杂度，原先使用多线程只能用系统的API，无法解决跨平台问题，一套代码平台移植，对应多线程代码也必须要修改。现在在C++11中只需使用语言层面的thread可以解决这个问题。所需头文件：#include构造函数1.默认构造函数thread()noexcept//不会产生异常一个空的std::thread执行对象2.初始化构造函数temp
C++11：开启高效编程之旅（万字详解） Main. 24 c++开发语言
1.列表初始化1.1.C++98传统的{}C++98中⼀般数组和结构体可以⽤{}进行初始化。structPoint{int_x;int_y;};intmain(){//初始化数组intarray1[]={1,2,3,4,5};intarray2[5]={0};//初始化结构体Pointp={1,2};return0;}1.2.C++11中的{}C++11以后想统⼀初始化⽅式，试图实现⼀切对象皆可⽤
C++随笔记录：区别()和{}创建对象 jax不摆烂 C++入门到精通算法
C++在C++11之前的初始化方式五花八门，所以C++11引入统一初始化语法。初始化值要用圆括号()或者花括号{}括起来，或者放到等号=的右边：不管是基本类型、数组还是复杂容器，都可以用花括号{}来初始化；int x(0); //使用圆括号初始化int y= 0; //使用"="初始化int z{ 0 }; //使用花括号初始化这里的=运算符可能会让人产生
c++之make_shared特性 _DCG_ c++c++开发语言
概念介绍c++11版本引入了智能指针shared_ptr/unique_ptr等，本文重点讲解share_ptr相关。由于引入了shared_ptr，根据shared_ptr的定义可以知晓shared_ptr一个模板类，支持基本数据类型，自定义数据类型的共享指针的构造。但是直接使用shared_ptr可能会引入一些问题，例如内存泄露。请看下面的例子：classMyClass{private:int
cpp智能指针 xianwu543 c++开发语言网络 mysql 数据库
普通指针的不足new和new[]的内存需要用delete和deletel]释放。程序员的主观失误，忘了或漏了释放。程序员也不确定何时释放。普通指针的释放类内的指针，在析构函数中释放。C++内置数据类型，如何释放?new出来的类，本身如何释放?C++11新增三个智能指针类型unique_ptrshared_ptrweak_ptr一、智能指针unique_ptrunique_ptr独享它指向的对象，也
C/C++、网络协议、网络安全类文章汇总大草原的小灰灰网络安全 c语言 c++网络协议网络安全密码学
文章简介本文章主要对本博客的所有文章进行了汇总，方便查找。内容涉及C/C++编程，CMake、Makefile、Shell脚本，GUI编程框架MFC和QT，Git版本控制工具，网络协议基础知识，网络安全领域相关知识，Windows、Linux和Mac平台软件打包流程，一些实用的C/C++开源框架。对于访问量过万的文章进行了标记。文章汇总C/C++编程C++11新特性之std::function类模
OpenCV相机标定与3D重建(64)用于迭代地优化图像点的位置函数undistortImagePoints()的使用 jndingxin OpenCV opencv 人工智能
操作系统：ubuntu22.04OpenCV版本：OpenCV4.9IDE:VisualStudioCode编程语言：C++11算法描述计算无畸变图像点的位置。cv::undistortImagePoints这个函数用于迭代地优化图像点的位置，以补偿镜头畸变，并且允许指定终止条件来控制迭代过程。函数原型voidcv::undistortImagePoints(InputArraysrc,Outpu
OpenCV相机标定与3D重建(65)对图像点进行去畸变处理函数undistortPoints()的使用 jndingxin OpenCV opencv
操作系统：ubuntu22.04OpenCV版本：OpenCV4.9IDE:VisualStudioCode编程语言：C++11算法描述从观测到的点坐标计算理想点坐标。该函数类似于undistort和initUndistortRectifyMap，但它操作的是稀疏点集而不是光栅图像。此外，该函数执行与projectPoints相反的变换。对于3D对象，它不会重建其3D坐标；但对于平面对象，如果指定
OpenCV相机标定与3D重建(66)对立体匹配生成的视差图（disparity map）进行验证的函数validateDisparity()的使用 jndingxin OpenCV opencv 3d
操作系统：ubuntu22.04OpenCV版本：OpenCV4.9IDE:VisualStudioCode编程语言：C++11算法描述使用左右检查来验证视差。矩阵“cost”应该由立体对应算法计算。cv::validateDisparity函数是OpenCV库中用于对立体匹配生成的视差图（disparitymap）进行后处理的一个工具。其主要功能是对计算出的视差值进行验证，确保相邻像素间的视差值
OpenCV相机标定与3D重建(2)鱼眼相机模型 jndingxin OpenCV 数码相机 opencv 3d
操作系统：ubuntu22.04OpenCV版本：OpenCV4.9IDE:VisualStudioCode编程语言：C++11算法描述鱼眼相机是一种具有非常宽视野的相机，通常会产生强烈的径向畸变。鱼眼相机模型旨在捕捉这种畸变，以便能够准确地处理和校正图像。鱼眼相机模型通常使用多项式函数来描述径向畸变。定义：设P是世界参考系中的一个3D点，其坐标为X(存储在矩阵X中）。点P在相机参考系中的坐标向量
OpenCV相机标定与3D重建(63)校正图像的畸变函数undistort()的使用 jndingxin OpenCV opencv 3d
操作系统：ubuntu22.04OpenCV版本：OpenCV4.9IDE:VisualStudioCode编程语言：C++11算法描述转换图像以补偿镜头畸变。该函数通过变换图像来补偿径向和切向镜头畸变。此函数仅仅是initUndistortRectifyMap（使用单位矩阵R）和remap（使用双线性插值）的组合。有关执行的具体变换详情，请参阅前者函数。对于在源图像中没有对应像素的目的图像中的像
C++ 条件变量-生产消费者模型 __雨夜星辰__ c++开发语言学习笔记多线程
条件变量是一种线程同步机制,当条件不满足时，相关线程被一直阻塞，直到某种条件出现，这些线程才会被唤醒.C++11的条件变量提供了两个类：condition_variable：只支持与普通mutex搭配，效率更高。condition_variable_any：是一种通用的条件变量，可以与任意mutex搭配（包括用户自定义的锁类型）包含头文件：1.condition_variable类主要成员函数：1
[并发并行]_[中级]_[C++实现synchronized方式的对象锁2.0] Peter(阿斯拉达) C++语言特性和标准库 C/C++多线程并发并行 c++同步 synchronized 对象锁 Java mutex thread
场景在前面的文章说过C++实现synchronized方式的对象锁[1]可以实现Java的synchronized易用特性。这个第一版的例子并没有说明如何删除pthread_mutex_t对象，随着加锁的对象增加会出现内存泄漏的情况，怎么解决？说明在C++11提供了可复制的共享的指针std::shared_ptr,利用这个指针我们可以判断mutex有没有被其他线程使用，从而释放mutex。改进版的
day 21 qq_50996930 C++学习专栏 c++stl
C++11新特性智能指针右值引用和move语句auto关键字（根据初始化的值自动推导类型）lambda表达式for的范围遍历类和结构体中初始化列表nullptr代替null统一的初始化方式…智能指针：智能指针利用RAII思想将指针进行封装，使其在构造时分配内存，析构时释放内存，将动态分配的内存交给类对象管理，防止堆内存泄漏。常见的三种智能指针分别是unique_ptr，shared_ptr，wea
C++面试知识点总结 Ivy_belief 面试必备 c++面试开发语言
目录1、面向对象（OO）编程的基本原则：SOLID原则2、面向对象四大基本特性3、重载与覆盖的区别4、谈一下虚函数；4.1为什么析构函数是虚函数？4.2而构造函数不能为虚函数？5、四种强制转换6、C++11新特性7、C++14新特性：在C++11基础上做了小改动8、C++17新特性：9、指针和引用：面向对象编程思想（OOP）1、面向对象（OO）编程的基本原则：SOLID原则（1）单一职责原则；S：
C++11 新特性总结 weixin_30955617 c/c++数据结构与算法
前言转载请注明出处，感谢！C++11的新特性1变量和基本类型1.1longlong类型扩展精度浮点数，10位有效数字1.2列表初始化初始化的几种不同形式，其中用花括号来初始化变量称为列表初始化；比如：inti=0;inti={0};inti{0};inti(0);需要注意的是，当用于内置类型的变量时，这种初始化形式有一个重要的特点：如果我们使用初始化且初始值存在丢失信息的风险，则编译器报错；例如：
C++11中的新特性 rainboots C++基础学习笔记 c++python 算法
C++11中的新特性文章目录一、基于范围的for循环C++11提供了一个特殊版本的for循环，在很多情况下，它都可以简化数组的处理，这就是基于范围的for循环。在使用基于范围的for循环处理数组时，该循环可以自动为数组中的每个元素迭代一次。不必使用计数器变量控制其迭代，也不必担心数组下标越界的问题。基于范围的for循环使用了一个称为范围变量的内置变量。每次基于范围的for循环迭代时，它都会复制下一
cpp智能指针 xianwu543 c++开发语言 mysql 数据库网络
普通指针的不足new和new[]的内存需要用delete和deletel]释放。程序员的主观失误，忘了或漏了释放。程序员也不确定何时释放。普通指针的释放类内的指针，在析构函数中释放。C++内置数据类型，如何释放?new出来的类，本身如何释放?C++11新增三个智能指针类型unique_ptrshared_ptrweak_ptr一、智能指针unique_ptrunique_ptr独享它指向的对象，也
C++ unordered_map 我要满血复活 c++开发语言
1.unordered系列关联式容器在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到，因此在C++11中，STL又提供了4个unordered系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是其底层结构不同,该系列容
C++中的std::initializer_list详解一倾而尽 C++/STL C++11/C++14 C++
initializer_list是C++11提供的一种新类型，其定义于头文件中，此头文件是工具库的一部分，定义如下：namespacestd{templateclassinitializer_list{public:usingvalue_type=E;usingreference=constE&;usingconst_reference=constE&;usingsize_type=size_t;
『 C++11 』模板可变参数包,Lambda表达式与 function 包装器 Dio夹心小面包 C++C++11 c++开发语言 linux
文章目录模板可变参数模板可变参数包的展开可变参数包与STL容器中的emplace函数关系Lambda表达式function包装器function包装器对成员函数的包装bind绑定模板可变参数模板可变参数模板是C++11引入的一个特性,允许模板接收任意数量的参数;该特性增加了C++的泛型编程能力;可变参数模板引入可使用...来表示模板参数包;可在模板参数和函数参数中使用;templatevoidfu
C++ initializer_list 列表初始化（八股总结） fadtes C++八股 c++游戏
定义std::initializer_list是C++11引入的一个类模板，用于支持列表初始化。它允许开发者使用花括号{}提供一组值直接初始化容器或自定义类型。std::initializer_list提供了一种简洁优雅的语法来传递多个值。主要用途初始化容器使用列表初始化方式为容器赋值。#include#includeintmain(){std::vectorvec={1,2,3,4,5};for
C++11特性简述因特麦克斯 c++开发语言
Lambda表达式捕获列表+参数列表（没有参数可以省略）+返回值+函数体类成员函数中定义lambda表达式可以捕获this指针，但是没有捕获函数参数的时候捕获this也不能访问函数参数自动推导返回值：必须是唯一形式的返回值类型才能推导出来，也就是不能出现二义性，比如返回列表时，由于数组和链表都可以以列表的形式返回，所以无法自动推导出返回值类型，这时就需要自己手动声明一下返回值类型"->返回值类型"
在纷繁多变的世界里茁壮成长：C++ 2006–2020（4）C++11：感觉像是门新语言草上爬 C/C++C++C++20
原文链接：GitHub-Cpp-Club/Cxx_HOPL4_zhC++11[Becker2011]发布后，其实现相对来说很快就出现了。这导致了极大的热情，增加了使用，有大量新人涌入C++世界，并进行了大量的实验。C++11的三个完整或几乎完整的实现在2013年面世。我当时的评论被广泛认为是准确的——C++11感觉像是一门新的语言[Stroustrup2014d]。为什么C++11在帮助程序员方面
Spring中@Value注解，需要注意的地方无量 spring bean @Value xml
Spring 3以后,支持@Value注解的方式获取properties文件中的配置值，简化了读取配置文件的复杂操作 1、在applicationContext.xml文件(或引用文件中)中配置properties文件 <bean id="appProperty" class="org.springframework.beans.fac
mongoDB 分片开窍的石头 mongodb
mongoDB的分片。要mongos查询数据时候先查询configsvr看数据在那台shard上，configsvr上边放的是metar信息，指的是那条数据在那个片上。由此可以看出mongo在做分片的时候咱们至少要有一个configsvr,和两个以上的shard（片）信息。第一步启动两台以上的mongo服务 &nb
OVER(PARTITION BY)函数用法 0624chenhong oracle
这篇写得很好，引自 http://www.cnblogs.com/lanzi/archive/2010/10/26/1861338.html OVER(PARTITION BY)函数用法 2010年10月26日 OVER(PARTITION BY)函数介绍开窗函数 &nb
Android开发中，ADB server didn't ACK 解决方法一炮送你回车库 Android开发
首先通知：凡是安装360、豌豆荚、腾讯管家的全部卸载，然后再尝试。一直没搞明白这个问题咋出现的，但今天看到一个方法，搞定了！原来是豌豆荚占用了 5037 端口导致。参见原文章：一个豌豆荚引发的血案——关于ADB server didn't ACK的问题简单来讲，首先将Windows任务进程中的豌豆荚干掉，如果还是不行，再继续按下列步骤排查。 &nb
canvas中的像素绘制问题换个号韩国红果果 JavaScript canvas
pixl的绘制，1.如果绘制点正处于相邻像素交叉线，绘制x像素的线宽，则从交叉线分别向前向后绘制x/2个像素，如果x/2是整数，则刚好填满x个像素，如果是小数，则先把整数格填满，再去绘制剩下的小数部分，绘制时，是将小数部分的颜色用来除以一个像素的宽度，颜色会变淡。所以要用整数坐标来画的话（即绘制点正处于相邻像素交叉线时），线宽必须是2的整数倍。否则会出现不饱满的像素。 2.如果绘制点为一个像素的
编码乱码问题灵静志远 java jvm jsp 编码
1、JVM中单个字符占用的字节长度跟编码方式有关，而默认编码方式又跟平台是一一对应的或说平台决定了默认字符编码方式；2、对于单个字符：ISO-8859-1单字节编码，GBK双字节编码，UTF-8三字节编码；因此中文平台(中文平台默认字符集编码GBK)下一个中文字符占2个字节，而英文平台(英文平台默认字符集编码Cp1252(类似于ISO-8859-1))。 3、getBytes()、getByte
java 求几个月后的日期 darkranger calendar getinstance
Date plandate = planDate.toDate(); SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd"); Calendar cal = Calendar.getInstance(); cal.setTime(plandate); // 取得三个月后时间 cal.add(Calendar.M
数据库设计的三大范式（通俗易懂） aijuans 数据库复习
关系数据库中的关系必须满足一定的要求。满足不同程度要求的为不同范式。数据库的设计范式是数据库设计所需要满足的规范。只有理解数据库的设计范式，才能设计出高效率、优雅的数据库，否则可能会设计出错误的数据库. 目前，主要有六种范式：第一范式、第二范式、第三范式、BC范式、第四范式和第五范式。满足最低要求的叫第一范式，简称1NF。在第一范式基础上进一步满足一些要求的为第二范式，简称2NF。其余依此类推。
想学工作流怎么入手 atongyeye jbpm
工作流在工作中变得越来越重要，很多朋友想学工作流却不知如何入手。很多朋友习惯性的这看一点，那了解一点，既不系统，也容易半途而废。好比学武功，最好的办法是有一本武功秘籍。研究明白，则犹如打通任督二脉。系统学习工作流，很重要的一本书《JBPM工作流开发指南》。本人苦苦学习两个月，基本上可以解决大部分流程问题。整理一下学习思路，有兴趣的朋友可以参考下。 1 首先要
Context和SQLiteOpenHelper创建数据库百合不是茶 android Context创建数据库
一直以为安卓数据库的创建就是使用SQLiteOpenHelper创建,但是最近在android的一本书上看到了Context也可以创建数据库,下面我们一起分析这两种方式创建数据库的方式和区别,重点在SQLiteOpenHelper 一:SQLiteOpenHelper创建数据库: 1,SQLi
浅谈group by和distinct bijian1013 oracle 数据库 group by distinct
group by和distinct只了去重意义一样，但是group by应用范围更广泛些，如分组汇总或者从聚合函数里筛选数据等。譬如：统计每id数并且只显示数大于3 select id ,count(id) from ta
vi opertion 征客丶 mac opration vi
进入 command mode （命令行模式）按 esc 键再按 shift + 冒号注：以下命令中带 $ 【在命令行模式下进行】，不带 $ 【在非命令行模式下进行】一、文件操作 1.1、强制退出不保存 $ q! 1.2、保存 $ w 1.3、保存并退出 $ wq 1.4、刷新或重新加载已打开的文件 $ e 二、光标移动 2.1、跳到指定行数字
【Spark十四】深入Spark RDD第三部分RDD基本API bit1129 spark
对于K/V类型的RDD,如下操作是什么含义？ val rdd = sc.parallelize(List(("A",3),("C",6),("A",1),("B",5)) rdd.reduceByKey(_+_).collect reduceByKey在这里的操作，是把
java类加载机制 BlueSkator java 虚拟机
java类加载机制 1.java类加载器的树状结构引导类加载器 ^ | 扩展类加载器 ^ | 系统类加载器 java使用代理模式来完成类加载，java的类加载器也有类似于继承的关系，引导类是最顶层的加载器，它是所有类的根加载器，它负责加载java核心库。当一个类加载器接到装载类到虚拟机的请求时，通常会代理给父类加载器，若已经是根加载器了，就自己完成加载。虚拟机区分一个Cla
动态添加文本框 BreakingBad 文本框
<script> var num=1; function AddInput() { var str=""; str+="<input
读《研磨设计模式》-代码笔记-单例模式 bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ public class Singleton { } /* * 懒汉模式。注意，getInstance如果在多线程环境中调用，需要加上synchronized，否则存在线程不安全问题 */ class LazySingleton
iOS应用打包发布常见问题 chenhbc ios iOS发布 iOS上传 iOS打包
这个月公司安排我一个人做iOS客户端开发，由于急着用，我先发布一个版本，由于第一次发布iOS应用，期间出了不少问题，记录于此。 1、使用Application Loader 发布时报错：Communication error.please use diagnostic mode to check connectivity.you need to have outbound acc
工作流复杂拓扑结构处理新思路 comsci 设计模式工作算法企业应用 OO
我们走的设计路线和国外的产品不太一样，不一样在哪里呢？国外的流程的设计思路是通过事先定义一整套规则(类似XPDL)来约束和控制流程图的复杂度(我对国外的产品了解不够多，仅仅是在有限的了解程度上面提出这样的看法)，从而避免在流程引擎中处理这些复杂的图的问题，而我们却没有通过事先定义这样的复杂的规则来约束和降低用户自定义流程图的灵活性，这样一来，在引擎和流程流转控制这一个层面就会遇到很
oracle 11g新特性Flashback data archive daizj oracle
1. 什么是flashback data archive Flashback data archive是oracle 11g中引入的一个新特性。Flashback archive是一个新的数据库对象，用于存储一个或多表的历史数据。Flashback archive是一个逻辑对象，概念上类似于表空间。实际上flashback archive可以看作是存储一个或多个表的所有事务变化的逻辑空间。
多叉树:2-3-4树 dieslrae 树
平衡树多叉树,每个节点最多有4个子节点和3个数据项,2,3,4的含义是指一个节点可能含有的子节点的个数,效率比红黑树稍差.一般不允许出现重复关键字值.2-3-4树有以下特征: 1、有一个数据项的节点总是有2个子节点(称为2-节点) 2、有两个数据项的节点总是有3个子节点(称为3-节
C语言学习七动态分配 malloc的使用 dcj3sjt126com c language malloc
/* 2013年3月15日15:16:24 malloc 就memory(内存) allocate(分配)的缩写本程序没有实际含义，只是理解使用 */ # include <stdio.h> # include <malloc.h> int main(void) { int i = 5; //分配了4个字节静态分配 int * p
Objective-C编码规范[译] dcj3sjt126com 代码规范
原文链接 : The official raywenderlich.com Objective-C style guide 原文作者 : raywenderlich.com Team 译文出自 : raywenderlich.com Objective-C编码规范译者 : Sam Lau
0.性能优化-目录 frank1234 性能优化
从今天开始笔者陆续发表一些性能测试相关的文章，主要是对自己前段时间学习的总结，由于水平有限，性能测试领域很深，本人理解的也比较浅，欢迎各位大咖批评指正。主要内容包括：一、性能测试指标吞吐量、TPS、响应时间、负载、可扩展性、PV、思考时间 http://frank1234.iteye.com/blog/2180305 二、性能测试策略生产环境相同基准测试预热等 htt
Java父类取得子类传递的泛型参数Class类型 happyqing java 泛型父类子类 Class
import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import org.junit.Test; abstract class BaseDao<T> { public void getType() { //Class<E> clazz =
跟我学SpringMVC目录汇总贴、PDF下载、源码下载 jinnianshilongnian springMVC
----广告-------------------------------------------------------------- 网站核心商详页开发掌握Java技术，掌握并发/异步工具使用，熟悉spring、ibatis框架；掌握数据库技术，表设计和索引优化，分库分表/读写分离；了解缓存技术，熟练使用如Redis/Memcached等主流技术；了解Ngin
the HTTP rewrite module requires the PCRE library 流浪鱼 rewrite
./configure: error: the HTTP rewrite module requires the PCRE library. 模块依赖性Nginx需要依赖下面3个包 1. gzip 模块需要 zlib 库 ( 下载: http://www.zlib.net/ ) 2. rewrite 模块需要 pcre 库 ( 下载: http://www.pcre.org/ ) 3. s
第12章 Ajax（中） onestopweb Ajax
index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
Optimize query with Query Stripping in Web Intelligence blueoxygen BO
http://wiki.sdn.sap.com/wiki/display/BOBJ/Optimize+query+with+Query+Stripping+in+Web+Intelligence and a very straightfoward video http://www.sdn.sap.com/irj/scn/events?rid=/library/uuid/40ec3a0c-936
Java开发者写SQL时常犯的10个错误 tomcat_oracle java sql
1、不用PreparedStatements 　　有意思的是，在JDBC出现了许多年后的今天，这个错误依然出现在博客、论坛和邮件列表中，即便要记住和理解它是一件很简单的事。开发者不使用PreparedStatements的原因可能有如下几个：　　他们对PreparedStatements不了解　　他们认为使用PreparedStatements太慢了　　他们认为写Prepar
世纪互联与结盟有感阿尔萨斯
10月10日，世纪互联与（Foxcon）签约成立合资公司，有感。全球电子制造业巨头（全球500强企业）与世纪互联共同看好IDC、云计算等业务在中国的增长空间，双方迅速果断出手，在资本层面上达成合作，此举体现了全球电子制造业巨头对世纪互联IDC业务的欣赏与信任，另一方面反映出世纪互联目前良好的运营状况与广阔的发展前景。众所周知，精于电子产品制造（世界第一），对于世纪互联而言，能够与结盟