c++ primer plus 第13章习题

最新推荐文章于 2024-06-13 15:45:00 发布
最新推荐文章于 2024-06-13 15:45:00 发布
阅读量642 收藏
点赞数
分类专栏： C++ 文章标签： c++ primer plus 第13章
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chinahnwqf/article/details/51461706
版权 
//第13章 13.14
#ifndef STACK_H
#define STACK_H
#include<iostream>

using std::ostream;
using std::istream;
class baseDMA
{
private:
	char *label;
	int rating;

public:
	baseDMA(const char *l = "null", int r = 0);
	baseDMA(const baseDMA &rs);
	virtual ~baseDMA();
	baseDMA & operator=(const baseDMA &rs);
	friend ostream & operator<<(ostream &os, const baseDMA &rs);
};
class lacksDMA :public baseDMA
{
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);
	friend std::ostream &operator<<(ostream &os, const lacksDMA &rs);
};
class hasDMA :public baseDMA
{
private:
	char *style;
public:
	hasDMA(const char *s = "none", const char * l = "null", int r = 0);
	hasDMA(const char *s, const baseDMA &rs);
	hasDMA(const hasDMA &hs);
	~hasDMA();
	hasDMA & operator=(const hasDMA &rs);
	friend ostream & operator<<(ostream &os, const hasDMA &rs);
};
#endif



//第13章 13.14
#include"zhan.h"
#include<iostream>
#include<cstring>


baseDMA::baseDMA(const char *l , int r )
{
	label = new char[std::strlen(l) + 1];
	std::strcpy(label, l);
	rating = r;
}
baseDMA::baseDMA(const baseDMA &rs)
{
	label = new char[std::strlen(rs.label) + 1];
	std::strcpy(label, rs.label);
	rating = rs.rating;
}
 baseDMA::~baseDMA()
{
	delete[]label;
}
 baseDMA & baseDMA::operator=(const baseDMA &rs)
 {
	 if (this == &rs)
		 return *this;
	 delete[]label;
	 label = new char[std::strlen(rs.label) + 1];
	 std::strcpy(label, rs.label);
	 rating = rs.rating;
	 return *this;
 }
 ostream & operator<<(ostream &os, const baseDMA &rs)//此处不要加类名
 {
	 os << "Lable:" << rs.label << std::endl;
	 os << "Rating:" << rs.rating << std::endl;
	 return os;
 }

 lacksDMA::lacksDMA(const char *c, const char * l, int r) :baseDMA(l,r)
 {
	 std::strncpy(color, c, 39);//把src所指向的字符串中以src地址开始的前n个字节复制到dest所指的数组中，并返回dest
	 color[39] = '\0';
 }
 lacksDMA::lacksDMA(const char *c, const baseDMA &rs) : baseDMA(rs)//?
 {
	 std::strncpy(color, c, 39);
	 color[39] = '\0';
 }
 std::ostream &operator<<(ostream &os, const lacksDMA &rs)
 {
	 os << (const baseDMA&)rs;//?
	 os << "Color: " << rs.color << std::endl;
	 return os;

 }

 hasDMA::hasDMA(const char *s, const char * l, int r) :baseDMA(l,r)
 {
	 style = new char[strlen(s) + 1];
	 std::strcpy(style, s);
 }
 hasDMA::hasDMA(const char *s, const baseDMA &rs) : baseDMA(rs)//?
 {
	 style = new char[strlen(s) + 1];
	 std::strcpy(style, s);
 }
 hasDMA::hasDMA(const hasDMA &hs) : baseDMA(hs)
 {
	 style = new char[strlen(hs.style) + 1];
	 std::strcpy(style, hs.style);
 }
 hasDMA::~hasDMA()
 {
	 delete[]style;
 }
 hasDMA & hasDMA::operator=(const hasDMA &rs)
 {
	 if (this == &rs)
		 return *this;
	 baseDMA::operator=(rs);
	 delete[]style;
	 style = new char[strlen(rs.style) + 1];
	 std::strcpy(style, rs.style);
	 return *this;
 }
 ostream & operator<<(ostream &os, const hasDMA &rs)
 {
	 os << (const baseDMA &)rs;
	 os << "Style: " << rs.style << std::endl;
	 return os;
 }



//第13章 13.14
#include<iostream>
#include"zhan.h"
#include<stdlib.h>


int main()
{
	using std::cout;
	using std::endl;

	baseDMA shirt("Portabelly", 8);
	lacksDMA balloon("red", "Buffalo", 4);
	hasDMA map("Mercator", "Buffalo Keys", 5);
	cout << "Displaying baseDMA oject:\n";
	cout << shirt << endl;
	cout << "Displaying lacksDMA object:\n";
	cout << balloon << endl;
	cout << "Displaying hasDMA object:\n";
	cout << map << endl;
	lacksDMA balloon2(balloon);
	cout << "Result of lackdDMA copy:\n";
	cout << balloon2 << endl;
	hasDMA map2;
	map2 = map;
	cout << "Result of hasDMA assignment:\n";
	cout << map2 << endl;
	system("pause");
	return 0;
}

//第13章第1题
#ifndef CLASS_H
#define CLASS_H
#include<iostream>
using std::cin;
using std::cout;
using std::endl;
class Cd
{
private:
	char performers[50];
	char label[20];
	int selections;
	double playtime;
protected:
	char *perfor(){ return performers; };
	char *lab(){ return label; };
	int sel(){ return selections; };
	double play(){ return playtime; };
public:
	Cd(char *s1, char *s2, int n, double x)
	{
		strcpy(performers, s1);//不用new了，因为performer 是数组
		strcpy(label, s2);
		selections = n;
		playtime = x;
	}
	Cd(const Cd &d)
	{
		strcpy(performers, d.performers);
		strcpy(label, d.label);
		selections = d.selections;
		playtime = d.playtime;
	}
	Cd(){};
	virtual ~Cd(){};//构造函数应为虚函数
	virtual void Report()const
	{
		cout << "Perfomers:" << performers << endl;
		cout << "Label:" << label << endl;
		cout << "selection:" << selections << endl;
		cout << "playtime:" << playtime << endl;
	}
	Cd & Cd::operator=(const Cd &d)
	{
		//return Cd(d);//这个狠啊，用的构造函数。这个下边没法赋值，局部变量
		if (this == &d)
			return *this;
		strcpy(performers, d.performers);
		strcpy(label, d.label);
		selections = d.selections;
		playtime = d.playtime;
		return *this;
	}

};
class Classic : public Cd
{
private:
	char mainLabel[50];
public:
	Classic(char *s1, char *s2, char *s3, int n, double x) :Cd(s1, s2, n, x)
	{
		strcpy(mainLabel, s3);//这个也狠，调用了构造函数完成基类复制。
	}
	Classic(Classic &c) :Cd(c.perfor(), c.lab(),c.sel(), c.play())
	{
		strcpy(mainLabel, c.mainLabel);
	}
	Classic(){};//必须有函数体
	virtual ~Classic(){};
	virtual void Report()const
	{
		Cd::Report();
		cout << "mainLabel:" << mainLabel << endl<<endl;
	}
	 Classic & Classic::operator=(const Classic &c)
	{
		if (this == &c)
			return *this;
		Cd::operator=(c);
		strcpy(mainLabel, c.mainLabel);
		return *this;
	}
};
#endif

//第13章第1题，第2题共用主函数
#include<iostream>
using namespace std;
#include"zhan.h"
#include<cstdlib>
void Bravo(const Cd &disk);
int main()
{
	Cd c1("Beatles", "Capitol", 14, 35.5);
	Classic c2 = Classic("Piano Sonata int B flat, Fantasia in C",
		"Alfred Brendel", "Philips", 2, 57.17);
	Cd *pcd = &c1;
	cout << "Using object directly:\n";
	c1.Report();
	c2.Report();

	cout << "Using type cd * pointer to objects:\n";
	pcd->Report();
	pcd = &c2;
	pcd->Report();

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

	cout << "Testing assignment:";
	Cd copy1;
	copy1 = c1;
	copy1.Report();

	Classic copy;
	copy = c2;
	copy.Report();
	system("pause");
	return 0;
}

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



//第13章第2题
#ifndef CLASS_H
#define CLASS_H
#include<iostream>
using std::cin;
using std::cout;
using std::endl;
class Cd
{
private:
	char *performers;
	char *label;
	int selections;
	double playtime;
public:
	Cd(char *s1, char *s2, int n, double x)
	{
		performers = new char[strlen(s1) + 1];
		strcpy(performers, s1);//用new了，因为performer 是指针
		label = new char[strlen(s2) + 1];
		strcpy(label, s2);
		selections = n;
		playtime = x;
	}
	Cd(const Cd &d)
	{
		performers = new char[strlen(d.performers) + 1];
		strcpy(performers, d.performers);
		label = new char[strlen(d.label) + 1];
		strcpy(label, d.label);
		selections = d.selections;
		playtime = d.playtime;
	}
	Cd(){};
	virtual ~Cd(){ delete[]performers; delete[]label; };//构造函数应为虚函数
	virtual void Report()const
	{
		cout << "Perfomers:" << performers << endl;
		cout << "Label:" << label << endl;
		cout << "selection:" << selections << endl;
		cout << "playtime:" << playtime << endl;
	}
	Cd & Cd::operator=(const Cd &d)
	{
		//return Cd(d);//这个狠啊，用的构造函数。这个下边没法赋值，局部变量
		if (this == &d)
			return *this;
		delete[]performers;
		delete[]label;//释放以前的字符串
		performers = new char[strlen(d.performers) + 1];
		strcpy(performers, d.performers);
		label = new char[strlen(d.label) + 1];
		strcpy(label, d.label);
		selections = d.selections;
		playtime = d.playtime;
		return *this;
	}

};
class Classic : public Cd
{
private:
	char  * mainLabel;
public:
	Classic(char *s1, char *s2, char *s3, int n, double x) :Cd(s1, s2, n, x)
	{
		mainLabel = new char[strlen(s3) + 1];
		strcpy(mainLabel, s3);//这个也狠，调用了构造函数完成基类复制。
	}
	Classic(Classic &c) :Cd(c)
	{
		mainLabel = new char[strlen(c.mainLabel) + 1];
		strcpy(mainLabel, c.mainLabel);
	}
	Classic(){};//必须有函数体
	virtual ~Classic(){ delete[]mainLabel; };
	virtual void Report()const
	{
		Cd::Report();
		cout << "mainLabel:" << mainLabel << endl << endl;
	}
	Classic & Classic::operator=(const Classic &c)
	{
		if (this == &c)
			return *this;
		Cd::operator=(c);
		delete[]mainLabel;
		mainLabel = new char[strlen(c.mainLabel) + 1];
		strcpy(mainLabel, c.mainLabel);
		return *this;
	}
};
#endif


//第13章第1题，第2题共用主函数
#include<iostream>
using namespace std;
#include"zhan.h"
#include<cstdlib>
void Bravo(const Cd &disk);
int main()
{
	Cd c1("Beatles", "Capitol", 14, 35.5);
	Classic c2 = Classic("Piano Sonata int B flat, Fantasia in C",
		"Alfred Brendel", "Philips", 2, 57.17);
	Cd *pcd = &c1;
	cout << "Using object directly:\n";
	c1.Report();
	c2.Report();

	cout << "Using type cd * pointer to objects:\n";
	pcd->Report();
	pcd = &c2;
	pcd->Report();

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

	cout << "Testing assignment:";
	Cd copy1;
	copy1 = c1;
	copy1.Report();

	Classic copy;
	copy = c2;
	copy.Report();
	system("pause");
	return 0;
}

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


//第13章第3题
#ifndef CLASS_H
#define CLASS_H
#include<iostream>
#include<string>
using namespace std;
class DMA
{
private:
	string label;
	int rating;
public:
	DMA(const string l = "NULL", int r = 0)
	{
		label = l;
		rating = r;
	}
	DMA(const DMA &rs)
	{
		label = rs.label;
		rating = rs.rating;
	}
	virtual void test()const = 0{};//纯虚函数。
	virtual void test2()
	{
		cout << "test2" << endl;
	}
	virtual ~DMA(){};
	friend ostream &operator<<(ostream &os, const DMA &rs)
	{
		os << "label:" << rs.label << " rating :" << rs.rating << endl;
		return os;
	}
	virtual void show()
	{
		cout << "label:" << label << " rating:" << rating << " " << endl;
	}
};

class baseDMA :public DMA
{
public:
	baseDMA(const string l = "NULL", int r = 0) :DMA(l, r)
	{}
	baseDMA(baseDMA &bd) :DMA(bd){}
	virtual void test()const{};//必须实现虚基类的所有虚函数
	virtual ~baseDMA(){}//虚函数是为了继承接口和默认行为  纯虚函数只是继承接口，行为必须重新定义
	friend ostream &operator<<(ostream &os, const baseDMA &bd)
	{
		os << "This is baseDMA:";
		os << (DMA &)bd;//通过强制转换调用基类友元函数
		return os;
	}
	virtual void show()
	{
		cout << "This is baseDMA:";
		DMA::show();
		cout << endl;
	}
};
class lacksDMA :public DMA
{
private:
	string color;
public:
	lacksDMA(const string c = "blank", const string l = "NULL", int r = 0) :DMA(l, r)
	{
		color = c;
	}
	virtual ~lacksDMA(){};
	virtual void test()const{};
	friend ostream &operator<<(ostream &os, const lacksDMA &ld)
	{
		os << "This is lacksDMA:";
		os << (DMA &)ld << " color:" << ld.color;
		return os;
	}
	virtual void show()
	{
		cout << "This is lacksDMA:";
		DMA::show();
		cout << " color:" << color;
		cout << endl;
	}
};

class hasDMA :public DMA
{
private:
	string style;
public:
	hasDMA(const string s = "none", const string l = "null", int r = 0) :DMA(l, r)
	{
		style = s;
	}
	virtual ~hasDMA(){};
	virtual void test()const{};
	virtual void show()
	{
		cout << "This is hasDMA: ";
		DMA::show();
		cout << " style:" << style;
		cout << endl;
	}
	friend ostream &operator<<(ostream &os, const hasDMA &hd)
	{
		os << "This is hasDMA:";
		os << (DMA &)hd << " style:" << hd.style;
		return os;
	}

};


#endif

//第13章第3题
#include<iostream>
#include"zhan.h"
using namespace std;
void main()
{
	DMA *pd[3];//虚基类不能创建对象，但可以创建指向其的指针
	for (int i = 0; i < 3; i++)
	{
		cout << "\nEnter the label:";
		string label;
		getline(cin, label);
		cout << "\nEnter the rating:";
		int rat;
		cin >> rat;
		cout << "Enter the 1 for baseDMA" << endl
			<< "2 for lacksDMA" << endl
			<< "3 for hasDMA" << endl;
		int temp;
		cin >> temp;
		cin.get();
		if (temp==1)
			pd[i] = new baseDMA(label, rat);
		else if (temp == 2)
		{
			cout << "Enter the color:";
			string color;
			getline(cin, color);
			pd[i] = new lacksDMA(color, label, rat);
		}
		else if (temp == 3)
		{
			cout << "Enter the style:";
			string style;
			getline(cin, style);
			pd[i] = new hasDMA(style, label, rat);
		}
		else
		{
			cout <<"Please try it again!" << endl;
			i--;
		}
		while (cin.get() != '\n')
			continue;
	}
	cout << endl;
	for (int i = 0; i < 3; i++)
	{
		pd[i]->show();
	}
	system("pause");
}



//第13章第4题
#ifndef CLASS_H
#define CLASS_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)
	{
		brand = new char[strlen(br) + 1];
		strcpy(brand, br);
		strcpy(style, st);
		bottles = b;
	}
	Port(const Port &p)
	{
		brand = new char[strlen(p.brand) + 1];
		strcpy(brand, p.brand);
		strcpy(style, p.style);
		bottles = p.bottles;
	}
	virtual~Port(){ delete[]brand; }
	Port &operator=(const Port &p)
	{
		if (this == &p)
			return *this;
		delete[]brand;//必须要有
		brand = new char[strlen(p.brand) + 1];
		strcpy(brand, p.brand);
		strcpy(style, p.style);
		bottles = p.bottles;
		return *this;
	}
	Port &operator+=(int b)
	{
		bottles += b;
		return *this;
	}
	Port &operator-=(int b)
	{
		bottles-= b;
		return *this;
	}

	int BottleCount()const { return bottles; };
	virtual void Show()const
	{
		cout << "Brand:" << brand<<endl;
		cout << "Styles:" << style << endl;
		cout << "Bottles:" << bottles << endl;
	}
	friend ostream &operator<<(ostream &os, const Port &p)
	{
		cout << p.brand << ", " << p.style << ", " << p.bottles << endl;
		return os;
	}
};
class VintagePort :public Port
{
private:
	char * nickname;
	int year;
public:
	VintagePort() :Port()
	{
		nickname = NULL;
		year = 0;
	}
	VintagePort(const char *br, int b, const char *nn, int y) :Port(br, "Vintage", b)
	{
		nickname = new char[strlen(nn) + 1];
		strcpy(nickname, nn);
		year = y;
	}
	VintagePort(const VintagePort &vp) :Port(vp)
	{
		nickname = new char[strlen(vp.nickname) + 1];
		strcpy(nickname, vp.nickname);
		year = vp.year;
	}
	~VintagePort(){ delete[]nickname; };
	VintagePort &operator=(const VintagePort &vp)
	{
		if (this == &vp)
			return *this;
		delete[]nickname;
		Port::operator=(vp);
		nickname = new char[strlen(vp.nickname) + 1];
		strcpy(nickname, vp.nickname);
		year = vp.year;
		return *this;
	}
	void Show()const
	{
		Port::Show();
		cout << "nickname:" << nickname << endl;
		cout << "year:" << year << endl;
	}
	friend ostream & operator<<(ostream & os, const VintagePort &vp)
	{
		os << (Port &)vp;
		cout << ","<<vp.nickname << "," << vp.year;
		return os;
	}
};
#endif




//第13章第4题
#include"zhan.h"
int main()
{
	Port *ptr;
	Port p("Gallo", "tawny", 20);
	ptr = &p;
	ptr->Show();
	cout << p << endl;
	VintagePort v("gallo", 20, "ttt", 20);
	ptr = &v;
	ptr->Show();
	cout << v << endl;
	system("pause");
	return 0;
}


chinawqf
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ Primer Plus 编程练习源码工程 第13章
10-26
C++ Primer Plus 编程练习源码工程 第13章 ，这是本人自己学习书籍时写的编程练习的源码工程，供大家参考交流。
C++ primer plus 学习笔记 （第13章）
qq_24251645的博客
01-17 237
第13章 类继承 类库由类声明和实现构成的。通常，类库是以源代码的方式提供的。 C++提供了比修改代码更好的方法来扩展和修改类。这种方法叫做类继承，它能够从已有的类派生出新的类，而派生类继承了原有类（称为基类）的特征，包括方法。通过继承派生出的类通常比设计新类要容易。下面是可以通过继承完成的一些工作： 可以在已有类的基础上添加功能； 可以给类添加数据； 可以修改类方法的行为； 13.1 一个简...
C++PrimerPlus:第十三章类和继承:一个简单的基类13.1-3
最新发布
zhyjhacker的博客
06-13 1014
从一个类派生出另一个类时，原始类称为基类，继承类称为派生类。为说明继承，首先需要一个基类。Webtown 俱乐部决定跟踪乒乓球会会员。作为俱乐部的首席程序员，需要设计一个简单的 TableTennisPlayer类，如程序清单 13.1和 13.2 所示。提示：以下是本篇文章正文内容，下面案例可供参考注意到该程序实例化对象时将C-风格字符串作为参数:但构造函数的形参类型被声明为 const string&。
C++ Primer Plus 第十三章知识点（一）
Raywit的博客
02-14 337
C++ Primer Plus 第十三章知识点简化1. 简单的基类2. 派生一个类3. 派生类和基类的特殊关系Reference： 1. 简单的基类        由于面向对象编程主要目的之一就是提供可重写的代码，对于扩展和修改类，除了去源码中修改之外，还有就是类继承；从一个类派生出另一个类时，原始类称为 基类，继承类称为 派生类。简单看下下面的程序： #ifndef HEAD_H_ #define HEAD_H_ #include&lt
c++PrimerPlus第13章
qq_36971581的博客
03-26 990
讲述了公有派生，is-a模型，派生类和基类当中有动态分配的方法定义情况。动态联编，静态联编。ABC抽象基类。保护成员protected
c++ Primer Plus（第六版）第十三章习题，写代码之路
Robot_x的博客
02-08 655
c++ Primer Plus（习题13.1) /*13.1题的实现文件，书上的测试文件*/ //哪个方法不需要也根据实现而定，始终跟随客户的脚步 //这题细节方面被坑了，mainworks字符数组设置太小了，导致了一系列不可思议的问题 #include #include"classic.h" using namespace std; void Bravo(const Cd&disk); int
C++ Primer Plus 第6版 中文版课后代码习题答案
03-10
《C++ Primer Plus 第6版 中文版》是一本深入浅出的C++学习书籍，其课后代码习题答案是学习过程中不可或缺的部分。这本书旨在帮助读者从零基础开始掌握C++编程语言，通过实例和习题来巩固理论知识，提升编程技能。...
C++Primer Plus附录源码等文件.zip
12-27
C++ Primer Plus第六版的课后题练习题是学习过程中不可或缺的一部分。通过解决这些题目，读者可以巩固所学知识，提高编程技能，包括变量、运算符、控制流、函数、数组、指针、类、对象、继承、多态性、模板等核心...
C++ Primer Plus 编程练习源码工程 第15章
12-25
《C++ Primer Plus 编程练习源码工程 第15章》是针对C++初学者的一个宝贵资源，它包含了作者LeonardoLiuwenbo在学习《C++ Primer Plus》这本经典教材时所做的编程练习。这个章节聚焦于C++语言的深入特性，旨在通过...
c++primer plus第七章到第十三章习题源码
03-12
8. **模板（Templates）**：第十三章的习题可能涉及到模板，它是C++中的泛型编程工具，可以创建通用的函数和类。`template <typename T>`这样的语句表示模板的声明。 9. **异常处理（Exception Handling）**：异常...
C++ Primer Plus第六版 第十三章 编程练习答案
蒟蒻升级中...Orz
11-21 2863
今天下午体测 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（1~13章）课后编程练习答案
12-27
我本人学习《C++ primer plus第六版》的时候所做的1~13章节的课后编程练习答案，当时的编译环境是vs2013，绝对可以通过，供大家参考.网上这本书的课后答案真的好少啊，好在我也慢慢学过来了。
c++ primer plus 十三章 类继承
weixin_59141600的博客
09-24 452
c++ primer plus 第十三章 类继承
《C++PrimerPlus》第13章 类继承
Mako5455的博客
12-30 497
类继承
C++_primer_plus学习笔记 第13章 类继承
Flying_Dutchman_的博客
07-12 407
is-a关系继承 公有派生 保护访问 构造函数成员初始化列表 向上和向下强制转换 虚成员函数 早起（静态）联编和晚期（动态）联编 抽象基类 纯虚函数 何时及如何使用公有继承
C++Primer Plus（第六版） 第十三章 第一题
greatlisten的博客
08-13 202
classic.h // base class // #pragma once #ifndef CLASSIC_H_ #define CLASSIC_H_ class Cd { // represents a CD disk private: char performers[50]; char label[20]; int selections; // number of selectio
【读书笔记:C++ primer plus 第六版 中文版】第13章 类继承
enyusmile
07-06 1314
转载请注明出处: 20150627,以此纪念一个特别的日子 本章内容包括: is-a关系的继承 如何以公有方式从一个类派生出另一个类 保护访问 构造函数成员初始化列表 向上和向下强制转换 虚成员函数 早期(静态)联编与晚期(动态)联编 抽象基类 纯虚函数 何时及如何使用公有继承 面向对象编程的主要目的之一是提供可重用的代码.目前,很多厂商提供了类库,类库由类声明和实现构成.因为类组合了数据
c++primer plus 6 读书笔记 第十三章 类继承
一只大鸽子的博客
08-01 526
类继承 C++提供了更高层次的重用性。类继承--从已有的类派生出新类。 继承通常： 在已有的类上面添加功能。 给类添加数据。 修改类方法的行为。 13.1 一个简单的基类 class Player{...} 13.1.1 派生一个类 使用派生的声明：   class RatedPlayer : public Player    //public 为公有派生 {...}   ...
C++ Primer Plus课后编程练习题答案和实现代码
C++ primer plus课后编程练习题答案 本资源提供了C++ primer plus课后编程练习题的答案，涵盖了课后练习题和编程练习题，使用QT亲自运行成功。以下是对该资源中所包含的知识点的详细解释： 1. 第六章分支语句和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值