C++ 学习记录

Generic Algorithm

泛型算法存在的意义在于，在 cpp 中我们可以直接使用cpp自带的数据结构而不是重新去创建自己的结构，而cpp根据它自带的结构设计好了算法可以直接使用，减小了程序编写的难度，是个非常好的工具。

需要注意的几点

• 泛型算法只操作iterator而不是container，所以不会改变container的大小

算法有很多但是结构只有5种：

• alg(beg, end, other args);

  • 这一种最典型的就是find(v.begin(), v.end(), value )，find( )返回的是一个iterator，通过比较返回值和container的尾即.end( )，如果没找到这两个就相等。如果找到了就返回指向第一个出现这个值的iterator。同样也可以对数据进行查找，返回的是pointer。

    // sum the elements in vec starting the summation with the value 0
    int sum = accumulate(vec.cbegin(), vec.cend(), 0);
    

  • accumulate( )也是这种类型的算法，它的第三个输入决定了它的返回类型和相加的初始值。

    // replace any element with the value 0 with 42
replace(ilst.begin(), ilst.end(), 0, 42); 很多算法有copy的版本就像接下来这个

    // use back_inserter to grow destination as needed
    replace_copy(ilst.cbegin(), ilst.cend(),	back_inserter(ivec), 0, 42);
    

    在这个copy的版本，ilst不会变，算法是把内容copy到ivec后面去了，这个算法是属于

  • for_each算法使用一个callable的object然后call input range中的所有元素
    eg:

    // print words of the given size or longer, each one followed by a space
    for_each(wc, words.end(), [](const string &s){cout << s << " ";});
    cout << endl;
    

    这是个将vector中元素打印出来的好办法，当然也可以使用for range的方法来打印.

• alg(beg, end, dest, other args);
  If dest is an iterator that refers directly to a container, then the algorithm writes its
  output to existing elements within the container，这就是dest 和下面beg2区别

  	// use back_inserter to grow destination as needed
  	replace_copy(ilst.cbegin(), ilst.cend(),	back_inserter(ivec), 0, 42);
  

  在这个copy的版本，ilst不会变，算法是把内容copy到ivec后面去了

• alg(beg, end, beg2, other args);
  这种是输入一个sequence的开始和结束，然后输入第二个sequence的开始，这种形式会假设第二个sequence至少和第一个sequence一样长

  copy( ) 也是这种类型，
  eg: auto ret = copy(begin(a1), end(a1), a2);//copy a1 into a2
  返回的是copy到a2的最后一个元素的后面一个

  // roster2 should have at least as many elements as roster1
  equal(roster1.cbegin(), roster1.cend(), roster2.cbegin(),pred);
  

  这个equal( )返回的返回值是boolean类型，比较两个sequence是不是相等，默认用==，可以用pred来判断。

• alg(beg, end, beg2, end2, other args);

还有一些少数不遵从这种规律的：

• fill_n(dest, n, val) 在dest这个地方放n个val，但是这个函数并不会去check写入是不是合法的，是不是有足够的空间来写入

其他知识点

back_inserter：
back_inserter要求输入一个container的reference然后返回一个绑定这个container的insert iterator，当我们通过这个iterator assign值的时候，它会自己叫push_back增加元素
我们经常用back_insert去创建iterator然后把其当做目的地输入到算法当中
eg：

fill_n(back_inserter(vec), 10, 0); // appends ten elements to vec

消除重复元素三连击：

// sort words alphabetically so we can find the duplicates
sort(words.begin(), words.end());
// unique reorders the input range so that each word appears once in the
// front portion of the range and returns an iterator one past the unique range
auto end_unique = unique(words.begin(), words.end());
// erase uses a vector operation to remove the nonunique elements
words.erase(end_unique, words.end());

消除重复元素的三连击，先是sort，然后unique，最后container operation— erase。
这么做的原因是unique算法通过重排输入去消除掉重复的单元，通过把重复的单元放到不重复的sequence后面，然后返回iterator指向不重复的sequence的最后一个之后

Lambdas
在有些算法中可以输入一个predicate，这个predicate可以是函数也可以是lambdas。这个predicate的主要作用是作为判断条件，比如说find_if( )这个算法，如果想对if做个人的设置的话可以使用function或者lambda。

[capture list] (parameter list) -> return type { function body }

其中capture list和function body是必须的，[capture list]中放的是需要使用的任何surrounding 函数的local variable.
eg:

// get an iterator to the first element whose size() is >= sz
auto wc = find_if(words.begin(), words.end(), [sz](const string &a)
													{ return a.size() >= sz; });

capture list只是被用作申明要使用local non-static的变量的，lambda可以直接使用local static 变量和申明在方程之外的变量

capture的方式也有两种，capture by value和capture by reference，如果是by value的话，对这个变量的改变不会实质影响到这个变量，但是如果是by reference的话，则就会改变到这个变量的值.（尽量去使用by value的方式，因为by reference需要程序员保证这个变量你使用它的时候还存在，不然就会报错）

也可以让compiler去推测我们要capture的值，通过在capture list中使用&或者=，当我们想要capture by value和reference混合使用的时候就可以采用这种办法
eg:

// sz implicitly captured by value 单独使用capture by value
wc = find_if(words.begin(), words.end(), [=](const string &s)
{ return s.size() >= sz; });

如果我们想要定义一个return type的话，我们必须要使用trailing return type
eg:

transform(vi.begin(), vi.end(), vi.begin(),[] (int i) -> int { if (i < 0) return -i; else return i; });

这个transform也是alg(beg, end, beg2, other args);这种类型的算法

bind 函数
这是一个可以把函数重新包装的函数，可以让你调整原来函数的参数列表。

auto newCallable = bind(callable, arg_list);

bind的第一个参数是一个callable的输入，后面接着一个由逗号隔开的参数表，参数表中的参数会传入到callable中去。
eg:

// check6 is a callable object that takes one argument of type string
// and calls check_size on its given string and the value 6
auto check6 = bind(check_size, _1, 6);
string s = "hello";
bool b1 = check6(s); // check6(s) calls check_size(s, 6)

参数在参数表中以_n的形式，n代表了产生的bind函数中参数的顺序。参数传到callable中作为callable的第几个参数决定于arg_list中参数的顺序。arg_list实际上就像是callable的参数表，除了_n代表了这个地方的参数被新的bind的第n个输入给取代。

//这个例子讲解新旧函数参数之间的关系
// g is a callable object that takes two arguments
auto g = bind(f, a, b, _2, c, _1);

f的输入依次是a,b,_2(产生的g的第二个输入参数)，c，_1(产生的g的第一个输入参数)

Reverse Iterators
和正常iterator相比是反向的，++就是向前，–则是向后
用法之一:

sort(vec.begin(), vec.end()); // sorts vec in ''normal'' order 从小到大
// sorts in reverse: puts the smallest element at the end of vec
sort(vec.rbegin(), vec.rend()); //从大到小

之二： 从后往前找东西

// find the last element in a comma-separated list
auto rcomma = find(line.crbegin(), line.crend(), ',');