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

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

习题15.3：

#ifndef QUOTE_H
#define QUOTE_H

#include <iostream>
#include <string>

class Quote
{
public:
	//构造函数
	Quote() = default;
	Quote(const std::string &book, const double &p) :bookNo(book), price(p){ }
	//返回ISBN编号
	std::string isbn()const{ return bookNo; }
	
	//虚函数 返回当前计算方法的总价格
	virtual double net_price(std::size_t n)const{ return n*price; }
	//虚析构函数 动态绑定
	virtual ~Quote() = default;
private:
	std::string bookNo;//书籍的ISBN编号
protected:
	double price;//未打折价格
};
double print_total(std::ostream &os, const Quote &item, std::size_t n)
{
	double ret = item.net_price(n);
	os << "ISBN: " << item.isbn() << " total due: " << ret << std::endl;
	return ret;
}
#endif

习题15.5_6_7：

#ifndef QUOTE_H
#define QUOTE_H

#include <iostream>
#include <string>

class Quote
{
public:
	//构造函数
	Quote() = default;
	Quote(const std::string &book, const double &p) :bookNo(book), price(p){ }
	//返回ISBN编号
	std::string isbn()const{ return bookNo; }
	
	//虚函数 返回当前计算方法的总价格
	virtual double net_price(std::size_t cnt)const{ return cnt*price; }
	//虚析构函数 动态绑定
	virtual ~Quote() = default;
private:
	std::string bookNo;//书籍的ISBN编号
protected:
	double price;//未打折价格
};


#endif

#ifndef BULK_QUOTE_H
#define BULK_QUOTE_H

#include "Quote.h"
class Bulk_quote :public Quote
{
public:
	Bulk_quote() = default;
	Bulk_quote(const std::string &book, const double &p, std::size_t least, double d)
		:Quote(book, p), min_qty(least), discount(d){ }
	double net_price(std::size_t cnt)const override{
		if (cnt >= min_qty)
			return cnt*price*(1 - discount);
		else
			return cnt*price;
	};
private:
	std::size_t min_qty = 0;
	double discount = 0.0;
};

#endif

#ifndef BOUND_QUOTE_H
#define BOUND_QUOTE_H

#include "Quote.h"

class Bound_quote:public Quote
{
public:
	Bound_quote() = default;
	Bound_quote(const std::string &book,const double &p,std::size_t most,double d)
		:Quote(book, p), max_qty(most), discount(d){ }
	double net_price(std::size_t cnt)
	{
		if (cnt <= max_qty)
			return cnt*price*(1 - discount);
		else
			return max_qty*price*(1 - discount) + (cnt - max_qty)*price;
	}
private:
	std::size_t max_qty = 0;
	double discount = 0.0;
};

#endif

习题15.15_16： 

#ifndef DISC_QUOTE_H
#define DISC_QUOTE_H

#include "Quote.h"

class Disc_quote:public Quote
{
public:
	Disc_quote() = default;
	Disc_quote(const std::string &book, const double &p, std::size_t qty, double d)
		:Quote(book, p), quantity(qty), discount(d){ }
	double net_price(std::size_t cnt)const = 0;
private:
	std::size_t quantity = 0;
	double discount = 0.0;
};

#endif

#ifndef BULK_QUOTE_H
#define BULK_QUOTE_H

#include "Disc_quote.h"
class Bulk_quote :public Disc_quote
{
public:
	Bulk_quote() = default;
	Bulk_quote(const std::string &book, const double &p, std::size_t least, double d)
		:Disc_quote(book, p, least, d){ }
	double net_price(std::size_t cnt)const override
	{
		return (cnt >= min_qty) ? cnt*price*(1 - discount) : cnt*price;
	};
	std::ostream &debug(std::ostream &os)const override
	{
		Quote::debug(os);
		os << "最小购买量:min_qty  折扣:discount  ";
		return os;
	}
private:
	std::size_t min_qty = 0;
	double discount = 0.0;
};

#endif

#ifndef BOUND_QUOTE_H
#define BOUND_QUOTE_H

#include "Disc_quote.h"

class Bound_quote :public Disc_quote
{
public:
	Bound_quote() = default;
	Bound_quote(const std::string &book,const double &p,std::size_t most,double d)
		:Disc_quote(book, p, most, d){ }
	double net_price(std::size_t cnt)const
	{
		return (cnt <= max_qty) ? cnt*price*(1 - discount) 
			: max_qty*price*(1 - discount) + (cnt - max_qty)*price;
	}
	std::ostream &debug(std::ostream &os)const override
	{
		Quote::debug(os);
		os << "最大购买量:max_qty  折扣:discount  ";
		return os;
	}
private:
	std::size_t max_qty = 0;
	double discount = 0.0;
};

#endif

#ifndef QUOTE_H
#define QUOTE_H

#include <iostream>
#include <string>

class Quote
{
public:
	//构造函数
	Quote() = default;
	Quote(const std::string &book, const double &p) :bookNo(book), price(p){ }
	//返回ISBN编号
	std::string isbn()const{ return bookNo; }
	
	//虚函数 返回当前计算方法的总价格
	virtual double net_price(std::size_t cnt)const{ return cnt*price; }
	//虚函数 显示类的数据成员
	virtual std::ostream &debug(std::ostream &os)const
	{
		os << "ISBN编号:bookNo  原价格:price  ";
		return os;
	}
	//虚析构函数 动态绑定
	virtual ~Quote() = default;
private:
	std::string bookNo;//书籍的ISBN编号
protected:
	double price;//未打折价格
};


#endif

习题15.21：

#ifndef SHAPE_H
#define SHAPE_H

#include <string>
#include <utility>

class Shape
{
public:
	using Coordinate = std::pair<double, double>;

	Shape() = default;
	Shape(const std::string &n) :name(n){ }

	virtual const double area()const = 0;
	virtual const double perimeter()const = 0;
	virtual ~Shape() = default;
private:
	std::string name;
};
class Rectangle:public Shape
{
public:
	Rectangle() = default;
	Rectangle(const std::string &s,
		const Coordinate &p1, const Coordinate &p2,
		const Coordinate &p3, const Coordinate &p4)//注意const
		:Shape(s), a(p1), b(p2),c(p3), d(p4){ }
	const double area()const;
	const double perimeter()const;
	~Rectangle() = default;
protected://为了让Rectangle的派生类可以访问
	Coordinate a;
	Coordinate b;
	Coordinate c;
	Coordinate d;
private:
	std::pair<Coordinate, Coordinate> corner()const;//工具函数 找出对定的两点
};
class Square :public Rectangle 
{
public:
	Square() = default;
	Square(const std::string &s,
		const Coordinate &p1, const Coordinate &p2,
		const Coordinate &p3, const Coordinate &p4)
		:Rectangle(s, p1, p2, p3, p4){ }
	~Square() = default;
	//const double area()const;//完全可以使用Rect版本而不需要自己定义
	//const double perimeter()const;//可以给出新定义just for efficiency.
};

std::pair<Shape::Coordinate, Shape::Coordinate> Rectangle::corner()const
{
	if (a.first != b.first && a.second != b.second)
		return std::make_pair(a, b);
	else if (a.first != c.first && a.second != c.second)
		return std::make_pair(a, c);
	else
		return std::make_pair(a, d);
}
const double Rectangle::area()const
{
	auto p = corner();
	Coordinate c1 = p.first, c2 = p.second;
	return abs((c1.first - c2.first)*(c1.second - c2.second));
}
const double Rectangle::perimeter()const
{
	auto p = corner();
	Coordinate c1 = p.first, c2 = p.second;
	return 2 * abs((c1.first - c2.first) + (c1.second - c2.second));
}
#endif

#include "Shape.h"
#include <iostream>
int main()
{
	//const std::string s("rect1");
	//Rectangle r1(s, { 1, 1 }, { 1, 5 }, { 4, 1 }, { 4, 5 });
	//std::cout << r1.area() << " " << r1.perimeter() << std::endl;
	Square s1("square1", { 0, 0 }, { 1, 1 }, { 0, 1 }, { 1, 0 });
	std::cout << s1.area() << " " << s1.perimeter() << std::endl;
	getchar();
	return 0;
}

习题15.26：

Quote.h：

#ifndef QUOTE_H
#define QUOTE_H

#include <iostream>
#include <string>
#include <stdexcept>

#ifndef _MSC_VER
#define NOEXCEPT noexcept
#else
#define NOEXCEPT
#endif

class Quote
{
public:
	//构造函数
	Quote(){ std::cout << "Quote: default constructor" << std::endl; }
	Quote(const std::string &book, const double &p) :bookNo(book), price(p)
	{
		std::cout << "Quote: constuctor func" << std::endl;
	}
	//拷贝构造函数
	Quote(const Quote &q) :bookNo(q.bookNo), price(q.price)
	{
		std::cout << "Quote: copy constuctor func" << std::endl;
	}
	//拷贝赋值运算符
	Quote &operator=(const Quote &rhs)
	{
		if (this != &rhs)
		{
			bookNo = rhs.bookNo;
			price = rhs.price;
		}
		std::cout << "Quote: copy operator= func" << std::endl;
		return *this;
	}
	//移动构造函数
	Quote(const Quote &&rhs)NOEXCEPT:bookNo(std::move(rhs.bookNo)), price(std::move(rhs.price))
	{
		std::cout << "Quote: move constructor func" << std::endl;
	}
	//移动赋值运算符
	Quote &operator=(const Quote &&rhs)NOEXCEPT
	{
		if (this != &rhs)
		{
			bookNo = std::move(rhs.bookNo);
			price = std::move(rhs.price);
		}
		std::cout << "Quote: move operator= func" << std::endl;
		return *this;
	}
	//返回ISBN编号
	std::string isbn()const{ return bookNo; }
	//虚函数 返回当前计算方法的总价格
	virtual double net_price(std::size_t cnt)const{ return cnt*price; }
	//虚函数 显示类的数据成员
	virtual std::ostream &debug(std::ostream &os)const
	{
		os << "ISBN编号:bookNo  原价格:price  ";
		return os;
	}
	//虚析构函数 动态绑定
	virtual ~Quote()
	{
		std::cout << "~Quote deconstructor func" << std::endl;
	}
private:
	std::string bookNo;//书籍的ISBN编号
protected:
	double price;//未打折价格
};

#endif

Disc_quote： 

#ifndef DISC_QUOTE_H
#define DISC_QUOTE_H

#include "Quote.h"

class Disc_quote:public Quote
{
public:
	Disc_quote(){ std::cout << "Disc_quote: default constructor func" << std::endl; }
	Disc_quote(const std::string &book, const double &p, std::size_t qty, double d)
		:Quote(book, p), quantity(qty), discount(d)
	{
		std::cout << "Disc_quote: constructor func" << std::endl;
	}
	Disc_quote(const Disc_quote &d) :Quote(d), quantity(d.quantity), discount(d.discount)
	{
		std::cout << "Disc_quote: copy constructor func" << std::endl;
	}
	Disc_quote &operator=(const Disc_quote &rhs)
	{
		if (this != &rhs)
		{
			Quote::operator=(rhs);
			quantity = rhs.quantity;
			discount = rhs.discount;
		}
		std::cout << "Disc_quote: copy operator= func" << std::endl;
		return *this;
	}
	//正好此处没用std::move看看是否影响
	//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
	//经检验，确实有影响。如果某一代没有用std::move显示调用移动构造或移动赋值
	//例如，Disc_quote没move,则对Bulk_quote类对象进行显示移动构造或赋值时
	//只有Bulk_quote的移动构造或赋值被调用，接下来只会回溯调用Disc_quote的拷贝
	//赋值或构造函数，然后回溯调用Quote基类的拷贝，最终顺序是自基类向派生类显示
	//所以一定不要在移动构造和赋值中忽视std::move的作用。
	Disc_quote(const Disc_quote &&d)NOEXCEPT 
		:Quote(std::move(d)), quantity(std::move(d.quantity)), discount(std::move(d.discount))
	{
		std::cout << "Disc_quote: move constructor func" << std::endl;
	}
	Disc_quote &operator=(const Disc_quote &&rhs)NOEXCEPT
	{
		if (this != &rhs)
		{
			Quote::operator=(std::move(rhs));
			quantity = std::move(rhs.quantity);
			discount = std::move(rhs.discount);
		}
		std::cout << "Disc_quote: move operator= func" << std::endl;
		return *this;
	}
	~Disc_quote(){ std::cout << "~Disc_quote deconstructor func" << std::endl; }

	double net_price(std::size_t cnt)const = 0;
private:
	std::size_t quantity = 0;
	double discount = 0.0;
};

#endif

Bulk_quote： 

#ifndef BULK_QUOTE_H
#define BULK_QUOTE_H

#include "Disc_quote.h"
class Bulk_quote :public Disc_quote
{
public:
	Bulk_quote(){ std::cout << "Bulk_quote: default constructor" << std::endl; }
	Bulk_quote(const std::string &book, const double &p, std::size_t least, double d)
		:Disc_quote(book, p, least, d)
	{
		std::cout << "Bulk_quote: construtor func" << std::endl;
	}
	Bulk_quote(const Bulk_quote &b) :Disc_quote(b), min_qty(b.min_qty), discount(b.discount)
	{
		std::cout << "Bulk_quote: copy construcot func" << std::endl;
	}
	Bulk_quote &operator=(const Bulk_quote &rhs)
	{
		if (this != &rhs)
		{
			Disc_quote::operator=(rhs);
			min_qty = rhs.min_qty;
			discount = rhs.discount;
		}
		std::cout << "Bulk_quote: copy operator= func" << std::endl;
		return *this;
	}
	Bulk_quote(const Bulk_quote &&b) NOEXCEPT
		:Disc_quote(std::move(b)), min_qty(std::move(b.min_qty)), discount(std::move(b.discount))
	{
		std::cout << "Bulk_quote: move constructor func" << std::endl;
	}
	Bulk_quote &operator=(const Bulk_quote &&rhs)NOEXCEPT
	{
		if (this != &rhs)
		{
			Disc_quote::operator=(std::move(rhs));
			min_qty = std::move(rhs.min_qty);
			discount = std::move(rhs.discount);
		}
		std::cout << "Bulk_quote: move operator= func" << std::endl;
		return *this;
	}

	double net_price(std::size_t cnt)const override
	{
		return (cnt >= min_qty) ? cnt*price*(1 - discount) : cnt*price;
	};
	std::ostream &debug(std::ostream &os)const override
	{
		Quote::debug(os);
		os << "最小购买量:min_qty  折扣:discount  ";
		return os;
	}
	~Bulk_quote(){ std::cout << "~Bulk_quote: deconstructor func" << std::endl; }
private:
	std::size_t min_qty = 0;
	double discount = 0.0;
};

#endif

习题15.28_29： 

#include "Quote.h"
#include "Disc_quote.h"
#include "Bulk_quote.h"
#include "Bound_quote.h"
#include <vector>
#include <memory>
using std::shared_ptr;
using std::make_shared;
double print_total(std::ostream &os, const Quote &item, std::size_t n);

int main()
{
	std::vector<Quote> basket_q;
	basket_q.push_back(Bulk_quote("1", 1, 5, 0.1));
	basket_q.push_back(Bulk_quote("1", 2, 10, 0.1));
	basket_q.push_back(Bulk_quote("1", 3, 10, 0.2));
	basket_q.push_back(Bulk_quote("1", 4, 5, 0.3));
	std::vector<shared_ptr<Quote>> basket;
	basket.push_back(make_shared<Bulk_quote>("2", 1, 5, 0.1));
	basket.push_back(make_shared<Bulk_quote>("2", 2, 10, 0.1));
	basket.push_back(make_shared<Bulk_quote>("2", 3, 10, 0.2));
	basket.push_back(make_shared<Bulk_quote>("2", 4, 5, 0.3));
	double sum1 = 0, sum2 = 0;
	for (auto q : basket_q)
	{
		sum1 += q.net_price(7);
	}
	for (auto pq : basket)
	{
		sum2 += pq->net_price(7);
	}
	std::cout << sum1 << " " << sum2 << std::endl;
	getchar();
	return 0;
}

double print_total(std::ostream &os, const Quote &item, std::size_t cnt)
{
	double ret = item.net_price(cnt);
	os << "ISBN: " << item.isbn() << " total due: " << ret << std::endl;
	return ret;
}


猫叔的大师兄
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《C++ Primer》读书笔记——第十五章_面向对象程序设计
ize
09-25 797
OOP基于三个基本盖面:数据抽象、继承和动态绑定。  以下的例子：基类Quote->派生类Bulk_quote  对于某些类，基类希望它的派生类各自定义适合自身的版本，此时基类就将这些函数声明称虚函数（virtual function）。 class Quote { public: std::string isbn() const; virtual double ne
C++ primer中文版-高清-带目录
11-21
学习C++的入门书籍，纸质清晰，有目录便于检索，很好的学习文档，分享给大家。
#define #undef noexcept
huanhuaqian的博客
05-15 182
#define #undef #define：宏定义，程序在预处理阶段将用define定义的内容进行替换。 #undef 取消一个宏的定义，限制宏定义的有效范围； #include <iostream> using namespace std; int main() { #define MODI 10 cout << "MODI = "<< MODI << endl; #undef MODI c
C++primer 第十五章笔记 初稿
Cao970824的博客
07-24 294
OPP 派生类 基类 继承 多态 动态绑定
C++ Primer Plus 第十五章笔记
sinat_41790904的博客
03-17 218
1.      友元类的所有方法都可以访问原始类的私有成员和保护成员，其声明可以位于公有、私有或保护部分。2.      包含意味着将类对象作为另一个类的成员，而对类进行嵌套不创建类成员，而是定义了一种类型，该类型仅在包含嵌套类声明的类中有效。3.      嵌套类的作用域：（1）      嵌套类在另一个类的私有部分声明，则只有后者知道它；（2）      在另一个类的保护部分声明，则它对于后者...
【读书笔记:C++ primer plus 第六版 中文版】第15章 友元、异常和其他
enyusmile
08-24 1123
转载请注明出处:本章内容包括: 友元类 友元类方法 嵌套类 引发异常,try块和catch块 异常类 运行阶段类型识别(RTTI) dynamic_cast和typeid static_cast,const_cast和reiterpret_cast RTTI是一种确定对象类型的机制.新的类型转换运算符提高了类型转换的安全性.15.1 友元 也可以将类作为友元,在这种情况下,友元类的所有方法都可以访问
C++ primer学习笔记 - 第十五章 面向对象程序设计
weixin_43471255的博客
03-23 1015
一、OOP：概述 继承(inheritance) 动态绑定(dynamic binding) 静态绑定 二、定义基类和派生类 定义基类 定义派生类 类型转换和继承 三、虚函数 四、抽象基类 五、访问控制与继承 六、继承中的类作用域 七、构造函数和拷贝函数 虚析构函数 合成拷贝控制与继承 派生类的拷贝控制成员 继承的构造函数 ...
C++ Primer学习笔记-----第九章：顺序容器
weixin_41155760的博客
07-19 336
代码】C++Primer学习笔记-----第九章顺序容器。
C++ Primer学习笔记-----第十五章：面向对象程序设计
weixin_41155760的博客
08-02 194
面向对象这章不说太多，简单说下语法即可，因为程序设计是一个比较大的命题，更多的问题是怎么设计，而不是语法。派生类的拷贝控制成员。
C++ primer plus笔记 --- 第4章、复合类型
qq_19432525的博客
05-04 240
string 类,必须包含头文件string，string类位于名称空间中。C++ 11字符串初始化,注意C/C++两种风格// C语言风格// C语言风格// C++风格// C++风格// C++风格C语言风格不能将一个数组赋值给另一个数组，但可以将一个string对象赋值给另一个string对象。结构（Structure）是一种用户自定义的数据类型，在程序中用于组织和存储相关的变量。结构包含一组不同的变量，这些变量可能是不同的数据类型，例如整型、浮点型、字符型等。在C++中，结构通过。
C++Primer读书笔记：C++概述.pdf
03-23
C++Primer中文第三版（C++从入门到精通）第一章的读书笔记，主要是C++程序、预处理器指示符、iostream库等的基础知识点读书笔记。
C++ Primer Plus 编程练习源码工程 第15章
12-25
C++ Primer Plus 编程练习源码工程 第15章 ，这是本人自己学习书籍时写的编程练习的源码工程，供大家参考交流。
c++ primer第1-16章读书报告.docx
10-27
c++ primer第1-16章读书报告，里面讲了c++ primer第五版的各种细节内容，并对之前学习的知识进行了回顾，也有各种举例说明。
c++primer 学习笔记
10-24
C++primer的笔记，可以看一下，一些容易犯错的陷阱
c++ primer 复习-函数
Dreamtide的博客
08-22 473
学到动态内存的时候，出现许多使用函数尤其是类的相关知识的应用，因练习量不足，知识出现遗忘，继续学习颇感吃力。因此决定在向下学习之前，先开始第一轮复习，将重要的知识系统梳理一遍，以便完成后续的学习内容。 1.参数传递 ①参数传递的方法有2种：传值参数、传引用参数。 a.传值参数：         对于整形此类，就是形参拷贝实参，对形参的改变不影响实参；对于指针形参，拷贝的是指针本身，
c++ primer 学习笔记-第十三章
Dreamtide的博客
09-06 470
习题13.5： #ifndef TEST_H #define TEST_H #include #include class HasPtr{ public: HasPtr(const std::string &s = std::string()) :ps(new std::string(s)), i(0){ }; HasPtr(const HasPtr &cs) :ps(new std:
c++ primer 学习笔记-第九章
Dreamtide的博客
08-11 447
习题9.4： #include #include using std::cin; using std::cout; using std::endl; using std::vector; using Iter = vector::const_iterator; bool find(Iter beg, Iter end, int num) { while (beg != end) {
c++ primer 学习笔记-第七章
Dreamtide的博客
08-06 443
习题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 学习笔记-第六章
Dreamtide的博客
08-03 409
习题6.2： #include #include #include #include using std::cin; using std::cout; using std::endl; using std::string; using std::vector; using std::begin; using std::end;
c++primer第七章学习笔记
最新发布
08-29
很抱歉，根据提供的引用内容，我没有找到关于"C primer第七章学习笔记"的相关信息。这些引用内容主要涉及到C++编程语言的转义序列和指针的初始化，以及结构体的初始化和数组的初始化。如果你有关于C primer第七章...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值