c++ primer中文版第五版作业第十八章

于 2024-03-08 21:26:00 发布
阅读量1.1k 收藏 19
点赞数 26
分类专栏： c/c++及数据结构 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fuluoyide312/article/details/136571869
版权

仓库地址

文章目录

18.1

  1. 此时r是一个range_error类型的局部对象
  2. 此时p是exception类型的指针,指向局部对象r
    如果throw p就会抛出一个指向局部对象的指针，那么有可能在执行catch语句之前，该局部对象已经被销毁。

18.2

 v和in可以调用其析构函数释放资源，而p无法正确释放资源，导致内存泄漏。

18.3

  1. 使用智能指针管理p
    unique_ptr<int []> p(new int[v.size()])
  2. 使用类来控制资源的分配
class ptr
{
	public:
		explicit ptr(size_t len):p(new int[len]) {}
		ptr(const ptr&)=delete;
		ptr & operator=(const ptr&)=delete;
		~ptr()
		{
			delete [] p;
		}
	private:
		int *p;
};

18.4

 catch语句是按照其出现的顺序逐一进行匹配的，所以根据继承体系catch(exception)后面的catch子句永远无法被匹配到。

try{
//
}catch(overflow_error eobj){
//
}catch(const runtime_error &re){
//
}catch(exception){/**/}

18.5

#include <iostream>
#include <exception>
#include <stdexcept>
#include <cstdlib>
int main(){
	try{
		//使用c++标准库
}catch(const exception &e){
	std::cout<<e.what()<<std::endl;
	abort();
}
}

18.6

  1. throw exceptionType * eobj，注意不能抛出一个指向局部对象的指针
  2. 抛出的所有异常都能被捕获
  3. int a=1;throw a;抛出的所有int类型值都能被捕获，但是其余的整型类型无法进行算数类型转换为int。

18.7

#ifndef BLOB_H
#define BLOB_H
#include <iostream>
#include <string>
#include <memory>
#include <vector>
#include <string>
#include <initializer_list>
#include <stdexcept>
template <typename> class BlobPtr;
template <typename> class Blob;
//Blob
template <typename T> bool operator==(const Blob<T> &,const Blob<T> &);
template <typename T> bool operator!=(const Blob<T> &,const Blob<T> &);
template <typename T> bool operator<(const Blob<T> &,const Blob<T> &);
template <typename T> bool operator<=(const Blob<T> &,const Blob<T> &);
template <typename T> bool operator>(const Blob<T> &,const Blob<T> &);
template <typename T> bool operator>=(const Blob<T> &,const Blob<T> &);
template <typename T> class Blob
{
	friend class BlobPtr<T>;
	friend bool operator==<T>(const Blob<T> &,const Blob<T> &);
	friend bool operator!=<T>(const Blob<T> &,const Blob<T> &);
	friend bool operator< <T>(const Blob<T> &,const Blob<T> &);
	friend bool operator<= <T>(const Blob<T> &,const Blob<T> &);
	friend bool operator> <T>(const Blob<T> &,const Blob<T> &);
	friend bool operator>= <T>(const Blob<T> &,const Blob<T> &);
	public:
		typedef T value_type;
		typedef typename std::vector<T>::size_type size_type;
		Blob() try:data(std::make_shared<std::vector<T>>()){} catch(std::bad_alloc &e){std::cout<<e.what()<<std::endl;}
		Blob(std::initializer_list<T> il) try:data(std::make_shared<std::vector<T>>(il)){} catch(std::bad_alloc &e){std::cout<<e.what()<<std::endl;}
		Blob(const Blob &org) try:data(std::make_shared<std::vector<T>>(*org.data)){} catch(std::bad_alloc &e){std::cout<<e.what()<<std::endl;}
		template <typename it> Blob(it b,it e) try:data(std::make_shared<std::vector<T>>(b,e)) {} catch(std::bad_alloc &ba){std::cout<<ba.what()<<std::endl;}
		Blob &operator=(const Blob &);
		T & operator[](size_type i);
		const T & operator[](size_type i) const;
		size_type size() const {return data->size();}
		bool empty() const {return data->empty;}
		void push_back(const T &t){data->push_back(t);}
		void push_back(T &&t){data->push_back(std::move(t));}
		void pop_back();
		T & front();
		T & back();
		const T & front() const;
		const T & back() const;
		BlobPtr<T> begin();
		BlobPtr<T> end();
	private:
		std::shared_ptr<std::vector<T>> data;
		void check(size_type i,const std::string &msg) const;
};
//BlobPtr
template <typename T> bool operator==(const BlobPtr<T> &,const BlobPtr<T> &);
template <typename T> bool operator!=(const BlobPtr<T> &,const BlobPtr<T> &);
template <typename T> bool operator<(const BlobPtr<T> &,const BlobPtr<T> &);
template <typename T> bool operator<=(const BlobPtr<T> &,const BlobPtr<T> &);
template <typename T> bool operator>(const BlobPtr<T> &,const BlobPtr<T> &);
template <typename T> bool operator>=(const BlobPtr<T> &,const BlobPtr<T> &);
template <typename T> class BlobPtr
{
	friend bool operator==<T>(const BlobPtr<T> &,const BlobPtr<T> &);
	friend bool operator!=<T>(const BlobPtr<T> &,const BlobPtr<T> &);
	friend bool operator< <T>(const BlobPtr<T> &,const BlobPtr<T> &);
	friend bool operator<=<T>(const BlobPtr<T> &,const BlobPtr<T> &);
	friend bool operator><T>(const BlobPtr<T> &,const BlobPtr<T> &);
	friend bool operator>=<T>(const BlobPtr<T> &,const BlobPtr<T> &);
	public:
		typedef typename std::vector<T>::size_type size_type;
		BlobPtr():curr(0){}
		BlobPtr(const Blob<T> &blob,size_type sz=0):wptr(blob.data),curr(sz){}
		T & operator[](size_type i);
		const T & operator[](size_type i) const;
		BlobPtr & operator++();
		BlobPtr & operator++(int);
		BlobPtr & operator--();
		BlobPtr & operator--(int);
		BlobPtr operator+(size_type) const;
		BlobPtr operator-(size_type) const;
		BlobPtr operator+=(size_type) const;
		BlobPtr operator-=(size_type) const;
		T & operator*() const;
		T * operator->() const;
	private:
		std::shared_ptr<std::vector<T>> check(size_type i,const std::string &msg) const;
		std::weak_ptr<std::vector<T>> wptr;
		size_type curr=0;
};
//Blob
template <typename T> Blob<T> & Blob<T>::operator=(const Blob &rhs)
{
	data=std::make_shared<std::vector<T>>(*rhs.data);
	return *this;
}
template <typename T> T & Blob<T>::operator[](size_type i)
{
	check(i,"subscript out of range");
	return (*data)[i];
}
template <typename T> const T & Blob<T>::operator[](size_type i) const
{
	check(i,"subscript out of range");
	return (*data)[i];
}
template <typename T> void Blob<T>::pop_back()
{
	check(0,"pop_back on empty Blob");
	data->pop_back();
}
template <typename T> T & Blob<T>::front()
{
	check(0,"front on empty Blob");
	return data->front();
}
template <typename T> const T & Blob<T>::front() const
{
	check(0,"front on empty Blob");
	return data->front();
}
template <typename T> T & Blob<T>::back()
{
	check(0,"back on empty Blob");
	return data->back();
}
template <typename T> const T & Blob<T>::back() const
{
	check(0,"back on empty Blob");
	return data->back();
}
template <typename T> BlobPtr<T> Blob<T>::begin()
{
	return BlobPtr<T>(*this);
}
template <typename T> BlobPtr<T> Blob<T>::end()
{
	return BlobPtr<T>(*this,data->size());
}
template <typename T> inline void Blob<T>::check(size_type i,const std::string &msg) const
{
	if(i>=data->size())
		throw std::out_of_range(msg);
}
template <typename T> bool operator==(const Blob<T> &lhs,const Blob<T> &rhs)
{
	return *lhs.data==*rhs.data;
}
template <typename T> bool operator!=(const Blob<T> &lhs,const Blob<T> &rhs)
{
	return !(lhs==rhs);
}
template <typename T> bool operator<(const Blob<T> &lhs,const Blob<T> &rhs)
{
	return *lhs.data<*rhs.data;
}
template <typename T> bool operator<=(const Blob<T> &lhs,const Blob<T> &rhs)
{
	return !(lhs>rhs);
}
template <typename T> bool operator>(const Blob<T> &lhs,const Blob<T> &rhs)
{
	return *lhs.data>*rhs.data;
}
template <typename T> bool operator>=(const Blob<T> &lhs,const Blob<T> &rhs)
{
	return !(lhs<rhs);
}
//BlobPtr
template <typename T> std::shared_ptr<std::vector<T>> BlobPtr<T>::check(size_type i,const std::string &msg) const
{
	auto ret=wptr.lock();
	if(!ret)
		throw std::runtime_error("unbound BlobPtr");
	if(i>=ret->size())
		throw std::out_of_range(msg);
	return ret;
}
template <typename T> T & BlobPtr<T>::operator[](size_type i)
{
	auto ret=check(i,"index out of range");
	return (*ret)[i];
}
template <typename T> const T & BlobPtr<T>::operator[](size_type i) const
{
	auto ret=check(i,"index out of range");
	return (*ret)[i];
}
template <typename T> BlobPtr<T> & BlobPtr<T>::operator++()
{
	check(curr,"increment past end of BlobPtr");
	++curr;
	return *this;
}
template <typename T> BlobPtr<T> & BlobPtr<T>::operator++(int)
{
	BlobPtr ret=*this;
	++*this;
	return ret;
}
template <typename T> BlobPtr<T> & BlobPtr<T>::operator--()
{
	--curr;
	check(curr,"decrement past the begin of BlobPtr");
	return *this;
}
template <typename T> BlobPtr<T> & BlobPtr<T>::operator--(int)
{
	BlobPtr ret=*this;
	--*this;
	return ret;
}
template <typename T> BlobPtr<T> BlobPtr<T>::operator+(size_type i) const
{
	BlobPtr ret(*this);
	ret+=i;
	return ret;
}
template <typename T> BlobPtr<T> BlobPtr<T>::operator-(size_type i) const
{
	BlobPtr ret(*this);
	ret-=i;
	return ret;
}
template <typename T> BlobPtr<T> BlobPtr<T>::operator+=(size_type i) const
{
	check(curr+i,"increment past end of range");
	while(--i)
		++*this;
	return *this;
}
template <typename T> BlobPtr<T> BlobPtr<T>::operator-=(size_type i) const
{
	check(curr-i,"decrement past begin of range");
	while(--i)
		--*this;
	return *this;
}
template <typename T> T & BlobPtr<T>::operator*() const
{
	auto p=check(curr,"dereference past end");
	return (*p)[curr];
}
template <typename T> T * BlobPtr<T>::operator->() const
{
	return & this->operator*();
}
template <typename T> bool operator==(const BlobPtr<T> &lhs,const BlobPtr<T> &rhs)
{
	auto l=lhs.wptr.lock();
	auto r=rhs.wptr.lock();
	if(l==r)
		return (!r||lhs.curr==rhs.curr);
	else
		return false;
}
template <typename T> bool operator!=(const BlobPtr<T> &lhs,const BlobPtr<T> &rhs)
{
	return !(lhs==rhs);
}
template <typename T> bool operator<(const BlobPtr<T> &lhs,const BlobPtr<T> &rhs)
{
	auto l=lhs.wptr.lock();
	auto r=rhs.wptr.lock();
	if(l==r&&l)
		return lhs.curr<rhs.curr;
	else
		return false;
}
template <typename T> bool operator<=(const BlobPtr<T> &lhs,const BlobPtr<T> &rhs)
{
	return !(lhs>rhs);
}
template <typename T> bool operator>(const BlobPtr<T> &lhs,const BlobPtr<T> &rhs)
{
	return rhs<lhs;
}
template <typename T> bool operator>=(const BlobPtr<T> &lhs,const BlobPtr<T> &rhs)
{
	return !(lhs<rhs);
}
#endif

18.8

#ifndef BLOB_H
#define BLOB_H
#include <iostream>
#include <string>
#include <memory>
#include <vector>
#include <string>
#include <initializer_list>
#include <stdexcept>
template <typename> class BlobPtr;
template <typename> class Blob;
//Blob
template <typename T> bool operator==(const Blob<T> &,const Blob<T> &);
template <typename T> bool operator!=(const Blob<T> &,const Blob<T> &);
template <typename T> bool operator<(const Blob<T> &,const Blob<T> &);
template <typename T> bool operator<=(const Blob<T> &,const Blob<T> &);
template <typename T> bool operator>(const Blob<T> &,const Blob<T> &);
template <typename T> bool operator>=(const Blob<T> &,const Blob<T> &);
template <typename T> class Blob
{
	friend class BlobPtr<T>;
	friend bool operator==<T>(const Blob<T> &,const Blob<T> &);
	friend bool operator!=<T>(const Blob<T> &,const Blob<T> &);
	friend bool operator< <T>(const Blob<T> &,const Blob<T> &);
	friend bool operator<= <T>(const Blob<T> &,const Blob<T> &);
	friend bool operator> <T>(const Blob<T> &,const Blob<T> &);
	friend bool operator>= <T>(const Blob<T> &,const Blob<T> &);
	public:
		typedef T value_type;
		typedef typename std::vector<T>::size_type size_type;
		Blob() noexcept(false) try:data(std::make_shared<std::vector<T>>()){} catch(std::bad_alloc &e){std::cout<<e.what()<<std::endl;}
		Blob(std::initializer_list<T> il) noexcept(false) try:data(std::make_shared<std::vector<T>>(il)){} catch(std::bad_alloc &e){std::cout<<e.what()<<std::endl;}
		Blob(const Blob &org) noexcept(false) try:data(std::make_shared<std::vector<T>>(*org.data)){} catch(std::bad_alloc &e){std::cout<<e.what()<<std::endl;}
		template <typename it> Blob(it b,it e) noexcept(false) try:data(std::make_shared<std::vector<T>>(b,e)) {} catch(std::bad_alloc &ba){std::cout<<ba.what()<<std::endl;}
		Blob &operator=(const Blob &);
		T & operator[](size_type i);
		const T & operator[](size_type i) const;
		size_type size() const {return data->size();}
		bool empty() const {return data->empty;}
		void push_back(const T &t){data->push_back(t);}
		void push_back(T &&t){data->push_back(std::move(t));}
		void pop_back();
		T & front();
		T & back();
		const T & front() const;
		const T & back() const;
		BlobPtr<T> begin();
		BlobPtr<T> end();
		~Blob() noexcept {};
	private:
		std::shared_ptr<std::vector<T>> data;
		void check(size_type i,const std::string &msg) const;
};
//BlobPtr
template <typename T> bool operator==(const BlobPtr<T> &,const BlobPtr<T> &);
template <typename T> bool operator!=(const BlobPtr<T> &,const BlobPtr<T> &);
template <typename T> bool operator<(const BlobPtr<T> &,const BlobPtr<T> &);
template <typename T> bool operator<=(const BlobPtr<T> &,const BlobPtr<T> &);
template <typename T> bool operator>(const BlobPtr<T> &,const BlobPtr<T> &);
template <typename T> bool operator>=(const BlobPtr<T> &,const BlobPtr<T> &);
template <typename T> class BlobPtr
{
	friend bool operator==<T>(const BlobPtr<T> &,const BlobPtr<T> &);
	friend bool operator!=<T>(const BlobPtr<T> &,const BlobPtr<T> &);
	friend bool operator< <T>(const BlobPtr<T> &,const BlobPtr<T> &);
	friend bool operator<=<T>(const BlobPtr<T> &,const BlobPtr<T> &);
	friend bool operator><T>(const BlobPtr<T> &,const BlobPtr<T> &);
	friend bool operator>=<T>(const BlobPtr<T> &,const BlobPtr<T> &);
	public:
		typedef typename std::vector<T>::size_type size_type;
		BlobPtr():curr(0){}
		BlobPtr(const Blob<T> &blob,size_type sz=0):wptr(blob.data),curr(sz){}
		T & operator[](size_type i);
		const T & operator[](size_type i) const;
		BlobPtr & operator++();
		BlobPtr & operator++(int);
		BlobPtr & operator--();
		BlobPtr & operator--(int);
		BlobPtr operator+(size_type) const;
		BlobPtr operator-(size_type) const;
		BlobPtr operator+=(size_type) const;
		BlobPtr operator-=(size_type) const;
		T & operator*() const;
		T * operator->() const;
	private:
		std::shared_ptr<std::vector<T>> check(size_type i,const std::string &msg) const;
		std::weak_ptr<std::vector<T>> wptr;
		size_type curr=0;
};
//Blob
template <typename T> Blob<T> & Blob<T>::operator=(const Blob &rhs)
{
	data=std::make_shared<std::vector<T>>(*rhs.data);
	return *this;
}
template <typename T> T & Blob<T>::operator[](size_type i)
{
	check(i,"subscript out of range");
	return (*data)[i];
}
template <typename T> const T & Blob<T>::operator[](size_type i) const
{
	check(i,"subscript out of range");
	return (*data)[i];
}
template <typename T> void Blob<T>::pop_back()
{
	check(0,"pop_back on empty Blob");
	data->pop_back();
}
template <typename T> T & Blob<T>::front()
{
	check(0,"front on empty Blob");
	return data->front();
}
template <typename T> const T & Blob<T>::front() const
{
	check(0,"front on empty Blob");
	return data->front();
}
template <typename T> T & Blob<T>::back()
{
	check(0,"back on empty Blob");
	return data->back();
}
template <typename T> const T & Blob<T>::back() const
{
	check(0,"back on empty Blob");
	return data->back();
}
template <typename T> BlobPtr<T> Blob<T>::begin()
{
	return BlobPtr<T>(*this);
}
template <typename T> BlobPtr<T> Blob<T>::end()
{
	return BlobPtr<T>(*this,data->size());
}
template <typename T> inline void Blob<T>::check(size_type i,const std::string &msg) const
{
	if(i>=data->size())
		throw std::out_of_range(msg);
}
template <typename T> bool operator==(const Blob<T> &lhs,const Blob<T> &rhs)
{
	return *lhs.data==*rhs.data;
}
template <typename T> bool operator!=(const Blob<T> &lhs,const Blob<T> &rhs)
{
	return !(lhs==rhs);
}
template <typename T> bool operator<(const Blob<T> &lhs,const Blob<T> &rhs)
{
	return *lhs.data<*rhs.data;
}
template <typename T> bool operator<=(const Blob<T> &lhs,const Blob<T> &rhs)
{
	return !(lhs>rhs);
}
template <typename T> bool operator>(const Blob<T> &lhs,const Blob<T> &rhs)
{
	return *lhs.data>*rhs.data;
}
template <typename T> bool operator>=(const Blob<T> &lhs,const Blob<T> &rhs)
{
	return !(lhs<rhs);
}
//BlobPtr
template <typename T> std::shared_ptr<std::vector<T>> BlobPtr<T>::check(size_type i,const std::string &msg) const
{
	auto ret=wptr.lock();
	if(!ret)
		throw std::runtime_error("unbound BlobPtr");
	if(i>=ret->size())
		throw std::out_of_range(msg);
	return ret;
}
template <typename T> T & BlobPtr<T>::operator[](size_type i)
{
	auto ret=check(i,"index out of range");
	return (*ret)[i];
}
template <typename T> const T & BlobPtr<T>::operator[](size_type i) const
{
	auto ret=check(i,"index out of range");
	return (*ret)[i];
}
template <typename T> BlobPtr<T> & BlobPtr<T>::operator++()
{
	check(curr,"increment past end of BlobPtr");
	++curr;
	return *this;
}
template <typename T> BlobPtr<T> & BlobPtr<T>::operator++(int)
{
	BlobPtr ret=*this;
	++*this;
	return ret;
}
template <typename T> BlobPtr<T> & BlobPtr<T>::operator--()
{
	--curr;
	check(curr,"decrement past the begin of BlobPtr");
	return *this;
}
template <typename T> BlobPtr<T> & BlobPtr<T>::operator--(int)
{
	BlobPtr ret=*this;
	--*this;
	return ret;
}
template <typename T> BlobPtr<T> BlobPtr<T>::operator+(size_type i) const
{
	BlobPtr ret(*this);
	ret+=i;
	return ret;
}
template <typename T> BlobPtr<T> BlobPtr<T>::operator-(size_type i) const
{
	BlobPtr ret(*this);
	ret-=i;
	return ret;
}
template <typename T> BlobPtr<T> BlobPtr<T>::operator+=(size_type i) const
{
	check(curr+i,"increment past end of range");
	while(--i)
		++*this;
	return *this;
}
template <typename T> BlobPtr<T> BlobPtr<T>::operator-=(size_type i) const
{
	check(curr-i,"decrement past begin of range");
	while(--i)
		--*this;
	return *this;
}
template <typename T> T & BlobPtr<T>::operator*() const
{
	auto p=check(curr,"dereference past end");
	return (*p)[curr];
}
template <typename T> T * BlobPtr<T>::operator->() const
{
	return & this->operator*();
}
template <typename T> bool operator==(const BlobPtr<T> &lhs,const BlobPtr<T> &rhs)
{
	auto l=lhs.wptr.lock();
	auto r=rhs.wptr.lock();
	if(l==r)
		return (!r||lhs.curr==rhs.curr);
	else
		return false;
}
template <typename T> bool operator!=(const BlobPtr<T> &lhs,const BlobPtr<T> &rhs)
{
	return !(lhs==rhs);
}
template <typename T> bool operator<(const BlobPtr<T> &lhs,const BlobPtr<T> &rhs)
{
	auto l=lhs.wptr.lock();
	auto r=rhs.wptr.lock();
	if(l==r&&l)
		return lhs.curr<rhs.curr;
	else
		return false;
}
template <typename T> bool operator<=(const BlobPtr<T> &lhs,const BlobPtr<T> &rhs)
{
	return !(lhs>rhs);
}
template <typename T> bool operator>(const BlobPtr<T> &lhs,const BlobPtr<T> &rhs)
{
	return rhs<lhs;
}
template <typename T> bool operator>=(const BlobPtr<T> &lhs,const BlobPtr<T> &rhs)
{
	return !(lhs<rhs);
}
#endif

18.9

Sales_data.h

#include <iostream>
#include <string>
#include <stdexcept>
class isbn_mismatch: public std::logic_error
{
public:
	explicit isbn_mismatch(const std::string &s):std::logic_error(s) {}
	isbn_mismatch(const std::string &s,const std::string &lhs,const std::string &rhs):std::logic_error(s),left(lhs),right(rhs) {}
	const std::string left,right;
};
class Sales_data
{
	friend std::istream & operator>>(std::istream &,Sales_data &);
	friend std::ostream & operator<<(std::ostream &,const Sales_data &);
	friend Sales_data operator+(const Sales_data &,const Sales_data &);
	public:
		std::string isbn() const {return bookNo;}
		Sales_data()=default;
		Sales_data(const std::string &s):bookNo(s) {}
		Sales_data(const std::string &s,unsigned n,double p):bookNo(s),units_sold(n),revenue(n*p) {}
		Sales_data & operator+=(const Sales_data &);
		operator std::string() const {return bookNo;}
		operator double() const {return revenue;}
	private:
		std::string bookNo;
		unsigned units_sold=0;
		double revenue=0.0;
		double avg_price() const;
};
std::istream & operator>>(std::istream &,Sales_data &);
std::ostream & operator<<(std::ostream &,const Sales_data &);
Sales_data operator+(const Sales_data &,const Sales_data &);
bool compareIsbn(const Sales_data &lhs,const Sales_data &rhs);

Sales_data.cpp

#include "Sales_data.h"
inline double Sales_data::avg_price() const
{
	if(units_sold)
		return revenue/units_sold;
	else
		return 0;
}
std::istream & operator>>(std::istream &is,Sales_data &src)
{
	double price=0.0;
	is>>src.bookNo>>src.units_sold>>price;
	if(is)
		src.revenue=src.units_sold*price;
	else
		src=Sales_data();
	return is;
}
std::ostream & operator<<(std::ostream &os,const Sales_data &src)
{
	os<<src.isbn()<<" "<<src.units_sold<<" "<<src.revenue<<" "<<src.avg_price();
	return os;
}
Sales_data & Sales_data::operator+=(const Sales_data & rhs)
{
	*this=*(this)+rhs;
	return *this;
}
Sales_data operator+(const Sales_data &lhs,const Sales_data &rhs)
{
	Sales_data tmp;
	if(lhs.isbn()!=rhs.isbn())
		throw isbn_mismatch("wrong isbns!",lhs.isbn(),rhs.isbn());
	tmp.bookNo=lhs.bookNo;
	tmp.units_sold=lhs.units_sold+rhs.units_sold;
	tmp.revenue=lhs.revenue+rhs.revenue;
	return tmp;
}
bool compareIsbn(const Sales_data &lhs,const Sales_data &rhs)
{
	return lhs.isbn()<rhs.isbn();
}

test1.cpp

#include <iostream>
#include "Sales_data.h"
int main(void)
{
	Sales_data a("111",2,30),b("112",3,50);
	a+b;
	return  0;
}

不处理异常的输出
terminate called after throwing an instance of ‘isbn_mismatch’
what(): wrong isbns!
Aborted
test2.cpp

#include <iostream>
#include "Sales_data.h"
int main(void)
{
	Sales_data a("111",2,30),b("112",3,50);
	try
	{
		a+b;
	}
	catch(const isbn_mismatch &e)
	{
		std::cerr<<e.what()<<": left isbn ("<<e.left<<") right isbn ("<<e.right<<")"<<std::endl;
	}
	return  0;
}

处理异常的输出
wrong isbns!: left isbn (111) right isbn (112)

18.10

见18.9

18.11

 如果what函数抛出异常的话，没有对应的catch子句捕获处理，就会调用terminate使程序结束，破坏正常逻辑。

18.12

Query.h

#ifndef _QUERY_H
#define _QUERY_H
#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <memory>
#include <fstream>
namespace chapter15
{
	class QueryResult;
	class TextQuery
	{
		public:
			using line_no=std::vector<std::string>::size_type;
			TextQuery(std::ifstream &);
			QueryResult query(const std::string &) const;
		private:
			std::shared_ptr<std::vector<std::string>> file;
			std::map<std::string,std::shared_ptr<std::set<line_no>>> wm;
	};
	class QueryResult
	{
		friend std::ostream &print(std::ostream &,const QueryResult &);
		public:
			QueryResult(std::string s,std::shared_ptr<std::set<std::vector<std::string>::size_type>> l,std::shared_ptr<std::vector<std::string>> f):sought(s),lines(l),file(f){}
			std::set<std::vector<std::string>::size_type>::iterator begin() const {return lines->begin();}
			std::set<std::vector<std::string>::size_type>::iterator end() const {return lines->end();}
			std::shared_ptr<std::vector<std::string>> get_file(){return file;}
		private:
			std::string sought;
			std::shared_ptr<std::set<std::vector<std::string>::size_type>> lines;
			std::shared_ptr<std::vector<std::string>> file;
	};
	std::ostream &print(std::ostream &,const QueryResult &);
	inline std::string make_plural(std::size_t count,const std::string &word,const std::string &ending)
	{
		return (count>1)?word+ending:word;
	}
	class Query_base
	{
		friend class Query;
		protected:
			using line_no=TextQuery::line_no;
			virtual ~Query_base()=default;
		private:
			virtual QueryResult eval(const TextQuery &) const=0;
			virtual std::string rep() const=0;
	};
	class Query
	{
		friend Query operator~(const Query &);
		friend Query operator&(const Query &,const Query &);
		friend Query operator|(const Query &,const Query &);
		public:
			Query(const std::string &);
			QueryResult eval(const TextQuery &t) const {return q->eval(t);}
			std::string rep() const {return q->rep();}
		private:
			Query(std::shared_ptr<Query_base> query):q(query) {}
			std::shared_ptr<Query_base> q;
	};
	class WordQuery:public Query_base
	{
		friend class Query;
		private:
			WordQuery(const std::string &s):query_word(s) {}
			virtual QueryResult eval(const TextQuery &t) const {return t.query(query_word);}
			virtual std::string rep() const {return query_word;}
			std::string query_word;
	};
	
	inline Query::Query(const std::string &s):q(new WordQuery(s)) {}
	
	class NotQuery:public Query_base
	{
		friend Query operator~(const Query &);
		private:
			NotQuery(const Query &q):query(q) {}
			virtual QueryResult eval(const TextQuery &) const;
			virtual std::string rep() const {return "~("+query.rep()+")";}
			Query query;
	};
	inline Query operator~(const Query &q) {return std::shared_ptr<Query_base>(new NotQuery(q));}
	class BinaryQuery:public Query_base
	{
		protected:
			BinaryQuery(const Query &left,const Query &right,const std::string &s):lhs(left),rhs(right),opSym(s) {}
			virtual std::string rep() const {return "("+lhs.rep()+" "+opSym+" "+rhs.rep()+")";}
			Query lhs,rhs;
			std::string opSym;
	};
	class AndQuery:public BinaryQuery
	{
		friend Query operator&(const Query&,const Query&);
		private:
			AndQuery(const Query &left,const Query &right):BinaryQuery(left,right,"&") {}
			virtual QueryResult eval(const TextQuery &) const;
	};
	inline Query operator&(const Query &left,const Query &right) {return std::shared_ptr<Query_base>(new AndQuery(left,right));}
	class OrQuery:public BinaryQuery
	{
		friend Query operator|(const Query &,const Query &);
		private:
			OrQuery(const Query &left,const Query &right):BinaryQuery(left,right,"|") {}
			virtual QueryResult eval(const TextQuery &) const;
	};
	inline Query operator|(const Query &left,const Query &right) {return std::shared_ptr<Query_base>(new OrQuery(left,right));}
	inline std::ostream & operator<<(std::ostream &os,const Query &q) {return os<<q.rep();}
}
#endif

Query.cpp

#include <sstream>
#include <algorithm>
#include <cctype>
#include "Query.h"
namespace chapter15
{
	TextQuery::TextQuery(std::ifstream &infile):file(new std::vector<std::string>)
	{
		std::string text;
		while(getline(infile,text))
		{
			file->push_back(text);
			std::size_t line_number=file->size()-1;
			std::istringstream line(text);
			std::string word;
			while(line>>word)
			{
				std::string key_word;
				for(auto c:word)
				{
					if(!ispunct(c))
						key_word+=c;
				}
				std::shared_ptr<std::set<line_no>> &lines=wm[key_word];
				if(!lines)
					lines.reset(new std::set<line_no>);
				lines->insert(line_number);
			}
		}
	}
	QueryResult TextQuery::query(const std::string &sought) const
	{
		static std::shared_ptr<std::set<line_no>> nodata(new std::set<line_no>);
		std::map<std::string,std::shared_ptr<std::set<line_no>>>::const_iterator map_it=wm.find(sought);
		if(map_it==wm.end())
			return QueryResult(sought,nodata,file);
		else
			return QueryResult(sought,map_it->second,file);
	}
	
	std::ostream &print(std::ostream &os,const QueryResult &qr)
	{
		os<<"Executing Query for: "<<qr.sought<<std::endl;
		os<<qr.sought<<" occurs "<<qr.lines->size()<<" "<<make_plural(qr.lines->size(),"time","s")<<std::endl;
		for(auto num:*(qr.lines))
			os<<"\t(line "<<num+1<<") "<<*(qr.file->begin()+num)<<std::endl;
		return os;
	}
	QueryResult NotQuery::eval(const TextQuery &text) const
	{
		auto result=query.eval(text);
		auto beg=result.begin(),end=result.end();
		auto ret_lines=std::make_shared<std::set<line_no>>();
		auto sz=result.get_file()->size();
		for(std::size_t n=0;n!=sz;++n)
		{
			if(beg==end||*beg!=n)
				ret_lines->insert(n);
			else if(beg!=end)
				++beg;
		}
		return QueryResult(rep(),ret_lines,result.get_file());
	}
	QueryResult OrQuery::eval(const TextQuery &text) const
	{
		auto left=lhs.eval(text),right=rhs.eval(text);
		auto ret_lines=std::make_shared<std::set<line_no>>(left.begin(),left.end());
		ret_lines->insert(right.begin(),right.end());
		return QueryResult(rep(),ret_lines,left.get_file());
	}
	QueryResult AndQuery::eval(const TextQuery &text) const
	{
		auto left=lhs.eval(text),right=rhs.eval(text);
		auto ret_lines=std::make_shared<std::set<line_no>>();
		set_intersection(left.begin(),left.end(),right.begin(),right.end(),inserter(*ret_lines,ret_lines->begin()));
		return QueryResult(rep(),ret_lines,left.get_file());
	}
}

TextQuery.h

#ifndef TEXT_QUERY_H
#define TEXT_QUERY_H
#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <memory>
#include <fstream>
#include <tuple>
namespace chapter10
{
	class TextQuery
	{
	public:
		using line_no=std::vector<std::string>::size_type;
		TextQuery(std::ifstream &);
		std::tuple<std::string,std::shared_ptr<std::set<std::vector<std::string>::size_type>>,std::shared_ptr<std::vector<std::string>>> query(const std::string &) const;
	private:
		std::shared_ptr<std::vector<std::string>> file;
		std::map<std::string,std::shared_ptr<std::set<line_no>>> wm;
	};
	inline std::string make_plural(std::size_t count,const std::string &word,const std::string &ending)
	{
	        return (count>1)?word+ending:word;
	}
	std::ostream &print(std::ostream &,const std::tuple<std::string,std::shared_ptr<std::set<std::vector<std::string>::size_type>>,std::shared_ptr<std::vector<std::string>>> &);
}
#endif

TextQuery.cpp

#include <fstream>
#include <iostream>
#include <sstream>
#include <vector>
#include <set>
#include <string>
#include <memory>
#include "TextQuery.h"
using namespace std;
namespace chapter10
{
	TextQuery::TextQuery(ifstream &infile):file(new vector<string>)
	{
		string text;
		while(getline(infile,text))
		{
			file->push_back(text);
			size_t line_number=file->size()-1;
			istringstream line(text);
			string word;
			while(line>>word)
			{
				shared_ptr<set<line_no>> &lines=wm[word];
				if(!lines)
					lines.reset(new set<line_no>);
				lines->insert(line_number);
			}
		}
	}
	std::tuple<std::string,std::shared_ptr<std::set<std::vector<std::string>::size_type>>,std::shared_ptr<std::vector<std::string>>> TextQuery::query(const string &sought) const
	{
		static shared_ptr<set<line_no>> nodata(new set<line_no>);
		map<string,shared_ptr<set<line_no>>>::const_iterator map_it=wm.find(sought);
		if(map_it==wm.end())
			return tuple(sought,nodata,file);
		else
			return tuple(sought,map_it->second,file);
	}
	std::ostream &print(std::ostream &os,const std::tuple<std::string,std::shared_ptr<std::set<std::vector<std::string>::size_type>>,std::shared_ptr<std::vector<std::string>>> &tp)
	{
		 os<<std::get<0>(tp)<<" occurs "<<std::get<1>(tp)->size()<<" "<<make_plural(std::get<1>(tp)->size(),"time","s")<<std::endl;
	        for(auto num:*(get<1>(tp)))
	                os<<"\t(line "<<num+1<<")"<<*(get<2>(tp)->begin()+num)<<std::endl;
	        return os;
	}
}

test.cpp

#include <fstream>
#include "Query.h"
using namespace std;
using chapter15::Query;
using chapter15::TextQuery;
int main(int argc,char *argv[])
{
	ifstream infile(argv[1]);
	TextQuery text(infile);
	Query q=Query("fiery")&Query("bird")|Query("wind");
	print(cout,q.eval(text));
	return 0;
}

18.13

 需要使用文件作用域或者命名空间作用域的静态变量时可以使用未命名的命名空间。

18.14

 mathLib::MatrixLib::matrix mathLib::MatrixLib::operator*(const matrix &,const matrix &);

18.15

using声明：一次只引入命名空间的一个成员，它的有效范围从using声明的地方开始，到using声音所在作用域结束为止。
using指示：使特定的命名空间中所有的名字都可见，这些名字一般被看作是出现在最近的外层作用域中，如果遇到成员冲突的情况，需要使用作用域运算符指明所需的版本。

18.16

位置一
using声明

ivar成员冲突

位置二
using声明

dvar成员冲突

位置一
using指示

++ivar这句将有二义性错误

位置二
using指示

++ivar这句将有二义性错误

18.17

1

#include <iostream>	
namespace Exercise
{
	int ivar=0;
	double dvar=0;
	const int limit=1000;
}
int ivar=0;

using Exercise::ivar;
using Exercise::dvar;
using Exercise::limit;

void manip()
{

	double dvar=3.1416;
	int iobj=limit+1;
	++ivar;
	++::ivar;
}
int main(void)
{
	return 0;
}

2

#include <iostream>	
namespace Exercise
{
	int ivar=0;
	double dvar=0;
	const int limit=1000;
}
int ivar=0;

void manip()
{

using Exercise::ivar;
using Exercise::dvar;
using Exercise::limit;

	double dvar=3.1416;
	int iobj=limit+1;
	++ivar;
	++::ivar;
}
int main(void)
{
	return 0;
}

3

#include <iostream>	
namespace Exercise
{
	int ivar=0;
	double dvar=0;
	const int limit=1000;
}
int ivar=0;

using namespace Exercise;

void manip()
{

	double dvar=3.1416;
	int iobj=limit+1;
	++ivar;
	++::ivar;
}
int main(void)
{
	return 0;
}

4

#include <iostream>	
namespace Exercise
{
	int ivar=0;
	double dvar=0;
	const int limit=1000;
}
int ivar=0;


void manip()
{

using namespace Exercise;

	double dvar=3.1416;
	int iobj=limit+1;
	++ivar;
	++::ivar;
}
int main(void)
{
	return 0;
}

18.18

 当mem1是一个string时程序因为更特例化的原因，会调用string中定义的swap版本，而int是内置类型，内置类型没有特定版本的swap，所以会调用std::swap。

18.19

 如果使用std::swap的形式，则是直接指明调用std命名空间中的swap版本。

18.20

  • 命名空间primerLib中声明的compte将被加入候选函数集
    候选函数void compute() void compute(const void *) void compute(int) void compute(double,double=3.4) void compute(char*,char*=0)
    可行函数
    void compute(const void *)0能转换成任意指针类型
    void compute(int)精确匹配
    void compute(double,double=3.4)int向double的算术类型转换
    void compute(char*,char*=0)0能转换成任意指针类型
  • 如果将using声明置于f函数中compute的调用点之前,将隐藏全局作用域中声明的compute.
    候选函数void compute() void compute(const void *)
    可行函数
    void compute(const void *)0能转换成任意指针类型

18.21

1 正确,public继承CAD,private继承Vehicle
2 错误，在一个派生列表中重复继承了同一个基类
3 正确，public继承istream,public继承ostream

18.22

 构造函数的执行顺序是A->B->C->X->Y->Z->MI

18.23

都允许

18.24

ZooAnimal *pz=new Panda("ying_yang")
pb->print();//调用Panda::print()
pb->cuddle();//错误，不属于ZooAnimal的接口
pb->highlight();//错误，不属于ZooAnimal的接口
delete->pb;//正确，Panda::~Panda()

18.25

  1. MI::print()
  2. MI::print()
  3. MI::print()
  4. MI::~MI()
  5. MI::~MI()
  6. MI::~MI()

18.26

 因为派生类的名字将隐藏基类的同名成员，所以MI不加前缀限定符的print函数只有接受std::vector参数的版本，而42无法隐式转换为该类型，所以调用失败。
可以这样修改：

struct MI:public Derived,public Base2
{
        void print(std::vector<double>);
        void print(int i)
        {
            Base1::print(i);
        }
    protected:
        int *ival;
        std::vector<double> dvec;
}

18.26

  1. 所有可见的名字：
函数内：
    int dval;
    double cval;
类内：
    int *ival;
    std::vector<double> dvec;
    void print(std::vector<double>);
Derived:
    void Derived::print(std::string) const;
    std::string sval;
    double Derived::dval;
Base1:
    void Base1::print(int) const;
    int Base1::ival;
    double Base1::dval;
    char Base1::cval;
Base2:
    void Base2::print(double) const;
    int Base2::ival;
    double fval;
    char Base2::cval;
全局作用域：
    int ival;
    double dval;

dval    cval    ival    print都是继承自多个基类。
dval:Derived::dval  Base1::dval
cval:Base1::cval    Base2::cval
ival:Base1::ival    Base2::ival
print:Derived::print    Base1::print    Base2::print

void MI::foo(double cval)
{
    int dval;
    dval=Base1::dval+Derived::dval;
}

void MI::foo(double cval)
{
    int dval;
    Base2::fval=dvec.back();
}

void MI::foo(double cval)
{
    int dval;
    sval[0]=Base1::cval;
}

18.28

无需前缀限定符：
    Derived1::bar
     Derived2::ival
需要前缀限定符：
     Derived1::foo
     Derived2::foo
     Base::bar
     Base::ival
     Derived1::cval
     Derived2::cval

18.29

构造函数顺序：Class() Base() D1() D2() MI() Class() Final()
析构函数顺序：Final() Class() MI() D2() D1() Base() Class()
2. 1个base部分，两个Class部分。
3.
pb=new Class错误，不存在基类指针向派生类的隐式转换
pc=new Final错误，Class接口的使用会导致二义性错误
pmi=pb错误，不存在基类指针向派生类的隐式转换
pd2=pmi正确

18.30

这样定义的话，由于存在歧义，直接基类Class在Final中无法访问
class Class{};
class Base:public Class
{
	public:
		Base()=default;
		Base(const Base &b):i(b.i) {}
		Base(const int &ri):i(ri) {}
	private:
		int i;
};
class D1:public virtual Base
{
	public:
		D1()=default;
		D1(const D1 &d):Base(d) {}
		D1(const int &ri):Base(ri) {}
};
class D2:public virtual Base
{
	public:
		D2()=default;
		D2(const D2 &d):Base(d) {}
		D2(const int &ri):Base(ri) {}
};
class MI:public D1,public D2
{
	public:
		MI()=default;
		MI(const MI &mi):Base(mi),D1(mi),D2(mi) {}
		MI(const int &ri):Base(ri),D1(ri),D2(ri) {}
};
class Final:public MI,public Class
{
	public:
		Final()=default;
		Final(const Final &fi):Base(fi),MI(fi),Class() {}
		Final(const int &ri):Base(ri),MI(ri),Class() {}
};
fuluoyide312
关注
  • 26
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++Primer第五版——习题答案+详解(完整版)
MISAYAONE的博客
12-21 33万+
C++Primer第五版——习题答案详解 看的也比较快，但是有很多东西确实用不上，所以很多都没有深入的探讨，但是知识点覆盖的很全面，每一道题涉及的知识点我都写上简单的解释了。 文中代码的中文注释也尽量都写上，自己皆编译通过。 水平有限，如有有误之处，希望大家不吝指教！ 下面的链接是 第一章：全部题目(第一章基础较多)http:/
c++ primer plus 第六版第十五章学习笔记
Schlangemm的博客
12-20 660
1、不同类间的友元： 1）友元类;A类是B类的友元；A中所以的方法都可以访问B类的私有成员，在B类公有成员中声明添加friend class B；语句即可。 2）特定友元成员函数：A类中的特定成员函数是B类的友元；只有在B类中声明为其友元的A类成员函数才能访问B类的私有成员，在B类公有成员声明中添加：friend 函数返回值 A类名::函数原型；语句即可。此时由于在A类友元声明中用到了B类名...
C++Primer第五版 习题答案 目录
热门推荐
shamozhizhoutx的博客
07-29 5万+
C++Primer第五版 习题答案 本文当作我学习C++的一个记录，这里的习题答案并不是标准答案，仅仅是我的理解，如有错误，请大家指出，谢谢！ 我参考的文章会在文末列出，谢谢大家。 第一章 ...
c++ primer plus 第六版第十四章编程练习
Schlangemm的博客
12-17 373
14.1 //Wine.h #include&lt;iostream&gt; #include&lt;string&gt; #include&lt;valarray&gt; #include&lt;utility&gt; typedef std::valarray&lt;int&gt; ArrayInt; typedef std::pair&lt;ArrayInt, ArrayInt&gt;...
C++ Primer中文版（第5版）李普曼 等著 pdf 1/3
02-24
C++ Primer中文版（第5版）[203M]分3个压缩包 本书是久负盛名的C++经典教程，其内容是C++大师Stanley B. Lippman丰富的实践经验和C++标准委员会原负责人Josée Lajoie对C++标准深入理解的完美结合，已经帮助全球无数...
c++primer第五版习题答案（第18章）
11-12
c++primer第五版中文版课后答案（第18章）pdf格式，真正的c++primer习题集（第五版），用手机拍的，但是每个字都能看的很清楚
C++ Primer第四版【中文高清扫描版】.pdf
03-13
【原书名】 C++ Primer (4th Edition) 【原出版社】 Addison Wesley/Pearson 【作者】 （美）Stanley B.Lippman,Josée ...第18章　特殊工具与技术 631 18.1 优化内存分配 632 18.1.1 C++中的内存分配 632 18.1.2 ...
c++primer中文版勘误表
10-21
C++ Primer 中文版勘误表 C++ Primer 是一种广泛使用的 C++ 编程语言教程书籍，而中文版的 C++ Primer 也存在一些小错误。以下是 C++ Primer 中文版勘误表，总结了书中的一些错误和修订内容。 1. 第 79 页表 3-4 ...
数据结构与算法分析--c语言描述(原书第二版)练习自答（第六章）
fuluoyide312的博客
07-21 2129
文章目录6.16.26.36.4 6.1 待完善 6.2 static void PercolateDown(int index,ElementType Data[],int Length) { ElementType Temp; int i,Child; for(i=index;i*2<=Length;i=Child) { Child=i*2; if(Chi
数据结构与算法分析--c语言描述(原书第二版)练习自答（第七章）
fuluoyide312的博客
08-30 1820
文章目录7.17.27.37.47.57.67.77.87.97.107.117.127.137.147.15 7.1 #!/bin/bash #形如7-1.sh 3 1 4 1 5 9 2 6 5的输入即可排序 array=(`echo $@`) length=${#array[@]} for((i=0;i<$length;i++)) do Tmp=${array[i]} j=$i while [ $j -gt 0 ]&&[ ${arr
c++ primer中文版第五版作业第十一章
fuluoyide312的博客
03-08 1482
如果关键字0在m中，则将其对应的值修改为1.如果关键字0不在m中，则向m中添加一个关键字为0，对应值为0的元素，然后将此元素的值修改为1.书中程序处理了这种情况的，如果文件中的某一行包含一个关键字和一个空格，那么这一行的转换规则不会录入map。而vector中的元素是按它们在容器中的位置来顺序保存和访问的。如果v中含有元素，则将v[0]赋值1.如果v是空的，则会产生严重错误。会返回相同的迭代器，迭代器会指向第一个不影响排序的关键字插入位置，而。中含有该关键字，那么下标操作会改变该关键字对应的值，而。
数据结构与算法分析--c语言描述练习自答（第二章）
fuluoyide312的博客
06-04 1392
2.7 2.7.h #ifndef _2_7_h #define _2_7_h #include <time.h> extern int RandInt(int i,int j); clock_t start,finish; extern void Substitution(int A[],int N); #endif RandInt.c #include <stdlib.h> #include <time.h> int RandInt(int i,int j) { .
数据结构与算法分析--c语言描述练习自答（第三章）(3.1~3.10)
fuluoyide312的博客
07-01 1349
list.h #ifndef _List_H #define _List_H struct Node; typedef struct Node *PtrToNode; typedef PtrToNode List; typedef PtrToNode Position; typedef int ElementType; List MakeEmpty(List L); //List L is unused int IsEmpty(List L); int IsLast(Position P,List L
c++ primer中文版第五版作业第十六章
fuluoyide312的博客
03-08 1274
特例化不影响函数匹配，它并不是为编译器进行函数匹配提供一个新的选择，而是为模版的一个特殊实例提供不同于原模版的特殊定义，本质上是接管了编译器在完成函数匹配后的部分实例化工作。如此一来，非可变参数版本就不在可变参数版本的作用域中，那么递归调用的将永远是可变参数版本的实例，即使res是空包，调用将依然进行下去，无法结束递归。用函数实参来确定模板实参的过程被称为模板实参推断，在模板实参推断的过程中，编译器使用函数调用中的实参类型来寻找模板实参，从而生成对应的模板实例。=而不是<，可减少你的算法适用容器的限制。
数据结构与算法分析--c语言描述(原书第二版)练习自答（第五章）
fuluoyide312的博客
06-30 1252
文章目录5.15.25.35.45.55.65.7 5.1 图片截自答案（非自己画的） 2. 3. 4. 将会插入失败 5.2 待完善 5.3 待完善 5.4 假设p为进行rehash时的装填因子，如果p接近或者等于1.0的话，那么一连串的insert和delete操作就会导致反复的rehash。 如果p为232\over332​，这时假设原tablesize是300，拥有elements200，在进行了100次delete后才需要调用rehash。如果tablesize是150，拥有eleme
c++ primer中文版第五版作业第三章
fuluoyide312的博客
02-29 1095
仓库地址 1.cpp 2.cpp 3.cpp 4.cpp 5.cpp 6.cpp 7.cpp 3.2 3-2-1.cpp 3-2-2.cpp 3.3   string类的输入运算符会忽略空白，getline函数会存储空白。3-4-1.cpp 3-4-2.cpp 3.5 3-5-1.cpp 3-5-2.cpp 3.6 3.7 一样的 3.8 3-8-1.cpp 3-8-2.cpp 3.9   不合法，使用下标访问空string的行为未定义。 3.11 合法，的类型是。 3.15 3.16 3.17 3
c++ primer中文版第五版作业第十七章
最新发布
fuluoyide312的博客
03-08 1081
没看懂意思，如果只是单纯要排除某些指定的单词的话，在匹配之后输出之前判断一下这个单词是否是要排除的那些单词之一即可，但这并不是一个好办法。一行的长度超过传递给getline的字符数组的大小时，会导致输入流的条件状态被置为错误，导致后续读入失败。如果使用[^c]ei进行初始化，那么此模式只能匹配首字母不是c的三个字母组成的单词，其余单词都不能匹配。如果循环内定义b、e，那么每步循环都会创建一个新引擎及分布对象，从而每步循环都会生成相同的值。版本稍微复杂一点，自己定义一个类的版本更自由。
C++ Primer第五版中文习题集详尽答案
《C++ Primer第五版中文版习题集答案》是由C++编程领域的权威作者Stanley B. Lippman、Joseph Lajoie和Barbara E. Moo共同完成的经典著作的配套教材。该书针对C++ Primer第五版进行了全面更新，特别强调了C++11标准...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值