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

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

部分习题解答：

14.1：

不同点： 重载运算符必须具有至少一个class或枚举类型的操作数。

重载运算符不保证操作数的求值顺序，例如对&&和||的重载版本不再具有“短路求值”的特性，两个操作数都要求值，而且不规定操作数的求值顺序。

相同点： 对于优先级和结合性级操作数的数目都不变。

14.2：

class Sales_data
{
friend std::istream& operator>>(std::istream&, Sales_data &);
friend std::ostream& operator<<(std::ostream&, const Sales_data&);
 
public:
	Sales_data& operator+=(const Sales_data&);
};
 
Sales_data operator+(const Sales_data&, const Sales_data&);

14.26：

class StrBlob {
public:
	string & operator[](size_t n) { return data[n]; };
	const string& operator[](size_t n) const { return data[n]; };
};
//其他类都类似

14.27：

class StrBlobPtr{
public:
	StrBlobPtr& operator++();
	StrBlobPtr& operator--();

	StrBlobPtr operator++(int);
	StrBlobPtr operator--(int);
};

StrBlobPtr& StrBlobPtr::operator++()
{
	check(curr, " increment past end of StrBlobPtr ");
	++curr;
	return *this;
}
StrBlobPtr& StrBlobPtr::operator--()
{
	--curr;
	check(-1, " decrement past begin of StrBlobPtr ");
	return *this;
}
StrBlobPtr StrBlobPtr::operator++(int)
{
	StrBlobPtr ret = *this;
	++*this;
	return ret;
}
StrBlobPtr StrBlobPtr::operator--(int)
{
	StrBlobPtr ret = *this;
	--*this;
	return ret;
}

14.28：

class StrBlobPtr{
public:
	friend StrBlobPtr operator+(int n);
	friend StrBlobPtr operator-(int n);
};
StrBlobPtr StrBlobPtr::operator+(int n)
{
	auto ret = *this;
	ret.curr += n;
	return ret;
}

StrBlobPtr StrBlobPtr::operator-(int n)
{
	auto ret = *this;
	ret.curr -= n;
	return ret;
}

14.29：

因为不论是递减或递增都会改变对象的值，所以不定义const版本

14.30：

class StrBlobPtr{
public:
	string & operator*() const {
		auto p = check(curr, "dereference past end");
		return (*p)[curr];
	}
	string* operator->() const {
		return &(this->operator*());
	}
};
class ConstStrBlobPtr {
public:
	const string & operator*() const {
		auto p = check(curr, "dereference past end");
		return (*p)[curr];
	}
	const string* operator->() const {
		return &(this->operator*());
	}
};

14.31：

StrBlobPtr有两个数据成员，分别为weak_ptr<vector<string>>和size_t类型的，前者定义了自己的拷贝操作，后者为内置类型，默认的拷贝语意即可

14.32：

class MyStrBlob{
public:
	string* operator->() const {
		return ptr->operator();
	}
private:
	StrBlobPtr *ptr;
}

14.33：

0个或多个

14.34：

class Ifthenelse {
public:
	Ifthenelse(){}
	Ifthenelse(int v1,int v2,int v3):val1(v1),val2(v2),val3(v3){}
	int operator()(int v1, int v2, int v3)
	{
		return v1 ? v2 : v3;
	}
private:
	int val1, val2, val3;
};

14.35：

class Readstring {
public:
	Readstring(istream &is = cin) :is(is) {}
	string operator()()
	{
		string line;
		if (!getline(is, line))
		{
			line = " ";
		}
		return line;
	}
private:
	istream &is;
};

14.36：

void testReadstring()
{
	Readstring re;
	vector<string> vec;
	while (true)
	{
		string line = re();
		if (!line.empty())
		{
			vec.push_back(line);
		}
		else
			break;
	}
}

14.37：

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

class IntCompare {
public:
	IntCompare(int v):val(v){}
	bool operator()(int v) { return val == v; }
private:
	int val;
};

int main()
{
	vector<int> vec = { 1,2,3,4,5,5,4,3,2,1 };
	const int oldval = 2;
	const int newval = 200;
	IntCompare intc(oldval);
	replace_if(vec.begin(), vec.end(), intc, newval);
	for (auto c : vec)
	{
		cout << c << " ";
	}
	system("pause");
    return 0;
}

14.38：

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

class StrLenComp{
public:
	StrLenComp(int l) :len(l) {}
	bool operator()( const string &str) { return str.size() == len; }
private:
	int len;
};

int main()
{
	vector<string> vec;
	string word;
	while (cin >> word)
	{
		vec.push_back(word);
	}
	const int minlen = 1;
	const int maxlen = 10;
	for (int i = minlen; i <= maxlen; ++i)
	{
		StrLenComp slc(i);
		cout << "len: " << i << ", cnt: " << count_if(vec.begin(), vec.end(), slc) << endl;
	}
	system("pause");
    return 0;
}

14.39：

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

class StrLenBetween{
public:
	StrLenBetween(int minl,int maxl) :minlen(minl),maxlen(maxl) {}
	bool operator()(const string &str) { return str.size() >= minlen && str.size() <= maxlen; }
private:
	int minlen,maxlen;
};

class StrLenNoshorter {
public:
	StrLenNoshorter(int minl) :minlen(minl) {}
	bool operator()(const string &str) { return str.size() >= minlen ; }
private:
	int minlen;
};

int main()
{
	vector<string> vec;
	string word;
	while (cin >> word)
	{
		vec.push_back(word);
	}
	StrLenBetween slb(1,9);
	StrLenNoshorter sln(10);
	cout << "len (1-9): " << count_if(vec.begin(), vec.end(), slb) << endl;
	cout << "len (>10): " << count_if(vec.begin(), vec.end(), sln) << endl;
	system("pause");
    return 0;
}

14.40：

class IsShorter {
public:
	bool operator()(const string &a, const string &b)
	{
		return a.size() < b.size();
	}
};
class IsLong {
public:
	IsLong(int ml):minlen(ml){}
	bool operator()(const string &a)
	{
		return a.size() >= minlen;
	}
private:
	int minlen;
};
class Print {
public:
	void operator()(const string &s) { cout << s << " "; }
};

void biggies(vector<string> &words, vector<string>::size_type sz)
{
	elimDups(words);
	IsShorter ish;
	stable_sort(words.begin(), words.end(), ish);
	IsLong isl(sz);
	auto wc = find_if(words.begin(), words.end(), isl);
	auto count = words.end() - wc;
	cout << count << " " << make_plural(count, "word", "s") <<
		" of length" << sz << " or longer" << endl;
	Print p;
	for_each(wc, words.end(), p);
	cout << endl;
}

14.41：

在C++11中，lambda是通过匿名的函数对象来实现的，因此我们可以把lambda看作是对函数对象在使用方式上进行的简化。当代码需要一个简单的函数，并且这个函数并不会在其他地方被使用时，就可以使用lambda来实现，此时它所起的作用类似于匿名函数。但如果这个函数需要多次使用，并且它需要保存某些状态的话，使用函数对象更合适一些。

14.42：

(a) count_if(vec.begin(), vec.end(), bind2nd(greater<int>(), 1024));
(b) find_if(vec.begin(), vec.end(), bind2nd(not_equal_to, "pooh"));
(c) transform(vec.begin(), vec.end(),vec.begin(), bind2nd(multiplies<int>(), 2));

14.43：

bool divideAll(vector<int> vec, int dividenum)
{
    return count_if(vec.begin(), vec,end(), bind1st(modulus<int>(), dividenum)) == 0;
}

14.44：

#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <map>
using namespace std;

map<string, function<int(int, int)>> binops = {
	{ "+",plus<int>() },
	{ "-",minus<int>() },
	{ "*",multiplies<int>() },
	{ "/",divides<int>() },
	{ "%",modulus<int>() }
};
int main()
{
	int a, b;
	string op;
	cin >> a >> op >> b;
	cout << binops[op](a, b) << endl;
	system("pause");
    return 0;
}

14.45:

如果要转换成string，那么返回值应该是bookNo。

如果要转换成double，那么返回值应该是revenue。

14.46:

前者将对象转换成const int，在接受const int值的地方才能够使用。

后者将对象转换成int值，相对来说更加通用一些。

14.48:

应该，定义一个bool的类型转换运算符，可以用来检测数据成员是否有效；应该声明成explicit，因为我们有意要在表达式中使用它

14.50：

对于int ex1 = ldOb;，它需要把LongDouble类型转换成int类型，但是LongDouble并没有定义对应的类型转换运算符，因此它会尝试使用其他的来进行转换。题中给出的两个都满足需求，但编译器无法确定那一个更合适，因此会产生二义性错误。

对于foloat ex2 = ldObj;，它需要把LongDouble转换成float类型，而我们恰好定义了对应的类型转换运算符，因此直接调用operator float()即可。

14.51：

这里会优先调用void calc(int)函数。

因为double转换为int是标准类型转换，而转换为LongDouble则是转换为用户自定义类型，实际上调用了转换构造函数，因此前者优先。

14.52：

对于ld=si+ld，由于LongDouble不能转换为SmallInt，因此Smallint的成员operator+和friend operator都不可行。

由于Smallint不能转换为LongDouble，LongDouble的成员operator+和非成员operator+也都不可行。

由于SmallInt可以转换为int， LongDouble了可以转换为float和double，所以内置的operator+(int, float)和operator+(int, double)都可行，会产生二义性。

对于ld=ld+si，类似上一个加法表达式，由于Smallint不能转换为double，LongDouble也不能转换为SmallInt，因此SmallInt的成员operator+和两个非成员operator+都不匹配。

LongDouble的成员operator+可行，且为精确匹配。

SmallInt可以转换为int，longDouble可以转换为float和double，因此内置的operator+(float, int)和operator(double, int)都可行。但它们都需要类型转换，因此LongDouble的成员operator+优先匹配。

14.53：

内置类型的operator+(int double)可行，3.14可转换成int，再转换成SmallInt，所以SmallInt的operator+也是可行的，会产生二义性，应改成double d = s1 + SmallInt(3.14);

小呀小二笙
关注
专栏目录
C++基础-第12周
qq_34755941的博客
11-28 156
STL排序算法sort STL：（Standardemplate Liary）
C++——list(2)
最新发布
dongxue727504的博客
09-28 1857
C++的list的const迭代器讲解
C++语法糖
三七的博客
02-01 648
语法记录
C++复习 14 重载操作符与转换
nx500的专栏
10-24 1817
声明,所有的朋友,如果要转我的帖子,务必注明"作者:黑啤来源:CSDN博客"和 具体的网络地址http://blog.csdn.net/nx500/archive/2007/10/24/1842538.aspx,并且我的所有 博客内容,禁止任何形式的商业用途,请大家尊重我的劳动.谢谢!目 录十四.重载操作符与转换.  001 通过操作符重载,程序员能够针对类类型的操作数定义不同的操作符版本,允许程
C++ STL 使用
浮生若梦
03-11 188
vector #include<bits/stdc++.h> /* 将元素置于一个动态数组中加以管理， 可以随机存取元素（用索引直接存取）， 数组尾部添加或移除元素非常快速。 但是在中部或头部安插元素比较费时, 方便尾部读取数据 */ using namespace std; const int N=10; void Print(vector<int> vec) { for(int i=0;i<vec.size();i++) {
C++ Primer第五版 第十三章---练习题答案（学习笔记）
m0_51248838的博客
09-26 688
1.
C++ primer plus第五版学习笔记
01-04
C++ primer plus 第五版的个人学习笔记，仅供大家学习参考。
《C++ Primer》第五版中文版学习笔记
03-05
《C++ Primer》第五版中文版学习笔记，适合完整看过原书一遍以上的人员复习与查阅使用。对于基础较好的，也可直接适用。
C++ Primer 第五版 ——《第十五章 》面向对象程序设计 （多态与继承）学习笔记
TAOTAO
02-16 1591
目录 OPP：概述 定义基类 定义派生类 派生类中的虚函数 、override 关键字（530P） 派生类到基类的类型转换 （530P） 派生类的构造函数 （531P） 在派生类中使用继承其基类的成员 （531P） 继承与静态成员 （ 532P ） 派生类的声明需要注意的地方 （532P） 被用作基类的类需要注意的地方 （533P） 通过 final 来 禁止类被继承 类型...
《C++ primer》第五版学习笔记--第七章 类
qq_36698189的博客
03-28 237
《C++ primer》比其他C++相关书籍，知识点细致很多很多，每次看书都会有新的理解~ 文章目录定义抽象数据类型定义成员函数引入`this`引入常量成员函数在类的外部定义成员函数定义一个返回this对象的函数定义类相关的非成员函数 类的基本思想：数据抽象和封装 数据抽象是一种依赖于接口和实现分离的编程技术。 类的接口包括用户所能执行的操作； 类的实现包括类的数据成员、负责接口实现的函数体以及定义类所需的各种私有函数。 封装实现了类的接口和实现的分离。封装后的类隐藏了它的实现细节，也就是，类的用户只能使
79.内建函数对象
augfun的博客
09-06 187
STL内建了一些函数对象。分为:算数类函数对象,关系运算类函数对象，逻辑运算类仿函数。这些仿函数所产生的对象，用法和一般函数完全相同，当然我们还可以产生无名的临时对象来履行函数功能。使用内建函数对象，需要引入头文件 #include<functional> 6个算数类函数对象,除了negate是一元运算，其他都是二元运算。 template<class T> T plu...
C++11之智能指针（RAII）
jiaao666的博客
08-09 929
C++11智能指针介绍（auto_ptr, unique_ptr, shared_ptr, weak_ptr）
C++operator()(重载小括号运算符)
jinzhu1911的专栏
09-24 2万+
在C++语言中有时候需要重载运算符: ()，今天我们主要介绍它主要应用的场合。 仿函数 先考虑一个简单的例子：假设有一个vector，你的任务是统计长度小于5的string的个数，如果使用count_if函数的话，你的代码可能长成这样： bool LengthIsLessThanFive(const string& str) { return str.length() &lt...
C++函数对象operator()
热门推荐
summer
10-29 3万+
函数对象：定义了调用操作符（）的类对象。当用该对象调用此操作符时，其表现形式如同普通函数调用一般，因此取名叫函数对象。举个最简单的例子： class A { public: int operator() ( int val ) { return val > 0 ? val : -val; } }; 类A中定义了操作符 ( )，A
C++类的operator bool()方法
HayPinF的博客
04-13 1931
#include<iostream> #include<string> #include<vector> class SubType{ public: static std::string clsfield; std::pair<bool,std::string> field; SubType(bool b,std::string str):field(std::make_pair(b,str)){}; ...
3-循环结构
qq_46344220的博客
04-18 1025
循环语句只需要抓住一点——代码执行顺序！ while循环 可以简单理解为循环版的if语句。if语句是判断一次，如果条件成立，则执行后面的语句；while是每次判断，如果成立，则执行循环体中的语句，否则停止。 #include <iostream> using namespace std; int main() { int i = 0; while (i < 10) { cout << i << endl;
函数对象
重文-技艺山海经
11-24 620
尽管函数指针被广泛用于实现函数回调，但C++还提供了一个重要的实现回调函数的方法，那就是函数对象。函数对象（也称“算符”）是重载了“()”操作符的普通类对象。因此从语法上讲，函数对象与普通的函数行为类似。   用函数对象代替函数指针有几个优点，首先，因为对象可以在内部修改而不用改动外部接口，因此设计更灵活，更富有弹性。函数对象也具备有存储先前调用结果的数据成员。在使用普通函数时需要将先前调
【C++ STL】深入解析神秘的 --- 仿函数
weixin_34067049的博客
06-24 608
一，概述 仿函数(functor)，就是使一个类的使用看上去象一个函数。其实现就是类中实现一个operator()，这个类就有了类似函数的行为，就是一个仿函数类了。 　　有些功能的的代码，会在不同的成员函数中用到，想复用这些代码。 1）公共的函数，可以，这是一个解决方法，不过函数用到的一些变量，就可能成为公共的全局变量，...
第三章 数据处理
weixin_41804732的博客
06-27 547
3.1 简单变量 3.1.1 变量名 在名称中只能使用字母字符、数字和下划线 名称的第一个字符不能是数字 区分大小写 不能使用关键字 int _Mystar3; //valid but reserved --starts with underscore int __foold; // valid but reserved --starts with two underscore 3.1.2 整型 3.1.3 整形short、int、long和long long short至少16位 int至少和sho
C++ Primer第五版2-7章答案解析
"C++ Primer第五版的第二章至第七章主要涵盖了C++语言的基础知识，包括数据类型、字面量、运算符、流程控制、数组和指针等核心概念。" 在C++ Primer第五版中，第二章主要讨论了基本的数据类型和字面量。书中提到了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值