c++ Primer Plus（第六版）第十三章习题，写代码之路

最新推荐文章于 2021-02-14 23:25:32 发布
最新推荐文章于 2021-02-14 23:25:32 发布
阅读量680 收藏 2
点赞数
分类专栏： c++第六版练习题答案 文章标签： c++primer plus 练习 练习题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Robot_x/article/details/54931967
版权 

c++ Primer Plus（习题13.1)
/*13.1题的实现文件，书上的测试文件*/
//哪个方法不需要也根据实现而定，始终跟随客户的脚步
//这题细节方面被坑了，mainworks字符数组设置太小了，导致了一系列不可思议的问题
#include<iostream>
#include"classic.h"
using namespace std;
void Bravo(const Cd&disk);
int main()
{
	Cd c1("Beatles","Capitol", 14, 35.5);
	Classic c2 = Classic("Piano Sonata in B flat, Fantasia in C", "Alfred Brendel",
		"Philips", 2, 57.17);			
	Cd *pcd = &c1;						//这里是测试虚方法
	cout << "Using object directly:\n";
	c1.Roport();
	c2.Roport();
	cout << "Using type cd *pointer to objects:\n";
	pcd->Roport();						
	pcd = &c2;
	pcd->Roport();
	cout << "Calling a funtion with a Cd reference argument:\n";
	Bravo(c1);							//这也是测试虚方法，由调用对象决定
	Bravo(c2);
	cout << "Testing assigment: \n";
	Classic copy;						//测试派生类的赋值运算符
	copy = c2;
	copy.Roport();
	return 0;
}

void Bravo(const Cd&disk)
{
	disk.Roport();
}


#pragma once
#pragma execution_character_set("utf-8")
//本文件为utf-8编码格式
//习题12.1的头文件
#ifndef CLASSIC_H
#define CLASSIC_H
#include<iostream>
class Cd
{
private:
	char performers[50];
	char label[20];
	int selections;
	double playtime;
public:
	Cd(char *s1, char*s2, int n, double x);
	Cd() {};
	Cd(const Cd&d);  
	~Cd() {};							//由于不是动态分配内存，需不需要这个都行
	virtual void Roport()const;
	Cd& operator=(const Cd &d);
}; 
class Classic:public Cd			//公有继承
{
private:
	char mainworks[50];			//存储主要作品
public:
	Classic(char *m, char *s1, char*s2, int n, double x);
	Classic() {};
	Classic(const Classic&c);
	~Classic() {};
	void Roport()const;
	Classic&operator=(const Classic &c);
};
#endif // !CLASSIC_H

#include"classic.h"

//base calss mothod
Cd::Cd(char *s1, char*s2, int n, double x):selections(n),playtime(x)
{
	std::strcpy(performers, s1);		//使用初始化列表好像无法初始化performers和label
	std::strcpy(label, s2);
}

//copy construction function
Cd::Cd(const Cd&d)
{
	std::strcpy(performers, d.performers);
	std::strcpy(label,d.label);
	selections = d.selections;
	playtime = d.playtime;
}
void Cd::Roport()const
{
	using std::cout;
	using std::endl;
	cout << "Performers: " << performers << endl
		<< "Lable: " << label << endl
		<< "Selections: " << selections << endl
		<< "Playtime: " << playtime << endl;
}

Cd& Cd::operator=(const Cd &d)
{
	if (this == &d)
		return *this;
	std::strcpy(performers, d.performers);
	std::strcpy(label, d.label);
	selections = d.selections;
	playtime = d.playtime;
	return *this;
}
//Classic mothods
Classic::Classic(char *m, char *s1, char*s2, int n, double x):Cd(s1,s2,n,x)
{										//成员初始化；列表初始化基类数据
	std::strcpy(mainworks, m);
}
void Classic::Roport()const
{
	Cd::Roport();				//调用基类的report方法
	std::cout << "Mainworks: " << mainworks << std::endl;
}

Classic&Classic::operator=(const Classic&c)
{
	if (this == &c)
		return *this;
	Cd::operator=(c);
	std::strcpy(mainworks, c.mainworks);
	return *this;
}
Classic::Classic(const Classic&c)
{
	std::strcpy(mainworks, c.mainworks);
}
c++ Primer Plus（习题13.2) 
#pragma once
#pragma execution_character_set("utf-8")
//本文件为utf-8编码格式
//习题12.1的头文件
#ifndef NEWCLASSIC_H
#define NEWCLASSIC_H
#include<iostream>
class Cd
{
private:
	char *performers;
	char *label;
	int selections;
	double playtime;
public:
	Cd(char *s1, char*s2, int n , double x);
	//Cd(const Cd&d);
	Cd() {};
	virtual ~Cd() { delete[]performers; delete[] label; };							//由于不是动态分配内存，需不需要这个都行
	virtual void Roport()const;
	Cd& operator=(const Cd &d);
};
class Classic :public Cd			//公有继承
{
private:
	char *mainworks;			//存储主要作品
public:
	Classic(char *m,char *s1, char*s2, int n, double x);
	Classic() {};
	virtual ~Classic() { delete[]mainworks; };
	void Roport()const;
	Classic&operator=(const Classic &c);
};
#endif // !CLASSIC_H


#include"newclassic.h"

//base calss mothod
Cd::Cd(char *s1, char*s2, int n, double x) :selections(n), playtime(x)
{
	performers = new char[std::strlen(s1)+1];
	label = new char[std::strlen(s2)+1];
	std::strcpy(performers, s1);		//使用初始化列表好像无法初始化performers和label
	std::strcpy(label, s2);
}

void Cd::Roport()const
{
	using std::cout;
	using std::endl;
	cout << "Performers: " << performers << endl
		<< "Lable: " << label << endl
		<< "Selections: " << selections << endl
		<< "Playtime: " << playtime << endl;
}

Cd& Cd::operator=(const Cd &d)
{
	if (this == &d)
		return *this;
	//这里不加delete[]perfomers是因为构造函数没用new[]初始化
	performers = new char[std::strlen(d.performers) + 1];
	label = new char[std::strlen(d.label) + 1];
	std::strcpy(performers, d.performers);
	std::strcpy(label, d.label);
	selections = d.selections;
	playtime = d.playtime;
	return *this;
}
//Classic mothods
Classic::Classic(char *m, char *s1, char*s2, int n, double x) :Cd(s1, s2, n, x)
{										//成员初始化；列表初始化基类数据
	mainworks = new char[std::strlen(m)+1];
	std::strcpy(mainworks, m);
}
void Classic::Roport()const
{
	Cd::Roport();				//调用基类的report方法
	std::cout << "Mainworks: " << mainworks << std::endl;
}

Classic&Classic::operator=(const Classic&c)
{
	if (this == &c)
		return *this;
	Cd::operator=(c);
    //这里也不用delete[]mainworks;
	mainworks = new char[std::strlen(c.mainworks) + 1];
	std::strcpy(mainworks, c.mainworks);
	return *this;
}
/*13.2题的实现文件，书上的测试文件*/
//和上一题一模一样的实现文件，就是把字符数组改成动态内存分配
//老套路，可删除的函数有复制构造函数，因为没用到，这么简单的题玩了一下午
#include<iostream>
#include"newclassic.h"
using namespace std;
void Bravo(const Cd&disk);
int main()
{
	Cd c1("Beatles", "Capitol", 14, 35.5);
	Classic c2 = Classic("Piano Sonata in B flat, Fantasia in C", "Alfred Brendel",
		"Philips", 2, 57.17);
	Cd *pcd = &c1;						//这里是测试虚方法
	cout << "Using object directly:\n";
	c1.Roport();
	c2.Roport();
	cout << "Using type cd *pointer to objects:\n";
	pcd->Roport();
	pcd = &c2;
	pcd->Roport();
	cout << "Calling a funtion with a Cd reference argument:\n";
	Bravo(c1);							//这也是测试虚方法，由调用对象决定
	Bravo(c2);
	cout << "Testing assigment: \n";
	Classic copy;						//测试派生类的赋值运算符和默认构造函数
	copy = c2;
	copy.Roport();
	return 0;
}

void Bravo(const Cd&disk)
{
	disk.Roport();
}

c++ Primer Plus（习题13.3)

//变更书上三种DMA的关系，使他们从一个抽象基类中派生出来
//这是根据书上程序清单13.10模仿出来的测试文件
//头文件省略了很多方法，可以说是一个专门解决特定客户需求的类
#include<iostream>
#include"dma.h"
const int CLENTS = 3;
int main()
{
	using namespace std;
	Abc *p[CLENTS];
	char temp[30];
	int temrating;
	char choose;
	for (int i = 0; i < CLENTS; i++)
	{
		cout << "Enter the label: ";
		cin.getline(temp, 30);
		cout << "Enter the rating: ";
		cin >> temrating;
		cout << "Enter 1 for baseDMA class or "
			"2 for lacksDMA class or 3 for hasDMA class: ";
		while (cin >> choose && (choose != '1'&&choose!='2'&&choose!='3'))
			cout << "Make you choice rightly!";			
		if (choose == '1')
			p[i] = new baseDMA(temp, temrating);
		else if (choose == '2')
		{
			char temc[10];
			cin.get();			//混合输入数字和字符串切记处理换行符
			cout << "Enter the color: ";
			cin.get(temc, 10);
			p[i] = new lacksDMA(temc, temp, temrating);
		}
		else
		{
			char temstyle[10];
			cout << "Enter the style: ";
			cin.get();
			cin.get(temstyle, 10);
			p[i] = new hasDMA(temstyle, temp, temrating);
		}
		while (cin.get() != '\n')
			continue;
	}
	cout << endl;
	for (int i = 0; i < CLENTS; i++)
	{
		p[i]->Report();
		cout << endl;
	}
	for (int i = 0; i < CLENTS; i++)
	{
		delete p[i];			//free emory!
	}
	cout << "*************Test complete!**************\n";
	return 0;
}
#pragma once
#pragma execution_character_set("utf-8")
//本文件为utf-8编码格式
//使用抽象基类abc派生出三个类
#ifndef DMA_H
#define DMA_H
#include<iostream>
class Abc
{
private:
	char *label;
	int rating;
protected:
	char* Label()const { return label; }		//保护方法，报告抽象基类中的成员
	int Rating()const { return rating; }
public:
	Abc(const char *l = "NULL", int r = 0);
	virtual void Report()const = 0;			//纯虚函数的标志,基类可以不提供定义
	virtual ~Abc() { delete[]label; }
};
class baseDMA:public Abc
{
public:
	baseDMA(const char *l = "NULL", int r = 0) :Abc(l, r) {};
	virtual ~baseDMA() {};
	virtual void Report()const;
};
class lacksDMA:public Abc
{
private:
	enum{COL_LEN=40};
	char color[COL_LEN];
public:
	lacksDMA(const char *la = "NULL", const char*l = "NULL", int r = 0);
	virtual ~lacksDMA() {};
	virtual void Report()const;
};
class hasDMA :public Abc
{
private:
	char *style;
public:
	hasDMA(const char*s = "NULL", const char*l = "NULL", int r = 0);
	virtual ~hasDMA() { delete[]style; };
	virtual void Report()const;
};
#endif // !DMA_H
#include"dma.h" 
using std::cout;
using std::endl;
//Abc mothod
Abc::Abc(const char *l, int r)
{
	label = new char[std::strlen(l) + 1];
	std::strcpy(label, l);
	rating = r;
}

//baseDMA METHOD
void baseDMA::Report()const
{
	cout << "Label: " << Label() << endl		//调用抽象基类的保护方法
		<< "Rating: " << Rating() << endl;
}
//lacksDMA method
lacksDMA::lacksDMA(const char *la, const char*l, int r) :Abc(l, r) 
{
	std::strcpy(color, la);
}
void lacksDMA::Report()const
{
	cout << "Label: " << Label() << endl
		<< "Rating: " << Rating() << endl
		<< "Color: " << color << endl;
}
//hasDMA method
hasDMA::hasDMA(const char*s, const char*l, int r) :
	Abc(l, r)
{
	style = new char[std::strlen(s) + 1];
	std::strcpy(style, s);
}

void hasDMA::Report()const
{
	cout << "Label: " << Label() << endl
		<< "Rating: " << Rating() << endl
		<< "Style: " << style << endl;
}
c++ Primer Plus（习题13.4) 

//一题填空题，得自己编写文件测试全部方法
//b:有的方法需要重新定义，比如说析构函数还有构造函数，等等，都是必须重新定义的
//c:重载的赋值运算符和输出符基类的引用完全够用，不用声明成虚的方法
#include<iostream>
#include"port.h"
int main()
{
	using std::cout;
	using std::endl;
	Port a("Hong", "tawny", 100);
	VintagePort b("La", 20, "The Noble", 2017);
	cout << "Resource A: " << a << "\nResource B: " << b << endl;
	cout << "Test copy construction c=a: \n";
	Port c=a;
	c.Show();
	cout << "Test << operator:\n";
	cout << c;
	cout << "\nTest a+=15 and b-=15:";
	a += 15;
	b -= 15;
	cout << " A: " << a << " B: " << b << endl;
	cout << "Test virtual method:\n ";
	Port *p = &a;
	p->Show();
	p = &b;
	p->Show();
	cout << "c=b ";
	c = b;
	c.Show();
	cout << "\n*************Test complete!**************\n";
	return 0;
}

#pragma once
#pragma execution_character_set("utf-8")
//本文件为utf-8编码格式
#ifndef PORT_H
#define PORT_H
#include<iostream>
using namespace std;
class Port
{
private:
	char *brand;
	char style[20];			//ie.,tawny,ruby,vintage
	int bottles;
public:
	Port(const char*br = "none", const char *st = "none", int b = 0);
	Port(const Port&p);
	virtual ~Port() { delete[] brand; }
	Port&operator=(const Port&p);
	Port&operator+=(int b);				// add b to bottles
	Port&operator-=(int b);
	virtual void Show()const;
	friend ostream& operator<<(ostream&os, const Port&p);
protected:
	int BottleCount()const { return bottles; }
	
};
class VintagePort :public Port
{
private:
	char *nickname;
	int year;
public:
	VintagePort();
	VintagePort(const char*nn, int y, const char*br, int b);
	VintagePort(const VintagePort &vp);
	~VintagePort() { delete[]nickname; };
	VintagePort&operator=(const VintagePort&vp);
	virtual void Show()const;
	friend ostream&operator<<(ostream&os, const VintagePort&pt);
};
#endif // !PORT_H


#include"port.h"
using std::cout;
using std::endl;
//Port methods
Port::Port(const char*br, const char *st, int b)
{
	brand = new char[std::strlen(br) + 1];
	std::strcpy(brand, br);
	std::strcpy(style, st);
	bottles = b;
}
Port::Port(const Port&p)
{
	brand = new char[std::strlen(p.brand) + 1];
	std::strcpy(brand, p.brand);
	std::strcpy(style, p.style);
	bottles = p.bottles;
}
Port&Port::operator=(const Port&p)
{
	if (this == &p)
		return *this;
	delete[]brand;
	brand = new char[std::strlen(p.brand) + 1];
	std::strcpy(brand, p.brand);
	std::strcpy(style, p.style);
	bottles = p.bottles;
	return *this;
}
Port&Port::operator+=(int b)
{
	bottles += b;
	return *this;
}
Port&Port::operator-=(int b)
{
	bottles -= b;
	return *this;
}
//out put methods
void Port::Show()const
{
	cout << "Brand: " << brand << endl
		<< "Kind: " << style << endl
		<< "Bottles: " << bottles << endl;
}
ostream& operator<<(ostream&os, const Port&p)
{
	os << p.brand << " , " << p.style << " , " << p.bottles;
	return os;
}

//VintagePort methods 
VintagePort::VintagePort()
{
	nickname = new char[1];
	nickname = nullptr;
	year = 0;
}
VintagePort::VintagePort(const char*br,int b, const char*nn, int y):Port(br,"vintage",b)
{
	nickname = new char[std::strlen(nn) + 1];
	std::strcpy(nickname, nn);
	year = y;
}

VintagePort::VintagePort(const VintagePort &vp):Port(vp)
{
	delete[]nickname;
	nickname = new char[std::strlen(vp.nickname) + 1];
	std::strcpy(nickname, vp.nickname);
	year = vp.year;
}

VintagePort&VintagePort::operator=(const VintagePort&vp)
{
	if (this == &vp)
		return *this;
	delete[]nickname;
	nickname = new char[std::strlen(vp.nickname) + 1];
	std::strcpy(nickname, vp.nickname);
	year = vp.year;
	return *this;
}
void VintagePort::Show()const
{
	Port::Show();					//调用基类的方法，用来显示基类部分
	cout << "Nick name: " << nickname << endl
		<< "Year: " << year << endl;
}

ostream&operator<<(ostream&os, const VintagePort&pt)
{
	os << (const Port&)pt;
	os << " , " << pt.nickname << " , ";
	return os;
}







Robot_x
关注
专栏目录
C++ Primer Plus第六版 第十三章 编程练习答案
蒟蒻升级中...Orz
11-21 2893
今天下午体测 GGGGGGGGGGGG //第一题 //main.cpp #include "cd.h" void Bravo(const Cd &disk); int main() { Cd c1("Beatles", "Capitol", 14, 35.5); Classic c2 = Classic("Piano Sonata in Bflat, Fantasia in C
C++ Primer Plus 第六版 所有章节课后编程练习答案
热门推荐
xiaojimmychen的专栏
11-01 8万+
C++ Primer Plus 第六版 所有章节课后编程练习答案
c++ primer plus 第13章习题
chinahnwqf的博客
05-20 677
//第13章 13.14 #ifndef STACK_H #define STACK_H #include using std::ostream; using std::istream; class baseDMA { private: char *label; int rating; public: baseDMA(const char *l = "null", int r = 0);
【读书笔记:C++ primer plus 第六版 中文版】第13章 类继承
enyusmile
07-06 1356
转载请注明出处: 20150627,以此纪念一个特别的日子 本章内容包括: is-a关系的继承 如何以公有方式从一个类派生出另一个类 保护访问 构造函数成员初始化列表 向上和向下强制转换 虚成员函数 早期(静态)联编与晚期(动态)联编 抽象基类 纯虚函数 何时及如何使用公有继承 面向对象编程的主要目的之一是提供可重用的代码.目前,很多厂商提供了类库,类库由类声明和实现构成.因为类组合了数据
C++ Primer Plus 第十三章知识点（一）
Raywit的博客
02-14 372
C++ Primer Plus 第十三章知识点简化1. 简单的基类2. 派生一个类3. 派生类和基类的特殊关系Reference： 1. 简单的基类        由于面向对象编程主要目的之一就是提供可重写的代码，对于扩展和修改类，除了去源码中修改之外，还有就是类继承；从一个类派生出另一个类时，原始类称为 基类，继承类称为 派生类。简单看下下面的程序： #ifndef HEAD_H_ #define HEAD_H_ #include&lt
C++ Primer Plus第五版 第十三章 编程练习答案
xiaohao_0715的博客
02-17 300
1.头文件：#ifndef _HEAD_H#define _HEAD_Hclass Cd{private: char performers[50]; char label[20]; int selections; double playtime;public: Cd(char * s1,char *s2,int n, double p); Cd(const Cd &amp;d); Cd(); vi...
C++ Primer Plus 第6版 中文版课后代码习题答案
最新发布
03-10
《C++ Primer Plus 第6版 中文版》是一本深入浅出的C++学习书籍，其课后代码习题答案是学习过程中不可或缺的部分。这本书旨在帮助读者从零基础开始掌握C++编程语言，通过实例和习题来巩固理论知识，提升编程技能。...
c++ primer plus 第六版 课后习题答案
01-15
《C++ Primer Plus 第六版》是一本深受程序员喜爱的C++学习书籍，它深入浅出地介绍了C++编程语言的基础知识和高级特性。作为学习过程中不可或缺的一部分，课后习题是检验和巩固所学知识的关键。这本书的第六版课后...
c++primerplus(第六版)课后编程练习答案.pdf
05-20
以上就是从《C++ Primer Plus（第六版）》第二章和第三章的课后编程练习答案中提取的一些重要知识点。通过这些示例，我们可以了解到C++的基本语法、函数定义与调用、数据类型以及如何处理用户输入和输出等核心概念。
【学习记录】关于Pin Tools的学习记录
长风一虾
05-31 1074
1、今天学习了Pin Tools。主要是了解了/source/tools/ManualExamples中的一些cpp的实际功用。   imageload 跟踪程序上传和下载image inscount0 记录程序运行指令总数 intrace 显示每个指令执行的内存地址 malloctrace 记录函数参数传递到函数的值或返回的值 pinatrace 检测指令读取和写入的内存地址
PinTools学习笔记（1）——安装和入门
diezuo6099的博客
06-21 439
介绍性文字就不说了，百度一下有很多，简单来说就是一个输入是可执行文件的动态插桩分析工具。 安装非常简单，不需要编译，直接从官网https://software.intel.com/en-us/articles/pintool-downloads下载、解压即可，PinTools自带很多例子，在source/tools/ManualExamples路径下，参考这些源码对学习PinTools...
STM32定时TIM2触发ADC采样，使用DMA保存结果
yuangaoping的专栏
11-18 1万+
1.adc.h文件 //ADC-------------------------------------------------------------------------// #ifndef __EVAL_ADC_H         #define __EVAL_ADC_H // Includes -----------------------------
C Primer Plus 第十三章 编程练习 1-13题
qazaq408的博客
03-09 1044
第一题#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; const int LEN = 100; int main(void) { char fileName[LEN]; FILE* tarFile; char ch; printf("PLease Input File Name:\n"); gets(fileName); ...
《C++ Primer Plus（第六版）》（27）（第十三章 类继承 编程题答案）
weixin_30767835的博客
12-28 336
13.11 编程练习 1.以下面的类声明为基础： class Cd { private: char performers[50]; char label[20]; int selections; double playtime; public: Cd(char * s1, char* s2, int n, double x); Cd(cons...
C++ primer plus 第六版 第十三章 编程练习答案
菜鸡harry的博客
08-21 3156
第十三章 编程练习答案 1. //头文件 #ifndef CD_H_ #define CD_H_ //Brass Cd 类 class Cd { private: char performers[50]; char label[20]; int selections; double playtime; public: Cd(char * s1,...
学生信息管理系统
weixin_43404836的博客
01-02 918
学生信息管理系统 一个期末作业，做的比较急，只有基本功能。 一、综合设计要求 为了熟练使用C++面对对象的相关知识，设计一个功能较为完善的学生信息管理系统。需要涵盖如下设计要点： 1、 设计语言：C++； 2、 设计平台为：Win32控制台应用程序或MFC对话框应用程序； 3、 开发平台：VC6.0 或 VS2010及各种版本，Ubuntu下的各种IDE设计环境，等等。 4、 程序结构：多文件结构...
C++ Primer Plus（第六版）编程练习答案 第13章 类继承
清水河C罗——Leonardo-Liu
10-26 2991
本章所有编程练习的工程源码可在此处下载（点击此链接下载），供大家参考交流！   1. 以下面的类声明为基础： {……代码省略……} 派生出一个Classic类，并添加一组char成员，用于存储指出CD中主要作品的字符串。修改上述声明，使基类的所有函数都是虚的。如果上述定义声明的某个方法并不需要，则请删除它。使用下面的程序测试您的产品： {……代码省略……}   本题提供了基类，但是该...
C++ Primer Plus 第五版习题解析与代码
C++ Primer Plus（第五版）习题解答提供了书中的练习题答案，涵盖了C++的基础知识，包括输入输出、函数、控制流等概念。 在Chapter 2中，我们看到的是基本输入输出和变量使用的练习。`pe2-2.cpp`展示了如何从用户...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值