C++PrimerPlus学习——第十三章编程练习

最新推荐文章于 2021-04-17 15:30:49 发布
最新推荐文章于 2021-04-17 15:30:49 发布
阅读量275 收藏
点赞数
分类专栏： C++primerplus学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m_zwa/article/details/106183933
版权

13-1
注意char*前面加const，不然就会报错
Classis.h

#ifndef CLASSIC_H_
#define CLASS_H_
#include <string>
class Cd {
private:
	char performers[50];
	char label[20];
	int selections;
	double playtime;
public:
	Cd(const char* s1, const char* s2, int n, double x);
	Cd(const Cd& ｄ);
	Cd();
	virtual ~Cd();
	virtual void Report() const;
	virtual Cd& operator=(const Cd& d);
};
class Classic:public Cd
{
private:
	char major[50];
public:
	Classic(const char* s1, const char* s2, const char* s3, int n, double x);
	Classic();
	~Classic();
	void Report();
	Classic& operator=(const Classic& d);
};
#endif // !CLASSIC_H_

Classic.cpp

#include <iostream>
#include "Classic.h"

Cd::Cd(const char* s1, const char* s2, int n, double x)
{
	strcpy_s(performers, strlen(s1) + 1, s1);
	strcpy_s(label, strlen(s2) + 1, s2);
	selections = n;
	playtime = x;
}
Cd::Cd(const Cd& d)
{
	strcpy_s(performers, strlen(d.performers) + 1, d.performers);
	strcpy_s(label, strlen(d.label) + 1, d.label);
	selections = d.selections;
	playtime = d.playtime;
}
Cd::Cd()
{
	performers[0] = '\0';
	label[0] = '\0';
	selections = 0;
	playtime = 0.0;
}
Cd::~Cd()
{

}
void Cd::Report() const
{
	std::cout << "Preformers: " << performers << '\n';
	std::cout << "Label: " << label << '\n';
	std::cout << "selectiongs: " << selections << '\n';
	std::cout << "playtime: " << playtime << '\n';
}
Cd& Cd::operator=(const Cd& d)
{
	if (this == &d)
		return *this;
	strcpy_s(performers, strlen(d.performers) + 1, d.performers);
	strcpy_s(label, strlen(d.label) + 1, d.label);
	selections = d.selections;
	playtime = d.playtime;
	return *this;
}
Classic::Classic(const char* s1, const char* s2, const char* s3, int n, double x):Cd(s2, s3, x, n)
{
	strcpy_s(major, strlen(s1)+1, s1);
}
Classic::Classic():Cd()
{
	major[0] = '\0';
}
Classic::~Classic()
{

}
void Classic::Report()
{
	Cd::Report();
	std::cout << "Major: " << major << '\n';
}
Classic& Classic::operator=(const Classic& d)
{
	if (this == &d)
		return *this;
	Cd::operator=(d);
	strcpy_s(major, strlen(d.major) + 1, d.major);
	return *this;
}

main.cpp

#include <iostream>
#include "Classic.h"
using std::cout;
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.Report();
	c2.Report();

	cout << "Calling a function with a Cd reference argument:\n";
	Bravo(c1);
	Bravo(c2);

	cout << "Testing assignment: ";
	Classic copy;
	copy = c2;
	copy.Report();

	return 0;
}

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

13-2
主函数仍然不变
Classic.h

#ifndef CLASSIC_H_
#define CLASSIC_H_
#include <string>
class Cd {
private:
	char* performers;
	char* label;
	int selections;
	double playtime;
public:
	Cd(const char* s1, const char* s2, int n, double x);
	Cd(const Cd& ｄ);
	Cd();
	virtual ~Cd();
	virtual void Report() const;
	virtual Cd& operator=(const Cd& d);
};
class Classic:public Cd
{
private:
	char* major;
public:
	Classic(const char* s1, const char* s2, const char* s3, int n, double x);
	Classic();
	~Classic();
	void Report();
	Classic& operator=(const Classic& d);
};
#endif // !CLASSIC_H_

Classic.cpp

#include <iostream>
#include "Classic.h"

Cd::Cd(const char* s1, const char* s2, int n, double x)
{
	performers = new char[strlen(s1) + 1];
	strcpy_s(performers, strlen(s1) + 1, s1);
	label = new char[strlen(s2) + 1];
	strcpy_s(label, strlen(s2) + 1, s2);
	selections = n;
	playtime = x;
}
Cd::Cd(const Cd& d)
{
	performers = new char[strlen(d.performers) + 1];
	strcpy_s(performers, strlen(d.performers) + 1, d.performers);
	label = new char[strlen(d.label) + 1];
	strcpy_s(label, strlen(d.label) + 1, d.label);
	selections = d.selections;
	playtime = d.playtime;
}
Cd::Cd()
{
	performers = new char[1];
	performers[0] = '\0';
	label = new char[1];
	label[0] = '\0';
	selections = 0;
	playtime = 0.0;
}
Cd::~Cd()
{
	delete[] performers;
	delete[] label;
}
void Cd::Report() const
{
	std::cout << "Preformers: " << performers << '\n';
	std::cout << "Label: " << label << '\n';
	std::cout << "selectiongs: " << selections << '\n';
	std::cout << "playtime: " << playtime << '\n';
}
Cd& Cd::operator=(const Cd& d)
{
	if (this == &d)
		return *this;
	delete[] performers;
	delete[] label;
	performers = new char[strlen(d.performers) + 1];
	strcpy_s(performers, strlen(d.performers) + 1, d.performers);
	label = new char[strlen(d.label) + 1];
	strcpy_s(label, strlen(d.label) + 1, d.label);
	selections = d.selections;
	playtime = d.playtime;
	return *this;
}
Classic::Classic(const char* s1, const char* s2, const char* s3, int n, double x):Cd(s2, s3, x, n)
{
	major = new char[strlen(s1) + 1];
	strcpy_s(major, strlen(s1)+1, s1);
}
Classic::Classic():Cd()
{
	major = new char[1];
	major[0] = '\0';
}
Classic::~Classic()
{
	delete[] major;
}
void Classic::Report()
{
	Cd::Report();
	std::cout << "Major: " << major << '\n';
}
Classic& Classic::operator=(const Classic& d)
{
	if (this == &d)
		return *this;
	Cd::operator=(d);
	delete[] major;
	major = new char[strlen(d.major) + 1];
	strcpy_s(major, strlen(d.major) + 1, d.major);
	return *this;
}

13-3
虽然不是很理解，但是这个套路是明白了
dma.h

#ifndef DMA_H_
#define DMA_H_
#include <iostream>

class ABC
{
	char* fullname;
	int level;
public:
	ABC(const char* f = "null", int I = 0);
	ABC(const ABC& ab);
	virtual ~ABC();
	ABC& operator=(const ABC& ab);
	virtual void show();
};

class baseDMA: public ABC
{
private:
	char* label;
	int rating;
public:
	baseDMA(const char* l = "null", int r = 0, const char* f = "null", int lv = 0);
	baseDMA(const baseDMA& rs);
	~baseDMA();
	baseDMA& operator=(const baseDMA& rs);
	virtual void show();
};

class lacksDMA: public ABC
{
private:
	enum{ COL_LEN = 40 };
	char color[COL_LEN];
public:
	lacksDMA(const char* c = "blank", const char* l = "null", int r = 0);
	lacksDMA(const char* c, const baseDMA& rs);
	virtual void show();
};

class hasDMA: public ABC
{
private:
	char* style;
public:
	hasDMA(const char* s = "none", const char* l = "null", int r = 0);
	hasDMA(const char* s, const baseDMA& hs);
	hasDMA(const hasDMA& hs);
	~hasDMA();
	hasDMA& operator=(const hasDMA& rs);
	virtual void show();
};
#endif // !DMA_H_

dma.cpp

#include<cstring>
#include<string>
#include "dma.h"

ABC::ABC(const char* a, int b)
{
	fullname = new char[strlen(a) + 1];
	strcpy_s(fullname, strlen(a) + 1, a);
	level = b;
}
ABC::ABC(const ABC& ab)
{
	fullname = new char[strlen(ab.fullname) + 1];
	strcpy_s(fullname, strlen(ab.fullname) + 1, ab.fullname);
	level = ab.level;
}
ABC::~ABC()
{
	delete[] fullname;
}
ABC& ABC::operator=(const ABC& ab)
{
	if (this == &ab)
		return *this;
	delete[] fullname;
	fullname = new char[strlen(ab.fullname) + 1];
	strcpy_s(fullname, strlen(ab.fullname) + 1, ab.fullname);
	level = ab.level;
	return *this;
}
void ABC::show()
{
	std::cout << "fullname: " << fullname << std::endl;
	std::cout << "level: " << level << std::endl;
}

baseDMA::baseDMA(const char* l, int r, const char* f, int lv):ABC(f, lv)
{
	label = new char[strlen(l) + 1];
	strcpy_s(label, strlen(l) + 1, l);
	rating = r;
}
baseDMA::baseDMA(const baseDMA& rs):ABC(rs)
{
	label = new char[strlen(rs.label) + 1];
	strcpy_s(label, strlen(rs.label) + 1, rs.label);
	rating = rs.rating;
}
baseDMA::~baseDMA()
{
	delete[] label;
}
baseDMA& baseDMA::operator=(const baseDMA& rs)
{
	if (this == &rs)
		return *this;
	ABC::operator=(rs);
	delete[] label;
	label = new char[strlen(rs.label) + 1];
	strcpy_s(label, strlen(rs.label) + 1, rs.label);
	rating = rs.rating;
	return *this;
}
void baseDMA::show()
{
	ABC::show();
	std::cout << "label: " << label << std::endl;
	std::cout << "rating: " << rating << std::endl;
}
lacksDMA::lacksDMA(const char* c, const char* l, int r):ABC(l, r)
{
	strcpy_s(color, strlen(c) + 1, c);
}
lacksDMA::lacksDMA(const char* c, const baseDMA& rs):ABC(rs)
{
	strcpy_s(color, strlen(c) + 1, c);
}
void lacksDMA::show()
{
	ABC::show();
	std::cout << "color: " << color << std::endl;
}
hasDMA::hasDMA(const char* s, const char* l, int r):ABC(l, r)
{
	style = new char[strlen(s) + 1];
	strcpy_s(style, strlen(s) + 1, s);
}
hasDMA::hasDMA(const char* s, const baseDMA& hs):ABC(hs)
{
	style = new char[strlen(s) + 1];
	strcpy_s(style, strlen(s) + 1, s);
}
hasDMA::hasDMA(const hasDMA& hs):ABC(hs)
{
	style = new char[strlen(hs.style) + 1];
	strcpy_s(style, strlen(hs.style) + 1, hs.style);
}
hasDMA::~hasDMA()
{
	delete[] style;
}
hasDMA& hasDMA::operator=(const hasDMA& hs)
{
	if (this == &hs)
		return *this;
	ABC::operator=(hs);
	delete[] style;
	style = new char[strlen(hs.style) + 1];
	strcpy_s(style, strlen(hs.style) + 1, hs.style);
	return *this;
}
void hasDMA::show()
{
	ABC::show();
	std::cout << "style: " << style << std::endl;
}

main.cpp

#include <iostream>
#include "dma.h"
using std::cout;

int main()
{
	baseDMA a1("asdfadsf", 9, "dsfadfa", 1);
	lacksDMA a2("dfafda", "daf d", 2);
	hasDMA a3("sdfadfas", "dfqwedsa", 3);
	cout << "baseDMA:\n";
	a1.show();
	cout << "lacksDMA:\n";
	a2.show();
	cout << "hasDMA:\n";
	a3.show();
	baseDMA a4 = a1;
	lacksDMA a5 = a2;
	hasDMA a6 = a3;
	return 0;
}

13-4
Port.h

#ifndef PORT_H_
#define PORT_H_
#include <iostream>
using namespace std;

class Port
{
private:
	char* brand;
	char style[20];
	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);
	Port& operator-=(int b);
	int BottleCount() const { return bottles; }
	virtual void Show() const;
	friend ostream& operator<<(ostream& os, const Port& p);
};

class VintagePort : public Port
{
private:
	char* nickname;
	int year;
public:
	VintagePort();
	VintagePort(const char* br, const char* st, int b, const char* nn, int y);
	VintagePort(const VintagePort& vp);
	~VintagePort() { delete[] nickname; }
	void Show() const;
	friend ostream& operator<<(ostream& os, const VintagePort& vp);
};
#endif // !PORT_H_

Port.cpp

#include "Port.h"
#include <cstring>
Port::Port(const char* br, const char* st, int b)
{
	brand = new char[strlen(br) + 1];
	strcpy_s(brand, strlen(br) + 1, br);
	strcpy_s(style, 20, st);
	bottles = b;
}

Port::Port(const Port& p)
{
	brand = new char[strlen(p.brand) + 1];
	strcpy_s(brand, strlen(p.brand) + 1, p.brand);
	strcpy_s(style, 20, p.style);
	bottles = p.bottles;
}

Port& Port::operator=(const Port& p)
{
	if (this == &p)
		return *this;
	delete[] brand;
	brand = new char[strlen(p.brand) + 1];
	strcpy_s(brand, strlen(p.brand) + 1, p.brand);
	strcpy_s(style, p.style);
	bottles = p.bottles;
	return *this;
	return *this;// TODO: 在此处插入 return 语句
}

Port& Port::operator+=(int b)
{
	bottles += b;
	return *this;// TODO: 在此处插入 return 语句
}

Port& Port::operator-=(int b)
{
	bottles -= b;
	return *this;	// TODO: 在此处插入 return 语句
}

void Port::Show() const
{
	std::cout << "Brand: " << brand << std::endl;
	std::cout << "King: " << style << std::endl;
	std::cout << "Bottles: " << bottles << std::endl;
}

ostream& operator<<(ostream& os, const Port& p)
{
	std::cout << p.brand << ", " << p.style << ", " << p.bottles << std::endl;
	return os;// TODO: 在此处插入 return 语句
}

ostream& operator<<(ostream& os, const VintagePort& vp)
{
	os << (const Port&)vp;
	std::cout << vp.nickname << ", " << vp.year << std::endl;
	return os;// TODO: 在此处插入 return 语句
}

VintagePort::VintagePort()
{
	nickname = new char[1];
	nickname[0] = '\0';
	year = 0;
}

VintagePort::VintagePort(const char* br, const char* st, int b, const char* nn, int y): Port(br, st, b)
{
	nickname = new char[strlen(nn) + 1];
	strcpy_s(nickname, strlen(nn) + 1, nn);
	year = y;
}

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

void VintagePort::Show() const
{
	Port::Show();
	std::cout << "Nickname: " << nickname << std::endl;
	std::cout << "Year: " << year << std::endl;
}

main.cpp

#include <iostream>
#include "Port.h"
using std::cout;

int main()
{
	Port wine1("Gallo", "tawny", 20);
	VintagePort wine2("Romance Conti", "vintage", 10, "The Noble", 1876);
	VintagePort wine3("Merlot", "ruby", 30, "Old Velvet", 1888);
	cout << "Show Port object:\n";
	wine1.Show();
	cout << wine1 << endl;
	cout << "Show VintagePort object:\n";
	wine2.Show();
	cout << wine2 << endl;
	cout << "Show VintagePort object:\n";
	wine3.Show();
	cout << wine3 << endl;
	Port(wine4) = wine1;
	cout << "Show VintagePort object:\n";
	wine4.Show();
	cout << wine4<< endl;
	return 0;
}
mzwa
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++ primer plus 第六版第十三章编程练习
Schlangemm的博客
12-17 432
13.1 //classic.h class Cd { private: char performers[50]; char label[20]; int selections; double playtime; public: Cd(const char *s1,const char *s2, int n, double x); //Cd(const Cd&amp;d);...
C++ Primer Plus 编程练习源码工程 第2章
07-10
C++ Primer Plus 编程练习源码工程 第2章 ，这是本人自己学习书籍时写的编程练习的源码工程，供大家参考交流。
C++ Primer Plus 编程练习源码工程 第13章
10-26
C++ Primer Plus 编程练习源码工程 第13章 ，这是本人自己学习书籍时写的编程练习的源码工程，供大家参考交流。
C++ Primer Plus 第十三章知识点（一）
Raywit的博客
02-14 202
C++ Primer Plus 第十三章知识点简化1. 简单的基类2. 派生一个类3. 派生类和基类的特殊关系Reference： 1. 简单的基类        由于面向对象编程主要目的之一就是提供可重写的代码，对于扩展和修改类，除了去源码中修改之外，还有就是类继承；从一个类派生出另一个类时，原始类称为 基类，继承类称为 派生类。简单看下下面的程序： #ifndef HEAD_H_ #define HEAD_H_ #include&lt
c++ Primer Plus (第13章编程练习)
weixin_39883581的博客
04-17 185
这里写目录标题13.11-113.11-2 13.11-1 //Cd.h #pragma once #ifndef CD_H_ #define CD_H_ #include <iostream> using namespace std; //base class class Cd//represents a CD disk { private: char performers[50]; char label[20]; int selection; //number of selectio
C++ Primer Plus：第十三章 - 类继承
qq_30534935的博客
08-24 167
0、本章内容： is-a关系的继承。 如何以公有方式从一个类派生出另一个类。 保护访问。 构造函数成员初始化列表。 向上和向下强制转换。 虚成员函数。 早期（静态）联编与晚期（动态）联编。 抽象基类。 纯虚函数。 何时及如何使用公有继承。 1、一个简单的基类： 1.1 派生一个类 存储了基类的数据成员。 可以使用基类方法。 需要自己的构造函数。 可以根据需要添加额外的数据成员和成员函数。 ...
C++ Primer Plus 编程练习源码工程 第15章
12-25
C++ Primer Plus 编程练习源码工程 第15章 ，这是本人自己学习书籍时写的编程练习的源码工程，供大家参考交流。
c++ primer plus第六版第十三章编程练习
jack的博客
02-25 232
根据声明编写派生类classic，添加char成员（存储CD中主要作品的字符串），并修改声明使得基类成员函数为虚，并且如果某个方法不需要，删除掉。 题目类声明 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++PrimerPlus 第十三章 类继承
一个小孩
12-18 151
1、公有派生中，基类的共有成员将成为派生类的共有成员；基类的私有部分也将成为派生类的一部分，但只能通过基类的公有和保护方法访问（换句话说，派生类的构造函数必须使用基类的构造函数）。 2、有关派生类构造函数的要点如下： 1）首先创建基类对象 2）派生类构造函数应通过成员初始化列表将基类信息传递给基类的构造函数 3）派生类构造函数应初始化话派生类新增的数据成员。 ...
C++ Primer Plus第五版 第十三章 编程练习答案
xiaohao_0715的博客
02-17 283
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++PrimePlus（第六版）第十三章课后编程练习
weixin_44735475的博客
03-01 182
1、 /*************CD.h***********************/ #pragma once #ifndef CD_H_ #define CD_H_ class Cd { private: char performers[50]; char label[20]; int selections; double playtime; public: Cd(const c...
C++ Primer Plus 第六版 第十三章课后编程练习答案
是鲤鱼啊
04-06 371
1. 首先，对于将题中基类修改为虚函数版本，我们只需要将基类的公有函数部分除构造函数和友元之外的函数，声明时前面加上关键字virtual即可；然后对于派生类，我们在私有成员里面添加一个char数组，然后将继承的函数写出来即可。 cd.h #ifndef CD_H #define CD_H #include <iostream> using namespace std; clas...
C++ primer plus 第六版 第十三章 复习题答案
菜鸡harry的博客
08-19 1004
第十三章 复习题答案 1. 基类的公有成员成为派生类的公有成员。基类的保护成员成为派生类的保护成员。基类的私有成员被基础，但不能直接访问。 2. 派生类不能继承构造函数，析构函数，赋值运算符和友元。 3. 若返回类型为void，则只能单个赋值，不能连续赋值。 若返回对象，则速度减慢，因为返回语句需要复制对象。 4. 按派生的顺序调用构造函数，最早的构造函数最先调用。调...
基于Java实现的明日知道系统.zip
05-31
基于Java实现的明日知道系统
NX二次开发uc1653 函数介绍
05-31
NX二次开发uc1653 函数介绍，Ufun提供了一系列丰富的 API 函数，可以帮助用户实现自动化、定制化和扩展 NX 软件的功能。无论您是从事机械设计、制造、模具设计、逆向工程、CAE 分析等领域的专业人士，还是希望提高工作效率的普通用户，NX 二次开发 Ufun 都可以帮助您实现更高效的工作流程。函数覆盖了 NX 软件的各个方面，包括但不限于建模、装配、制图、编程、仿真等。这些 API 函数可以帮助用户轻松地实现自动化、定制化和扩展 NX 软件的功能。例如，用户可以通过 Ufun 编写脚本，自动化完成重复性的设计任务，提高设计效率；或者开发定制化的功能，满足特定的业务需求。语法简单易懂，易于学习和使用。用户可以快速上手并开发出符合自己需求的 NX 功能。本资源内容 提供了丰富的中英文帮助文档，可以帮助用户快速了解和使用 Ufun 的功能。用户可以通过资源中的提示，学习如何使用 Ufun 的 API 函数，以及如何实现特定的功能。
别墅图纸编号D020-三层-10.00&12.00米- 效果图.dwg
最新发布
05-31
别墅图纸编号D020-三层-10.00&12.00米- 效果图.dwg
操作系统实验指导书（2024）单面打印(1).pdf
05-31
操作系统实验指导书（2024）单面打印(1).pdf
基于Python实现的校园教务系统
05-31
Api Function | Api | Description | Argument | | :-------- | :----- | :---- | | user_login | 登陆函数 | account, password, user_type=1, use_cookie_login=True | | get_schedule | 课表查询 | schedule_year=None, schedule_term=None, schedule_type=None | | get_score | 成绩查询 | score_year=None, score_term=None, use_api=0 | | get_info | 用户信息查询 | | | get_place_schedule| 教学场地课表查询（可用于空教室查询） |campus_list=None,
Qt+ContentMargin+QWidget设置内容边距
05-31
设置控件窗口边框与内容的边距，包含左、上、右、下四个边距。示例中点击界面按钮设置按钮控件、text browser控件两者与父节点的GridLayout之间的边距，通过点击按钮可看到边距变化导致的界面布局的变化。包含源码可直接在qtcreator中编译运行。
c++ primer 和c++ primer plus有什么区别
05-23
而C++ Primer Plus则更注重实用性，介绍了更多的编程示例和练习。 3.风格：C++ Primer使用了更为正式的语言风格，较为严谨；C++ Primer Plus则更加轻松幽默，适合初学者阅读。 总之，如果你已经有一定的编程基础，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值