C++ Primer Plus 第十三章习题答案+收获

已于 2023-01-23 21:21:01 修改
阅读量483 收藏 3
点赞数 2
CC 4.0 BY-SA版权
分类专栏： C++ Primer Plus C++ 文章标签： c++ 开发语言
于 2022-09-12 21:18:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/GodFishhh/article/details/126805003
本文介绍了C++中不同类的设计与实现，包括基类Cd及其派生类Classic，展示了如何使用构造函数、析构函数、复制构造函数和赋值运算符。后续章节探讨了使用动态内存分配、纯虚函数和多态性的经典案例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录

13.1

13.2

13.3

13.4

13.1

//class.h

#pragma once

#ifndef _CLASS_H_
#define _CLASS_H_

//基类
class Cd
{
private:
	char performance[50];
	char label[20];
	int selections;
	double payment;
public:
	Cd(const char* s1="none", const char* s2="none", int n=0, double x=0); //自定义的构造函数的所有参数均为默认参数时则无需再自定义一个默认构造函数
	//Cd(const Cd& d); 没有使用new开辟动态内存空间，类默认的复制构造函数便可以完成任务
	//~Cd(); 析构函数同理
	//Cd & operator=(const Cd&d); 重载赋值运算符同理
	virtual void Report()const; //在派生类中重新定义，需使用虚函数来完成多态
};

class Classic :public Cd
{
private:
	//属于派生类的数据
	char essential[50];
public:
	Classic(const char* s = "none", const char* s1 = "none", const char* s2 = "none", int n = 0, double x = 0);
	//自定义的构造函数的所有参数均为默认参数时则无需再自定义一个默认构造函数
	virtual void Report()const;
};

#endif

//fuc.cpp

#include<cstring>
#include"class.h"
#include<iostream>
using namespace std;

#pragma warning(disable:4996);

Cd::Cd(const char* s1, const char* s2, int n, double x)
{
	strcpy(performance, s1);
	strcpy(label, s2);
	selections = n;
	payment = x;
}

void Cd::Report()const
{
	cout << "Performance: " << performance << endl;
	cout << "Label: " << label << endl;
	cout << "Selections: " << selections << endl;
	cout << "Payment: " << payment << endl;
}

Classic::Classic(const char* s, const char* s1, const char* s2, int n, double x) :Cd(s1, s2, n, x) //通过成员初始化先创建基类对象
{
	strcpy(essential, s);
}

void Classic::Report()const
{
	Cd::Report(); //基类部分的report(调用基类的Report()函数)
	cout << "Essential: " << essential << endl; //派生类部分的report
}

//main.cpp

#include"class.h"
#include<iostream>
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 directl: " << endl;
	c1.Report();
	c2.Report();

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

	cout << "Calling a fuction with a Cd reference argument: " << endl;
	Bravo(c1);
	Bravo(c2);

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


	system("pause");
	return 0;
}



void Bravo(const Cd& disk) //参数为基类引用，实参可以为基类对象或者派生类对象
{
	disk.Report();
}

13.2

//class.h

#pragma once

#ifndef _CLASS_H_
#define _CLASS_H_


//使用动态内存分配来记录字符串(则需要自定义析构函数，复制构造函数，重载赋值运算符)
//基类
class Cd
{
private:
	char *performance;
	char * label;
	int selections;
	double payment;
public:
	Cd(const char* s1 = "none", const char* s2 = "none", int n = 0, double x = 0); //自定义的构造函数的所有参数均为默认参数时则无需再自定义一个默认构造函数
	Cd(const Cd& d);
	virtual ~Cd(); 
	Cd & operator=(const Cd&d);
	virtual void Report()const; //在派生类中重新定义，需使用虚函数来完成多态
};

class Classic :public Cd
{
private:
	//属于派生类的数据
	char *essential;
public:
	Classic(const char* s = "none", const char* s1 = "none", const char* s2 = "none", int n = 0, double x = 0);
	//自定义的构造函数的所有参数均为默认参数时则无需再自定义一个默认构造函数
	Classic(const Classic& cl);
	~Classic();
	Classic& operator=(const Classic& cl);
	virtual void Report()const;
};



#endif

//fuc.cpp

#include"class.h"
#include<cstring>
#include<iostream>
using namespace std;

#pragma warning(disable:4996)

//base class
Cd::Cd(const char* s1, const char* s2 , int n, double x) //自定义的构造函数的所有参数均为默认参数时则无需再自定义一个默认构造函数
{
	performance = new char[strlen(s1) + 1];
	strcpy(performance, s1);
	label = new char[strlen(s2) + 1];
	strcpy(label, s2);
	selections = n;
	payment = x;
}

Cd::Cd(const Cd& d)
{
	//深度复制
	performance = new char[strlen(d.performance) + 1];
	strcpy(performance, d.performance);
	label = new char[strlen(d.label) + 1];
	strcpy(label, d.label);
	selections = d.selections;
	payment = d.payment;
}

Cd::~Cd()
{
	delete[]performance;
	delete[]label;
}

Cd& Cd::operator=(const Cd& d)
{
	delete[]performance;
	performance = new char[strlen(d.performance) + 1];
	strcpy(performance, d.performance);
	delete[]label;
	label = new char[strlen(d.label) + 1];
	strcpy(label, d.label);
	selections = d.selections;
	payment = d.payment;
	return *this;
}

void Cd::Report()const //在派生类中重新定义，需使用虚函数来完成多态
{
	cout << "Performance：" << performance << endl;
	cout << "Label: " << label << endl;
	cout << "Selections: " << selections << endl;
	cout << "Payment: " << payment << endl;
}

//derived class
Classic::Classic(const char*s,const char* s1, const char* s2 , int n, double x):Cd(s1,s2,n,x)
{
	essential = new char[strlen(s) + 1];
	strcpy(essential, s);
}

//自定义的构造函数的所有参数均为默认参数时则无需再自定义一个默认构造函数
Classic::Classic(const Classic& cl) :Cd(cl)
{
	essential = new char[strlen(cl.essential) + 1];
	strcpy(essential, cl.essential);
}

Classic::~Classic()
{
	delete[]essential;
}

Classic& Classic::operator=(const Classic& cl)
{
	Cd::operator=(cl); //调用基类的重载赋值运算符，来完成基类部分数据的赋值
	delete[]essential;
	essential = new char[strlen(cl.essential) + 1];
	strcpy(essential, cl.essential);
	return *this;
}

void Classic::Report()const
{
	Cd::Report();
	cout << "Essential: " << essential << endl;
}

//main.cpp

#include"class.h"
#include<iostream>
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 directl: " << endl;
	c1.Report();
	c2.Report();

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

	cout << "Calling a fuction with a Cd reference argument: " << endl;
	Bravo(c1);
	Bravo(c2);

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


	system("pause");
	return 0;
}



void Bravo(const Cd& disk) //参数为基类引用，实参可以为基类对象或者派生类对象
{
	disk.Report();
}

13.3

//class.h
//修改base，lacks，has三个类，让三个类都从一个ABC派生而来( ABC抽象基类(包含纯虚函数，无法创建对象) -> 派生类)

#pragma once

#include<iostream>
using namespace std;

#ifndef _CLASS_H_
#define _CLASS_H_

//ABC抽象基类
class ABC
{
private:
	char* label;
	int rating;
public:
	ABC(const char* s1, int n);
	ABC(const ABC& abc);
	virtual ~ABC(); //基类的虚构函数设置为虚函数
	ABC& operator=(const ABC& abc);
	virtual void View() = 0; //纯虚函数 -- 抽象基类
};

//BaseDMA
class BaseDMA :public ABC
{
private:

public:
	BaseDMA(const char* s1, int n);
	//此派生类中没有动态分配内存，无需自定义复制构造函数，析构函数，重载赋值运算符
	//BaseDMA(const BaseDMA& bd);   
	//~BaseDMA();
	//BaseDMA& operator=(const BaseDMA& bd);
	virtual void View();
};

//LacksDMA
class LacksDMA:public ABC
{
private:
	const static int COL_LEN = 40;
	char color[COL_LEN];
public:
	LacksDMA(const char* s, const char* s1, int n);
	virtual void View();
};

//HasDMA
class HasDMA:public ABC
{
private:
	char* style;
public:
	HasDMA(char* s, char* s1, int n);
	HasDMA(HasDMA& hd);
	~HasDMA();
	HasDMA& operator=(const HasDMA& hd);
	virtual void View();
};




#endif

//fuc.cpp

#include<iostream>
#include<cstring>
#include"class.h"
using namespace std;

#pragma warning(disable:4996)

//ABC

ABC::ABC(const char* s1, int n)
{
	label = new char[strlen(s1) + 1];
	strcpy(label, s1);
	rating = n;
}
ABC::ABC(const ABC& abc)
{
	label = new char[strlen(abc.label) + 1];
	strcpy(label, abc.label);
	rating = abc.rating;
}

ABC::~ABC() //基类的虚构函数设置为虚函数
{
	delete[]label;
}

ABC& ABC::operator=(const ABC& abc)
{
	delete[]label;
	label = new char[strlen(abc.label) + 1];
	strcpy(label, abc.label);
	rating = abc.rating;
	return *this;
}
void ABC::View() //纯虚函数 -- 抽象基类
{
	cout << "Label: " << label << endl;
	cout << "Rating: " << rating << endl;
}

//BASE
BaseDMA::BaseDMA(const char* s1, int n) :ABC(s1, n)
{
	//BaseDMA无额外的数据成员，所以只需要调用基类的构造函数即可
}

void BaseDMA::View()
{
	cout << "The type is BaseDMA" << endl;
	ABC::View();
}

//LACKS
LacksDMA::LacksDMA(const char* s, const char* s1, int n) :ABC(s1, n)
{
	strcpy(color, s);
}

void LacksDMA::View()
{
	cout << "The type is LacksDMA" << endl;
	ABC::View();
	cout << "Color： " << color << endl;
}

//HAS
HasDMA::HasDMA(char* s, char* s1, int n):ABC(s1,n)
{
	style = new char[strlen(s) + 1];
	strcpy(style, s);
}

HasDMA::HasDMA(HasDMA& hd) :ABC(hd)
{
	style = new char[strlen(hd.style) + 1];
	strcpy(style, hd.style);
}

HasDMA::~HasDMA()
{
	delete[] style;
}

HasDMA& HasDMA::operator=(const HasDMA& hd)
{
	ABC::operator=(hd); //调用基类的重载赋值运算符来对基类数据进行赋值
	delete[] style;
	style = new char[strlen(hd.style) + 1];
	strcpy(style, hd.style);
	return *this;
}

void HasDMA::View()
{
	cout << "The type is HasDMA" << endl;
	ABC::View();
	cout << "Style: " << style << endl;
}

//main.cpp

#include<iostream>
#include"class.h"
using namespace std;


int main()
{
	//包含纯虚函数的基类不能创建对象，但可以创建基类的指针，指向派生类
	ABC* points[3];
	int selection;
	int i = 0;
	char label[50];
	int rating;
	char color[50];
	char style[50];	
	cout << "1----BaseDMA" << endl;
	cout << "2----LacksDMA" << endl;
	cout << "3----HasDMA" << endl;
	while (i < 3)
	{
		//指针必须要通过new来分配相应的内存，声明一个指针并不会给其分配内存
		cout << "Please enter your choice: ";
		cin >> selection;
		if (selection == 1)
		{
			cout << "Please enter the label: " << endl;
			cin >> label;
			cout << "Please enter the rating: " << endl;
			cin >> rating;
			points[i] = new BaseDMA(label, rating); // 在最后加上()直接利用相应构造函数进行初始化 
		}
		else if (selection == 2)
		{
			cout << "Please enter the label: " << endl;
			cin >> label;
			cout << "Please enter the rating: " << endl;
			cin >> rating;
			cout << "Please enter the color: " << endl;
			cin >> color;
			points[i] = new LacksDMA(color, label, rating);
		}
		else if (selection == 3)
		{
			cout << "Please enter the label: " << endl;
			cin >> label;
			cout << "Please enter the rating: " << endl;
			cin >> rating;
			cout << "Please enter the sytle: " << endl;
			cin >> style;
			points[i] = new HasDMA(style, label, rating);
		}
		i++;
	}
	cout << "Reporting: " << endl;
	for (int i = 0; i < 3; i++)
	{
		points[i]->View();
	}


	system("pause");
	return 0;
}

//声明一个指针并不会为其分配内存，必须要通过new运算符或者将指针指向一个对象。

13.4

//class.h

#pragma once

#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);
	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(const char* br = "none", const char*st = "none",int b = 0,  const char* nn = "none", int y = 0);
	Vintageport(const Vintageport& vp);
	~Vintageport()
	{
		delete[]nickname;
	}
	Vintageport& operator=(const Vintageport& vp);
	void Show()const;
	friend ostream& operator<<(ostream& os, const Vintageport& vp);
};




#endif

//fuc.cpp

#include<cstring>
#include"class.h"

#pragma warning(disable:4996)

//base
port::port(const char* br, const char* st, int b)
{
	brand = new char[strlen(br) + 1];
	strcpy(brand, br);
	strcpy(style, st);
	bottles = b;
}

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

port& port::operator=(const port& p)
{
	delete[]brand; //赋值是对于已经初始化过的对象使用的，所以相当于复制构造函数是针对未初始化的对象，要多一步delete防止内存的损耗
	brand = new char[strlen(p.brand) + 1];
	strcpy(brand, p.brand);
	strcpy(style, p.style);
	bottles = p.bottles;
	return *this;
}

port& port::operator+=(int b)
{
	bottles += b;
	return *this;
}

port& port::operator-=(int b)
{
	if (bottles < 0)
	{
		cout << "There are no bottles left" << endl;
		return *this;
	}
	else
	{
		bottles -= b;
		return *this;
	}
}

void port::Show()const
{
	cout << "Brand: " << brand << endl;
	cout << "Kind： " << style << endl;
	cout << "Bottles: " << bottles << endl;
}

ostream& operator<<(ostream& os, const port& p)
{
	os << p.brand << " ," << p.style << " ," << p.bottles << endl;
	return os;
}

//derived
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(nickname, nn);
	year = y;
}

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

Vintageport& Vintageport::operator=(const Vintageport& vp)
{
	port::operator=(vp); //调用基类的重载赋值运算符
	delete[]nickname;
	nickname = new char[strlen(vp.nickname) + 1];
	strcpy(nickname, vp.nickname);
	year = vp.year;
	return *this;
}
void Vintageport::Show()const
{
	port::Show(); //基类部分
	cout << "Nickname: " << nickname << endl;
	cout << "Year: " << year << endl;
}

//友元函数无需声明是哪个类中的，因为友元函数不属于成员函数
ostream& operator<<(ostream& os, const Vintageport& vp)
{
	//通过强制类型转换来访问基类的友元函数:将派生类参数转换为基类参数来匹配基类的友元函数
	cout << (const port&)vp << ", " << vp.nickname << ", " << vp.year << endl;
	return os;
}

//main.cpp

#include"class.h"

int main()
{
	port p1("GodFishhh", "Fishing", 10);
	port p2("AFish", "Fish", 20);
	cout <<"p1: "<< p1 << endl;
	cout <<"p2: " << p2 << endl;
	p1.Show();
	p2.Show();
	p1 += 10;
	p2 -= 5;
	cout << "After refreshing: " << endl;
	p1.Show();
	p2.Show();
	Vintageport v1("GodFishhh", "Fishing", 10, "AFish", 20);
	cout << "V1: " << v1 << endl;
	v1.Show();

	system("pause");
	return 0;
}

//通过强制类型转换来访问基类的友元函数:将派生类参数转换为基类参数以匹配基类的友元函数。

//友元函数无需声明位于哪里类中，因为友元函数不属于类成员函数。

C Primer Plus(第6版)第十三章复习题答案
weixin_42912350的博客
03-05 908
13.10复习题 1.下面的程序有什么问题？ 改正后的程序如下 #include &amp;amp;amp;lt;stdio.h&amp;amp;amp;gt; int main(void) { FILE * fp; int k; fp = fopen(&amp;amp;quot;gelatin&amp;amp;quot;, &amp;amp;quot;w&amp;amp;quot;); //要提供一种模式，例如“w” &amp;amp;quot
C++primer plus 习题+答案
yj
05-22 2910
解释：一般来说，调用一个函数流程为：当前调用命令的地址被保存下来，程序将跳转到所调用的函数并执行该函数，最后跳转回之前所保存的命令地址。对于经常需要调用的小函数来说，这大大降低了程序运行效率。所以，新增了内联函数。关键字inline告诉编译器，任何地方只要调用内联函数，就直接把函数的机器码插入到调用它的地方。这样程序执行更有效率，就好像将内联函数中的语句直接插入到了源代码文件中需要调用该函数的地方一样。适合于：只有一行代码的小型，非递归函数适合作为内联函数。
《C++ Primer Plus》第13章编程练习 答案及思考
grey_orange的博客
05-16 945
以下面的类声明为基础： class Cd{ private: char performers[50]; char label[20]; int selections; double playtime; public: Cd(char * s1, char * s2, int n, double x); Cd(const Cd & d); Cd(); ~Cd(); void Report() const; Cd & operator=(const Cd & d).
C++ Primer Plus 第十三章答案 类继承
qq_56677326的博客
07-09 205
复习题 //13.10 //1 基类的公有成员成为派生类的公有成员。基类的保护成员成为派生类的保护成员。 基类的私有成员被继承，但不能直接访问。 //2 不能继承构造函数，析构函数，赋值运算符和友元。 //3 返回类型为void则可以使用单个赋值而不能使用连锁赋值。 如果返回对象而不是引用，则该方法的执行速度变慢，因为返回语句需要复制对象。 //4 按派生的顺序调用构造函数，最早的构造函数最先调用，调用析构函数的顺序正好相反。 //5 需要，每个类都需要自己的构造函数，如果派生类没有添加新成员，
C Primer Plus（第六版）第十三章 编程练习答案
weixin_50166464的博客
09-28 410
这章打了两天，也不知道是算久还是不久，当然不是一天写到底，这次感觉打开了程序与其他文件的路口，本来对fopen一知半解，还有关于文件该如何操作，但这章让我了解挺多！--9.28 CH13Code answer 1: #include <stdio.h> #include <stdlib.h> #define SIZE 20 int main(void) { int ch; FILE * fp; unsigned long count = 0; char nam.
c primer plus（第六版） 第十三章答案（vscode编译运行通过）
qq_41701950的博客
07-26 267
10. #include <stdio.h> #include <math.h> #include <stdlib.h> #define SLEN 81 int main(int argc, char **argv) { FILE * fp; long pos = 0; char name[SLEN]; int ch; puts("Please input the file's name: "); scanf("%..
C++ Primer Plus 第6版 中文版课后代码习题答案
03-10
《C++ Primer Plus 第6版 中文版》是一本深入浅出的C++学习书籍，其课后代码习题答案是学习过程中不可或缺的部分。这本书旨在帮助读者从零基础开始掌握C++编程语言，通过实例和习题来巩固理论知识，提升编程技能。...
C++ primer plus 课后习题答案
03-30
《C++ Primer Plus》是一本深受程序员喜爱的C++学习书籍，它深入浅出地介绍了C++编程语言的基础和高级特性。课后习题是学习过程中不可或缺的一部分，它们旨在帮助读者巩固理论知识，提高实际编程技能。这个压缩包...
C++ primer plus课后编程练习题答案
04-22
C++ Primer Plus 课后编程练习题答案 C++ Primer Plus 是一本经典的 C++ 程序设计教材，旨在帮助读者学习 C++ 语言的基础知识和高级编程技术。本书涵盖了 C++ 语言的所有方面，包括基本语法、数据类型、函数、数组...
C++Primer（第4版）-课后习题答案.pdf
11-01
13. 第十三章复制控制：探讨对象的创建、复制和销毁，包括拷贝构造函数、赋值运算符重载以及浅拷贝和深拷贝的问题。 14. 后续章节还会涉及模板、异常处理、命名空间、STL容器的高级用法、智能指针、多态、继承、虚...
C++ Primer Plus 编程练习源码工程 第13章
10-26
C++ Primer Plus 编程练习源码工程 第13章 ，这是本人自己学习书籍时写的编程练习的源码工程，供大家参考交流。
c++ primer plus(第6版)中文版 第十三章编程练习答案
gd275313的专栏
05-26 2116
第十三章编程练习答案 13.1根据Cd基类，完成派生出一个Classic类，并测试 //13.1根据Cd基类，完成派生出一个Classic类，并测试 #include #include using namespace std; // base class class Cd { char performers[50]; char label[20]; int selections;
C++ primer Plus（第六版）第十三章 类继承 章节编程练习答案
是鲤鱼啊
02-03 680
1.以下面的类声明为基础： 派生出一个Classic类，并添加一组char成员，用于存储指出CD中主要作品的字符串。修改上述声明，使基类的所有函数都是虚的。如果上述定义声明的某个方法并不需要，则请删除它。使用下面的程序测试您的产品： 完成如下： 2. ...
C++primer第十三章（第五版）答案
sdlkj1的博客
08-27 1024
C++primer第十三章（第五版）答案 13.1 拷贝构造函数定义了当用同类型的对象初始化本对象的时候做什么。如果构造函数的第一个参数是自身的引用，且所有参数都有默认值，则这个构造函数是一个拷贝构造函数。 拷贝构造函数发生在需要拷贝初始化的时候，拷贝初始化发生的条件如下 使用=定义变量时 将一个对象作为实参传递给一个非引用类型的形参 从一个返回类型为非引用类型的函数返回一个对象 用花括号列表初始化一个数组中的元素或一个聚合类中的成员 13.2 拷贝构造函数的第一个参数必须是一个引用类型 13.3 拷贝S
C++ primer plus 第六版 第十三章 复习题答案
菜鸡harry的博客
08-19 1142
第十三章 复习题答案 1. 基类的公有成员成为派生类的公有成员。基类的保护成员成为派生类的保护成员。基类的私有成员被基础，但不能直接访问。 2. 派生类不能继承构造函数，析构函数，赋值运算符和友元。 3. 若返回类型为void，则只能单个赋值，不能连续赋值。 若返回对象，则速度减慢，因为返回语句需要复制对象。 4. 按派生的顺序调用构造函数，最早的构造函数最先调用。调...
c语言中void plusone,《C Primer Plus》第6版 编程练习答案参考 第十三章(全)
weixin_39683978的博客
05-18 216
《C Primer Plus》第6版 编程练习 第十三章目录(如果无法使用,可以选用右侧的目录选项)教程连接先看这里(很重要！)：函数原型:fopen_() ：fgetc() 和 fputc():rewind() 函数:源码 + 题目 + 运行效果：Pe13-1:Pe13-2:Pe13-3：Pe13-4:Pe13-5:Pe13-6:Pe13-7:Pe13-8：Pe13-9:Pe13-10:Pe...
c++primer（第五版） 第十三章 拷贝控制习题答案
旧时光
03-29 4107
纯原创    转载请注明出处:http://blog.youkuaiyun.com/axuan_k 13.2    13.3   13.4    13.5 #include using namespace std; class Point{ int a; }; Point global; //13.4 Point foo_bar(Point arg) //1
C++Primer_课后习题第十三章
Huangpengyu123的博客
11-29 902
本文答案,部分参考于C++ Primer 习题集 前面章节的习题答案 第一章 第二章 第三章 第四章 第五章 第六章 第七章 第八章 第九章 第十章 第十一章 第十二章 配套的学习资料 https://www.jianguoyun.com/p/DTK5uJgQldv8CBjKv80D 13.1 如果构造函数的第一个参数是自身类类型的引用.且所有其他参数都有默认值.则此构造函数是拷贝构造函数,拷贝构造函数在以下几种情况下会被使用. ​ 拷贝初始化(用=定义变量) ​ 将一个对象作为实参传递给非引用类型的形参
C++ Primer Plus第十三章练习
16的博客
05-24 203
13.11.1 成员数据并无不需要动态内存分配所以不需要拷贝构造与赋值构造 Cd.h #ifndef CD_H #define CD_H #include <iostream> #include <cstring> using namespace std; class Cd { private: char performers[50]; char label[20]; int selections; double playtime; public:
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值