C++Primer 第十五章 面向对象程序设计 习题答案

于 2023-03-10 20:48:58 发布
阅读量226 收藏
点赞数
分类专栏： C++Primer第五版 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BadWomannnn/article/details/129420790
版权

15.1

对于某些函数，基类希望它的派生类各自定义适合自身的版本，此时基类就将这些函数声明为虚函数。

15.2

派生类可以访问基类的保护成员，但是不能访问基类的私有成员。同时二者都禁止其他对象访问。

15.3

.h

#pragma once
#include<string>
class Quote
{
public:
	Quote() = default;
	Quote(const std::string &book, double sales_price) :
		bookNo(book), price(sales_price) {}
	std::string isbn()const { return bookNo; }
	virtual double net_price(std::size_t n)const //返回书籍的实际销售价格
	{return n * price;}
	virtual ~Quote() = default;
private:
	std::string bookNo;//书籍的ISBN编号
protected:
	double price = 0.0; //普通状态下不打折的价格
};
class Bulk_quote:public Quote
{
public:
	double net_price(std::size_t)const override;
};

.cpp

#include"Quote.h"
double print_total(std::ostream &os, const Quote &item, size_t n)
{
	double ret = item.net_price(n);
	os << "ISBN:"<<item.isbn() << " #sold:" << n << "total due:" << ret << std::endl;
	return ret;
}

15.4

(a)错误，一个类不能派生它本身
(b)正确
©错误，声明不用写出它的派生列表

15.5

#pragma once
#include"Quote.h"
class Bulk_quote :public Quote
{
public:
	Bulk_quote() = default;
	Bulk_quote(const std::string&book, double p, std::size_t qty, double disc):
		Quote(book,p),min_qty(qty),discount(disc){}
	double net_price(std::size_t)const override;
private:
	std::size_t min_qty = 0; //使用折扣政策的最低购买量
	double discount = 0.0; //小数表示的折扣额
};
//如果达到一定购买量，就可以享受折扣
double Bulk_quote::net_price(std::size_t cnt)const
{
	if (cnt >= min_qty)
		return cnt * (1 - discount)*price;
	else
		return cnt * price;
}

15.6

#include"Quote.h"
#include"Bulk_quote.h"
#include<iostream>
double print_total(std::ostream &os, const Quote &item, size_t n)
{
	double ret = item.net_price(n);
	os << "ISBN:"<<item.isbn() << " #sold:" << n << " total due:" << ret << std::endl;
	return ret;
}
int main()
{
	Quote q("114514",11);
	Bulk_quote b("114514",11,10,0.1);
	print_total(std::cout, q, 11);
	print_total(std::cout, b, 11);
	return 0;
}

15.7

double Bulk_quote::net_price(std::size_t cnt)const
{
	if (cnt >= min_qty)
		return min_qty * (1 - discount)*price+(cnt- min_qty)*price;
	else
		return cnt * (1 - discount)*price;
}

15.8

表达式的静态类型在编译时总是已知的，它时变量声明时的类型或表达式生成的类型；动态类型则是变量或表达式表示的内存中对象的类型，直到运行时才可知

15.9

Bulk_quote bulk;
Quote *quote_pointer = &bulk;// 指针
Quote &quote_reference = bulk; // 引用
Quote quote= bulk; // 赋值

15.10

read接收的形参时istream&,因此可以引入istream的派生类ifstream作为动态类型。

15.11

base:

virtual void debug()const {
		std::cout << "INBN():" << bookNo << " price:" << price << std::endl;
	}

bulk:

void Bulk_quote::debug()const
{
	std::cout << "min_qty:" << min_qty << " discount:" << discount << std::endl;
}

15.12

有必要，因为两者并不冲突，override时复写继承的基类虚函数，final表示禁止自己的虚函数被禁止。

15.13

base:作为虚函数输出基类的私有成员
derived:作为成员函数调用自身，会导致无限递归.
修改：表明作用域

void print(ostream &os) {
base::print(os);
os<<" "<<i;
}

15.14

(a)base;
(b)derived;
©base;
(d)base;
(e)base;
(f)derived;

15.15

Disc_quote.h

#pragma once
#include"Quote.h"
// 抽象基类
class Disc_quote :public Quote
{
public:
	Disc_quote() = default;
	Disc_quote(const std::string& book,double price,std::size_t qty,double disc):
		Quote(book, price), quantity(qty),discount(disc){}
	double net_price(std::size_t)const = 0; //纯虚函数
protected:
	std::size_t quantity = 0; //折扣适用的购买量
	double discount = 0.0; //表示折扣的小数值
};

bulk.h

#pragma once
#include"Quote.h"
#include"Disc_quote.h"
class Bulk_quote :public Disc_quote
{
public:
	Bulk_quote() = default;
	Bulk_quote(const std::string&book, double p, std::size_t qty, double disc):
		Disc_quote(book,p,qty,disc){}
	double net_price(std::size_t)const override;
	virtual void debug()const override;
private:
	//std::size_t min_qty = 0; //使用折扣政策的最低购买量
	//double discount = 0.0; //小数表示的折扣额
};

15.16

double Bulk_quote::net_price(std::size_t cnt)const
{
	if (cnt >= quantity)
		return quantity * (1 - discount)*price+(cnt- quantity)*price;
	else
		return cnt * (1 - discount)*price;
}

15.17

代码	说明	文件	行	禁止显示状态
E0322	不允许使用抽象类类型 "Disc_quote" 的对象:

15.18

Base *p=&d1; 合法
p=&d2; 不合法，用户代码不能使用该转换
p=&d3; 不合法，同上
p=&dd1; 合法
p=&dd2; 不合法，同上
p=&dd3; 不合法，同上

15.19

base 合法
不管D以什么方式继承B，D的成员函数和友元都能使用派生类向基类的转换，所以Pub_Derv,Priv_Derv,合法
如果D继承B的方式时公有的或保护的，则D的派生类的成员和友元可以使用D向B的转换,所以drived_from_public合法，drived_from_private非法。

15.21&22

#include<iostream>
#include<string>
class Shape
{
public:
	virtual double area()const = 0;
	virtual double perimiter()const = 0;
	virtual ~Shape() = default;
private:
	std::string name;
};
class Rectangle: public Shape
{
private:
	Rectangle(double l,double w):
		length(l),width(w){}
	double area()const override { return length * width; }
	double perimiter()const override { return 2 * (length + width); }
private:
	double length;
	double width;
};
class Circle :public Shape
{
public:
	Circle(double r) :radius(r) {}
	double area()const override
	{
		return radius * radius * 3.14;
	}
	double perimiter()const override
	{
		return 2 * radius * 3.14;
	}
protected:
	double radius;
};
class spshere :public Circle
{
public:
	spshere(double r) :Circle(r) {}
	double area()const override
	{
		return 4 * 3.14 * radius, radius;
	}
	double volume()const
	{
		return 3 / 4 * 3.14 * radius * radius * radius;
	}
};
class Circle_Cone : public Circle
{
public:
	double volume() const
	{
		return 3.14 * radius * radius * height;
	}
private:
	double height;
}; 
int main()
{

}

15.23

int fcn()overrive{}
bp2->fcn(); 将会调用D1::fcn

15.24

基类需要虚析构函数

15.25

因为基类的默认构造函数会影响到派生类的默认初始化；
如果去除掉以后Bulk_quote将无法进行自己的默认构造函数从而初始化。

15.26

quote.h

#pragma once
#include<string>
#include<iostream>
class Quote
{
	friend bool operator!=(const Quote&lhs, const Quote&rhs);
public:
	Quote() { std::cout << "基类默认构造函数：" << std::endl; }
	Quote(const std::string &book, double sales_price) :
		bookNo(book), price(sales_price) {
		std::cout << "基类带两个参数的构造函数:" << std::endl;
	}
	Quote(const Quote&q):bookNo(q.bookNo),price(q.price)
	{ std::cout << "基类拷贝构造函数:" << std::endl; }
	Quote(Quote&& q):bookNo(std::move(q.bookNo)),price(std::move(q.price))
	{
		std::cout << "基类移动构造函数：" << std::endl;}
	Quote& operator=(const Quote&rhs) {
		if (*this != rhs) {
			bookNo = rhs.bookNo;
			price = rhs.price;
		}
		std::cout << "基类拷贝赋值运算符：" << std::endl;
		return *this;
	}
	Quote& operator=(Quote&&rhs)noexcept {
		if (*this != rhs)
		{
			bookNo = std::move(rhs.bookNo);
			price = std::move(rhs.price);
		}
		std::cout << "基类移动赋值运算符：" << std::endl;
		return *this;
	}

	std::string isbn()const { return bookNo; }
	virtual double net_price(std::size_t n)const { return n * price; } //返回书籍的实际销售价格
	virtual void debug()const {
		std::cout << "INBN():" << bookNo << " price:" << price << std::endl;}
	virtual ~Quote() { std::cout << "基类析构函数：" << std::endl; }
private:
	std::string bookNo;//书籍的ISBN编号
protected:
	double price = 0.0; //普通状态下不打折的价格
};
bool operator!=(const Quote&lhs, const Quote&rhs)
{
	return lhs.bookNo != rhs.bookNo&&lhs.price != rhs.price;
}

Bulk_quote.h

#pragma once
#include"Quote.h"
#include"Disc_quote.h"
class Bulk_quote :public Disc_quote
{
public:
	//五件套
	Bulk_quote() { std::cout << "孙子类默认构造函数：" << std::endl; }
	Bulk_quote(const std::string&book, double p, std::size_t qty, double disc):
		Disc_quote(book, p, qty, disc) {
		std::cout << "孙子类带四个参数构造函数:" << std::endl;}
	Bulk_quote(const Bulk_quote&b):Disc_quote(b){
		std::cout << "孙子类拷贝构造函数:" << std::endl;}
	Bulk_quote& operator=(const Bulk_quote&rhs) {
		Disc_quote::operator=(rhs);
		std::cout << "孙子类拷贝赋值运算符:" << std::endl;}
	Bulk_quote(Bulk_quote&&b)noexcept:Disc_quote(std::move(b)) {
		std::cout << "孙子类移动构造函数：" << std::endl;}
	Bulk_quote& operator=(Bulk_quote&&rhs)noexcept {
		Disc_quote::operator=(std::move(rhs));
		std::cout << "孙子类移动赋值运算符:" << std::endl;}
	~Bulk_quote() override{
		std::cout << "孙子类析构函数：" << std::endl;}

	double net_price(std::size_t)const override;
	virtual void debug()const override;
private:
};
//如果达到一定购买量，就可以享受折扣
double Bulk_quote::net_price(std::size_t cnt)const
{
	if (cnt >= quantity)
		return quantity * (1 - discount)*price+(cnt- quantity)*price;
	else
		return cnt * (1 - discount)*price;
}
//void Bulk_quote::debug()const
//{
//	std::cout << "min_qty:" << min_qty << " discount:" << discount << std::endl;
//}

15.27

	/*Bulk_quote(const std::string&book, double p, std::size_t qty, double disc):
		Disc_quote(book, p, qty, disc) {
		std::cout << "孙子类带四个参数构造函数:" << std::endl;}*/
	using Disc_quote::Disc_quote;

15.28

Quote.h

#pragma once
#include<string>
#include<iostream>
class Quote
{
	friend bool operator!=(const Quote&lhs, const Quote&rhs);
public:
	Quote() { std::cout << "基类默认构造函数：" << std::endl; }
	Quote(const std::string &book, double sales_price) :
		bookNo(book), price(sales_price) {
		std::cout << "基类带两个参数的构造函数:" << std::endl;
	}
	Quote(const Quote&q):bookNo(q.bookNo),price(q.price)
	{ std::cout << "基类拷贝构造函数:" << std::endl; }
	Quote(Quote&& q):bookNo(std::move(q.bookNo)),price(std::move(q.price))
	{
		std::cout << "基类移动构造函数：" << std::endl;}
	Quote& operator=(const Quote&rhs) {
		if (*this != rhs) {
			bookNo = rhs.bookNo;
			price = rhs.price;
		}
		std::cout << "基类拷贝赋值运算符：" << std::endl;
		return *this;
	}
	Quote& operator=(Quote&&rhs)noexcept {
		if (*this != rhs)
		{
			bookNo = std::move(rhs.bookNo);
			price = std::move(rhs.price);
		}
		std::cout << "基类移动赋值运算符：" << std::endl;
		return *this;
	}

	std::string isbn()const { return bookNo; }
	virtual double net_price(std::size_t n)const { return n * price; } //返回书籍的实际销售价格
	virtual void debug()const {
		std::cout << "INBN():" << bookNo << " price:" << price << std::endl;}
	virtual ~Quote() { std::cout << "基类析构函数：" << std::endl; }
private:
	std::string bookNo;//书籍的ISBN编号
protected:
	double price = 0.0; //普通状态下不打折的价格
};
bool inline operator!=(const Quote&lhs, const Quote&rhs)
{
	return lhs.bookNo != rhs.bookNo&&lhs.price != rhs.price;
}

Disc_quote.h

#pragma once
#include"Quote.h"
// 抽象基类
class Disc_quote :public Quote
{
public:
	Disc_quote() = default;
	Disc_quote(const std::string& book,double price,std::size_t qty,double disc):
		Quote(book, price), quantity(qty), discount(disc) {
		std::cout << "子类带有四个参数的构造函数：" << std::endl;}
	~Disc_quote()
	{
		std::cout << "子类析构函数：" << std::endl;}
	double net_price(std::size_t)const = 0; //纯虚函数
protected:
	std::size_t quantity = 0; //折扣适用的购买量
	double discount = 0.0; //表示折扣的小数值
};

Bulk_quote.h

#pragma once
#include"Quote.h"
#include"Disc_quote.h"
class Bulk_quote :public Disc_quote
{
public:
	//五件套
	Bulk_quote() = default;
	/*Bulk_quote(const std::string&book, double p, std::size_t qty, double disc):
		Disc_quote(book, p, qty, disc) {
		std::cout << "孙子类带四个参数构造函数:" << std::endl;}*/
	using Disc_quote::Disc_quote;

	Bulk_quote(const Bulk_quote&b):Disc_quote(b){
		std::cout << "孙子类拷贝构造函数:" << std::endl;}
	Bulk_quote& operator=(const Bulk_quote&rhs) {
		Disc_quote::operator=(rhs);
		std::cout << "孙子类拷贝赋值运算符:" << std::endl;
		return *this;}
	Bulk_quote(Bulk_quote&&b)noexcept:Disc_quote(std::move(b)) {
		std::cout << "孙子类移动构造函数：" << std::endl;}
	Bulk_quote& operator=(Bulk_quote&&rhs)noexcept {
		Disc_quote::operator=(std::move(rhs));
		std::cout << "孙子类移动赋值运算符:" << std::endl;}
	~Bulk_quote() override{
		std::cout << "孙子类析构函数：" << std::endl;}

	double net_price(std::size_t)const override;
	virtual void debug()const override;
private:
};
//如果达到一定购买量，就可以享受折扣
double Bulk_quote::net_price(std::size_t cnt)const
{
	if (cnt >= quantity)
		return quantity * (1 - discount)*price+(cnt- quantity)*price;
	else
		return cnt * (1 - discount)*price;
}
void Bulk_quote::debug()const
{
	//std::cout << "min_qty:" << min_qty << " discount:" << discount << std::endl;
}

main.cpp

#include"Quote.h"
#include"Bulk_quote.h"
#include"Disc_quote.h"
#include<memory>
#include<vector>
int main()
{
	 std::vector<std::shared_ptr<Quote>>basket;
	 basket.push_back(std::make_shared<Bulk_quote>("No-123", 30, 20, 0.2));
	double total = 0.0;
	for (const auto&i : basket)
	{
		total += i->net_price(20);
	}
	std::cout << total << std::endl;
/*基类带两个参数的构造函数:
子类带有四个参数的构造函数：
480
孙子类析构函数：
子类析构函数：
基类析构函数：*/
}

15.29

不一致是因为前者是值传递，因此调用的是基类的net_price函数；后者是地址传递，调用的是Bulk_quote的net_price函数。

15.30

.h

#pragma once
#include"Quote.h"
#include<memory>
#include<set>
class Basket
{
public:
	//使用默认的构造和拷贝函数
	//void add_itme(const std::shared_ptr<Quote> &sale) { items.insert(sale); }
	void add_item(const Quote& sale)
	{items.insert(std::shared_ptr<Quote>(sale.clone()));}
	void add_item(Quote&& sale)
	{items.insert(std::shared_ptr<Quote>(std::move(sale).clone()));}
	// 打印每本书的总价和购物篮中所有书的总价
	double total_receipt(std::ostream&)const;
private:
	//该函数用于比较shared_ptr,multiset会引用他
	static bool compare(const std::shared_ptr<Quote> &lhs, const std::shared_ptr<Quote> &rhs)
	{return lhs->isbn() < rhs->isbn();}
	//multiset保存多个报价，按照compare成员排序
	std::multiset<std::shared_ptr<Quote>, decltype(compare)*> items{ compare };
};

.cpp

#include"Quote.h"
#include"Basket.h"
double Basket::total_receipt(std::ostream&os)const
{
	double sum = 0.0; //总价格
	// upper_bound返回一个迭代器，指向元素的尾后位置
	for (auto iter = items.cbegin(); iter != items.cend(); iter = items.upper_bound(*iter))
	{
		sum += print_total(os, **iter, items.count(*iter));//**iter是一个quote对象
	}
	os << "Total sale:" << sum << std::endl;
	return sum;
}

15.31

(a)OrQuery, AndQuery, NotQuery, WordQuery
(b)同上
©OrQuery, AndQuery, WordQuery

15.32

拷贝：会调用合成的拷贝构造函数，拷贝Query的数据成员，成员q由于是shared_ptr，其引用计数会加1.
移动：会调用合成移动构造函数。新对象的shared_ptr的引用计数加1，原对象的shared_ptr的引用计数减1。
赋值：调用合成的赋值函数，结果与拷贝操作相同。
销毁：调用合成的析构函数，shared_ptr的引用计数减1，如果其引用计数减至0，则会释放它指向的内存

15.33

query_base是一个抽象类，因此无法使用抽象类类型的对象；
可以通过它的子类的对象来进行这些操作，结果同上。

15.34

略

15.35

query.h

Skip to content
Search or jump to…
Pull requests
Issues
Codespaces
Marketplace
Explore
 
@whitenighttttt 
Mooophy
/
Cpp-Primer
Public
Fork your own copy of Mooophy/Cpp-Primer
Code
Issues
106
Pull requests
90
Actions
Projects
Wiki
Security
Insights
Cpp-Primer/ch15/ex15.34.35.36.38/query.h
@Mooophy
Mooophy change comment mark to // for .h files
…
Latest commit b36f6d8 on Aug 25, 2015
 History
 2 contributors
@pezy@Mooophy
55 lines (47 sloc)  1.26 KB

#ifndef QUERY_H
#define QUERY_H

#include <iostream>
#include <string>
#include <memory>
#include "query_base.h"
#include "queryresult.h"
#include "textquery.h"
#include "wordquery.h"
class Query
{
    friend Query operator~(const Query&);
    friend Query operator|(const Query&, const Query&);
    friend Query operator&(const Query&, const Query&);
public:
    // build a new WordQuery
    Query(const std::string& s) : q(new WordQuery(s))
    {
        std::cout << "Query::Query(const std::string& s) where s="+s+"\n";
    }
    QueryResult eval(const TextQuery& t) const
    { return q->eval(t); }
    std::string rep() const
    {
        std::cout << "Query::rep() \n";
        return q->rep();
    }

private:
    // constructor only for friends
    Query(std::shared_ptr<Query_base> query) :
        q(query)
    {
        std::cout << "Query::Query(std::shared_ptr<Query_base> query)\n";
    }
    std::shared_ptr<Query_base> q;
};

inline std::ostream&
operator << (std::ostream& os, const Query& query)
{
    return os << query.rep();
}

#endif // QUERY_H

query_base.h

#ifndef QUERY_BASE_H
#define QUERY_BASE_H
#include "textquery.h"
#include "queryresult.h"
class Query_base
{
    friend class Query;
protected:
    using line_no = TextQuery::line_no; 
    virtual ~Query_base() = default;
private:
    virtual QueryResult eval(const TextQuery&) const = 0;
    virtual std::string rep() const = 0;
};
#endif // QUERY_BASE_H
yuk1noshita
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++程序设计_第八章_习题解答
我们都是木头人
10-17 1334
谭浩强教授编著的《C++程序设计》课后练习的代码。这些代码都是我独立完成的，并且已在机器上成功运行。之所以要贴到博客上，是为了要督促自己完成每天的学习任务。习题1#include "stdafx.h" #include using namespace std; class Time { public: void set_time(void); void show_time(void); private: int hour; int minute; int second;
C++面向程序设计-练习答案
qq_45289233的博客
03-26 950
FIRST Write a program that prints the sizes of the fundamental types, a few pointer types, and a few enumerations of your choice. Use the sizeof operator. 翻译（编写一个程序，打印基本类型的大小、一些指针类型和一些您选择的枚举。使用sizeof操...
面向对象程序设计c 语言描述 答案,c面向对象程序设计习题解答全.doc
weixin_35087326的博客
05-18 827
c面向对象程序设计习题解答全《C++面向对象程序设计》习题解答陈腊梅目录TOC \o "1-3" \h \z \u HYPERLINK \l "_Toc381868601" 第一章 面向对象程序设计概述 PAGEREF _Toc381868601 \h 错误!未定义书签。HYPERLINK \l "_Toc381868602" 第二章对C语言的基础扩充 PAGEREF _Toc381868602...
C++Primer第五版 习题答案 第十五章 面向对象程序设计（Object-Oriented Programming）
shamozhizhoutx的博客
05-25 3574
练习15.1 什么是虚成员？ 虚函数是基类希望其派生类进行覆盖的函数。 练习15.2 protected 访问说明符与 private 有何区别？ 派生类的成员函数可以访问protected访问运算符的成员，而不能访问private的。 练习15.3 定义你自己的 Quote 类和 print_total 函数。 Quote_ex03.h #ifndef QUOTE_H_ #defin...
C++程序设计原理与实践 习题答案 第十五章 第15章习题答案
qq_36765586的博客
11-02 622
第十五章：容器和迭代器 习题答案Document 本章的文本编辑器实现Document.hDocument.cpp我自己实现的循环链表15.2 and 15.315.415.5 为 vector 定义输入和输出运算符15.615.715.815.9 and 15.1015.1115.12 and 15.13 list15.12 list_tail.h15.13 list_notail.hmain.cpp 测试两个list15.1415.15 pvector15.16 ovector15.17 ownersh
C++Primer第15章：面向对象程序设计(习题解答）
qq_50271250的博客
12-25 911
15.2.1节练习 15.1 在类中被声明为virtual的成员，基类希望这种成员在派生类中重定义，除了构造函数外，任意非 static成员都可以为虚成员 15.2 protected可以被该类的成员，友元和派生类成员访问，而不可以被该类型的普通成员访问，而private 成员只能被基类和友元访问，派生类不可访问 15.3 ...
C++Primer（第4版）-课后习题答案.pdf
最新发布
11-01
《C++ Primer（第4版）》是一本深入学习C++编程语言的经典教材，其课后习题答案提供了丰富的实践练习和问题解析，帮助读者巩固并深化对C++语法、概念的理解。以下将针对各章节的主要知识点进行详细阐述： 1. 第一章...
C++Primer 第四版课后习题解答(第1~18章完整答案)完整版
01-23
第十二章“类和数据抽象”介绍了面向对象编程的基础，如封装、继承和多态。习题解答将涉及类的设计、对象的创建和使用，以及虚函数和抽象类的应用。 第十三章“复制控制”讲解了构造函数、析构函数、拷贝构造函数和...
C++ Primer Plus 编程练习源码工程 第15章
12-25
《C++ Primer Plus 编程练习源码工程 第15章》是针对C++初学者的一个宝贵资源，它包含了作者LeonardoLiuwenbo在学习《C++ Primer Plus》这本经典教材时所做的编程练习。这个章节聚焦于C++语言的深入特性，旨在通过...
c++面向对象程序设计 谭浩强（第二版）习题答案
09-06
c++面向对象程序设计 C++是由C发展而来的,与C兼容｡用C语言写的程序基本上可以不加修改地用于C++｡从C++的名字可以看出它是C的超集｡C++既可用于面向过程的结构化程序设计,又可用于面向对象的程序设计,是一种功能强大的混合型的程序设计语言｡
java面向对象程序设计课后答案
09-13
java面向对象程序设计课后答案，是耿祥义，张跃平编著的。
C++面向对象程序设计课后习题答案-陈维兴等人
01-08
此为清华大学出版社陈维兴等人编写的《C++面向对象程序设计教程》习题答案，仅供学习参考
C++ Primer Plus(第六版) 7-18章 习题答案
04-28
《C++ Primer Plus（第六版）7-18章习题答案》是针对这本经典C++学习书籍的习题解答资源，包含了第七章至第十八章的所有练习题的源代码。这些章节涵盖了C++语言的高级特性和面向对象编程的关键概念。下面将对每个...
面向对象程序设计答案-马石安
04-22
面向对象程序设计答案-马石安
面向对象程序设计答案
03-16
java课后答案，第二章 有具体的过程 答案非常详细
C++ Primer第四版课后习题答案1-18章
"这份资源是C++ Primer第四版的课后题解答，涵盖了从第一章到第十八章的全部内容，包括快速入门、变量和基本类型、标准库类型、数组和指针、表达式、语句、函数、标准IO库、容器、泛型算法、类和数据抽象、复制控制...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值