c++primer plus 第12章习题

最新推荐文章于 2023-05-29 17:30:19 发布
最新推荐文章于 2023-05-29 17:30:19 发布
阅读量499 收藏 1
点赞数
分类专栏： C++ 文章标签： c++primer plus 第12章习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chinahnwqf/article/details/51461614
版权 
//第12章第1题
#ifndef STACK_H
#define STACK_H
#define _CRT_SECURE_NO_WARNINGS
class Cow
{
private:
	char name[20];
	char *hobby;
	double weight;
public:
	Cow();
	Cow(const char *nm, const char * ho, double wt);
	Cow(const Cow & c);
	~Cow();
	Cow & operator = (const Cow & c);
	void ShowCow()const;
};
#endif

#include"zhan.h"
#include<iostream>
//第12章第1题
Cow::Cow()
{
	weight = 0;
	name[0]= '\0';
	hobby = NULL;
}
Cow::Cow(const char *nm, const char * ho, double wt)
{
	strcpy_s(name,nm);//这里要用strcpy
	hobby = new char[strlen(ho) + 1];//这里分配
	strcpy(hobby, ho);				//这里赋值
	weight = wt;
}
Cow::Cow(const Cow & c)
{
	strcpy_s(name, c.name);
	hobby = new char[strlen(c.hobby) + 1];
	strcpy(hobby, c.hobby);
	weight = c.weight;
}
Cow::~Cow()
{
	delete[]hobby;//释放  char *
}
Cow & Cow::operator = (const Cow & c)
{
	if (this == &c)
		return *this;
	delete[]hobby;
	hobby = new char[strlen(c.hobby) + 1];
	strcpy(hobby, c.hobby);
	strcpy_s(name, c.name);
	weight = c.weight;
	return *this;
}
void Cow::ShowCow()const
{
	std::cout << "Name:" << name << "\n";
	std::cout << "Hobby:" << hobby << "\n";
	std::cout << "Weight:" << weight << "\n";
}

第12章第1题
#include<iostream>
#include"zhan.h"
#include<cstdlib>
int main()
{

	Cow c1 = { "wqf", "pingpang", 60 };
	c1.ShowCow();
	Cow c2 = { "hhj", "chifan", 50 };
	c2.ShowCow();
	Cow c3= c1;
	c3.ShowCow();
	Cow c4 ;
	c4 = c2;
	c4.ShowCow();

	system("pause");
	return 0;
}


//第12章程序第2题.
#ifndef STRING1_H
#define STRING1_H
#include<iostream>
using std::ostream;
using std::istream;

class String
{
private:
	char *str;
	int len;
	static int num_strings;
	static const int CINLIM = 80;
public:
	String(const char *s);//字符数组构造函数
	String();
	String(const String &s);//copy构造函数
	~String();
	int length()const{ return len; }
	//一般成员函数
	void stringlow();
	void stringup();
	int has(char);
	
	//重载操作符
	String & operator=(const String &s);
	String & operator=(const char *s);//重载=运算符
	String & operator+=(const char *s);//重载=运算符
	char & operator[](int i);
	const char& operator[](int i)const;//只能读const对象的。
	//重载友元函数
	friend String operator+(const String &s1, const String &s2);//必须声明为友元函数，重载运算符不行
	friend bool operator<(const String &st, const String &st2);
	friend bool operator>(const String &st, const String &st2);
	friend bool operator==(const String &st, const String &st2);
	friend ostream& operator<<(ostream &os, const String &st);
	friend istream& operator>>(istream &is,  String &st);//不能const ，不然怎么输入
	//设置静态函数
	static int HowMany();
};
#endif

//第12章程序第2题
#define _CRT_SECURE_NO_WARNINGS
#include"zhan.h"
#include<iostream>
#include<cstring>
#include<string.h>
#include<cctype>
using std::cin;
using std::cout;
using std::string;


int String::num_strings = 0;
String::String(const char *s)//字符数组构造函数
{
	len = std::strlen(s);
	str = new char[len + 1];//不能用小括号
	strcpy(str, s);
	num_strings++;
}
String::String()
{
	len = 4;
	str = new char[1];
	str[0] = '\0';
	num_strings++;

}
String::String(const String &s)//copy构造函数
{
	num_strings++;
	len = s.len;
	str = new char[len + 1];
	std::strcpy(str, s.str);
}
String::~String()
{
	--num_strings;
	delete[]str;
}
void String::stringup()
{
	for (int i = 0; i < len; i++)
	{
		str[i] = toupper(str[i]);
	}
}
void String::stringlow()
{
	for (int i = 0; i < len; i++)
	{
		str[i] = tolower(str[i]);
	}
}
int String::has(char a)
{
	int count=0;
	for (int i = 0; i < len; i++)
	{
		if (str[i] == a)
			++count;
	}
	return count;
}

//重载操作符
String & String::operator=(const String &s)
{
	if (this == &s)//this 指针是地址
		return *this;
	delete[]str;
	len = s.len;
	str = new char[len + 1];//深copy
	std::strcpy(str, s.str);
	return *this;
}
String & String::operator+=(const char *s)//重载=运算符
{
	return *this + s;
}
String & String::operator=(const char *s)//重载=运算符 c风格
{
	delete[]str;
	len = strlen(s);
	str = new char[len + 1];
	std::strcpy(str, s);
	return *this;
}
char & String::operator[](int i)
{
	return str[i];
}
const char& String::operator[](int i)const//只能读const对象的。
{
	return str[i];
}
//重载友元函数
bool operator<(const String &st, const String &st2)
{
	return (std::strcmp(st.str, st2.str)<0);
}
bool operator>(const String &st, const String &st2)
{
	return (std::strcmp(st.str, st2.str)>0);
}
bool operator==(const String &st, const String &st2)
{
	return (std::strcmp(st.str, st2.str) == 0);

}
String  operator+(const String &s1, const String &s2)//必须声明为友元函数，重载运算符不行
{
	String st;
	st.len = s1.len + s2.len;
	st.str = new char[st.len + 1];
	strcpy(st.str, s1.str);
	strcat(st.str, s2.str);
	return st;
}
ostream& operator<<(ostream &os, const String &st)
{
	os << st.str;
	return os;
}
istream& operator>>(istream &is, String &st)
{
	char temp[String::CINLIM];
	is.get(temp, String::CINLIM);
	if (is)
	{
		st = temp;
	}
	while (is&&is.get() != '\n')
	{
		continue;
	}
	return is;
}
//设置静态函数
int String::HowMany()
{
	return num_strings;
} 

//第12章第2题

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

int main()
{
	String s1(" and I am a C++ student.");
	String s2 = "Please enter your name:";
	String s3;
	cout << s2;
	cin >> s3;
	s2 = "My name is " + s3;
	cout << s2 << "\n";
	s2 = s2 + s1;
	s2.stringup();
	cout << "The string\n" << s2 << "\ncontains " << s2.has('A') << " 'A' characters int it.\n";
	s1 = "red";
	String rgb[3] = { String(s1), String("green"), String("blue") };
	cout << "Enter the name of a primay color for mixing light:";
	String ans;
	bool success = false;
	while (cin >> ans)
	{
		ans.stringlow();
		for (int i = 0; i < 3; i++)
		{
			if (ans == rgb[i])
			{
				cout << "That's right!\n";
				success = true;
				break;
			}
		}
		if (success)
			break;
		else
			cout << "Try again!\n";
	}
	cout << "Bye\n";
	system("pause");
	return 0;

}

//第12章第3题
#ifndef STACK_H
#define STACK_H
#define _CRT_SECURE_NO_WARNINGS
class Stock
{
private:
	char *company;
	int shares;
	double share_val;
	double total_val;
	void set_tot(){ total_val = shares*share_val; }
public:
	Stock();
	Stock(const char *str, long n = 0, double pr = 0.0);
	~Stock();
	void buy(long num, double price);
	void shell(long num, double price);
	void update(double price);
	void show()const;
	const Stock & topval(const Stock & s)const;
};


#endif

//第12章第3题
#include"zhan.h"
#include<iostream>
#include<string>
Stock::Stock()
{
	company = new char[strlen("lenovo ")];
	strcpy(company, "lenovo");
	shares = 0;
	share_val = 0.0;
	total_val = 0.0;
}
Stock::Stock(const char *str, long n , double pr)
{
	company = new char[strlen(str)+1];
	strcpy(company, str);
	if (n < 0)
	{
		std::cout << "Number of shares can't be negtive;" << company << "shares set to 0.0\n";
		shares = 0;
	}
	else
		shares = n;
	share_val = pr;
	set_tot();
}
Stock::~Stock()
{

}
void Stock::buy(long num, double price)
{
	if (num < 0)
	{
		std::cout << "Numbers of shares purchased can't be negative." << "Transation is aborted.\n";

	}
	else
	{
		shares += num;
		share_val = price;
		set_tot();
	}
}
void Stock::shell(long num, double price)
{
	using std::cout;
	if (num < 0)
	{
		cout << "Numbers of shares sold can't be negative." << "Transaction is aborted.\n";
	}
	else if (num>shares)
	{
		cout << "You can't sell more than you have1" << "Transaction is aborted.\n";
	}
	else
	{
		shares -= num;
		share_val = price;
		set_tot();
	}
}
void Stock::update(double price)
{
	share_val = price;
	set_tot();
}
void Stock::show()const
{
	using std::cout;
	using std::ios_base;
	ios_base::fmtflags orig = cout.setf(ios_base::fixed, ios_base::floatfield);
	std::streamsize prec = cout.precision(3);
	cout << "Company:" << company << " Shares:" << shares << "\n";
	cout << " Shares price:$" << total_val << "\n";
	cout.setf(orig, ios_base::floatfield);
	cout.precision(prec);
}
const Stock & Stock::topval(const Stock & s)const
{
	if (s.total_val > total_val)
		return s;
	else
		return *this;
}
//第12章第3题
#include"zhan.h"
#include<iostream>
const int STKS = 4;
int main()
{
	Stock stocks[STKS] = { Stock("NanoSmart", 12, 20.0), Stock("Boffo Objects", 200, 2.0),
		Stock("NanoSmart", 130, 3.25), Stock("Fleep Enterprises", 60, 6.5) };
	std::cout << "Stock holdings:\n";
	int st;
	for (st = 0; st < STKS; st++)
		stocks[st].show();
	const Stock * top = &stocks[0];
	for (st = 1; st < STKS; st++)
		top = &top->topval(stocks[st]);
	std::cout << "\n Most valueable holding:\n";
	top->show();
	system("pause");
	return 0;
}



第12章第4题
#ifndef STACK_H
#define STACK_H

typedef unsigned long Item;
class Stack
{
private:
	enum{ MAX = 10 };
	Item *pitems;
	int size;
	int top;
public:
	Stack(int n = MAX)
	{
		pitems = new Item[MAX];//初始化
		size = 0;
		top = 0;
	}
	Stack(const Stack &st)//看清楚是Stack类型
	{
		pitems = new Item[st.size];
		for (int i = 0; i < st.size; i++)
		{
			pitems[i] = st.pitems[i];
			size++;
			top++;
		}
	}
	~Stack()
	{
		delete[]pitems;//必须要在这里删除
	}
	bool isempty()const
	{
		return top == 0;
	}
	bool isfull()const
	{
		return top == MAX;
	}
	bool push(const Item &item)//Item 类型
	{
		if (top < MAX)
		{
			pitems[top++] = item;
			size++;
			return true;
		}
		else
			return false;
	}
	bool pop(Item &item)
	{
		if (top > 0)
		{
			item = pitems[--top];
			--size;
			return true;
		}
		else
			return false;
	}
	Stack &operator=(const Stack &st)
	{
		delete[]pitems;//赋值时先删除旧的
		pitems = new Item[size];
		for (int i = 0; i < st.size; i++)
		{
			pitems[i] = st.pitems[i];
			size++;
			top++;
		}
	}
};

#endif

第12章第4题
#include<iostream>
#include"zhan.h"
#include<cctype>
#include<stdlib.h>
int main()
{
	using namespace std;
	Stack st;
	char ch;
	unsigned long po;
	cout << "Please enter A to add a purchase order,\n"
		<< "P to process a P0,or Q to quit.\n";
	while (cin >> ch&&toupper(ch) != 'Q')
	{
		while (cin.get() != '\n')
			continue;
		if (!isalpha(ch))
		{
			cout << '\a';
			continue;
		}
		switch (ch)
		{
		case'A':
		case'a':cout << "Enter a Po number to add:";
			cin >> po;
			if (st.isfull())
				cout << "stack already full\n";
			else
				st.push(po);
			break;
		case'P':
		case'p':if (st.isempty())
			cout << "stack already empty\n";
				else
				{
					st.pop(po);
					cout << "PO #" << po << " poped\n";
				}
				break;
		}
		cout << "Please enter A to add a purchase order,\n"
			<< "P to process a P0,or Q to quit.\n";
	}
	cout << "Bye!";
	system("pause");
	return 0;
}


//第12章第5题
#ifndef QUEUE_H_
#define QUEUE_H_
class Customer
{
private:
	long arrive;	//到达时间
	int processtime;//处理时间
public:
	Customer()
	{
		arrive = processtime = 0;
	}
	void set(long when);
	long when()const
	{
		return arrive;
	}
	int ptime()
	{
		return processtime;
	}
};
typedef Customer Item;

class Queue
{
private:
	struct Node{ Item item; struct Node *next; };//包含数据,和一个指向下个数据块的指针
	enum {Q_SIZE=10};
	Node *front;//第一个
	Node *rear;//最后一个
	int items; //总序列号
	const int qsize;//最大序列号
	Queue(const Queue & q) :qsize(0){}//这两个是私有的，暂时不用，
	Queue &operator=(const Queue &q)//包括copy构造函数和赋值运算符
	{
		return *this;
	}
public:
	Queue(int qs = Q_SIZE);//构造函数
	~Queue();
	bool isempty()const;   //是否为空
	bool isfull()const;    //是否为满
	int queuecount()const; //计数
	bool enqueue(const Item &item);//增加
	bool dequeue(Item &item);
};
#endif


//第12章第5题.
#include"zhan.h"
#include<cstdlib>


void Customer::set(long when)
{
	processtime = std::rand() % 3 + 1;
	arrive = when;
}

Queue::Queue(int qs):qsize(qs)//构造函数,这种方式让常量qsize可以在实现的时候赋值
{
	front = rear = NULL;
	items = 0;
}
Queue::~Queue()
{
	Node * temp;
	while (front != NULL)
	{
		temp = front;//先保存
		front = front->next;//后讲第二个设置为第一个
		delete temp;//把第一个删除
	}
}
bool Queue::isempty()const  //是否为空
{
	return items == 0;
}
bool Queue::isfull()const    //是否为满
{
	return items == qsize;
}
int Queue::queuecount()const //计数
{
	return items;
}
bool Queue::enqueue(const Item &item)//增加
{
	if (isfull())
		return false;//先判断是否满
	Node *add = new Node;//创建新结点
	add->item = item;//加顾客
	add->next = NULL;
	items++;
	if (front == NULL)
		front = add;
	else
		rear->next = add;//把尾地址给add连在一起
	rear = add;//将add变为尾部
	return true;
}
bool Queue::dequeue(Item &item)
{
	if (front == NULL)
		return false;
	item = front->item;
	items--;
	Node *temp = front;
	front = front->next;
	delete temp;
	if (items == 0)
		rear = NULL;
	return true;
}

//第12章第5题
#include<iostream>
#include"zhan.h"
#include<cstdlib>
#include<ctime>

const int Min_Per_Hr = 60;

bool newcustomer(double x);

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

	std::srand(std::time(0));//设置时间种子
	cout << "Case Study: Bank of Heather Automatic Teller\n";
	cout << "Enter maximum size of queue:";
	int qs;
	cin >> qs;
	Queue line(qs);//设置最大序列长度

	cout << "Enter the number of simulation hours: ";
	int hours;
	cin >> hours;
	long cyclelimit = Min_Per_Hr*hours;//分钟数

	cout << "Enter the average number of customers per hous: ";
	double perhour;
	cin >> perhour;
	double min_per_cust = Min_Per_Hr;//平均多少分钟来一个人

	Item temp;
	long turnaways = 0;//掉头走的
	long customers = 0;//加入排队
	long served = 0;// 服务的
	long sum_line = 0;//总长度
	int wait_time = 0;//等待时间
	long line_wait = 0;// 排队的等待时间

	for (int cycle = 0; cycle < cyclelimit; cycle++)//循环一次，代表一分钟
	{
		if (newcustomer(min_per_cust))//来了新人
		{
			if (line.isfull())
				turnaways++;//拒绝服务
			else
			{
				customers++;
				temp.set(cycle);
				line.enqueue(temp);
			}
		}
		if (wait_time <= 0 && !line.isempty())//第一个顾客走了
		{
			line.dequeue(temp);
			wait_time = temp.ptime();//该用户处理业务时间
			line_wait += cycle - temp.when();//所有客户的等待时间
			served++;
		}
		if (wait_time > 0)
			wait_time--;//处理业务时间-1，因为过了一分钟
		sum_line += line.queuecount();//每分钟计算一次队伍长度
	}
	if (customers > 0)
	{
		cout << "customers accepted :" << customers << endl;
		cout << "  customers served :" << served << endl;
		cout << "          turnaways:" << turnaways << endl;
		cout << "average queue size :";
		cout.precision(2);
		cout.setf(ios_base::fixed, ios_base::floatfield);
		cout << (double)sum_line / cyclelimit << endl;
		cout << " average wait time:" << (double)line_wait / served << " minutes\n";
	}
	else
		cout << "No customers!\n";
	cout << "Done!\n";
	system("pause");
	return 0;
}

bool newcustomer(double x)
{
	return (std::rand()*x / RAND_MAX < 1);
}

第六题，第七题课本上有吧

chinawqf
关注
专栏目录
C++ Primer Plus 第6版 中文版课后代码习题答案
03-10
《C++ Primer Plus 第6版 中文版》是一本深入浅出的C++学习书籍，其课后代码习题答案是学习过程中不可或缺的部分。这本书旨在帮助读者从零基础开始掌握C++编程语言，通过实例和习题来巩固理论知识，提升编程技能。...
《C Primer Plus》第12章复习题与编程练习
ProgramNovice的博客
11-09 838
《C Primer Plus》第12章复习题与编程练习
C Primer Plus第十二章编程练习答案
最新发布
sakura0908的博客
05-29 1015
学完C语言之后，我就去阅读《C Primer Plus》这本经典的C语言书籍，对每一章的编程练习题都做了相关的解答，仅仅代表着我个人的解答思路，如有错误，请各位大佬帮忙点出！
C++ Primer Plus第十二章练习
16的博客
05-21 136
12.10.1 Cow.cpp #include "Cow.h" Cow::Cow(void) { strcpy(name, "xswl"); hobby = new char[1]; hobby[0] = '\0'; weight = 0; } Cow::Cow(const char * nm, const char * ho, double wt) : weight(wt) { strcpy(name, nm); hobby = new char[strl
C Primer Plus(第6版)第十二章复习题答案
weixin_42912350的博客
10-13 882
12.8复习题 哪些类别的变量可以成为它所在函数的局部变量？ 答：（我的答案）具有块作用域的变量，还有函数头中的形式参数。 （标准答案）自动存储类别；寄存器存储类别；静态、无链接存储类别 哪些类别的变量可以在它所在的程序的运行期一直存在？ 答：（我的答案）具有静态存储期的变量。 （标准答案）静态、无链接存储类别；静态、内部链接存储类别；静态、外部链接存储类别。 哪些类别的变量可以被多个文件使用？...
C++ Primer Plus 第十二章习题答案+收获
GodFishhh的博客
08-29 1147
C++ Primer Plus 第十二章习题收获(欢迎指正) -- 头文件cstring中函数的使用，头文件cctype中函数的使用，重载赋值运算符时返回值的两种选择
C++Primer Plus附录源码等文件.zip
12-27
C++ Primer Plus第六版的课后题练习题是学习过程中不可或缺的一部分。通过解决这些题目，读者可以巩固所学知识，提高编程技能，包括变量、运算符、控制流、函数、数组、指针、类、对象、继承、多态性、模板等核心...
C++ primer plus 课后习题答案
03-30
《C++ Primer Plus》是一本深受程序员喜爱的C++学习书籍，它深入浅出地介绍了C++编程语言的基础和高级特性。课后习题是学习过程中不可或缺的一部分，它们旨在帮助读者巩固理论知识，提高实际编程技能。这个压缩包...
c++primer plus第七章到第十三章习题源码
03-12
6. **继承（Inheritance）**：第十二章介绍了类之间的继承关系，子类可以继承父类的属性和行为。在源码中，`class Derived : access-specifier Base`这样的语句表示继承。 7. **多态（Polymorphism）**：多态允许...
C++ primer plus课后编程练习题答案
04-22
第十六章和第十七章讲解了高级主题，包括模板、异常处理、输入/输出流等，提供了相关的编程练习题和答案，帮助读者掌握 C++ 语言的高级使用技巧。 本书的每一章都提供了详细的理论讲解、实践编程练习和复习题，旨在...
【C++ Primer Plus】第12章 类和动态内存分配
chaiky的博客
09-18 1321
对类成员使用动态内存分配。 隐式和显式复制构造函数。 隐式和显式重载赋值运算符。 在构造函数中使用new所必须完成的工作。 使用静态类成员。 将定位new运算符用于对象。 使用指向对象的指针。 实现队列抽象数据类型（ADT）。
C++ primer第6版 12章课后题
xiaomimi1993的博客
08-13 477
12.1 对于下面的类声明： class Cow{ char name[20]; char* hobby; double weight; public: Cow(); Cow(const char* nm, const char* ho, double wt); Cow(const Cow &amp;amp;amp;amp;c); ~Cow(); Co...
复制构造函数和赋值操作符--深拷贝，浅拷贝
bug07250432的专栏
08-27 735
首先，大家要知道，C＋＋类有以下这些极为重要的函数： 一：复制构造函数。 二：赋值函数。 我们先来讲复制构造函数。什么是复制构造函数呢？比如，我们可以写下这样的代码：String test1(test2);这是进行初始化。我们知道，初始化对象要用构造函数。可这儿呢？按理说，应该有声明为这样的构造函数：String(const String &);可是，我们并没有定义这个构造函数呀
C++_primer_plus学习笔记 第12章 类和动态内存分配
Flying_Dutchman_的博客
07-11 492
对类成员使用动态内存分配 隐式和显式复制构造函数 隐式和显式重载赋值运算符 在构造函数中使用new所必须完成的工作 使用静态类成员 将定位new运算符用于对象 使用指向对象的指针 实现队列抽象数据类型......
C++:‘std::ostream& String::operator<<(std::ostream&, const String&)’ must take exactly one argument
热门推荐
linwh8的博客
04-08 1万+
C++:‘std::ostream& String::operator<<(std::ostream&, const String&)’ must take exactly one argument标签： C++编译错误by 小威威以下是我编译某些源文件是出现的问题：错误信息如下：‘std::ostream& String::operator<<(std::ostream&, const Strin
C++ primer plus 第六版 第十二章 编程练习答案
菜鸡harry的博客
08-14 3627
第十二章 编程练习答案 1. //头文件 #ifndef COW_H_ #define COW_H_ class Cow{ private: char name[20]; char * hobby; double weight; public: Cow(); Cow(const char * nm, const char * ho, double wt...
C++ Primer Plus（第六版）编程练习答案 第12章 类和动态内存分配
清水河C罗——Leonardo-Liu
09-28 4409
本章所有编程练习的工程源码可在此处下载（点击此链接下载），供大家参考交流！   1. 对于下面的类声明： class Cow {          char name[20];          char *hobby;          double weight; public:          Cow();          Cow(const char * nm, co...
C++ Primer Plus 第六版第十二章编程练习答案
biubiu_buaa的博客
03-21 686
//question1 //Cow.h #ifndef COW_H #define COW_H class Cow { char name[20]; char * hobby; double weight; public: Cow(); Cow(const char * nm, const char...
C++ Primer plus 第十二章
YL950305的博客
11-17 344
文章目录12.1 2 3代码结果知识点12.4 5 6代码结果知识点12.1代码结果知识点12.1代码结果知识点总结 12.1 2 3 代码 //strngbad.h #include <iostream> #ifndef STRNGBAD_H_ #define STRNGBAD_H_ class StringBad { private: //指针定义的字符串没有分配内存， //数组定义的字符串分配了内存 char * str; int len; //无论创造多少个对象，程序只创
C++ Primer Plus 第五版习题解析
"C++ Primer Plus(第五版)是一本广泛使用的C++学习教材，它提供了丰富的习题来帮助读者巩固所学知识。这个资源包含了该书第二章和第三章的部分习题解答，包括程序代码和相关的函数实现。" 在C++ Primer Plus的第五...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值