C++ primer 第十三章课后练习

最新推荐文章于 2024-06-22 21:53:36 发布
最新推荐文章于 2024-06-22 21:53:36 发布
阅读量288 收藏
点赞数
分类专栏： C++ 文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44918105/article/details/126593029
版权

在这里插入图片描述
在这里插入图片描述

#ifndef CD_H_
#define CD_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& d);
	Cd();
	~Cd();
	virtual void Report()const;
	Cd& operator=(const Cd& d);
};
class Classic:public Cd
{
private:
	char  main_productor[20];
public:
	Classic(const char* s1,const char* s2, const char* s3, int n, double x);
	Classic(const char*s3,const Cd& d);
	Classic();
	 ~Classic();
	virtual void Report()const;
	 Classic& operator=(const Classic& d);

};
#endif // !13_1_H_

#include"13_1.h"
#include<iostream>
#include<cstring>
using namespace std;
Cd::Cd(const char* s1,const char* s2, int n, double x)
{
	strncpy_s(performers, s1, 50);
	performers[49] = '\0';
	strncpy_s(label, s2, 20);
	label[19] = '\0';
	selections = n;
	playtime = x;

}
Cd::Cd(const Cd& d)
{
	strncpy_s(performers, d.performers, 50);
	performers[49] = '\0';
	strncpy_s(label, d.label, 20);
	label[19] = '\0';
	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
{
	 cout << "Performers:" << performers<<endl;
	 cout << "Label:" << label<<endl;
	 cout << "Selections:" << selections << endl;
	 cout << "Playtime:" << playtime << endl;
}
 Cd& Cd::operator=(const Cd& d)
 {
	 if (this == &d)
		 return *this;
	 strncpy_s(performers, d.performers, 50);
	 performers[49] = '\0';
	 strncpy_s(label, d.label, 20);
	 label[19] = '\0';
	 selections = d.selections;
	 playtime = d.playtime;
	 return *this;

 }
 Classic::Classic(const char* s1, const char* s2, const char* s3, int n, double x) :Cd(s1, s2, n, x)
 {
	 strncpy_s(main_productor, s3, 20);
	 main_productor[19] = '\0';
 }
 Classic::Classic(const char*s3,const Cd& d) : Cd(d)
 {
	 strncpy_s(main_productor, s3, 20);
	 main_productor[19] = '\0';
 }
 Classic::Classic() : Cd()
 {
	 main_productor[0] = '\0';
 }
 Classic::~Classic() {}
 void Classic::Report()const
 {
	 Cd::Report();
	 cout << "Main_productor:" << main_productor << endl;
 }
 Classic& Classic::operator=(const Classic& d)
 {
	 if (this == &d)
		 return *this;
	 Cd::operator=(d);
	 strncpy_s(main_productor, d.main_productor, 20);
	 main_productor[19] = '\0';
	 return *this;
	 
 }


#include<iostream>
using namespace std;
#include"13_1.h"
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", "Aflred 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 funcion 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();
}

在这里插入图片描述

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

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 << "Using type cd * pointer to objects:\n";
    pcd->Report();
    pcd = &c2;
    pcd->Report();

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

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

    return 0;
}

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


#ifndef CD_H_
#define CD_H_

class Cd //原有的数组修改为指针便于动态分配内存;
{
private:
    char *performers;
    char *labels;
    int selections;
    double playtime;

public:
    Cd(const char *s1, const char *s2, int n, double x);
    Cd(const Cd &d);
    Cd();
    virtual ~Cd(); //虚析构函数;
    virtual void Report() const;
    Cd &operator=(const Cd &d);
};

#endif


#include <iostream>
#include "cd.h"
#include <cstring>

Cd::Cd(const char *s1, const char *s2, int n, double x) //用户定义构造函数;
{
    performers = new char[std::strlen(s1) + 1];
    std::strcpy(performers, s1);
    labels = new char[std::strlen(s2) + 1];
    std::strcpy(labels, s2);
    selections = n;
    playtime = x;
}

Cd::Cd(const Cd &d) //用户定义构造函数;
{
    performers = new char[std::strlen(d.performers) + 1];
    std::strcpy(performers, d.performers);
    labels = new char[std::strlen(d.labels) + 1];
    std::strcpy(labels, d.labels);
    selections = d.selections;
    playtime = d.playtime;
}

Cd::Cd() //用户定义默认构造函数;
{
    performers = new char[1];
    performers[0] = '\0';
    labels = new char[1];
    labels[0] = '\0';
    selections = 0;
    playtime = 0.0;
}

Cd::~Cd()
{
    delete[] performers;
    delete[] labels;
}

void Cd::Report() const
{
    std::cout << "Performers: " << performers << std::endl;
    std::cout << "Label: " << labels << std::endl;
    std::cout << "Selections: " << selections << std::endl;
    std::cout << "Playtime: " << playtime << std::endl;
    return;
}

Cd &Cd::operator=(const Cd &d) //重载赋值运算符;
{
    if (this == &d)
    {
        return *this;
    }
    delete[] performers; //释放原有已分配的内存空间;
    delete[] labels;     //同上;
    performers = new char[std::strlen(d.performers) + 1];
    std::strcpy(performers, d.performers);
    labels = new char[std::strlen(d.labels) + 1];
    std::strcpy(labels, d.labels);
    selections = d.selections;
    playtime = d.playtime;
    return *this;
}


#ifndef CLASSIC_H_
#define CLASSIC_H_
#include "cd.h"

class Classic : public Cd //公有继承派生类;
{
private:
    char *cdstr;

public:
    Classic();
    Classic(const char *s1, const char *s2, const char *s3, int n, double x);
    Classic(const char *s, const Cd &d);
    ~Classic();
    virtual void Report() const;
    Classic &operator=(const Classic &cs);
};

#endif


#include <iostream>
#include <cstring>
#include "classic.h"

Classic::Classic() : Cd()
{
    cdstr = new char[1];
    cdstr[0] = '\0';
}

Classic::Classic(const char *s, const char *s1, const char *s2, int n, double x) : Cd(s1, s2, n, x) //基类构造函数的成员列表初始化;
{
    cdstr = new char[std::strlen(s) + 1];
    std::strcpy(cdstr, s);
}

Classic::Classic(const char *s, const Cd &d) : Cd(d) //基类构造函数的成员列表初始化;
{
    cdstr = new char[std::strlen(s) + 1];
    std::strcpy(cdstr, s);
}

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

void Classic::Report() const
{
    Cd::Report();
    std::cout << "Major article in the CD is: " << cdstr << std::endl;
    std::cout.put('\n');
    return;
}

Classic &Classic::operator=(const Classic &cs)
{
    if (this == &cs)
    {
        return *this;
    }
    delete[] cdstr;
    Cd::operator=(cs);
    cdstr = new char[std::strlen(cs.cdstr) + 1];
    std::strcpy(cdstr, cs.cdstr);
    return *this;
}

在这里插入图片描述
在这里插入图片描述

//
//  Test.h
//  HelloWorld
//
//  Created by feiyin001 on 16/12/21.
//  Copyright (c) 2016年 FableGame. All rights reserved.
//
 
#ifndef _Test_H_
#define _Test_H_
#include <iostream>
using namespace std;
namespace FableGame
{
	
	class ABC
	{
	private:
		char* label;
		int rating;
	public:
		ABC(const char* l = "null", int r = 0);
		ABC(const ABC& rs);
		virtual ~ABC();
		ABC& operator=(const ABC& rs);
		friend std::ostream& operator<<(std::ostream& os, const ABC& rs);
		virtual void view() = 0;
		char* getLabel(){ return label; }
		int getRating(){ return rating; }
	};
 
	class baseDMA :public ABC
	{
	public:
		baseDMA(const char* l = "null", int r = 0);
		baseDMA(const baseDMA& rs);
		virtual void view();
	};
	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 ABC& ls);
		friend std::ostream& operator<<(std::ostream& os, const lacksDMA& ls);
		virtual void view();
	};
 
	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 ABC& hs);
		hasDMA(const hasDMA& hs);
		~hasDMA();
		hasDMA& operator=(const hasDMA& hs);
		friend std::ostream& operator<<(std::ostream& os, const hasDMA& hs);
		virtual void view();
	};
}
#endif

//
//  Test.cpp
//  HelloWorld
//
//  Created by feiyin001 on 16/12/21.
//  Copyright (c) 2016年 FableGame. All rights reserved.
//
 
#include "Test.h"
#include <iostream>
#include <cstdlib>
using namespace std;
using namespace FableGame;
 
 
FableGame::ABC::ABC(const char* l /*= "null"*/, int r /*= 0*/)
{
	int size = strlen(l) + 1;
	label = new char[size];
	strcpy_s(label, size, l );
	rating = r;
}
 
FableGame::ABC::ABC(const ABC& rs)
{
	int size = strlen(rs.label) + 1;
	label = new char[size];
	strcpy_s(label, size, rs.label);
	rating = rs.rating;
}
 
FableGame::ABC::~ABC()
{
	delete[] label;
}
 
ABC& FableGame::ABC::operator=(const ABC& rs)
{
	if (this == &rs)
	{
		return *this;
	}
	delete[] label;
	int size = strlen(rs.label) + 1;
	label = new char[size];
	strcpy_s(label, size, rs.label );
	rating = rs.rating;
	return *this;
}
 
void FableGame::ABC::view()
{
	cout << "Label: " << getLabel() << endl;
	cout << "Rating: " << getRating() << endl;
}
 
std::ostream& FableGame::operator<<(std::ostream& os, const ABC& rs)
{
	os << "Label: " << rs.label << endl;
	os << "Rating: " << rs.rating << endl;
	return os;
}
 
FableGame::lacksDMA::lacksDMA(const char* c, const char* l, int r) : ABC(l, r)
{
	strncpy_s(color, c, 39);
	color[39] = '\0';
}
 
FableGame::lacksDMA::lacksDMA(const char* c, const ABC& rs) :ABC(rs)
{
	strncpy_s(color, c, COL_LEN - 1);
	color[COL_LEN - 1] = '\0';
}
 
void FableGame::lacksDMA::view()
{
	ABC::view();
	cout << "Color: " << color << endl;
}
 
std::ostream& FableGame::operator<<(std::ostream& os, const lacksDMA& ls)
{
	os << (const ABC&)ls;
	os << "Color: " << ls.color << endl;
	return os;
}
 
FableGame::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);
}
 
FableGame::hasDMA::hasDMA(const char* s, const ABC& rs) :ABC(rs)
{
	style = new char[strlen(s) + 1];
	strcpy_s(style, strlen(s) + 1, s);
}
 
FableGame::hasDMA::hasDMA(const hasDMA& hs) :ABC(hs)
{
	style = new char[strlen(hs.style) + 1];
	strcpy_s(style, strlen(hs.style) + 1, hs.style);
}
 
FableGame::hasDMA::~hasDMA()
{
	delete[] style;
}
 
hasDMA& FableGame::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 FableGame::hasDMA::view()
{
	ABC::view();
	cout << "Style: " << style << endl;
}
 
std::ostream& FableGame::operator<<(std::ostream& os, const hasDMA& hs)
{
	os << (const ABC&)hs;
	os << "Style: " << hs.style << endl;
	return os;
}
 
FableGame::baseDMA::baseDMA(const char* l /*= "null"*/, int r /*= 0*/) :ABC(l, r)
{
 
}
 
FableGame::baseDMA::baseDMA(const baseDMA& rs) : ABC(rs)
{
 
}
 
void FableGame::baseDMA::view()
{
	ABC::view();
}

#include <iostream>     
#include "Test.h"
#include <string>
using namespace std;
using namespace FableGame;
const int ARR_SIZE = 3;
int main(int argc, const char * argv[])
{
	ABC* p_ABC[ARR_SIZE];
	char temp[40];
	int tempnum;
	int kind;
	for (int i = 0; i < ARR_SIZE; i ++)
	{
		cout << "Enter label: ";
		cin.getline( temp, 40);
		cout << "Enter Rating: ";
		cin >> tempnum;
		
		cout << "Enter 1 for baseDMA or 2 for lacksDMA or 3 for hasDMA: ";
		while (cin >> kind && (kind != 1 && kind != 2 && kind != 3))
		{
			cout << "Enter either 1 or 2 or 3: ";
		}
		cin.get();
		if (kind == 1)
		{
			p_ABC[i] = new baseDMA(temp, tempnum);
		}
		else if (kind == 2)
		{
			char color[40];
			cout << "Enter the color: ";
			cin.getline(color, 40);
			p_ABC[i] = new lacksDMA(color, temp, tempnum);
		}
		else if (kind == 3)
		{
			char style[40];
			cout << "Enter the style: ";
			cin.getline(style, 40);
			p_ABC[i] = new hasDMA(style, temp, tempnum);
		} 
	}
	cout << endl;
	for (int i = 0; i < ARR_SIZE; i ++)
	{
		p_ABC[i]->view();
		cout << endl;
	}
	for (int i = 0; i < ARR_SIZE; i ++)
	{
		delete p_ABC[i];
	}
	cout << "Done." <<endl;
	return 0;
}

在这里插入图片描述

//
//  Test.h
//  HelloWorld
//
//  Created by feiyin001 on 16/12/21.
//  Copyright (c) 2016年 FableGame. All rights reserved.
//
 
#ifndef _Test_H_
#define _Test_H_
#include <iostream>
using namespace std;
namespace FableGame
{
	
	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, int b, const char* nn, int y);
		VintagePort(const VintagePort& vp);
		~VintagePort(){ delete[] nickname; }
		VintagePort& operator=(const VintagePort& vp);
		void show()const;
		friend ostream& operator<<(ostream& os, const VintagePort& vp);
	};
}
#endif

//
//  Test.cpp
//  HelloWorld
//
//  Created by feiyin001 on 16/12/21.
//  Copyright (c) 2016年 FableGame. All rights reserved.
//
 
#include "Test.h"
#include <iostream>
#include <cstdlib>
using namespace std;
using namespace FableGame;
 
 
FableGame::Port::Port(const char* br /*= "none"*/, const char* st /*= "none"*/, int b /*= 0*/)
{
	brand = new char[strlen(br) + 1];
	strcpy_s(brand, strlen(br) + 1, br);
	strcpy_s(style, 20, st);
	bottles = b;
}
 
FableGame::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& FableGame::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, 20, p.style);
	bottles = p.bottles;
	return *this;
}
 
Port& FableGame::Port::operator+=(int b)
{
	bottles += b;
	return *this;
}
Port& FableGame::Port::operator-=(int b)
{
	bottles -= b;
	return *this;
}
 
void FableGame::Port::Show() const
{
	cout << "Brand: " << brand << endl;
	cout << "Kind : " << style << endl;
	cout << "Bottles : " << bottles << endl;
}
 
ostream& FableGame::operator<<(ostream& os, const Port& p)
{
	os << p.brand << ", " << p.style << ", " << p.bottles;
	return os;
}
 
FableGame::VintagePort::VintagePort() :Port()
{
 
}
 
FableGame::VintagePort::VintagePort(const char* br, int b, const char* nn, int y) : Port(br, "", b)
{
	nickname = new char[strlen(nn) + 1];
	strcpy_s(nickname, strlen(nn) + 1, nn);
	year = y;
}
 
FableGame::VintagePort::VintagePort(const VintagePort& vp) :Port(vp)
{
	nickname = new char[strlen(vp.nickname) + 1];
	strcpy_s(nickname, strlen(vp.nickname) + 1, vp.nickname);
	year = vp.year;
}
 
VintagePort& FableGame::VintagePort::operator=(const VintagePort& vp)
{
	if (this == &vp)
	{
		return *this;
	}
	Port::operator=(vp);
	delete[] nickname;
	nickname = new char[strlen(vp.nickname) + 1];
	strcpy_s(nickname, strlen(vp.nickname) + 1, vp.nickname);
	year = vp.year;
	return *this;
}
 
void FableGame::VintagePort::show() const
{
	Port::Show();
	cout << "nickname: " << nickname << endl;
	cout << "year: " << year << endl;
}
 
ostream& FableGame::operator<<(ostream& os, const VintagePort& vp)
{
	os << (const Port&)vp;
	os << ", " << vp.nickname << ", " << vp.year;
	return os;
}
JoengGaap
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++Primer第五版——习题答案+详解(完整版)
MISAYAONE的博客
12-21 33万+
C++Primer第五版——习题答案详解 看的也比较快，但是有很多东西确实用不上，所以很多都没有深入的探讨，但是知识点覆盖的很全面，每一道题涉及的知识点我都写上简单的解释了。 文中代码的中文注释也尽量都写上，自己皆编译通过。 水平有限，如有有误之处，希望大家不吝指教！ 下面的链接是 第一章：全部题目(第一章基础较多)http:/
C++Primer_课后习题第十三章
Huangpengyu123的博客
11-29 746
本文答案,部分参考于C++ Primer 习题集 前面章节的习题答案 第一章 第二章 第三章 第四章 第五章 第六章 第七章 第八章 第九章 第十章 第十一章 第十二章 配套的学习资料 https://www.jianguoyun.com/p/DTK5uJgQldv8CBjKv80D 13.1 如果构造函数的第一个参数是自身类类型的引用.且所有其他参数都有默认值.则此构造函数是拷贝构造函数,拷贝构造函数在以下几种情况下会被使用. ​ 拷贝初始化(用=定义变量) ​ 将一个对象作为实参传递给非引用类型的形参
c++ primer 第十三章习题
无所知的博客
09-26 1263
练习13.1 拷贝构造函数是参数为同类对象引用其它参数都有默认值的构造函数。使用其它对象初始化新对象时使用。 练习13.2 应该使用引用参数，否则会陷入循环调用。 练习13.3 拷贝其中的资源与值   拷贝其中的指针对象 练习13.4 书上 练习13.5  HasPtr(HasPtr&amp; hp) { ps = new string(*hp.ps); i = hp.i;...
C++Primer第13章：拷贝控制（习题解答）
qq_50271250的博客
12-21 785
13.1.1节练习 13.1：构造拷贝函数是什么？什么时候使用它？ 答:如果构造函数的第一个参数是自身类型的引用，且所有其他参数（如果有的话）都有默认值，则此构造函数是拷贝构造函数。拷贝构造函数在以下几种情况下会被使用 1.拷贝初始化（用=定义变量） 2.将一个对象作为实参传递给非引用类型的实参 3.一个返回类型为非引用类型的函数返回一个对象 4.用花括号列表初始化一个数组中的元素或者一个聚合类中的成员 5.初始化标准库容器或调用其insert/push操作时，容器会对其元素进行初始化 13.2：解释下为什
C++Primer(第五版 ）第十三章 拷贝控制 章节编程练习
qq_44741516的博客
03-27 1018
练习13.1 拷贝构造函数是什么？什么 时候使用它？ 拷贝构造函数第一个参数是一个类类型的引用，其他的参数都有默认值。 当拷贝初始化发生时，该拷贝初始化需要拷贝构造函数或移动构造函数。 拷贝初始化当使用=时会发生。 将一个对象作为实参 ...
C++ primer 第八章课后练习题
weixin_44918105的博客
07-27 238
代码】C++primer第八章课后练习题。
《c++ primer》 第10章 课后练习（一）
qq_44741516的博客
03-11 332
练习 10.1 头文件algorthm中定义了一个名为count的函数，它类似于find，接受一对迭代器和一个值作为参数。count返回定值出现的次数。编写程序，读取int序列存入vector中，打印有多少个元素值等于定值。 vector<int> ivec; int i ; while(cin >> i) ivec.push_back(i); int n1 = count(ivec.begin(),ivec.end(),1
C++Primer第五版 习题答案 目录
热门推荐
shamozhizhoutx的博客
07-29 5万+
C++Primer第五版 习题答案 本文当作我学习C++的一个记录，这里的习题答案并不是标准答案，仅仅是我的理解，如有错误，请大家指出，谢谢！ 我参考的文章会在文末列出，谢谢大家。 第一章 ...
【c++ primer】第五版第十七章习题答案
qq_51931826的博客
09-26 739
【c++ primer】第五版第十七章习题答案
C++Primer（第4版）-课后习题答案.pdf
11-01
13. 第十三章复制控制：探讨对象的创建、复制和销毁，包括拷贝构造函数、赋值运算符重载以及浅拷贝和深拷贝的问题。 14. 后续章节还会涉及模板、异常处理、命名空间、STL容器的高级用法、智能指针、多态、继承、虚...
c++primer第五版习题答案（第13章）
11-12
c++primer第五版中文版课后答案（第13章）pdf格式，真正的c++primer习题集（第五版），用手机拍的，但是每个字都能看的很清楚
C++ Primer 第四版课后习题答案
07-25
第十三章 复制控制：讲解构造函数、析构函数、拷贝构造函数和赋值运算符，以及深拷贝和浅拷贝的概念。 这些章节的习题旨在帮助读者掌握每个主题的关键概念，通过实际操作加深理解和应用。解答习题是提升技能和解决...
C++primer plus（1~13章）课后编程练习答案
12-27
我本人学习《C++ primer plus第六版》的时候所做的1~13章节的课后编程练习答案，当时的编译环境是vs2013，绝对可以通过，供大家参考.网上这本书的课后答案真的好少啊，好在我也慢慢学过来了。
C++primer 课后题答案
10-13
C++primer 课后题答案 ...第十三章 复制控制 94 第十四章 重载操作符与转换 102 第十五章 面向对象编程 116 第十六章 部分选做习题 133 第十七章　用于大型程序的工具 138 第十八章　特殊工具与技术 138
C的I/O操作
weidl001的博客
06-17 740
输入输出（I/O）操作在C语言编程中占据重要地位，包括文件与目录操作、字符流与字节流处理，以及序列化与反序列化。通过深入理解和掌握这些I/O操作，程序员可以实现与外部环境的高效数据交互，为各种应用场景提供稳定可靠的解决方案。无论是文本文件的读写、二进制数据的处理，还是复杂数据结构的序列化和反序列化，这些I/O操作的掌握都对编写高效、健壮的C程序至关重要。
LeetCode 算法：排序链表 c++
最新发布
小金牛来了
06-22 553
LeetCode 算法：排序链表 c++
线程简介及其函数使用实例（gcc *.c -lpthread）
CSDN_DU666666的博客
06-20 372
线程概念、线程接口提供方式、线程创建使用到的函数、多线程创建实例 、多线程创建实例 、多线程执行顺序问题和多线程占用内存问题
STL中vector、list、map和set的主要区别
2402_84885073的博客
06-16 346
在C++的STL（Standard Template Library）中，是四种常用的容器，它们各自具有不同的特性和用途。
c++ primer第五版课后习题
07-08
C++ Primer第五版是一本非常经典的C++编程入门教材，它包含了大量的课后习题帮助读者巩固所学的知识。这些习题涵盖了从基础到高级的各个方面，可以帮助读者提升编程能力。 如果你有具体的习题需要帮助或者想要了解一些习题的解答思路，我会尽力帮助你。请告诉我你感兴趣的具体习题或者需要解答思路的章节，我会尽量提供帮助！

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值