c++ primer第五版----学习笔记（十）Ⅱ

最新推荐文章于 2020-10-20 10:07:10 发布
最新推荐文章于 2020-10-20 10:07:10 发布
阅读量180 收藏 2
点赞数
分类专栏： 【c++ primer学习笔记】 C++ primer第五版学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38790716/article/details/82380038
版权

部分习题解答：

10.1：

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main()
{
	vector<int> vec;
	int word, val = 42;
	cout << "input a sequence: " << endl;
	while (cin >> word)
	{
		vec.push_back(word);
	}
	int cnt = count(vec.begin(), vec.end(), val);
	cout << "The value comes out " << cnt << " times." << endl;
	system("pause");
        return 0;
}

10.3：

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <algorithm>
#include <numeric>
using namespace std;

int main()
{
	vector<int> vec;
	int word;
	cout << "input a sequence: " << endl;
	while (cin >> word)
	{
		vec.push_back(word);
	}
	int sum = accumulate(vec.begin(), vec.end(), 0);
	cout << "所有元素的和为：" << sum << endl;
	system("pause");
        return 0;
}

10.4：

将初值设为0，表明返回类型是int，使用之后，将double转化为int，损失精度

10.5：

equal使用==运算符比较两个序列中的元素。string类重载了==，可比较两个字符串是否长度相等且其中元素对位相等。而C风格字符串本质是char *类型，用==比较两个char *对象，只是检查两个指针值是否相等，即地址是否相等，而不会比较其中字符是否相同。所以，只有当两个序列中的指针都指向相同的地址时，equal才会返回true，否则，即使字符串内容完全相同，也会返回false。

10.6：

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <algorithm>
#include <numeric>
using namespace std;

int main()
{
	vector<int> vec;
	int word;
	cout << "input a sequence: " << endl;
	while (cin >> word)
	{
		vec.push_back(word);
	}
	cout << "修改前的元素值为：" << endl;
	for (auto c : vec)
	{
		cout << c << " ";
	}
	fill_n(vec.begin(),vec.size(), 0);         //注意fill_n算法只传入一个迭代器
	cout<<endl << "修改后的元素值为：" << endl;
	for (auto c : vec)
	{
		cout << c << " ";
	}
	system("pause");
        return 0;
}

10.7：

(a)有错误，copy算法要求目标序列至少要包含与源序列一样多的元素，而此程序中，vec进行缺省初始化，它是空的，copy无法进行。可以将第三个参数改为back_inserter(vec)，通过它，copy算法即可将lst中的元素拷贝插入到lst的末尾。

(b)也有错误。此时，vec仍然为空，没有任何元素。而算法又不具备向容器添加元素的能力，因此fill_n仍然失败。这里还是将第一个参数改成back_inserter(vec)来让fill_n有能力向vec添加元素。

10.8：

算法只是产生了一个插入迭代器，然后使用该迭代器进行插入操作

10.9：

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <algorithm>
#include <numeric>
using namespace std;

void elimDups(vector<string> &words)             //删除序列中重复元素
{
	sort(words.begin(), words.end());
	auto end_unique = unique(words.begin(), words.end());
	words.erase(end_unique, words.end());
}
int main()
{
	vector<string> vec;
	string word;
	while (cin >> word)
	{
		vec.push_back(word);
	}
	elimDups(vec);
	for (auto c : vec)
	{
		cout << c << " ";
	}
	system("pause");
        return 0;
}

10.11：

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <algorithm>
#include <numeric>
using namespace std;

void elimDups(vector<string> &words)             //删除序列中重复元素
{
	sort(words.begin(), words.end());
	auto end_unique = unique(words.begin(), words.end());
	words.erase(end_unique, words.end());
}
bool isShorter(const string &s1, const string &s2)  //使字符串按从短到长排列
{
	return s1.size() < s2.size();
}

int main()
{
	vector<string> vec{ "the","quick","red","fox","jumps","over","the","slow","red","turtle" };
	elimDups(vec);
	stable_sort(vec.begin(), vec.end(), isShorter);      //使相同长度字符串按字典序排列
	for (auto &c : vec)
	{
		cout << c << " ";
	}
	system("pause");
        return 0;
}

10.12：

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <algorithm>
#include <numeric>
using namespace std;

class Sales_data
{
public:
	Sales_data() {}
	Sales_data(string s) :_isbn(s)//列表初始化格式（：类内变量名（初始化值），）
	{

	}
	string isbn()
	{
		return _isbn;
	}
	string _isbn;
};

bool compareIsbn(Sales_data s1, Sales_data s2)
{
	return s1.isbn().size() < s2.isbn().size();
}

int main(int argc, char**argv)

{
	Sales_data a("because");//初始化对象

	Sales_data b("I");

	Sales_data c("Like");

	Sales_data d("your");

	Sales_data e("beautiful");

	Sales_data f("eyes");
	vector<Sales_data> vec1{ a,b,c,d,e,f };

	stable_sort(vec1.begin(), vec1.end(), compareIsbn);//排序
	cout << "排序后的vector:" << endl;
	for (int i = 0; i < vec1.size(); ++i)
	{
		cout << vec1[i].isbn() << " ";
	}
	system("pause");
	return 0;
}

10.13：

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <algorithm>
#include <numeric>
using namespace std;

bool divide(string &s)
{
	return s.size() < 5;
}

int main(int argc, char**argv)

{
	vector<string> words;
	string word;
	cout << "输入划分的序列：" << endl;
	while (cin >> word)
	{
		words.push_back(word);
	}
	auto it = partition(words.begin(),words.end(),divide);
	cout << "输出长度大于等于5的元素：" << endl;
	for (; it != words.end(); ++it)
	{
		cout << *it << " ";
	}
	cout << endl;
	system("pause");
	return 0;
}

10.14：

[] (int &a,int &b) {return a+b;}

10.15:

[a] (int &b) {return a+b;}

10.16:

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <algorithm>
#include <numeric>
using namespace std;

void elimDups(vector<string> &words)             //删除序列中重复元素
{
	sort(words.begin(), words.end());
	auto end_unique = unique(words.begin(), words.end());
	words.erase(end_unique, words.end());
}
string make_plural(size_t ctr, const string &word, const string &ending)        //看满足条件的单词是否为复数
{
	return (ctr > 1) ? word + ending : word;
}
void biggies(vector<string> &words,
	vector<string>::size_type sz)
{
	elimDups(words);                                        //将words按字典序排序，删除重复单词
	//按长度排序，长度相同的单词维持字典序
	stable_sort(words.begin(), words.end(),                 
		[](const string&a, const string &b)
		{return a.size() < b.size(); });
	//获取一个迭代器，指向第一个满足size()>=sz的元素
	auto wc = find_if(words.begin(), words.end(),
				[sz](const string &a)
				{return a.size() >= sz; });
	//计算满足size>=sz的元素的数目
	auto count = words.end() - wc;
	cout << count << " " << make_plural(count, "word", "s")
		<< " of length " << sz << " or longer " << endl;
	//打印长度大于等于给定值的单词，每个单词后面接一个空格
	for_each(wc, words.end(),
		[](const string &s) {cout << s << " "; });
}

int main(int argc, char**argv)

{
	vector<string> vec{ "the","quick","red","fox","jumps","over","the","slow","red","turtle" };
	string::size_type i = 4;
	biggies(vec, i);
	system("pause");
	return 0;
}

10.18、10.19、10.20：

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <algorithm>
#include <numeric>
using namespace std;

void elimDups(vector<string> &words)             //删除序列中重复元素
{
	sort(words.begin(), words.end());
	auto end_unique = unique(words.begin(), words.end());
	words.erase(end_unique, words.end());
}
string make_plural(size_t ctr, const string &word, const string &ending)        //看满足条件的单词是否为复数
{
	return (ctr > 1) ? word + ending : word;
}
void biggies(vector<string> &words,
	vector<string>::size_type sz)
{
	elimDups(words);                                        //将words按字典序排序，删除重复单词
															//按长度排序，长度相同的单词维持字典序
	stable_sort(words.begin(), words.end(),
		[](const string&a, const string &b)
	{return a.size() < b.size(); });
	//获取一个迭代器，指向第一个满足size()>=sz的元素
	auto wc = partition(words.begin(), words.end(),                //10.19将partition改为stable_partition
		[sz](const string &a)
	{return a.size() >= sz; });
	//计算满足size>=sz的元素的数目
	auto count = wc - words.begin();  
 /*10.20改为auto count = count_if(words.begin(), words.end(),              //返回满足条件的单词的个数
		[sz](const string &a)
	{return a.size() >= sz; });*/
	cout << count << " " << make_plural(count, "word", "s")
		<< " of length " << sz << " or longer " << endl;
	//打印长度大于等于给定值的单词，每个单词后面接一个空格
	for_each(words.begin(), wc,
		[](const string &s) {cout << s << " "; });
}

int main(int argc, char**argv)

{
	vector<string> vec{ "the","quick","red","fox","jumps","over","the","slow","red","turtle" };
	string::size_type i = 4;
	biggies(vec, i);
	system("pause");
	return 0;
}

10.21：

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <algorithm>
#include <numeric>
using namespace std;

void fcn()
{
	int val = 42;
	auto f = [&val]()->bool {
		if (val != 0)
		{
			--val;
			return 0;
		}
		else  
			return 1;};
	auto j = f();
	cout << j << endl;
}

int main(int argc, char**argv)

{
	fcn();
	system("pause");
	return 0;
}

10.22：

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <algorithm>
#include <numeric>
using namespace std;

bool fcn(string &s)
{
	return s.size() <= 6;
}

int main(int argc, char**argv)

{
	vector<string> vec;
	string word;
	while (cin >> word)
	{
		vec.push_back(word);
	}
	auto cnt = count_if(vec.begin(), vec.end(), fcn);
	cout << "长度小于等于6的单词数量有" << cnt << "个" << endl;
	system("pause");
	return 0;
}

10.23:

第一个参数为可调用对象A，若A接受x个参数，则bind的参数个数应为x+1

10.24：

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <functional>
#include <algorithm>
#include <numeric>
using namespace std;
using namespace placeholders;

bool check_size(const string &s, int sz)
{
	return s.size() < sz;
}

int main(int argc, char**argv)

{
	vector<int> vec;
	int  word;
	cout << "输入目标序列：" << endl;
	while (cin >> word)
	{
		vec.push_back(word);
	}
	cin.clear();
	string s;
	cout << "输入比较的字符串:" << endl;
	cin >> s;
	auto wc = find_if(vec.begin(), vec.end(), bind(check_size,s,_1));
	cout << *wc << endl;
	system("pause");
	return 0;
}

10.25：

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <algorithm>
#include <numeric>
#include <functional>
using namespace std;
using placeholders::_1;

void elimDups(vector<string> &words)             //删除序列中重复元素
{
	sort(words.begin(), words.end());
	auto end_unique = unique(words.begin(), words.end());
	words.erase(end_unique, words.end());
}
string make_plural(size_t ctr, const string &word, const string &ending)        //看满足条件的单词是否为复数
{
	return (ctr > 1) ? word + ending : word;
}

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

void biggies(vector<string> &words,
	vector<string>::size_type sz)
{
	elimDups(words);                                        //将words按字典序排序，删除重复单词
															//按长度排序，长度相同的单词维持字典序
	stable_sort(words.begin(), words.end(),
		[](const string&a, const string &b)
	{return a.size() < b.size(); });
	//获取一个迭代器，指向第一个满足size()>=sz的元素
	auto wc = partition(words.begin(), words.end(), bind(check_size, _1, sz));

	//计算满足size>=sz的元素的数目
	auto count = wc - words.begin();
	
	cout << count << " " << make_plural(count, "word", "s")
		<< " of length " << sz << " or longer " << endl;
	//打印长度大于等于给定值的单词，每个单词后面接一个空格
	for_each(words.begin(), wc,
		[](const string &s) {cout << s << " "; });
}

int main(int argc, char**argv)

{
	vector<string> vec{ "the","quick","red","fox","jumps","over","the","slow","red","turtle" };
	string::size_type i = 4;
	biggies(vec, i);
	system("pause");
	return 0;
}

10.27：

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <algorithm>
using namespace std;

int main(int argc, char**argv)
{
	vector<int> vec = { 1,1,2,3,4,4,5,6,7,7,8,9 };
	list<int> lst;
	unique_copy(vec.begin(),vec.end(),back_inserter(lst));
	for (auto &c : lst)
	{
		cout << c << " ";
	}
	system("pause");
	return 0;
}

10.28：

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <algorithm>
#include <iterator>
using namespace std;

int main(int argc, char**argv)
{
	vector<int> vec = { 1,2,3,4,5,6,7,8,9 };
	list<int> vec1, vec2, vec3;
	copy(vec.begin(), vec.end(), back_inserter(vec1));
	copy(vec.begin(), vec.end(), front_inserter(vec2));
	copy(vec.begin(), vec.end(),inserter(vec3,vec3.begin()));
	for (auto &c : vec1) { cout << c << " "; }
	cout << endl;
	for (auto &c : vec2) { cout << c << " "; }
	cout << endl;
	for (auto &c : vec3) { cout << c << " "; }
	cout << endl;
	system("pause");
	return 0;
}

10.29：

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <fstream>
#include <algorithm>
#include <iterator>
using namespace std;

int main(int argc, char**argv)
{
	ifstream in("10.txt");
	istream_iterator<string> str_it(in), eof;
	vector<string> vec;
	while (str_it != eof)
	{
		vec.push_back(*str_it++);
	}
	for (auto &c : vec)
	{
		cout << c << " ";
	}
	system("pause");
	return 0;
}

10.30、10.31：

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <fstream>
#include <algorithm>
#include <iterator>
using namespace std;

int main(int argc, char**argv)
{
	istream_iterator<int> str_it(cin), eof;
	vector<int> vec;
	while (str_it != eof)
	{
		vec.push_back(*str_it++);
	}
	ostream_iterator<int> out(cout, " ");
	copy(vec.begin(), vec.end(), out);    //将copy改为unique_copy
	system("pause");
	return 0;
}

10.33：

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <fstream>
#include <algorithm>
#include <iterator>
using namespace std;

int main(int argc, char**argv)
{
	ifstream in("10.txt");
	istream_iterator<int> str_it(in), eof;
	vector<int> vec; //存储读取的数据
	while (str_it != eof)
	{
		vec.push_back(*str_it++);
	}

	ofstream out1("10.1.txt");
	ofstream out2("10.2.txt");
	ostream_iterator<int> it1(out1, " ");
	ostream_iterator<int> it2(out2, "\n");
	for (auto it = vec.begin(); it != vec.end(); ++it)
	{
		if (*it % 2 != 0)
		{
			it1 = *it;
		}
		else
		{
			it2 = *it;
		}
	}
	system("pause");
	return 0;
}

10.34：

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <fstream>
#include <algorithm>
#include <iterator>
using namespace std;

int main(int argc, char**argv)
{
	vector<string> vec;
	string word;
	while (cin >> word)
	{
		vec.push_back(word);
	}
	for (auto it = vec.crbegin(); it != vec.crend(); ++it)
	{
		cout << *it << " ";
	}
	system("pause");
	return 0;
}

10.35：

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <fstream>
#include <algorithm>
#include <iterator>
using namespace std;

int main(int argc, char**argv)
{
	vector<string> vec;
	string word;
	while (cin >> word)
	{
		vec.push_back(word);
	}
	auto it = vec.begin();
	for ( it = vec.end()-1; it != vec.begin(); --it)
	{
		cout << *it << " ";
	}
	cout << *it << endl;
	system("pause");
	return 0;
}

10.36：

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <fstream>
#include <algorithm>
#include <numeric>
#include <iterator>
using namespace std;

int main(int argc, char**argv)
{
	list<int> lst;
	int n;
	while (cin >> n)
	{
		lst.push_back(n);
	}
	auto it = find(lst.rbegin(), lst.rend(), 0);
	if (it != lst.rend())
	{
		cout << *it << endl;
	}
	else
	{
		cout << " 0 is not present" << endl;
	}
	system("pause");
	return 0;
}

10.37：

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <fstream>
#include <algorithm>
#include <numeric>
#include <iterator>
using namespace std;

int main(int argc, char**argv)
{
	vector<int> vec{ 0,1,2,3,4,5,6,7,8,9 };
	list<int> lst;
	/*for (auto it = vec.rbegin() + 2; it != vec.rend() - 3; ++it)
	{
		lst.push_back(*it);
	}*/
	copy(vec.rbegin() + 2, vec.rend() - 3, back_inserter(lst));
	for (auto &c : lst)
	{
		cout << c << " ";
	}
	system("pause");
	return 0;
}

10.42：

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <fstream>
#include <algorithm>
#include <numeric>
#include <iterator>
using namespace std;

int main(int argc, char**argv)
{
	list<string> lst;
	string word;
	while (cin >> word)
	{
		lst.push_back(word);
	}
	lst.sort();
	lst.unique();
	for (auto &c : lst)
	{
		cout << c << " ";
	}
	system("pause");
	return 0;
}

 

小呀小二笙
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CCF 第二题：游戏
weixin_37944830的博客
03-08 410
这是网上大神的解 我的解 #include&lt;iostream&gt; #include&lt;list&gt; #include&lt;algorithm&gt; using namespace std; void erase(list&lt;int&gt; &amp;lt, int cc,int begin) { int i = begin; list&lt;...
c++ primer Plus （第六版）第五章学习笔记
Schlangemm的博客
10-23 597
1、cout可以输出表达式的值，在不特殊设置的情况下，若表达式为判断表达式则输出的是0/1，若为赋值表达式则将修改其中的变量值，注意在输出表达式的值时要加将表达式加（），因为&lt;&lt;的优先级高于表达式中的运算符。 例： #include&lt;stdafx.h&gt; #include &lt;iostream&gt; using namespace std; int main()...
C++PRIMER第十章课后练习
hubinyiyi的博客
10-19 582
10.1 #include #include #include using namespace std; int main() { vector vec{ 1,1,1,1,2,2,2 }; int n=count(vec.begin(), vec.end(), 1); cout return 0; } 10.2 #include #include #includ
STL源码剖析疑难记录
Dave_lzw的博客
10-20 181
4.3 list list不能使用STL算法sort() , 必须使用自己的sort（）成员函数。因为STL算法sort（）只接受random access iterator.(list是双向链表，不能随机访问 list<T,Alloc>::sort()实现采用非递归的归并排序 #include <iostream> #include <list> #include <algorithm> using namespace std ; void print(
#include<algorithm>中常用函数的使用
brilliantZC的博客
04-15 4211
   #include< algorithm >是C++的标准模版库（STL）中最重要的头文件之一，提供了大量基于迭代器的非成员模板函数。以下将介绍几个常用的库函数： 一、max(),min()和swap() max(x,y)　　//返回两个元素中值最大的元素 min(x,y)　　//返回两个元素中值最小的元素 swap(x,y)　　//用来交换x和y的值 二、reverse() ...
C++ primer plus(第六版）学习笔记、习题答案（5）
最需要奋斗的这几年
12-14 794
第六章学习笔记和答案
C++ primer plus第五版学习笔记
01-04
C++ primer plus 第五版的个人学习笔记，仅供大家学习参考。
《C++ Primer》第五版中文版学习笔记
03-05
《C++ Primer》第五版中文版学习笔记，适合完整看过原书一遍以上的人员复习与查阅使用。对于基础较好的，也可直接适用。
C++primer_plus_第五版_学习笔记
12-08
对初学C++primer这本书的童鞋非常有用！！
C++ Primer第五版中文版
10-31
C++ Primer第五版中文版，很完整的文档，同样是C++学习最好的帮助文档。
my-C-plus-plus:c++的学习笔记
05-27
《C++ Primer》百科级 最新是第五版 作者参与了C++第一个编译器的实现 《The C++ Programming Language》最新是第四版，作者是C++之父，目前还没有中文版 《Effective C++》最新是第三版，告诉你什么改写，什么不该...
C++ primer 个人学习总结
小二笙的博客
11-08 2127
欢迎大家来访二笙的小房子，一同学习分享生活！ 文章目录1. 个人见解：C++2. primer学习总结2.1 第一章：开始2.2 Part1：C++基础2.3 Part2：C++标准库2.4 Part3：类设计者的工具2.5 高级主题3. future 1. 个人见解：C++ 先来说说对C++的感觉吧，由于个人不是特别热爱学习的那种，自律性也比较差，加之上学期才刚接触C++，于是在经过一个学期的c...
c++ primer第五版----学习笔记（十九）Ⅰ
小二笙的博客
11-06 1327
特殊工具与技术 1.控制内存分配 应用程序需要重载new和delete运算符以控制内存分配 1.1 重载new和delete 使用一个new表达式时，实际执行了三步操作 new表达式调用一个名为delete new(或者operator new[])的标准库函数 编译器运行相应的构造函数初始化特定类型的对象 对象被分配了空间并构造完成，返回一个指向该对象的指针 使用了delete...
c++ primer第五版----学习笔记（五）
小二笙的博客
08-17 859
1.空语句：最简单的语句，只包含一个单独的分号 复合语句：指用花括号括起来的语句和声明的序列，复合语句也被称为块 2.if语句： //语法形式： if (condition) statement //if、else语句 if (condition) statement else statement1 //悬垂else：就c++而言，规定else与离它最近的尚未匹...
c++ primer 第五版----学习笔记（一）
小二笙的博客
08-07 646
由于已经学习过c++的基础课程，对于第一章节的内容就大致的过了一遍，对于以下几个不太熟悉或平常不太注意的方面又有了一些了解和掌握。 1.c++注释的种类：单行注释与界定符对注释。（之前在编写代码时没有编写注释的习惯，以后一定加强!!!) 单行注释：以双斜线（//）开始，以换行符结束，当前行双斜线右侧的所有内容都会被编译器忽略。 注释界定符：可以放置于任何允许放置制表符、空行符或换行符的地方，...
c++ primer 第五版----学习笔记（二）
小二笙的博客
08-13 479
1.算术类型：字符、整型数、布尔值和浮点数；c++标准规定的尺寸的最小值： c++语言规定一个int至少和一个short一样大，一个long long至少和一个long一样大。其中数据类型long long实在c++11中新定义的。 带符号类型（signed），无符号类型（unsigned）；在带符号类型名前添加unsigned就能得到无符号类型。 如何选择类型：(1)当明确知晓数值不可...
c++ primer第五版----学习笔记（七）
小二笙的博客
08-25 404
1.类的基本思想：数据抽象和封装 数据抽象：一种依赖于接口和实现分离的编程技术。类的接口包括用户所能执行的操作；类的实现则包括类的数据成员、负责接口实现的函数体以及定义类所需的各种私有函数 封装实现了类的接口和实现的分离，封装后的类隐藏了它的实现细节 2.关于类： 定义在类内部的函数是隐式的inline函数（内联函数） this：当我们调用成员函数时，实际上实在替某个对象调用它；任何对类成...
c++ primer第五版----学习笔记（三）
小二笙的博客
08-15 376
1.标准库类型string： 初始化string对象：直接初始化与拷贝初始化 string s1 = "hiya"; //拷贝初始化（使用 = 初始化变量） string s2("hiya"); //直接初始化 string s3(10,'c'); //直接初始化，s3的内容是cccccccccc string对象上的部分操作：(1)get...
(完整word版)c++-primer-plus(第六版)第二至第六章课后编程练习全部答案.doc
最新发布
11-15
(完整word版)c++-primer-plus(第六版)第二至第六章课后编程练习全部答案.doc

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值