c++ primer 学习笔记-第十四章

最新推荐文章于 2022-10-13 14:59:36 发布
最新推荐文章于 2022-10-13 14:59:36 发布
阅读量400 收藏
点赞数
分类专栏： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dreamtide/article/details/48465773
版权

习题14.2：

Sales_data.h：

#ifndef SALES_DATA_H
#define SALES_DATA_H
#include <iostream>   
#include <fstream>
#include <string>
using std::string;
using std::cin; using std::cout; using std::endl;
using std::istream; using std::ostream;
using std::ifstream; using std::ofstream;

//为了在类内定义第四个构造函数所进行的声明
class Sales_data;
istream &operator>>(istream &, Sales_data &);
//类
class Sales_data
{
	friend istream &operator>>(istream &is, Sales_data &item);
	friend ostream &operator<<(ostream &os, const Sales_data &item);
	friend Sales_data operator+(const Sales_data &lhs, const Sales_data &rhs);
public:
	//公有成员函数
	string isbn()const;
	Sales_data &combine(const Sales_data &);
	//构造函数
	explicit Sales_data(const string &s, unsigned int n, double p) :bookIsbn(s), units_sold(n), revenue(p*n){}
	Sales_data() :Sales_data("", 0, 0){}//默认构造函数 委托构造函数
	Sales_data(const string &s) :Sales_data(s, 0, 0){ }
	Sales_data(istream &is) :Sales_data(){ is >> *this; }
	//+=运算符重载
	Sales_data &operator+=(const Sales_data &);
private:
	//成员变量
	string bookIsbn;
	unsigned units_sold = 0;
	double revenue = 0.0;
	//私有成员函数
	double avg_price()const;
};
//<<、>>、+运算符重载
Sales_data operator+(const Sales_data &, const Sales_data &);
istream &operator>>(istream &, Sales_data &);
ostream &operator<<(ostream &, const Sales_data &);
#endif

Sales_data.cpp：

#include <stdexcept>//使用runtime_error
#include "Sales_data.h"

using std::runtime_error;

//类外定义的构造函数

//成员函数
string Sales_data::isbn()const
{ 
	return bookIsbn; 
}
Sales_data & Sales_data::combine(const Sales_data &rhs)
{
	units_sold += rhs.units_sold;
	revenue += rhs.revenue;
	return *this;
}
double Sales_data::avg_price()const
{
	return units_sold ? revenue / units_sold : 0;
}

//非成员函数
Sales_data &Sales_data::operator+=(const Sales_data &rhs)
{
	while (true)
	{
		try{
			if (this->isbn() == rhs.isbn())
			{
				this->combine(rhs);
				return *this;
			}
			else
				throw runtime_error("输入的ISBN不相同,不能相加！");
		}
		catch (runtime_error err){
			cout << err.what() << endl
				<< "Oops, try again? Enter Y/N." << endl;
			char c;
			cin >> c;
			if (!cin || tolower(c) == 'n')
				break;
		}
	}
	cout << "输入不正确，接下来的结果不予保证！" << endl;
	return Sales_data();//返回一个空对象
}
Sales_data operator+(const Sales_data &lhs, const Sales_data &rhs)
{
	Sales_data sum = lhs;
	while (true)
	{
		try{
			if (lhs.isbn() == rhs.isbn())
			{
				sum.combine(rhs);
				return sum;
			}
			else
				throw runtime_error("输入的ISBN不相同,不能相加！");
		}
		catch (runtime_error err){
			cout << err.what() << endl
				<< "Oops, try again? Enter Y/N." << endl;
			char c;
			cin >> c;
			if (!cin || tolower(c) == 'n')
				break;
		}
	}
	cout << "输入不正确，接下来的结果不予保证！" << endl;
	return sum;//到这里应该只是随意返回一个错误对象了
}
istream &operator>>(istream &is, Sales_data &item)
{
	//cout << "请输入ISBN、已售数目、书本单价：" << endl;
	//cout << "read() called." << endl;
	double price = 0;
	is >> item.bookIsbn >> item.units_sold >> price;
	item.revenue = item.units_sold*price;
	return is;
}
ostream &operator<<(ostream &os, const Sales_data &item)
{
	os << "ISBN编号：" << item.isbn() << "  已售出："
		<< item.units_sold << "本  平均价格：" << item.revenue / item.units_sold
		<< "元  总收益：" << item.revenue << "元";
	return os;
}

main：

#include "Sales_data.h"

int main(){
	cout << "this is a test:" << endl;
	string read_file = "售卖记录.txt", write_file = "统计结果.txt";
	ifstream in(read_file);
	ofstream out(write_file,ofstream::app);
	if (in && out)
	{
		cout << "Open file: " + read_file + " & " + write_file << endl;
		Sales_data total;
		if (in >> total)
		{
			Sales_data trans;
			while (in >> trans)//到最后一条时 此处不是输入数据的地方，cin返回true
			{
				if (total.isbn() == trans.isbn())//可在else下加入cout测得trans.bookIsbn为空，返回0，进入else
					total.combine(trans);
				else
				{
					out << total << endl;//这样写可以保证最后一条数据正常显示
					total = trans;
				}
			}
			out << total << endl;
		}
		else
		{
			cout << "特么的啥也没有？" << endl;
		}
	}
	else
		cout << "Cannot open file:" + read_file + "&" + write_file << endl;
	
	getchar();
	getchar();
	return 0;
}

习题14.7：

String.h：

#ifndef STRING_H
#define STRING_H

#include <iostream>
#include <memory>
#include <utility>
#include <algorithm>
using std::cout; using std::endl;
using std::istream; using std::ostream;
#ifndef _MSC_VER
#define NOEXCEPT noexcept
#else
#define NOEXCEPT
#endif
class String
{
	friend ostream &operator<<(ostream &, const String &);
public:
	//移动构造函数&移动赋值运算符
	String(String &&)NOEXCEPT;
	String &operator=(String &&)NOEXCEPT;
	//构造函数
	String()
		:String(""){
		cout << "默认拷贝构造函数" << endl;
	};
	String(const char *);
	//拷贝构造函数
	String(const String &);
	//拷贝赋值运算符
	String &operator=(const String &rhs);
	//析构函数
	~String();

	std::size_t size(){ return first_free - element; }
	std::size_t capacity(){ return cap - element; }

	void push_back(const char &c);
private:
	std::allocator<char> alloc;
	char *element;
	char *first_free;
	char *cap;
	std::pair<char *, char *> alloc_n_copy(const char *, const char *);
	void range_init(const char *, const char *);
	void check_n_alloc();
	void free();
	void reallocate();
};
//输出运算符
ostream &operator<<(ostream &, const String &);
#endif

String.cpp： 

#include "String.h"

String::String(String &&rhs) NOEXCEPT
	:element(rhs.element), first_free(rhs.first_free), cap(rhs.cap)
{
	cout << "移动构造函数" << endl;
	rhs.element = rhs.first_free = rhs.cap = nullptr;
}
String &String::operator=(String &&rhs)NOEXCEPT
{
	cout << "移动赋值运算符" << endl;
	if (this != &rhs)
	{
		free();
		element = rhs.element;
		first_free = rhs.first_free; 
		cap = rhs.cap;
		rhs.element = rhs.first_free = rhs.cap = nullptr;
	}
	return *this;
}
void String::check_n_alloc()
{
	//std::cout << "check_n_alloc~" << std::endl;
	if (size() == capacity())
		reallocate();
}
void String::push_back(const char &c)
{
	//std::cout << "push_back~" << std::endl;
	check_n_alloc();
	alloc.construct(first_free++, c);
}
void String::reallocate()
{
	//std::cout << "reallocate~" << std::endl;
	auto new_capacity = size() ? 2 * size() : 1;
	auto new_data = alloc.allocate(new_capacity);
	auto dest = new_data;
	auto elem = element;
	for (size_t i = 0; i != size(); ++i)
		alloc.construct(dest++, std::move(*elem++));
	free();
	element = new_data;
	cap = first_free = element + new_capacity;
}
std::pair<char *, char *> String::alloc_n_copy(const char *beg, const char *end)
{
	//std::cout << "alloc_n_copy~" << std::endl;
	auto new_beg = alloc.allocate(end - beg);
	return{ new_beg, std::uninitialized_copy(beg, end, new_beg) };
}
void String::range_init(const char *beg, const char *end)
{
	//std::cout << "range_init~" << std::endl;
	auto new_data = alloc_n_copy(beg, end);
	element = new_data.first;
	first_free = new_data.second;
}
String::String(const char *pc_beg)
{
	std::cout << "C风格字符串构造函数调用~" << std::endl;
	auto pc_end = const_cast<char*>(pc_beg);
	while (*pc_end)
		++pc_end;
	range_init(pc_beg, ++pc_end);
}
String::String(const String &rhs)
{
	std::cout << "拷贝构造函数调用~" << std::endl;
	range_init(rhs.element, rhs.first_free);
}
String &String::operator=(const String &rhs)
{
	std::cout << "赋值运算符调用~" << std::endl;
	auto data = alloc.allocate(rhs.first_free - rhs.element);
	free();
	element = rhs.element;
	first_free = rhs.first_free;
	return *this;
}
void String::free()
{
	std::cout << "free~" << std::endl;
	if (element)
		std::for_each(element, first_free, [this](const char &c){alloc.destroy(&c); });
	alloc.deallocate(element, first_free - element);
	element = first_free = nullptr;
}
String::~String()
{
	free();
}

//overloaded operator functions
ostream &operator<<(ostream &os, const String &s)
{
	for (auto beg = s.element; beg != s.first_free; ++beg)
		os << *beg;
	return os;
}

main.cpp： 

#include "String.h"
#include <vector>

String func()
{
	String ret("a");
	return ret;
}
int main()
{
	//String s = func();
	String ss( "hello" );
	cout << ss << endl;
	getchar();
	return 0;
}

习题14.16： 

//运算符重载
bool operator==(const StrVec &lhs, const StrVec &rhs)
{
	return lhs.size() == rhs.size() && std::equal(lhs.begin(), lhs.end(), rhs.begin());
}
bool operator!=(const StrVec &lhs, const StrVec &rhs)
{
	return !(lhs == rhs);
}
begin() end()都是定义的有const限定符的成员函数，只是返回数据成员，即那几个指针。

习题14.18：

bool operator<(const StrVec &lhs, const StrVec &rhs)
{
	auto lp = lhs.begin(), rp = rhs.begin();
	while (lp != lhs.end() && rp != rhs.end())
	{
		if (*lp < *rp)
			return true;
		else if (*lp>*rp)
			return false;
		++lp, ++rp;
	}
	if (lp == lhs.end() && rp!=rhs.end())
		return true;
	else
		return false;
}
bool operator<=(const StrVec &lhs, const StrVec &rhs)
{
	return !(rhs < lhs);
}
bool operator>(const StrVec &lhs, const StrVec &rhs)
{
	return rhs < lhs;
}
bool operator>=(const StrVec &lhs, const StrVec &rhs)
{
	return !(lhs < rhs);
}

习题14.23： 

StrVec &StrVec::operator=(std::initializer_list<std::string> slst)//构造函数已经有了就用啊
{
	*this = StrVec(slst);
	return *this;
}

习题14.26： 

char &String::operator[](std::size_t n)
{
	return element[n];
}
const char &String::operator[](std::size_t n)const
{
	return element[n];
}

习题14.35： 
#ifndef PRINTPAINT_H
#define PRINTPAINT_H

#include <iostream>
#include <string>
using std::cin; using std::string; using std::istream;

class GetInput
{
public:
	GetInput(std::istream &i = std::cin) :is(i){ }
	string operator()()const
	{
		string s;
		getline(is, s);
		return is ? s : string();
	}
private:
	istream &is;//注意这里一定是引用
};

#endif

习题14.36： 

#include "标头.h"
#include <vector>
int main()
{
	std::vector<string> givec;
	GetInput gi;
	for (string temp; !(temp = gi()).empty();
		givec.push_back(temp));
	for (auto g : givec)
		std::cout << g << " ";
	std::cout << std::endl;
	getchar();
	return 0;
}

习题14.37：

.h

#ifndef PRINTPAINT_H
#define PRINTPAINT_H

#include <iostream>
#include <string>
using std::cin; using std::string; using std::istream;

class Equal
{
public:
	Equal(const int &ii) :i(ii){ };
	bool operator()(const int &i2)const
	{
		return i == i2;
	}
private:
	int i;
};

#endif

.cpp

#include "标头.h"
#include <vector>
#include <algorithm>
using std::vector;
int main()
{
	vector<int> ivec{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 5, 2, 4, 6, 1, 3 };
	//Equal eq(5);
	//for (auto beg = ivec.begin();
		//(beg = std::find_if(beg, ivec.end(), eq)) != ivec.end();
		//*beg = 42);
	std::replace_if(ivec.begin(), ivec.end(), Equal(5), 42);
	for (auto i : ivec)
		std::cout << i << " ";
	std::cout << std::endl;
	getchar();
	return 0;
}

习题14.38： 

#ifndef PRINTPAINT_H
#define PRINTPAINT_H

#include <iostream>
#include <string>
using std::cin; using std::string; using std::istream;

class Count
{
public:
	Count(std::size_t t) :n(t){ };
	bool operator()(const string &s)
	{
		return s.size() == n;
	}
private:
	std::size_t n;
};

#endif

#include "标头.h"
#include <vector>
#include <iterator>
#include <algorithm>
#include <fstream>
using std::vector;
int main()
{
	std::ifstream file("有标点单词段落测试.txt");
	vector<string> svec;
	string s_temp;
	while (file >> s_temp)
	{
		string s_org;
		std::remove_copy_if(s_temp.begin(), s_temp.end(), std::back_inserter(s_org), ispunct);
		svec.push_back(s_org);
		std::cout << s_org << std::endl;
	}

	vector<int> ivec;
	for (std::size_t i = 0; i != 10; ++i)
		ivec.push_back(std::count_if(svec.begin(), svec.end(), Count(i + 1)));

	for (auto i : ivec)
		std::cout << i << " ";
	std::cout << std::endl;

	getchar();
	return 0;
}

习题14.39： 

#ifndef PRINTPAINT_H
#define PRINTPAINT_H

#include <iostream>
#include <string>
using std::cin; using std::string; using std::istream;

class Count
{
public:
	Count(std::size_t low, std::size_t high)
		:_low(low), _high(high){ };
	bool operator()(const string &s)
	{
		return s.size() >= _low && s.size() <= _high;
	}
private:
	std::size_t _low;
	std::size_t _high;
};

#endif

#include "标头.h"
#include <vector>
#include <iterator>
#include <algorithm>
#include <fstream>
using std::vector;
int main()
{
	std::ifstream file("有标点单词段落测试.txt");
	vector<string> svec;
	string s_temp;
	while (file >> s_temp)
	{
		string s_org;
		std::remove_copy_if(s_temp.begin(), s_temp.end(), std::back_inserter(s_org), ispunct);
		svec.push_back(s_org);
		std::cout << s_org << std::endl;
	}
	
	vector<int> ivec;
	ivec.push_back(std::count_if(svec.begin(), svec.end(), Count(1, 9)));
	ivec.push_back(std::count_if(svec.begin(), svec.end(), Count(10, 100)));
	for (auto i : ivec)
		std::cout << i << " ";
	std::cout << std::endl;
	

	getchar();
	return 0;
}

习题14.43： 

	int n;
	cin >> n;
	vector<int> ivec{ 2, 3, 5 };
	std::modulus<int> mod;
	auto predicate = [&](const int i){return 0 != mod(n, i); };
	auto iter = std::find_if(ivec.begin(), ivec.end(), predicate);
	if (iter == ivec.end())
		std::cout << "true" << std::endl;
	else
		std::cout << "false" << std::endl;

习题14.44：

#ifndef CALCULATOR_H
#define CALCULATOR_H

#include <iostream>
#include <functional>
#include <map>
#include <string>
#include <algorithm>
//普通函数
int multiply(int i, int j){ return i*j; }
//函数对象类
struct mod{
	int operator()(int i, int j){ return i%j; }
};
//命名的lambda
auto devide = [](int i, int j){return i / j; };
//
std::map<std::string, std::function<int(int, int)>> binops = {
	{ "+", [](int i, int j){return i + j; } },//未命名lambda
	{ "-", std::minus<int>() },//标准库函数对象
	{ "*", multiply },
	{ "%",mod()},
	{ "/",devide }
};

int calc(std::string &calc_operator, int lhs, int rhs)
{
	return binops[calc_operator](lhs, rhs);
}
void arrange_calc()//其实顺序读入变量就好了 我这搞得还分离了一下字符串 傻了
{
	std::string input;
	std::string calc_operator;
	std::string lhs_s, rhs_s;
	std::cout << ">>";
	while (std::cin >> input && input[0]!='q')
	{
		auto op = std::find_if_not(input.begin(), input.end(), isalnum);
		auto iter = std::find_if(op, input.end(), isalnum);
		std::copy(input.begin(), op, std::back_inserter(lhs_s));
		std::copy(op, iter, std::back_inserter(calc_operator));
		std::copy(iter, input.end(), std::back_inserter(rhs_s));
		std::cout << calc(calc_operator, atoi(lhs_s.c_str()), atoi(rhs_s.c_str())) << std::endl;
		std::cout << ">>";
		lhs_s.clear(); rhs_s.clear(); calc_operator.clear();
	}
}
#endif


猫叔的大师兄
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++基础：异常，不对的情况报出来
凯凯在此
06-25 467
文章目录 抛出异常 #include <iostream> #include <stdexcept> using namespace std; int main(){ int n,m; cin >> n >> m; if(0 == m) throw runtime_error("除数不能为0"); // 抛出异常 cout << n/m << endl; } 结果
2021-09-05 《C++ Primer》学习记录：第14章
zheliku的博客
09-16 287
文章目录第 14 章 重载运算与类型转换14.1 基本概念14.2 输入和输出运算符14.2.1 重载输出运算符 <<14.2.2 重载输入运算符 >>14.3 算术和关系运算符14.3.1 相等运算符14.3.2 关系运算符（*）14.4 赋值运算符14.5 下标运算符14.6 递增和递减运算符14.7 成员访问运算符14.8 函数调用运算符14.8.1 lambda 是函数对象14.8.2 标准库定义的函数对象14.8.3 可调用对象与 function14.9 重载、类型转换与
c++ primer 第十四章重载运算与类型转换
无所知的博客
10-04 300
c++ primer 第十四章重载运算与类型转换14.1 基本概念14.2 输入和输出运算符14.2.1 重载输出运算符&lt;&lt;14.2.2 重载输入运算符&gt;&gt;14.3 算术和关系运算符14.3.1 相等运算符14.3.2 关系运算符14.4 赋值运算符14.5 下标运算符14.6 递增和递减运算符14.7 成员访问运算符14.8 函数调用运算符14.8.1 lambda是函数...
C++ primer 查漏补缺十：Sales_data类的设计
fuyouzhiyi的博客
08-12 733
类的基本思想是数据抽象(data abstraction)和封装(encapsulation)。数据抽象是一种依赖于接口(interface)和实现(implementation)分离的编程（以及设计）技术。类的接口包括用户所能执行的操作：类的实现则包括类的数据成员、负责接口实现的函数体以及定义类所需的各种私有函数。封装实现了类的接口和实现的分离。封装后的类隐藏了它的实现细节，也就是说，类的用户只能使用接口而无法访问实现部分。...
c++ primer 学习笔记-第七章
Dreamtide的博客
08-06 456
习题7.1： #include #include using std::cin; using std::cout; using std::endl; using std::string; struct Sales_data { string bookIsbn; unsigned units_sold = 0; double price = 0.0; double reve
C++ Primer 第十四章 重载操作符与转换 思维导图笔记
03-18
在C++编程语言中，重载操作符与转换是两个重要的概念，它们允许程序员自定义基本操作符的...通过阅读《C++ Primer》第四版第十四章的思维导图笔记，你可以深入学习这些概念，巩固理论知识，并在实际编程中应用它们。
C++primer_plus_第五版_学习笔记
12-08
### C++ Primer Plus 第五版 学习笔记关键知识点概览 #### 一、C++ 源代码风格规范 1. **每行一条语句**：为了提高代码的可读性和可维护性，建议每行只写一条语句。 2. **花括号格式**： - 每个函数的两个花括号...
《C++ primer plus》读书笔记(二)
09-04
《C++ Primer Plus》读书笔记(二)涵盖了C++的基础知识，主要集中在第五至第八章。下面是这些章节中的一些关键知识点： 1. **for循环**：for循环的语法结构为`for(initialization; test-expression; update-...
my-C-plus-plus:c++的学习笔记
05-27
《C++ Primer》百科级 最新是第五版 作者参与了C++第一个编译器的实现 《The C++ Programming Language》最新是第四版，作者是C++之父，目前还没有中文版 《Effective C++》最新是第三版，告诉你什么改写，什么不该...
c++异常处理理解
最新发布
sdhdsf132452的博客
10-13 267
c++
六、C++语言初阶：异常
小脑斧的博客
05-08 162
抛出异常和捕获异常
C++ Primer Plus第六版 第十四章 编程练习答案
蒟蒻升级中...Orz
12-05 3536
这章有点难的= =。。。那个虚MI和模板把我看的有点晕QAQ //main.cpp #include #include "winec.h" int main() { using std::cin; using std::cout; using std::endl; cout << "Enter name of wine: "; char lab[50]; cin.getline
c++ primer 第十四章习题
无所知的博客
10-04 1461
c++ primer 第十三章习题 练习14.2 ostream&amp;amp;amp; operator&amp;amp;lt;&amp;amp;lt;(std::ostream&amp;amp;amp; os, const Sales_data&amp;amp;amp; item){ os &amp;amp;lt;&amp;amp;lt; item.isbn() &amp;amp;lt;&amp;amp;lt; &
第26课 - 异常处理 - 下
qq_36521904的博客
05-29 371
第26课 - 异常处理 - 下    一.深入异常处理        问题：有时在工程中只关心是否产生了异常，而不关心具体异常的类型,C++语言可以做到吗?                            1.1 C++中的catch语句可以使用...捕获所有的异常            ...作参数表示可变参数函数，可以接受任意参数       Source Example 1.1: ...
C++学习一错误处理
HotIce0
02-10 384
C++中的错误处理，涉及到try...catch   throw来实现。 最简单的是 void fun() { throw 10; } int main() { try { fun(); } catch(int){ cout << "Error" << endl; } return 0; }，这里只是遇到抛出整型的值就进入对应的int型的错误处理。 如果要获取到抛出的值就
C++primer第14章习题解答
宝剑锋从磨砺出 梅花香自苦寒来
04-19 5824
练习14.1：在什么情况下重载的运算符与内置运算符有所区别？在什么情况下重载的运算符又与内置运算符一样？ 不同点： 重载运算符必须具有至少一个class或枚举类型的操作数。 重载运算符不保证操作数的求值顺序，例如对&&和||的重载版本不再具有“短路求值”的特性，两个操作数都要求值，而且不规定操作数的求值顺序。 相同点： 对于优先级和结合性级操作数的数目都不变。 练习14.2：为
Day 11 C++异常处理
zjjaibc的博客
01-28 1202
异常
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值