笔记：C++学习之旅---泛型算法

       标准库并未给每个容器定义成员函数来实现这些操作，而是定义了一组泛型算法（generic algorithm）:称他们为”算法“，是因为他们实现了一些经典算法的公共接口，如排序和搜索：称他们是“泛型的”，是因为它们可以用于不同类型的元素和多种容器类型（不仅包括标准库类型，如vector或list，还包括内置的数组类型），以及我们将看到的，还能用于其他类型的序列。

练习10.3，10.4

#include
<iostream>

#include
<vector>

#include
<numeric>

using
namespace
std;

int
main()

{

            
vector
<
int
> vec;

            
int
i = 0;

            cout <<
"请输入整数"
<< endl;

            
while
(cin >> i)

            {

                        
if
(i == -1)

                                    
break
;

                        vec.push_back(i);

            }

            
int
val;

            cout <<
"请输入你要查找的数字\n"
;

            cin >> val;

            
auto
result = find(vec.cbegin(), vec.cend(), val);
//查找输入的数字是否在容器中，在则显示the value x is present，否则显示the value is not present；

            cout <<
"The value "
<< val << (result == vec.cend() ?
" is not present\n "
:
" is present\n"
) << endl;
//

            cout <<
"accumulate1:"
<< accumulate(vec.cbegin(), vec.cend(), 0)<<endl;
//算出元素之和；

            
vector
<
double
> ivec = { 1.1, 2.2, 3.3, 4.4,5.5 };

            cout <<
"accumulate2:"
<< accumulate(ivec.cbegin(), ivec.cend(), 0.0)<<endl;   //16.5   前面是double，一定要注意用0.0

            
return
0;

}

关键概念：算法永远不会执行容器的操作

慎用内联
内联能提高函数的执行效率，为什么不把所有的函数都定义成内联函数？
如果所有的函数都是内联函数，还用得着“内联”这个关键字吗？
内联是以代码膨胀（复制）为代价，仅仅省去了函数调用的开销，从而提高函数的
执行效率。如果执行函数体内代码的时间，相比于函数调用的开销较大，那么效率的收
获会很少。另一方面，每一处内联函数的调用都要复制代码，将使程序的总代码量增大，
消耗更多的内存空间。以下情况不宜使用内联：
（1）如果函数体内的代码比较长，使用内联将导致内存消耗代价较高。
（2）如果函数体内出现循环，那么执行函数体内代码的时间要比函数调用的开销大。
类的构造函数和析构函数容易让人误解成使用内联更有效。要当心构造函数和析构
函数可能会隐藏一些行为，如“偷偷地”执行了基类或成员对象的构造函数和析构函数。
所以不要随便地将构造函数和析构函数的定义体放在类声明中。
一个好的编译器将会根据函数的定义体，自动地取消不值得的内联（这进一步说明
了inline 不应该出现在函数的声明中）。

C++ 语言支持函数内联，其目的是为了提高函数的执行效率（速度）。

重排容器元素的算法（sort）、消除重复单词（unique）、使用容器操作删除元素（erase）

练习：10.9

实现你自己的elimDups。测试你的程序，分别在读取输入后，调用unique后以及调用erase后打印vector。

#include
<iostream>

#include
<vector>

#include
<string>

#include
<algorithm>

using
namespace
std;

void
elimDups(
vector
<
string
> &
vec
)

{

            sort(
vec
.begin(),
vec
.end());
//排序

            
auto
end_unique = unique(
vec
.begin(),
vec
.end());
//重排输入范围，使得每个单词只出现一次,找到重复元素；

            cout <<
"unique after\n"
;

            
for
(
auto
i = 0; i !=
vec
.size(); ++i)

            {

                        cout<<
vec
[i] <<
" "
;

            }

            cout<< endl;

            
vec
.erase(end_unique,
vec
.end());
//删除重复元素

            cout <<
"erase after\n"
;

            
for
(
auto
i = 0; i !=
vec
.size(); ++i)

            {

                        cout <<
vec
[i] <<
" "
;

            }

            cout << endl;

}

int
main()

{

            
string
word;

            
vector
<
string
> vec;

            cout <<
"请输入一串单词(#结束)\n"
;

            
while
(cin >> word)

            {

                        
if
(word ==
"#"
)

                                    
break
;

                        vec.push_back(word);

            }

            elimDups(vec);

            
return
0;

}

lambda 表达式

练习10.16

使用lambda编写你自己版本的biggies.

#include
<iostream>

#include
<string>

#include
<vector>

#include
<algorithm>

using
namespace
std;

void
elimpDups(vector<string> &s)

{

            sort(s.begin(), s.end());
//排序；

            
auto
new_end = unique(s.begin(), s.end());
//找出重复元素；

            s.erase(new_end, s.end());
//删除重复元素；

}

void
biggies(vector<string> &words, vector<string>::size_type sz,ostream &os = cout,
char
c =
' '
)

{

            elimpDups(words);

            stable_sort(words.begin(), words.end(), [](string
const
&lhs, string
const
&rhs){

                        
return
lhs.size() < rhs.size();});
//按长度排序，长度相同的单词维持字典序；

                        
auto
wc = find_if(words.begin(), words.end(), [sz](string
const
&a){

                                    
return
a.size() >= sz;});
//找到满足size >= sz的元素数目；

                                    
/*for_each(wc, words.end(),[](const string &s){

                                                cout << s << " ";});// 打印长度大于等于给定值的单词，每个单词后面接一个空格；

                                                cout << endl;

                                                */

                                    for_each(wc, words.end(), [&os, c](
const
string &s){

                                                os << s << c;});
//加入引用捕获；ostream &os = cout,char c = ' ';

                                                os << endl;

}

void
  fun1()

{

            size_t v1 = 42;

            
auto
f2 = [&v1]{
return
++v1; };

            v1 = 0;

            
auto
j1 = f2();

            cout << j1 << endl;
//j1 = 1;

}

void
fun2()

{

            size_t v1 = 42;

            
auto
f2 = [v1]()
mutable
{
return
++v1; };

            v1 = 0;

            
auto
j2 = f2();

            cout << j2 << endl;
//j2 = 43

}

int
main()

{

            vector<string> vec = {
"1234"
,
"1234"
,
"1234"
,
"hi~"
,
"alan"
,
"alan"
,
"cp"
,
"a"
,
"abc"
};

            biggies(vec,3);

            fun1();
//引用捕获

            fun2();
//变量捕获

            
return
0;

}

默认情况下，对一个被拷贝的变量，lambda不会改变其值，如果我们希望能改变一个被捕获的变量的值，就必须在参数列表首加上关键字mutable。因此，可变的lambda能省略参数列表。

引用捕获

隐示捕获

谓词：
是一个可调用的表达式，其返回结果是一个能用做条件的的值。标准库算法所使用的的谓词分为两类：一元谓词（意味着它只接受单一参数）、二元谓词（意味着它们有两个参数）。

练习10.24：

给定一个string，使用bind和chaeck_size在一个int的vector中查找第一个大于string长度的值。

#include
<iostream>

#include
<vector>

#include
<algorithm>

#include
<string>

#include
<functional>

using
namespace
std;

inline
bool
check_size(
const
string
&
s
,
vector
<
int
>::
size_type
sz
)

{

            
return
s
.size() <
sz
;

}

inline
vector
<
int
>::
const_iterator
find_first_bigger(
const
vector
<
int
> &
vec
,
const
string
&
s
)

{

            
return
find_if(
vec
.cbegin(),
vec
.cend(),

                        bind(check_size,
s
, placeholders::_1));

}

int
main()

{

            
vector
<
int
> vec = { 1, 2, 3, 4, 5, 6 };

            
string
s = {
"test"
};

            cout << *find_first_bigger(vec, s)<<endl;
//5,找到第一个比字符串“test“ 4 大的数.

            
return
0;

}

再探迭代器

除了为每个容器定义的迭代器之外，标准库在头文件iterator中还定义了额外几种迭代器：

插入迭代器：这些迭代器被绑定到一个容器上，可以来向容器插入元素。

流迭代器：这些迭代器被绑定到输入输出流上，可用来遍历所关联的IO流。

反向迭代器：这些迭代器向后面不是向前移动，除了forword_list之外的标准库容器都有反向迭代器。

移动迭代器：这些专用的迭代器不是拷贝其中的元素，而是移动它们。

插入迭代器

流迭代器