《C++primer(第五版)》学习之路-第十章：泛型算法

最新推荐文章于 2022-03-28 15:21:50 发布
最新推荐文章于 2022-03-28 15:21:50 发布
阅读量2.3k 收藏 4
点赞数
分类专栏： C++primer(第五版)学习之路 《C++primer(第五版)》学习之路 文章标签： C++primer
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/libin1105/article/details/48706281
版权

【 声明：版权所有，转载请标明出处，请勿用于商业用途。  联系信箱：libin493073668@sina.com】


10.1 概述


1.大多数算法都定义在头文件algorithm中。标准库还在文件numeric中定义了一组数值泛型算法。


10.2 初识泛型算法


1.

accumulate：定义在头文件numeric中。作用是对范围求和。

euqal：定义在头文件algorithm中。作用是判断给定两个区间是否相等。

fill：定义在头文件algorithm中。作用是对给定区间全部赋予某值。

fill_n：定义在头文件algorithm中。作用是对给定迭代器后的n个元素赋予某值。

back_inserter：定义在头文件iterator中。得到指向容器尾部的迭代器。

sort：定义在头文件algorithm中。对指定区间排序。

unique：定义在头文件algorithm中。“消除”重复项，返回指向不重复值范围末尾的迭代器。

erase：定义在头文件algorithm中。删除指定范围内的元素。


10.3 定制操作


1.谓词是一个可调用的表达式，其返回结果是一个能用作条件的值。谓词分为：一元谓词和二元谓词。几元谓词接受几元参数。


2.可调用对象定义;对于一个对象或一个表达式，如果可以对其使用调用运算符，则称为可调用的；可调用的对象有：函数、函数指针、重载函数调用运算符的类和lambda表达式。
lambda表达式形式：
[capture list](parameter list)->return type{function body};
capture list是一个lambda所在函数中定义的局部变量的列表（通常为空）；
return type、parameter list和function body分别表示返回类型、参数列表和函数体。


3.标准库bind函数

头文件：functional ；它接受一个可调用对象，生成一个新的可调用对象来适应原对象的参数列表。
调用bind的形式：
auto newCallable=bind(callable, arg_list);
newCallable本身是一个可调用对象，arg_list是一个逗号分隔的参数列表，对应给定的callable的参数。arg_list中的参数可能包含形如_n的名字，_1是newCallable的第一个参数,_2为第二个参数，依次类推。


4.bind拷贝参数而不能拷贝ostream。我们可以使用ref函数。

函数ref返回一个对象，包含给定引用，此对象是可以拷贝的。标准库中海油一个cref函数，生成一个保存const引用的类。与bind一样，函数ref和cref也定义在头文件functional 中。


10.4 再探迭代器


1.

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

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

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

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


2.

back_inserter            创建一个使用push_back的迭代器

front_inserter            创建一个使用push_front的迭代器

inserter                      创建一个使用insert的迭代器。此函数接受第二个参数，这个参数必须是一个指向给定容器的

                                  迭代器。元素将插入到给定迭代器所表示的元素之前。


3.

istream_iterator操作

istream_iterator<T> in(is)           in从输入流is读取类型为T的值

istream_iterator<T> end;           读取类型为T的值的istream_iterator迭代器，表示尾后位置

in1 == in2                                   in1和in2必须读取相同类型。如果它们都是尾后迭代器，或绑定到相同

in1 != in2                                    的输入，则两者相等

*in                                               返回从流中读取的值

in->mem                                     与(*in).mem的含义相同

++in,in++                                   使用元素类型所定义的>>运算符从输入流中读取下一值。与以往一样，前置版本返回一个指向递增后迭代器的引用，后置版本返回旧值


4.

ostream_iterator操作

ostream_iterator<T> out(os);         out将类型为T的值写到输出流os中

ostream_iterator<T> out(os,d);      out将类型为T的值写到输出流os中，每个值后面都输出一个d。d指向一个空字符结尾的字符数组

out = val;                                        用<<运算符将val写入到out所绑定的ostream中。val的类型必须与out可写的类型兼容。

*out,++out,out++;                          这些运算符是存在的，但不对out做任何事情。每个运算符都返回out


10.5 泛型算法结构


1.迭代器类别

输入迭代器                只读，不写；单遍扫描，只能递增

输出迭代器                只写，不读；单遍扫描，只能递增

前向迭代器                可读写，多遍扫描，只能递增

双向迭代器                可读写，多遍扫描，可递增递减

随机访问迭代器         可读写，多遍扫描，支持全部迭代器运算


10.6 特定容器算法


1.

list和forward_list成员函数版本的算法

lst.merga(lst2)            

lst.megra(lst2,comp)    将来自lst2的元素合并入lst。lst和lst2都必须是有序的。元素将从lst2中删除。在合并之后，lst2变成空。第一个版本使用<运算符；第二个版本使用给定的比较操作。

lst.remove(val)            

lst.remove_if(pred)      调用erase删除掉与给定值相等(==)或令一元谓词为真的每个元素

lst.reverse()                 反转lst中元素的顺序

lst.sort()                       

lst.sort(comp)               使用<或给定比较操作排序元素

lst.unique()        

lst.unique(pred)            调用erase删除统一个值的连续拷贝。第一个版本使用==；第二个版本使用给定的二元谓词


2.

list和forward_list的splice成员函数的参数

lst.splice(args)或flst.splice_after(args)

(p,lst2)         p是一个指向lst中元素的迭代器，或一个指向flst首前位置的迭代器。函数将lst2的所有元素移动到lst中p之前的位置或是flst中p之后的位置。将元素从lst2中删除。lst2的类型必须与lst或flst相同，且不能是同一个链表。

(p,lst2,p2)    p2是一个指向lst2中位置的有效迭代器。将p2指向的元素移动到lst中，或将p2之后的元素移动到flst中。lst2可以是与lst或flst相同的链表。

(p,lst2,b,e)   b和e必须表示lst2中的合法范围。将给定范围中的元素从lst2移动到lst或flst。lst2与lst(或flst)可以是相同的链表，但p不能指向给定范围中元素。



PS：部分练习答案


练习10.1 & 10.2

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <list>

int main()
{
	std::vector<int> vec = {1,2,2,3,3,3,4,4,4,4,5,5,5,5,5,5};
	std::cout << "ex 10.1: " << std::count(vec.cbegin(),vec.cend(),5) << "times" << std::endl;
	
	std::list<std::string> lst = {"a","aa","aa","aa"};
	std::cout << "ex 10.2: " << std::count(lst.cbegin(),lst.cend(),"aa") << "times" << std::endl;
	
	return 0;
}

练习10.3 & 10.4

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <numeric>

int main()
{
	std::vector<int> ivec = {1,2,3,4,5};
	std::cout << "ex 10.3: " << std::accumulate(ivec.cbegin(),ivec.cend(),0) << std::endl;
	
	std::vector<double> dvec = {1.1,2.2,3.3,4.4,5.5};
	std::cout << "ex 10.4: " << std::accumulate(dvec.cbegin(),dvec.cend(),0) << std::endl;
	std::cout << "ex 10.4: " << std::accumulate(dvec.cbegin(),dvec.cend(),double(0)) << std::endl;
	
	return 0;
}

练习10.5 

#include <algorithm>
#include <iostream>
#include <vector>
#include <list>

int main()
{
	std::vector<const char*> roster1{"one","two","three"};
	std::list<const char*> roster2{"one","two","three","four","five"};
	
	std::cout << std::equal(roster1.cbegin(),roster1.cend(),roster2.cbegin()) << std::endl;
}

练习10.6 

#include <algorithm>
#include <iostream>
#include <vector>

int main()
{
	std::vector<int> ivec {1,2,3,4,5,6,7,8,9,10};
	std::fill_n(ivec.begin(),ivec.size(),0);
	for(auto i: ivec)
		std::cout << i << " ";
	std::cout << std::endl;
}

练习10.7

a.运行错误，改正为

vector<int> vec;
list<int> lst;
int i;
while (cin >> i) lst.push_back(i);
vec.resize(lst.size());
copy(lst.cbegin(), lst.cend(), vec.begin());

b.没有错误，但是vec还是空，reserve只是改变vec能存的最大容量，目前能存的容量没有改变

练习10.9

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

template <typename Sequence> auto println(Sequence const& seq) -> std::ostream&
{
	for(auto const& elem : seq)
		std::cout << elem << " ";
	return std::cout << std::endl;
}

auto elimDups(std::vector<std::string>& vs) -> std::vector<std::string>&
{
	std::sort(vs.begin(),vs.end());
	println(vs);

	auto new_end = std::unique(vs.begin(),vs.end());
	println(vs);

	vs.erase(new_end,vs.end());
	return vs;
}

int main()
{
	std::vector<std::string> vs {"a", "v", "a", "s", "v", "a", "a"};
	println(vs);
	println(elimDups(vs));
	return 0;
}

练习10.11

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <numeric>
#include <list>

template <typename Sequence> inline std::ostream& println(Sequence const& seq)
{
	for(auto const& elem : seq)
		std::cout << elem << " ";
	return std::cout;
}

inline bool is_shorter(std::string const& lhs,std::string const& rhs)
{
	return lhs.size() < rhs.size();
}

void elimDups(std::vector<std::string>& vs)
{
	std::sort(vs.begin(),vs.end());
	auto new_end = std::unique(vs.begin(),vs.end());
	vs.erase(new_end,vs.end());
}

int main()
{
	std::vector<std::string> vec {"1234", "1234", "1234", "Hi", "alan", "wang"};
	elimDups(vec);
	std::stable_sort(vec.begin(),vec.end(),is_shorter);
	std::cout << "ex 10.11 :" << std::endl;
	println(vec);
	return 0;
}
练习10.12 

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <numeric>
#include "ex7_26.h"

inline bool compareIsbn(const Sales_data& d1,const Sales_data& d2)
{
	return d1.isbn()<d2.isbn();
}

int main()
{
	Sales_data d1("aa"),d2("aaaa"),d3("aaa"),d4("z"),d5("aaaaz");
	std::vector<Sales_data> vec {d1,d2,d3,d4,d5};

	std::sort(vec.begin(),vec.end(),compareIsbn);

	for(const auto& elem : vec)
		std::cout << elem.isbn() << " ";
	std::cout << std::endl;
	return 0;
}
练习10.13 

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

bool predicate(const std::string& s)
{
	return s.size()>=5;
}

int main()
{
	auto vec = std::vector<std::string>{"a","aaaa","aasaa","bbbbbbb","ccc"};
	auto pivot = std::partition(vec.begin(),vec.end(),predicate);
	for(auto it = vec.begin();it!=pivot;++it)
	std::cout << *it << " ";
	std::cout << std::endl;
	
	return 0;
}
练习10.14 

auto add = [](int lhs,int rhs){return lhs+rhs;};
练习10.15 

int a = 10;
auto add = [a](int b){return a+b;};
练习10.16 

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

void elimDups(std::vector<std::string>& vec)
{
	sort(vec.begin(),vec.end());
	auto new_end = std::unique(vec.begin(),vec.end());
	vec.erase(new_end,vec.end());
}

void biggies(std::vector<std::string> vec,std::size_t sz)
{
	using std::string;
	
	elimDups(vec);
	
	std::stable_sort(vec.begin(),vec.end(),[](string const& lhs,string const& rhs){return lhs.size()<rhs.size();});
	
	auto wc = find_if(vec.begin(),vec.end(),[sz](string const&lhs){return lhs.size()>=sz;});
	
	std::for_each(wc,vec.end(),[](const string& s){std::cout << s << " ";});
	std::cout << std::endl;
}

int main()
{
	std::vector<std::string> vec {"1234", "1234", "1234", "hi~", "alan", "alan", "cp"};
	biggies(vec,3);
	std::cout << std::endl;
	return 0;
}

练习10.17 

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <numeric>
#include "ex7_26.h"

int main()
{
	Sales_data d1("aa"),d2("aaaa"),d3("aaa"),d4("z"),d5("aaaaz");
	std::vector<Sales_data> vec {d1,d2,d3,d4,d5};

	std::sort(vec.begin(),vec.end(),[](const Sales_data& d1,const Sales_data& d2){return d1.isbn()<d2.isbn();});

	for(const auto& elem : vec)
		std::cout << elem.isbn() << " ";
	std::cout << std::endl;
	return 0;
}

练习10.18 & 10.19 

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

//from ex 10.9
void elimdups(std::vector<std::string>& vs)
{
	std::sort(vs.begin(), vs.end());
	auto new_end = std::unique(vs.begin(), vs.end());
	vs.erase(new_end, vs.end());
}

//ex10.18
void biggies_partition(std::vector<std::string>& vs, std::size_t sz)
{
	elimdups(vs);

	auto pivot = partition(vs.begin(), vs.end(), [sz](const std::string& s)
	{
		return s.size() >= sz;
	});

	for (auto it = vs.cbegin(); it != pivot; ++it)
		std::cout << *it << " ";
}

//ex10.19
void biggies_stable_partition(std::vector<std::string>& vs, std::size_t sz)
{
	elimdups(vs);

	auto pivot = stable_partition(vs.begin(), vs.end(), [sz](const std::string& s)
	{
		return s.size() >= sz;
	});

	for (auto it = vs.cbegin(); it != pivot; ++it)
		std::cout << *it << " ";
}

int main()
{
	//ex10.18
	std::vector<std::string> v {"the",  "quick", "red",  "fox", "jumps", "over", "the",   "slow", "red", "turtle"};

	std::cout << "ex10.18: ";
	std::vector<std::string> v1(v);
	biggies_partition(v1, 4);
	std::cout << std::endl;

	//ex10.19
	std::cout << "ex10.19: ";
	std::vector<std::string> v2(v);
	biggies_stable_partition(v2, 4);
	std::cout << std::endl;

	return 0;
}

练习10.20 

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

std::size_t bigerThan6(std::vector<std::string> vec)
{
	return count_if(vec.begin(),vec.end(),[](std::string const& s){return s.size()>6;});
}

int main()
{
	std::vector<std::string> vec{"alan",    "moophy",  "1234567", "1234567", "1234567", "1234567"};
    std::cout << bigerThan6(vec) << std::endl;
}

练习10.21 

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

int main()
{
	int i = 7;
	auto fun = [&i]()
	{
		return --i?false:true;
	};
	while(!fun())
		std::cout << i << " ";
	std::cout << std::endl;
}

练习10.22 

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>

using namespace std::placeholders;

bool isBigerThan6(std::string& s,std::size_t sz)
{
	return s.size()>6;
}

int main()
{
	std::vector<std::string> vec {"alan", "moophy", "1234567", "1234567", "1234567", "1234567"};
	std::cout << count_if(vec.begin(),vec.end(),bind(isBigerThan6,_1,6)) << std::endl;
}

练习10.22 

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>

using namespace std::placeholders;

inline bool check_size(const std::string& s,std::string::size_type sz)
{
	return s.size()<sz;
}

inline std::vector<int>::const_iterator find_first_bigger(const std::vector<int>& vec,const std::string& s)
{
	return find_if(vec.cbegin(),vec.cend(),bind(check_size,s,_1));
}

int main()
{
	std::vector<int> vec{1,2,3,4,5,6,7};
	std::string s("test");
	std::cout << *find_first_bigger(vec,s) << std::endl;
	return 0;
}

练习10.25 

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>

using namespace std::placeholders;
using std::vector;
using std::string;

void elimDups(vector<string>& vs)
{
	sort(vs.begin(),vs.end());
	vs.erase(unique(vs.begin(),vs.end()));
}

bool check_size(const string& s,string::size_type sz)
{
	return s.size()>=sz;
}

void biggies(vector<string>& words,vector<string>::size_type sz)
{
	elimDups(words);
	auto iter = std::stable_partition(words.begin(),words.end(),bind(check_size,_1,sz));
	for_each(words.begin(),iter,[](const string&s){std::cout<<s<<std::endl;});
}

int main()
{
	 vector<string> vec{"the",  "quick", "red",  "fox", "jumps", "over", "the", "slow", "red", "turtle"};
	 biggies(vec,4);
	return 0;
}

练习10.27 

#include <iostream>
#include <vector>
#include <list>
#include <algorithm>

int main()
{
	std::vector<int> vec{1,1,2,2,2,3,3,3,4,5};
	std::list<int> lst;
	
	std::unique_copy(vec.begin(),vec.end(),back_inserter(lst));
	
	for(auto elem : lst)
	std::cout << elem << " ";
	std::cout << std::endl;	
}

练习10.28 

#include <iostream>
#include <vector>
#include <list>
#include <algorithm>

template <typename Sequence> void print(Sequence const& seq)
{
	for(const auto& elem : seq)
	std::cout << elem << " ";
	std::cout << std::endl;
}

int main()
{
	std::vector<int> vec{1,2,3,4,5,6,7,8,9};
	std::list<int> lst1,lst2,lst3;
	
	std::unique_copy(vec.cbegin(),vec.cend(),inserter(lst1,lst1.begin()));
	print(lst1);
	
	std::unique_copy(vec.cbegin(),vec.cend(),back_inserter(lst2));
	print(lst2);
	
	std::unique_copy(vec.cbegin(),vec.cend(),front_inserter(lst3));
	print(lst3);
}

练习10.29 

#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
#include <fstream>
#include <iterator>

using std::string;

int main()
{
	std::ifstream ifs("data.txt");
	std::istream_iterator<string> in(ifs),eof;
	std::vector<string> vec;
	std::copy(in,eof,back_inserter(vec));
	
	std::copy(vec.cbegin(),vec.cend(),std::ostream_iterator<string>(std::cout,"\n"));
	return 0;
}

练习10.30 

#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>

int main()
{
	std::istream_iterator<int> in_iter(std::cin),eof;
	std::vector<int> vec;
	while(in_iter!=eof)
	vec.push_back(*in_iter++);
	std::sort(vec.begin(),vec.end());
	std::copy(vec.cbegin(),vec.cend(),std::ostream_iterator<int>(std::cout," "));
}

练习10.31 

#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>

int main()
{
	std::istream_iterator<int> in_iter(std::cin),eof;
	std::vector<int> vec;
	while(in_iter!=eof)
	vec.push_back(*in_iter++);
	std::sort(vec.begin(),vec.end());
	std::unique_copy(vec.cbegin(),vec.cend(),std::ostream_iterator<int>(std::cout," "));
}

练习10.32 

#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
#include <numeric>
#include "Sales_item.h"

int main()
{
    std::istream_iterator<Sales_item> in_iter(std::cin),in_eof;
    std::vector<Sales_item> vec;
    
    while(in_iter!=in_eof)
    vec.push_back(*in_iter++);
    sort(vec.begin(),vec.end(),[](Sales_item const& lhs,Sales_item const& rhs){return lhs.isbn()<rhs.isbn();});
    
    for(auto beg = vec.cbegin(),end = beg;beg!=vec.cend();beg = end)
    {
    	end = find_if(beg,vec.cend(),[beg](const Sales_item& item){return item.isbn()!=beg->isbn();});
    	std::cout << std::accumulate(beg,end,Sales_item(beg->isbn())) << std::endl;
	}
}

练习10.33 

#include <fstream>
#include <iterator>
#include <algorithm>

int main(int argc, char** argv)
{
	if (argc != 4) return -1;

	std::ifstream ifs(argv[1]);
	std::ofstream ofs_odd(argv[2]), ofs_even(argv[3]);

	std::istream_iterator<int> in(ifs), in_eof;
	std::ostream_iterator<int> out_odd(ofs_odd, " "), out_even(ofs_even, "\n");

	std::for_each(in, in_eof, [&out_odd, &out_even](const int i)
	{
		*(i & 0x1 ? out_odd : out_even)++ = i;
	});

	return 0;
}

练习10.34~10.37 

#include <iostream>
#include <fstream>
#include <algorithm>
#include <iterator>
#include <string>
#include <list>


//ex 10.34
inline void r_print(const std::vector<std::string>& v)
{
    std::for_each(v.crbegin(), v.crend(),
                  [](const std::string& s) { std::cout << s << " "; });
}

//! ex 10.35
inline void r_withOrdinary_print(const std::vector<std::string>& v)
{
    for (auto it = std::prev(v.cend()); it != std::prev(v.cbegin()); --it)
        std::cout << *it << " ";
}

//ex 10.36
inline std::list<int>::iterator find_last_0(std::list<int>& l)
{
    auto r_it = std::find(l.rbegin(), l.rend(), 0);
    auto it = r_it.base();
    return std::prev(it);
}

//ex 10.37:
inline void vec2list_3_7_reverse(const std::vector<int>& v, std::list<int>& l)
{
    std::copy(v.crbegin() + 3, v.crbegin() + 8, std::back_inserter(l));
}

int main()
{

    std::vector<std::string> v = {"aa", "bb", "cc"};

    //test for 10.34
    r_print(v);
    std::cout << "\n";

    //test for 10.35
    r_withOrdinary_print(v);
    std::cout << "\n";

    //test for 10.36
    std::list<int> l = {1, 2, 3, 4, 0, 5, 6};
    auto it = find_last_0(l);
    std::cout << *it << "\n";

    //test for 10.37
    std::vector<int> vi = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    std::list<int> lst;
    vec2list_3_7_reverse(vi, lst);
    for (auto e : lst) std::cout << e << " ";
    std::cout << std::endl;

    return 0;
}

练习10.42 

#include <iostream>
#include <string>
#include <list>

using std::string;
using std::list;

void elimDups(list<string>& words)
{
	words.sort();
	words.unique();
}

int main()
{
	list<string> l = {"aa", "aa", "aa", "aa", "aasss", "aa"};
	elimDups(l);
	for (const auto& e : l)
		std::cout << e << " ";
	std::cout << std::endl;
}


月下键客
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++ Primer(第五版)|练习题答案与解析(第十章:泛型算法)
01-06
C++ Primer(第五版)|练习题答案与解析(第十章:泛型算法) 本博客主要记录C++ Primer(第五版)中的练习题答案与解析。 参考:C++ Primer C++ Primer 练习题10.1 头文件algorithm中定义了一个名为count的函数，它类似find...
C++Primer(第5版） 习题10.9、10.11
Teng_NaoDan的博客
06-07 159
10.9实现elimDups函数，作用为排序并删除重复元素； 10.11对elimpDups进一步处理，作用为首先按元素大小排序，且等长度的元素会保持字典顺序；
C++ lambda 表达式
storm
09-24 733
在看c++ Primer 关于泛型编程的章节中，看到了lambda和bindlia
《C++ Primer》学习笔记（十）：泛型算法
南方以北
05-17 398
《C++ Primer》学习笔记（十）：泛型算法初识泛型算法只读算法写容器元素的算法重排容器元素的算法定制操作向算法传递函数lambda表达式 泛型算法是一组公共接口，可以用于不同类型的元素和多种容器类型。 泛型算法本身不会执行容器的操作，只会运行于特定迭代器上，执行迭代器的操作，即不会改变底层容器的大小。但是标准库定义了一类特殊的迭代器：插入器（inserter)。与普通迭代器只能遍历所绑定的容器相比，插入器能做更多的事情。当给这类迭代器赋值时，它们会在底层的容器上执行插入操作。因此当一个算法操作这样的迭
C++Primer第五版 习题答案 第十章 泛型算法
qq_24898229的博客
03-28 776
10.1 #include<iostream> #include<algorithm> #include<vector> using namespace std; int main() { vector<int>v1{ 1,2,4,5,3,1,5,6,8,7,1,1,1,1 }; cout << count(v1.cbegin(), v1.cend(), 1) << endl; return 0; } 10.2 #inclu
C++ 泛型算法（一）初识泛型算法，lambda表达式
强者之路
04-14 676
文章目录概述算法工作原理泛型算法只读算法写容器算法重排容器元素算法指定操作及算法传参lambda表达式谓词lambda介绍lambda传参捕获列表用lambda改写算法lambda捕获和返回值捕获引用捕获隐式捕获显式捕获可变lambda指定lambda返回类型 概述 对于顺序容器的操作，我们前面介绍了添加，删除，大小操作，但是我们还有比如查找，排序等操作，这些操作是基于算法的，C++给我们提供了...
C++Primer第11章-泛型算法-课后习题答案[收集].pdf
10-11
C++Primer第11章-泛型算法-课后习题答案[收集].pdf
java坑爹的笔试题-cpp-primer-5th:C++Primer第五版学习资料
06-13
第10、11章有点基础的看起来不是很难，第十章的泛型算法，如果能用起来会让你的程序更上一层楼。第12章动态内存个人觉得对于一个想要深入学习C++的人来说非常重要，对于内存的理解、动态数组、new和delete运算符，...
C++ Primer习题集(第五版)
12-08
C++ Primer习题集(第五版) , 带目录完整版。 --------------------------------------------------------------------------- 目录 第1章............................................................ 1 练习1.1 ...
Cpp-Primer:C ++ Primer解决方案第五答案
04-01
C ++ Primer解决方案第五答案 概述 该项目仅包括C ++ Primer 5th的第8章至第19章的解决方案。 环保环境 WSL Ubuntu 20.04 编译器 gcc 9.3.0 编辑 Visual studio code 语境 第二部分：C ++库 第9章顺序容器 第10章...
C++Primer 第五版 —— 《第十章 》泛型算法
TAOTAO
01-03 464
目录 目录 Preface 概述（ find 算法） find 算法是如何工作的 只读算法(find、count、accumulate 338P） 使用accumulate 算法将 vector中的 string 元素连接起来 用equal 操作两个序列（339P） 使用 fill 和 fill_n 算法向容器写入元素（340P） 介绍 back_inserter 插入迭代器...
C++Primer第五版 第十章习题答案（1~10）
whjstudy1的博客
10-22 841
1：这个比较简单，类比下 find() 函数也就知道了。 #include&lt;iostream&gt; #include&lt;algorithm&gt; #include&lt;vector&gt; using namespace std; void main() { int number = 0; int arr[] = { 0, 0, 1, 2, 3, 4, 5, 6, 7, 8...
力扣OJ（0201-400）
nameofcsdn的博客
01-25 2282
目录 202. 快乐数 204. 计数质数（筛法） 207. 课程表 210. 课程表 II 222. 完全二叉树的节点个数 225. 用队列实现栈 231. 2的幂 234. 回文链表 258. 各位相加 260. 只出现一次的数字 III 263. 丑数 268. 缺失数字 279. 完全平方数 287. 寻找重复数 292. Nim 游戏 300. 最长上升子序列 307. 区域和检索 - 数组可修改 319. 灯泡开关 322. 零钱兑换 326. 3的幂..
C++primer学习笔记及作业答案之第十章
blue_coffeei的博客
05-09 489
笔记： 1.概述 迭代器令算法不依赖于容器，但算法依赖于元素类型的操作。 标准库通过算法和数据结构的分离来实现泛型。 算法永远不会改变底层容器的大小。 2.初识泛型算法 C风格字符串本质是char *类型，用==比较两个char *对象，只是检查两个指针值是否相等，即地址是否相等，而不会比较其中字符是否相同 标准库算法从来不直接操作容器，它们只操作迭代器，从而间接访问容器。能不能插入...
C++lambda表达式
GUI1259802368的博客
07-02 633
在介绍lambda表达式之前，先来看一下什么是谓词。下面是一个例子 void elimDups(vector&lt;string&gt; &amp;words) { sort(words.begin(),words.end()); //按字典序排序words,以便查找重复单词 //排列在范围的前部，返回指向不重复区域之后一个位置的迭代器 a...
《c++ primer》第10章 泛型算法 学习笔记
IT小小鸟～～
12-03 2589
概述：大多数算法都定义在头文件#include,标准库还在#include定义了一组数值泛型算法。 泛型算法本身不会执行容器操作，它们只会运行在迭代器之上，执行迭代器的操作 结论：算法永远不会改变底层容器的大小，算法可能改变容器中保存的元素的值或者移动元素，但永远不会直接添加或者删除元素。 ！除了少数以外，标准库算法都对一个范围内的元素进行操作，我们将此元素范围称为“输入范围”。接受
【C++Primer】泛型算法简述
weixin_44700635的博客
05-11 174
引言 初识泛型算法 写容器元素的算法 算法不检查写操作 back_inserter（插入迭代器） 拷贝算法 重排容器元素的算法 定制操作 向算法传递函数 1、引言 泛型算法 大多数算法都定义在头文件algorithm中，标准库的头文件numeric中定义了一组数值型算法。泛型算法的作用是通过迭代器间接访问容器，不会执行容器的操作，只运行在迭代器之上，迭代器可以做什么，泛型算法就可以做什么。 迭代器算法不依赖于容器，但算法依赖于元素类型的操作。 2、初识泛型算法 2.1写容器元素的算法.
【C++ Primer】第十章 泛型算法 (练习)
闻韶
09-29 467
C++ Primer 5th - 第十章 - 练习
c++ primer 第五版 第六章
最新发布
09-20
《C Primer》是一本针对C语言初学者的经典教材，第五版的第六章主要介绍了函数的基本概念和用法。 在第六章中，教材首先介绍了函数的定义和调用。函数是具有独立功能的代码块，可以通过函数名来调用。函数由函数头...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值