C++ primer第14章课后练习

于 2022-09-02 17:09:24 发布
阅读量126 收藏
点赞数
分类专栏： C++ 文章标签： c++ 图论 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44918105/article/details/126651189
版权

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

#ifndef WINEC_H_
#define WINEC_H_
#include<string>
#include<valarray>
using namespace std;
template <typename T1, typename T2>
class Pair
{
private:
    T1 year;
    T2 bottles;
    

public:
    Pair() {}
    Pair(const T1& yr, const T2& bt) : year(yr), bottles(bt) {}
    void Set(const T1& yr, const T2& bt);
    int Sum() const;
    void Show(int y) const;
};

template <typename T1, typename T2>
void Pair<T1, T2>::Set(const T1& yr, const T2& bt)
{
    year = yr;
    bottles = bt;
}

template <typename T1, typename T2>
int Pair<T1, T2>::Sum() const
{
    return bottles.sum();
}

template <typename T1, typename T2>
void Pair<T1, T2>::Show(int y) const
{
    for (int i = 0; i < y; i++)
    {
        cout << '\t' << year[i] << '\t' << bottles[i] << endl;
    }
    return;
}

typedef valarray<int> ArraryInt;
typedef Pair<ArraryInt, ArraryInt> PairArray;
class Wine 
{
private:
	string name;
    PairArray year_bottle;
    int year;
public:
    Wine(const char*l, int y) ;
    Wine(const char* l, int y, const int yr[], const int bot[]) ;
    ~Wine();
    void GetBottles() ;
    string &Label() ;
    int sum() ;
    void Show()const;




};
#endif // !WINEC_H_


#include<iostream>
#include"14_1.h"
using namespace std;
Wine::Wine(const char* l, int y)
{
	name = l;
	year_bottle.Set(ArraryInt(y),ArraryInt(y));
}
Wine::Wine(const char* l, int y, const int yr[], const int bot[])
{
	name = l;
	year_bottle.Set(ArraryInt(yr, y), ArraryInt(bot, y));
	year = y;
}
Wine::~Wine()
{}
void Wine::GetBottles()
{
	ArraryInt yr(year);
	ArraryInt bt(year);
	cout << "Enetr " << name << " data for " << year << " year(s):" << endl;
	for (int i = 0; i < year; i++)
	{
		cout << "Enter year:";
		cin >> yr[i];
		cout << "Enter bottles:";
		cin >> bt[i];
	}
	year_bottle.Set(yr, bt);
}

string& Wine::Label()
{
	return name;
}
int Wine::sum()
{
	return year_bottle.Sum();
}
void Wine::Show()const
{
	cout << "Wine: " << name << endl;
	cout << "\tYear\tBottles" << endl;
	year_bottle.Show(year);
}

#include<iostream>
#include"14_1.h"
int main(void)
{
	using std::cin;
	using std::cout;
	using std::endl;
	cout << "Enter name of wine: ";
	char lab[50];
	cin.getline(lab, 50);
	cout << "Enter number of years: ";
	int yrs;
	cin >> yrs;
	Wine holding(lab, yrs);
	holding.GetBottles();
	holding.Show();
	const int YRS = 3;
	int y[YRS] = { 1993,1995,1998 };
	int b[YRS] = { 48,60,72 };
	Wine more("Gushing Grape Red", YRS, y, b);
	more.Show();
	cout << "Total bottles for " << more.Label() << ":" << more.sum() << endl;
	cout << "Bye\n";
	return 0;
}

在这里插入图片描述

#ifndef WINEC_H_
#define WINEC_H_
#include<string>
#include<valarray>
using namespace std;
template <typename T1, typename T2>
class Pair
{
private:
    T1 year;
    T2 bottles;


public:
    Pair() {}
    Pair(const T1& yr, const T2& bt) : year(yr), bottles(bt) {}
    void Set(const T1& yr, const T2& bt);
    int Sum() const;
    void Show(int y) const;
};

template <typename T1, typename T2>
void Pair<T1, T2>::Set(const T1& yr, const T2& bt)
{
    year = yr;
    bottles = bt;
}

template <typename T1, typename T2>
int Pair<T1, T2>::Sum() const
{
    return bottles.sum();
}

template <typename T1, typename T2>
void Pair<T1, T2>::Show(int y) const
{
    for (int i = 0; i < y; i++)
    {
        cout << '\t' << year[i] << '\t' << bottles[i] << endl;
    }
    return;
}

typedef valarray<int> ArraryInt;
typedef Pair<ArraryInt, ArraryInt> PairArray;
class Wine:private string,private PairArray
{
private:

    int year;
public:
    Wine(const char* l, int y);
    Wine(const char* l, int y, const int yr[], const int bot[]);
    ~Wine();
    void GetBottles();
    string& Label();
    int sum();
    void Show()const;




};
#endif // !WINEC_H_

#include<iostream>
#include"14_2.h"
using namespace std;
Wine::Wine(const char* l, int y):string(l)
{
	PairArray::operator=(PairArray(ArraryInt(y), ArraryInt(y)));
	year = y;
}
Wine::Wine(const char* l, int y, const int yr[], const int bot[]):string(l)
{
	PairArray::operator=(PairArray(ArraryInt(yr,y), ArraryInt(bot,y)));
	year = y;
}
Wine::~Wine()
{}
void Wine::GetBottles()
{
	ArraryInt yr(year);
	ArraryInt bt(year);
	cout << "Enetr " << (const string&)*this << " data for " << year << " year(s):" << endl;
	for (int i = 0; i < year; i++)
	{
		cout << "Enter year:";
		cin >> yr[i];
		cout << "Enter bottles:";
		cin >> bt[i];
	}
	PairArray::operator=(PairArray(yr, bt));
}

string& Wine::Label()
{
	return (string&)*this; //使用强制类型转换访问私有对象;
}
int Wine::sum()
{
	return Pair::Sum();
}
void Wine::Show()const
{
	cout << "Wine: " << (const string&)*this << endl;
	cout << "\tYear\tBottles" << endl;
    Pair::Show(year);
}

#include<iostream>
#include"14_2.h"
int main(void)
{
	using std::cin;
	using std::cout;
	using std::endl;
	cout << "Enter name of wine: ";
	char lab[50];
	cin.getline(lab, 50);
	cout << "Enter number of years: ";
	int yrs;
	cin >> yrs;
	Wine holding(lab, yrs);
	holding.GetBottles();
	holding.Show();
	const int YRS = 3;
	int y[YRS] = { 1993,1995,1998 };
	int b[YRS] = { 48,60,72 };
	Wine more("Gushing Grape Red", YRS, y, b);
	more.Show();
	cout << "Total bottles for " << more.Label() << ":" << more.sum() << endl;
	cout << "Bye\n";
	return 0;
}

在这里插入图片描述

#ifndef QUEUETP_H_
#define QUEUETP_H_

template <typename Item>
class QueueTp
{
private:
    enum{ Q_SIZE = 10 };
    struct Node
    {
        Item item;
        struct Node *next;
    };
    Node *front;
    Node *rear;
    int items;
    const int qsize;
    QueueTp(const QueueTp &q) : qsize(0) {}
    QueueTp &operator=(const QueueTp &q) { return *this; }

public:
    QueueTp(int qs = Q_SIZE);
    ~QueueTp();
    bool isempty() const;
    bool isfull() const;
    int queuecount() const;
    bool enqueue(const Item &item);
    bool dequeue(Item &item);
};

template <typename Item>
QueueTp<Item>::QueueTp(int qs) : qsize(qs)
{
    front = rear = nullptr;
    items = 0;
}

template <typename Item>
QueueTp<Item>::~QueueTp()
{
    Node *temp;

    while (front != nullptr)
    {
        temp = front;
        front = front->next;
        delete temp;
    }
}

template <typename Item>
bool QueueTp<Item>::isempty() const
{
    return 0 == items;
}

template <typename Item>
bool QueueTp<Item>::isfull() const
{
    return qsize == items;
}

template <typename Item>
int QueueTp<Item>::queuecount() const
{
    return items;
}

template <typename Item>
bool QueueTp<Item>::enqueue(const Item &item)
{
    if (isfull())
    {
        return false;
    }
    Node *add = new Node;
    add->item = item;
    add->next = nullptr;
    ++items;
    if (nullptr == front)
    {
        front = add;
    }
    else
    {
        rear->next = add;
    }
    rear = add;
    return true;
}

template <typename Item>
bool QueueTp<Item>::dequeue(Item &item)
{
    if (isempty())
    {
        return false;
    }
    item = front->item;
    --items;
    Node *temp = front;
    front = front->next;
    delete temp;
    if (0 == items)
    {
        rear = nullptr;
    }
    return true;
}

#endif


#ifndef WORKER_H_
#define WORKER_H_
#include <string>

class Worker
{
private:
    std::string fullname;
    long id;

public:
    Worker() : fullname("no one"), id(0L) {}
    Worker(const std::string &s, long n) : fullname(s), id(n) {}
    ~Worker();
    void Set();
    void Show() const;
};

#endif

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

#ifndef PERSONMI_H_
#define PERSONMI_H_
#include <string>
using std::string;

class Person
{
private:
    string firstname;
    string lastname;

protected:
    virtual void Data() const; //虚保护方法打印基类成员信息, 使得派生类可以间接访问;
    virtual void Get();        //虚保护方法获取基类成员信息, 使得派生类可以间接访问;

public:
    Person() : firstname("no"), lastname("one") {}
    Person(const string &fname, const string &lname) : firstname(fname), lastname(lname) {}
    virtual ~Person() = 0;
    virtual void Set() = 0;
    virtual void Show() const = 0;
};

class Gunslinger : virtual public Person
{
private:
    int nicks;

protected:
    void Data() const; //重新定义保护方法;
    void Get();

public:
    Gunslinger() : Person(), nicks(0) {}
    Gunslinger(const string &f, const string &l, int n) : Person(f, l), nicks(n) {}
    Gunslinger(const Person &p, int n) : Person(p), nicks(n) {}
    void Set();
    void Show() const;
    double Draw() const; //打印枪手的拔枪时间;
};

class PokerPlayer : virtual public Person
{
protected:
    void Data() const; //重新定义保护方法;

public:
    PokerPlayer() : Person("no", "one") {}
    PokerPlayer(const string &f, const string &l) : Person(f, l) {}
    PokerPlayer(const Person &p) : Person(p) {}
    void Set();
    void Show() const;
    int Draw() const; //表示扑克牌的值;
};

class BadDude : public Gunslinger, public PokerPlayer
{
protected:
    void Data() const; //重新定义保护方法;
    void Get();

public:
    BadDude() {}
    BadDude(const string &f, const string &l, int n) : Person(f, l), Gunslinger(f, l, n), PokerPlayer(f, l) {}
    BadDude(const Person &p, int n) : Person(p), Gunslinger(p, n), PokerPlayer(p) {}
    BadDude(const Gunslinger &g) : Person(g), Gunslinger(g), PokerPlayer(g) {}
    BadDude(const PokerPlayer &p, int n) : Person(p), Gunslinger(p, n), PokerPlayer(p) {}
    void Set();
    void Show() const;
    double Gdraw() const; //打印坏蛋拔枪的时间;
    int Cdraw() const;    //打印下一张扑克牌的值;
};

#endif


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

Person::~Person()
{
}

void Person::Data() const
{
    cout << "First name: " << firstname << endl;
    cout << "Last name: " << lastname << endl;
    return;
}

void Person::Get()
{
    cout << "Please enter your first name: ";
    getline(cin, firstname);
    cout << "Please enter your last name: ";
    getline(cin, lastname);
    return;
}

void Gunslinger::Data() const
{
    cout << "Gunslinger nicks: " << nicks << endl;
    return;
}

void Gunslinger::Get()
{
    cout << "Please enter the nicks for gunslinger: ";
    cin >> nicks;
    while (cin.get() != '\n')
        continue;
    return;
}

void Gunslinger::Set()
{
    cout << "Enter Gunslinger name" << endl;
    Person::Get();
    Get();
    return;
}

void Gunslinger::Show() const
{
    cout << "Category: Gunslinger" << endl;
    Person::Data();
    Data();
    return;
}

double Gunslinger::Draw() const
{
    return double(rand() % 5 + 1); //枪手的拔枪时间设置为1到5之间的值;
}

void PokerPlayer::Data() const
{
    cout << "The cards: " << Draw() << endl;
    return;
}

void PokerPlayer::Set()
{
    cout << "Enter PokerPlayer name" << endl;
    Person::Get();
    return;
}

void PokerPlayer::Show() const
{
    cout << "Category: PokerPlayer" << endl;
    Person::Data();
    Data();
    return;
}

int PokerPlayer::Draw() const //扑克牌的值;
{
    return rand() % 52 + 1;
}

void BadDude::Data() const
{
    Gunslinger::Data();
    PokerPlayer::Data();
    cout << "The time for a bad guy to draw his gun is " << Gdraw() << endl;
    cout << "The next card is " << Cdraw() << endl;
    return;
}

void BadDude::Get()
{
    Gunslinger::Get();
    return;
}

void BadDude::Set()
{
    cout << "Enter BadDude name" << endl;
    Person::Get();
    Get();
    return;
}

void BadDude::Show() const
{
    cout << "Category: BadDude" << endl;
    Person::Data();
    Data();
    return;
}

double BadDude::Gdraw() const
{
    return Gunslinger::Draw();
}

int BadDude::Cdraw() const
{
    return PokerPlayer::Draw();
}


#include <iostream>
#include <cstring>
#include "personmi.h"
const int SIZE = 5;

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

    int i, ct;
    Person *people[SIZE];

    for (ct = 0; ct < SIZE; ct++)
    {
        char choice;
        cout << "Enter the person category:" << endl;
        cout << "g: gunslinger" << endl;
        cout << "p: pokerplayer" << endl;
        cout << "b: baddude" << endl;
        cout << "q: quit" << endl;
        cin >> choice;
        while (NULL == strchr("bgpq", choice))
        {
            cout << "Please enter b, g, p or q: ";
            cin >> choice;
        }
        if ('q' == choice)
        {
            break;
        }
        switch (choice)
        {
        case 'b':
        {
            people[ct] = new BadDude;
            break;
        }
        case 'g':
        {
            people[ct] = new Gunslinger;
            break;
        }
        case 'p':
        {
            people[ct] = new PokerPlayer;
            break;
        }
        }
        cin.get();
        people[ct]->Set();
    }
    cout << "\nHere is your message for some people:" << endl;
    for (i = 0; i < ct; i++)
    {
        cout << endl;
        people[i]->Show();
    }
    for (i = 0; i < ct; i++)
    {
        delete people[i];
    }
    cout << "Bye.\n";

    return 0;
}

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

#include"14_5.h"
#include<iostream>
#include<string>
using namespace std;
abstr_emp::abstr_emp() :fname("None"), lname("None"), job("None") {}
abstr_emp::abstr_emp(const std::string& fn, const std::string& ln, const std::string& j) : fname(fn), lname(ln), job(j) {}
void abstr_emp::ShowAll() const
{
	cout << "First name:" << fname << endl;
	cout << "Last name:" << lname << endl;
	cout << "Job:" << job << endl;
}
void abstr_emp::SetAll()
{
	cout << "Enter first name:";
	cin >> fname;
	cout << "Enter last name:";
	cin >> lname;
	cout << "Enter job:";
	cin >> job;
}
std::ostream&  operator<<(std::ostream& os, const abstr_emp& e)
{
	os << "First name:" << e.fname << endl;
	os << "Last name:" << e.lname << endl;
	os << "Job:" << e.job << endl;
	return os;

}
abstr_emp:: ~abstr_emp() {}

employee::employee() :abstr_emp() {};
employee::employee(const std::string& fn, const std::string& ln, const std::string& j) :abstr_emp(fn, ln, j) {}
void employee::ShowAll() const
{
	abstr_emp::ShowAll();
}
void employee::SetAll()
{
	abstr_emp::SetAll();
}

manager::manager() :abstr_emp(), inchargeof(0) {}
manager::manager(const std::string& fn, const std::string& ln, const std::string& j, int ico ) : abstr_emp(fn, ln, j), inchargeof(ico) {}
manager::manager(const abstr_emp& e, int ico) : abstr_emp(e), inchargeof(ico) {}
manager::manager(const manager& m) : abstr_emp(m) {}
void manager::ShowAll() const
{
	abstr_emp::ShowAll();
	cout << "Inchargeof:" << inchargeof << endl;
}
void manager::SetAll()
{
	abstr_emp::SetAll();
	cout << "Enter inchargeof:";
	cin >> inchargeof;
}

fink::fink() :abstr_emp(), reportsto("None") {}
fink::fink(const std::string& fn, const std::string& ln, const std::string& j, const std::string& rpo) : abstr_emp(fn, ln, j), reportsto(rpo) {}
fink::fink(const abstr_emp& e, const std::string& rpo) : abstr_emp(e), reportsto(rpo) {}
fink::fink(const fink& e) : abstr_emp(e) {}
void fink::ShowAll() const
{
	abstr_emp::ShowAll();
	cout << "Reportsto:" << reportsto << endl;
}
void fink::SetAll()
{
	abstr_emp::SetAll();
	cout << "Enter reportsto:";
	cin >> reportsto;
}

highfink::highfink() :abstr_emp(),manager(), fink() {}
highfink::highfink(const std::string& fn, const std::string& ln, const std::string& j, const std::string& rpo, int ico) :abstr_emp(fn,ln,j), manager(fn, ln, j, ico), fink(fn, ln, j, rpo) {}
highfink::highfink(const abstr_emp& e, const std::string& rpo, int ico) :abstr_emp(e), manager(e, ico), fink(e, rpo) {}
highfink::highfink(const fink& f, int ico) :abstr_emp(f), manager(f, ico), fink(f) {}
highfink::highfink(const manager& m, const std::string& rpo) :abstr_emp(m), manager(m), fink(m, rpo) {}
highfink::highfink(const highfink& h) :abstr_emp(h), manager(h), fink(h) {}
void highfink::ShowAll() const
{
	abstr_emp::ShowAll();
	cout << "In charge of: " << manager::InChargeOf() << endl;
	cout << "Reports to: " << fink::ReportsTo() << endl;

}
void highfink::SetAll()
{
	abstr_emp::SetAll();
	cout << "Please enter a number for inchargerof: ";
	cin >> InChargeOf();
	while (cin.get() != '\n')
		continue;
	cout << "Please enter a string for reportsto: ";
	getline(cin, ReportsTo());
	
}

(1)：因为没有使用new进行动态内存分配因此使用的是隐式赋值运算符。
(2)：在派生类中进行了再次定义，所以声明为虚函数。
(3)：使得从多个类(基类相同)派生出的对象只继承1个基类对象。
(4)：没有新增的数据成员，继承过来的数据成员需用基类方法间接访问。
(5)：因为只访问对象中的3个数据部分，其余部分未进行访问。
(6)：编译器将会报错，抽象基类不能进行实例化，但可以使用抽象基类的指针来访问派生出来的多个不同类。

JoengGaap
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C Primer Plus 第6版 第十四章编程练习答案(C语言)(自学记录)
这个很可以的博客
05-05 735
第十四章编程练习 第一题 #define _CRT_SECURE_NO_WARNINGS //第十四章，编程练习题，第一题 #include <stdio.h> #include <stdlib.h> #include <string.h> int yearday(char*); struct months { char monname[10]; char montead[4]; int day; int num; }; struct months years[1
C++ primer 14章习题答案
digitalkee的博客
10-01 382
14.1节 练习14.1 相同点：对于优先级和结合型以及操作数的数目都不变。 不同点：重载操作符必须具有至少一个class或枚举类型的操作数。 14.2
c++ primer 第十四章习题
无所知的博客
10-04 1458
c++ primer 第十三章习题 练习14.2 ostream&amp;amp;amp; operator&amp;amp;lt;&amp;amp;lt;(std::ostream&amp;amp;amp; os, const Sales_data&amp;amp;amp; item){ os &amp;amp;lt;&amp;amp;lt; item.isbn() &amp;amp;lt;&amp;amp;lt; &
C++ primer Plus（第六版）第十四章 C++中的代码重用 章节编程练习答案
是鲤鱼啊
02-09 298
1.Wine类有一个string类对象成员（参见第4章）和一个Pair对象（参见本章）；其中前者用于存储葡萄酒的名称，而后者有2个valarray<int>对象（参见本章），这两个valarray<int>对象分别保存了葡萄酒的酿造年份和该年生产的瓶数。例如，Pair的第1个valarray<int>对象可能为1988、1992和1996年，第2个valarray<int>对象可能为24、48和144瓶。Wine最好有1个int成员用于存储年数。另外，一些ty
C++Primer第五版 第十四章编程练习（包含、私有继承、类模板、多重继承）
qq_37172182的博客
12-16 248
1：     //winec.h #ifndef WINE_H_ #define WINE_H_ #include&lt;iostream&gt; #include&lt;valarray&gt; #include&lt;string&gt; template&lt;class Y, class B&gt; class Pair { private: Y year; B bot...
C++Primer（第4版）-课后习题答案.pdf
11-01
《C++ Primer（第4版）》是一本深入学习C++编程语言的经典教材，其课后习题答案提供了丰富的实践练习和问题解析，帮助读者巩固并深化对C++语法、概念的理解。以下将针对各章节的主要知识点进行详细阐述： 1. 第一章...
C++Primer 第四版课后习题解答(第1~18章完整答案)完整版
01-23
《C++ Primer 第四版》是一本经典的C++学习书籍，涵盖了从基础到高级的各种主题。这份课后习题解答提供了第1至18章的完整答案，旨在帮助读者深入理解书中的概念并提高编程技能。 第一章“快速入门”引导读者进入C++...
C++ Primer Plus课后练习题 代码
03-27
在提供的压缩包文件中，我们能看到的是《C++ Primer Plus》一书的课后练习代码。这些代码实例通常包括解决特定问题或实现特定功能的程序，它们可以帮助读者深入理解书中的理论知识，并通过实际操作来提升编程技能。 ...
C++Primer第五章习题答案
03-04
《C++ Primer第五章习题答案》 C++ Primer是一本经典的C++学习教材，它深入浅出地介绍了C++语言的各种概念和技术。第五章主要涉及C++的基础语法和编程技巧，包括类的使用、对象的创建与初始化、成员函数、友元、...
C++ Primer 第四版课后习题答案
07-25
《C++ Primer 第四版》是一本广受欢迎的C++学习教材，其课后习题是深入理解并巩固所学知识的重要环节。以下是对各章节主要内容的详细解释： 第一章 快速入门：介绍C++的基本结构，包括如何编写、编译和运行程序，...
C Primer Plus 课后习题所有答案 完整版
04-14
C Primer Plus 课后习题所有答案 完整版，比官方给出的答案更全。
c++ primer 第14章 习题解答
digitalkee的博客
11-27 1341
14.1节 14.1答 不同点： 重载操作符必须具有至少一个class或枚举类型的操作数。 重载操作符不保证操作数的求值顺序，例如对&&和| | 的重载版本不再具有“短路求值”的特征，两个操作数，两个操作数都要进行求值，而且不规定操作数的求值顺序。 相同点： 对于优先级和结合性及操作数的数目都不变。 14.2 答： 文件sales_data.cc #include <iostream> #include <string> #i...
《C++ Primer Plus（第六版）》（29）（第十四章 C++中的代码重用 复习题答案）
weixin_30855761的博客
12-28 187
14.6 复习题 1.以A栏的类为基类时，B栏的类采用共有派生还是私有派生更合适。 A B 派生类型 class Bear class PolarBear 公有派生 class Kitchen class Home 私有派生 class Person class Programmer 公有派生 class Pers...
C++PrimerPlus学习——第十四章编程练习
m_zwa的博客
05-20 454
14-1 参考14.19 winec.h #ifndef WINEC_H_ #define WINEC_H_ #include <string> #include <valarray> using std::string; template<class T1, class T2> class Pair { private: T1 year; T2 bottles; public: Pair() {}; Pair(const T1 y, const T2 b) :
C++ PrimerPlus第六版第十四章C++中的代码与重用编程练习答案
qq_44800780的博客
11-02 360
1. winec.h #ifndef winec_H_ #define winec_H_ #include<iostream> #include<valarray> #include<string> using std::cout; using std::cin; template <typename T1, typename T2> class P...
C++ Primer Plus第十四章练习
16的博客
05-29 147
14.7.1 Wine.h #ifndef WINE_H #define WINE_H #include <iostream> #include <valarray> #include <string> using namespace std; template <typename T1, typename T2> class Pair { private: T1 a; T2 b; public: Pair(void) {} i
C++ Primer Plus 第六版 第十四章课后编程练习答案
是鲤鱼啊
04-10 704
1. winec.h #ifndef WINEC_H #define WINEC_H #include <iostream> using namespace std; #include <valarray> #include <string> template <class T1, class T2> class Pair{ T1 a...
c++ primer plus第六版编程练习第十四章
jack的博客
03-01 280
List item
c++ Primer Plus（第六版）第十四章习题，写代码之路
Robot_x的博客
02-08 1661
c++ Primer Plus（习题14.1) //书上的测试文件，相当于客户的使用说明书 //对于书上那个Pair对象，不认真的人都怀疑是否学过 //竟然是一个模板,这道题目想了很久很久，还是没思路 //看网上的习题，才学会了模仿，总之还是书上没完全就看懂，才会出现这种问题 //两题一样的测试文件 #include #include"winec.h" int main() { using s
c++ primer第五版课后习题
最新发布
07-08
C++ Primer第五版是一本非常经典的C++编程入门教材，它包含了大量的课后习题帮助读者巩固所学的知识。这些习题涵盖了从基础到高级的各个方面，可以帮助读者提升编程能力。 如果你有具体的习题需要帮助或者想要了解...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值