第十三章 编程练习

最新推荐文章于 2024-01-11 16:09:40 发布
最新推荐文章于 2024-01-11 16:09:40 发布
阅读量266 收藏
点赞数
分类专栏： 产品经理学习C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yituhuashi/article/details/53347722
版权

编程练习1

//Classic.h
#ifndef CLASSIC_H_
#define CLASSIC_H_
//base class
#include <cstring>

class Cd
{
private:
    char performers[50];
    char lable[20];
    int selections;
    double playtime;
public:
    Cd(char * s1, char * s2, int n, double x);
    Cd(const Cd & d);
    Cd();
    virtual void Report() const;
    Cd & operator=(const Cd & d);
};

class Classic:public Cd
{
private:
    char mainselection[50];
public:
    Classic(){}
    Classic(char * s, char * s1, char * s2, int n, double x):Cd(s1, s2, n, x) {strcpy(mainselection, s); }
    Classic(char * s, const Cd & c):Cd(c) {strcpy(mainselection, s); }
    Classic(const Classic &c);
    virtual void Report() const;
    Classic & operator=(const Classic & c);
};
#endif

//Classic.cpp
#include "Classic.h"
#include <cstring>
#include <iostream>

Cd::Cd(char * s1, char * s2, int n, double x)
{
    strcpy(performers, s1);
    strcpy(lable, s2);
    selections = n;
    playtime = x;
}

Cd::Cd(const Cd & d)
{
    strcpy(performers, d.performers);
    strcpy(lable, d.lable);
    selections = d.selections;
    playtime = d.playtime;
}

Cd::Cd()
{
    strcpy(performers, "80s");
    strcpy(lable, "Rock");
    selections = 0;
    playtime = 0;
}

void Cd::Report() const
{ 
    using std::cout;
    using std::endl;
    cout << "Performers of this CD is: " << performers << endl;
    cout << "Lable of this CD is: " << lable << endl;
    cout << "This CD has " << selections << " selections, and playtime is " 
        << playtime << " minutes." << endl;
}
Cd & Cd::operator=(const Cd & d)
{
    if (this == &d)
        return *this;
    strcpy(performers, d.performers);
    strcpy(lable, d.lable);
    selections = d.selections;
    playtime = d.playtime;

    return *this;
}


Classic::Classic(const Classic &c)
{
    Cd::Cd(c);
    strcpy(mainselection, c.mainselection);
}
void Classic::Report() const
{ 
    using std::cout;
    using std::endl;
    Cd::Report();
    cout << "Main selection of this CD is: " << mainselection << endl;

}

Classic & Classic::operator=(const Classic & c)
{
    if (this == &c)
        return *this;
    Cd::operator=(c);
    strcpy(mainselection, c.mainselection);
    return *this;
}
//main.cpp
#include "Classic.h"
#include <iostream>
using std::cout;
using std::endl;

void Bravo(const Cd &disk);

int main()
{
    Cd c1("Beatles", "Capitol", 14, 35.5);
    Classic c2 = Classic("Piano Sonata in Bflat, Fantasia in C", "Alfred Brendel", "Philips", 2, 57.17);
    Cd *pcd = &c1;

    std::cout << "Using object directly:\n";
    c1.Report();
    c2.Report();

    std::cout << "Using type cd *pointer to object:\n";
    pcd->Report();
    pcd = &c2;
    pcd->Report();

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

    system("pause");
    return 0;
}

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

编程练习2 ，这里只需修改类，主函数跟上题一样

//Classic.h
#ifndef CLASSIC_H_
#define CLASSIC_H_
//base class
#include <cstring>

class Cd
{
private:
    char * performers;
    char * lable;
    int selections;
    double playtime;
public:
    Cd(char * s1, 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 * mainselection;
public:
    Classic();
    Classic(char * s, char * s1, char * s2, int n, double x);
    Classic(char * s, const Cd & c);
    Classic(const Classic &c);
    ~Classic();
    virtual void Report() const;
    Classic & operator=(const Classic & c);
};
#endif


//classic.cpp
#include "Classic.h"
#include <cstring>
#include <iostream>

Cd::Cd(char * s1, char * s2, int n, double x)
{
    int len1 = strlen(s1);
    int len2 = strlen(s2);
    performers = new char[len1+1];
    lable = new char[len2+1];
    strcpy(performers, s1);
    strcpy(lable, s2);
    selections = n;
    playtime = x;
}

Cd::Cd(const Cd & d)
{
    int len1 = strlen(d.performers);
    int len2 = strlen(d.lable);
    performers = new char[len1+1];
    lable = new char[len2+1];
    strcpy(performers, d.performers);
    strcpy(lable, d.lable);
    selections = d.selections;
    playtime = d.playtime;
}

Cd::Cd()
{
    int len1 = strlen("80s");
    int len2 = strlen("Rock");
    performers = new char[len1+1];
    lable = new char[len2+1];
    strcpy(performers, "80s");
    strcpy(lable, "Rock");
    selections = 0;
    playtime = 0;
}

Cd::~Cd()
{
    delete [] lable;
    delete [] performers;
}
void Cd::Report() const
{ 
    using std::cout;
    using std::endl;
    cout << "Performers of this CD is: " << performers << endl;
    cout << "Lable of this CD is: " << lable << endl;
    cout << "This CD has " << selections << " selections, and playtime is " 
        << playtime << " minutes." << endl;
}
Cd & Cd::operator=(const Cd & d)
{
    if (this == &d)
        return *this;
    delete [] performers;
    delete [] lable;
    int len1 = strlen(d.performers);
    int len2 = strlen(d.lable);
    performers = new char[len1+1];
    lable = new char[len2+1];
    strcpy(performers, d.performers);
    strcpy(lable, d.lable);
    selections = d.selections;
    playtime = d.playtime;

    return *this;
}


Classic::Classic(const Classic &c)
{
    Cd::Cd(c);
    int len = strlen(c.mainselection);
    mainselection = new char[len+1];
    strcpy(mainselection, c.mainselection);
}
Classic::Classic()
{
    Cd::Cd();
    int len = strlen("aaa");
    mainselection = new char[len+1];
    strcpy(mainselection, "aaa");
}
Classic::Classic(char * s, char * s1, char * s2, int n, double x)
{
    Cd::Cd(s1, s2, n, x);
    int len = strlen(s);
    mainselection = new char[len+1];
    strcpy(mainselection, s); 
}
Classic::Classic(char * s, const Cd & c)
{
    Cd::Cd(c); 
    int len = strlen(s);
    mainselection = new char[len+1];
    strcpy(mainselection, s);
}
void Classic::Report() const
{ 
    using std::cout;
    using std::endl;
    Cd::Report();
    cout << "Main selection of this CD is: " << mainselection << endl;  
}

Classic & Classic::operator=(const Classic & c)
{
    if (this == &c)
        return *this;
    Cd::operator=(c);
    delete [] mainselection;
    int len = strlen(c.mainselection);
    mainselection = new char[len+1];
    strcpy(mainselection, c.mainselection);
    return *this;
}

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

编程练习3，这道题添加一个抽象基类感觉完全然并乱啊，不得其解。。。

//dma.h
#ifndef DMA_H_
#define DMA_H_
#include <iostream>

class DMA
{
private:
    char *label;
    int rating;
public:
    DMA() { label = NULL; rating = 0; }
    DMA(const char *l, const int r);
    virtual ~DMA() { delete[] label; label = NULL; }

    char *GetLabel() const { return label; }
    int GetRating() const { return rating; }
    DMA &operator=(const DMA &rs);
    virtual void View() const = 0;
};

class baseDMA : public DMA
{
public:
    baseDMA() : DMA() {}
    baseDMA(const char *l, const int r) : DMA(l, r) {}

    baseDMA &operator=(const baseDMA &rs);
    virtual void View() const;
};

class lacksDMA : public DMA
{
private:
    char color[40];
public:
    lacksDMA() : DMA() { std::strcpy(color, "NULL"); }
    lacksDMA(const char *l, const int r, const char *c) : DMA(l, r) { std::strcpy(color, c); }

    lacksDMA &operator=(const lacksDMA &rs);
    virtual void View() const;
};

class hasDMA : public DMA
{
private:
    char *style;
public:
    hasDMA() : DMA() { style = NULL; }
    hasDMA(const char *l, const int r, const char *s);
    ~hasDMA() { delete[] style; style = NULL; }

    hasDMA &operator=(const hasDMA &res);
    virtual void View() const;
};

#endif
//dma.cpp
#include "DMA.h"
DMA::DMA(const char *l, const int r)
{
    label = new char[std::strlen(l) + 1];
    std::strcpy(label, l);
    rating = r;
}

DMA &DMA::operator=(const DMA &rs)
{
    if (this == &rs)
        return *this;
    delete[] label;
    label = new char[std::strlen(rs.label) + 1];
    std::strcpy(label, rs.label);
    rating = rs.rating;
    return *this;
}

baseDMA &baseDMA::operator=(const baseDMA &rs)
{
    if (this == &rs)
        return *this;
    DMA::operator=(rs);
    return *this;
}

void baseDMA::View() const
{
    std::cout << "label: " << GetLabel() << std::endl;
    std::cout << "rating: " << GetRating() << std::endl;
}

lacksDMA &lacksDMA::operator=(const lacksDMA &rs)
{
    if (this == &rs)
        return *this;
    DMA::operator=(rs);
    std::strcpy(color, rs.color);
    return *this;
}

void lacksDMA::View() const
{
    std::cout << "label: " << GetLabel() << std::endl;
    std::cout << "rating: " << GetRating() << std::endl;
    std::cout << "color: " << color << std::endl;
}

hasDMA::hasDMA(const char *l, const int r, const char *s) : DMA(l, r)
{
    style = new char[std::strlen(s) + 1];
    std::strcpy(style, s);
}

hasDMA &hasDMA::operator=(const hasDMA &rs)
{
    if (this == &rs)
        return *this;
    DMA::operator=(rs);
    delete[]style;
    style = new char[std::strlen(rs.style) + 1];
    std::strcpy(style, rs.style);
    return *this;
}

void hasDMA::View() const
{
    std::cout << "label" << GetLabel() << std::endl;
    std::cout << "rating: " << GetRating() << std::endl;
    std::cout << "style: " << style << std::endl;
}
//main.cpp
#include "DMA.h"
const int LEN = 2;

int main()
{
    DMA *p[LEN];
    for (int i = 0; i < LEN; ++i)
    {
        int flag;
        std::cout << "Please select object，1:lacksDMA 2:hasDMA : ";
        std::cin >> flag;
        if (1 == flag)
        {
            lacksDMA l("Tree", 100, "BLACK");
            p[i] = &l;
            p[i]->View();
        }
        else
        {
            hasDMA h("Tree", 100, "OMG");
            p[i] = &h;
            p[i]->View();
        }
    }
    system("pause");
    return 0;
}

编程练习4

//port.h
#ifndef PORT_H_
#define PORT_H_

#include <iostream>

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 std::ostream &operator<<(std::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);
    virtual void Show() const;
    friend std::ostream &operator<<(std::ostream &os, const VintagePort &vp);
};
#endif

//port.cpp
#include "Port.h"
#include <iostream>

Port::Port(const char *br, const char *st, int b)
{
    brand = new char[strlen(br)+1];
    strcpy(brand, br);
    strncpy(style, st,20);
    style[19] = '\0';
    bottles = b;
}
Port::Port(const Port &p)
{
    brand = new char[strlen(p.brand)+1];
    strcpy(brand, p.brand);
    strncpy(style, p.style,20);
    style[19] = '\0';
    bottles = p.bottles;
}

Port & Port::operator=(const Port &p)
{
    if(this==&p)
        return *this;
    delete [] brand;
    brand = new char[strlen(p.brand)+1];
    strcpy(brand, p.brand);
    strncpy(style, p.style,20);
    style[19] = '\0';
    bottles = p.bottles;
    return *this;
}
Port & Port::operator+=(int b)
{
    bottles +=b;
    return *this;
}
Port & Port::operator-=(int b)
{
    bottles -=b;
    return *this;
}

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

std::ostream &operator<<(std::ostream &os, const Port &p)
{
    os << p.brand << ", " << p.style << ", " << p.bottles << '\n';
    return os;
}


VintagePort::VintagePort():Port()
{
    nickname = new char[1];
    nickname = nullptr;
    year = 0;
}
VintagePort::VintagePort(const char *br, int b, const char *nn, int y):Port(br, "Vintage", 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)
{
    if(this == &vp)
        return *this;
    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();
    std::cout << "nick name: " << nickname << std::endl;
    std::cout << "year: " << year << std::endl;
}

std::ostream &operator<<(std::ostream &os, const VintagePort &vp)
{
    os << (Port &)vp;
    std::cout << ", " << vp.nickname << ", " << vp.year;
    return os;
}
//main.cpp
#include "Port.h"
#include <iostream>
int main()
{
    Port *ptr;
    Port p("Gallo", "tawny", 20);
    ptr = &p;
    ptr->Show();
    std::cout << p << std::endl;
    VintagePort v("Gallo", 20, "gal", 20);
    ptr = &v;
    ptr->Show();
    std::cout << v << std::endl;
    system("pause");
    return 0;
}
yituhuashi
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C Primer Plus 第六版 第十三章 编程练习
vo_ai_sen的博客
06-12 219
C Primer Plus 第六版第十三章 编程练习
C Primer Plus (第六版) 第十三章_编程练习答案
weixin_44603568的博客
06-09 2704
no1.c // 修改程序清单13.1中的程序,要求提示用户输入文件名,并读取用户输入信息,不使用命令行参数. # include <stdio.h> # include <stdlib.h> int main(void) { int ch ; FILE * fp ; char st[100]; unsigned long count = 0 ; prin...
第十三章编程练习(1)
Maninblack_C的博客
02-27 283
Classic.h #pragma once #ifndef Classic_H_ #define Classic_H_ class Cd { private: char performers[50]; char label[20]; int selections; double playtime; public: Cd(char * s1, char * s2, int n, dou
C PRIMER PLUS第六版 第十三章编程练习
o707191418的博客
08-23 1931
复习题第五题代码 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #define BUF 256 int has_ch(char, char *); int main(int argc, char * argv []) { char ch; FILE * fp; char line[BUF]; if(a...
C Primer Plus （中文版）第13章编程练习 参考答案(仅供参考~)
最新发布
在导航领域努力的小白 ~ (●'◡'●) 加油加油！！
01-11 1965
C Primer Plus （中文版）第13章编程练习 参考答案(仅供参考~)
C++ primer plus 第六版 第十三章 编程练习答案
菜鸡harry的博客
08-21 3067
第十三章 编程练习答案 1. //头文件 #ifndef CD_H_ #define CD_H_ //Brass Cd 类 class Cd { private: char performers[50]; char label[20]; int selections; double playtime; public: Cd(char * s1,...
C++ Primer Plus第六版 第十三章 编程练习答案
蒟蒻升级中...Orz
11-21 2844
今天下午体测 GGGGGGGGGGGG //第一题 //main.cpp #include "cd.h" void Bravo(const Cd &disk); int main() { Cd c1("Beatles", "Capitol", 14, 35.5); Classic c2 = Classic("Piano Sonata in Bflat, Fantasia in C
java第十版基础篇答案第三章_java语言程序设计基础篇第十版第十三章练习答案.docx...
weixin_42467661的博客
02-24 377
java语言程序设计基础篇第十版第十三章练习答案01public class Exercise13_01 {public static void main(String[] args) {TriangleNew triangle = new TriangleNew(1, 1.5, 1);triangle.setColor("yellow");triangle.setFilled(true);Sys...
C++ primer plus 第六版 第八章 编程练习答案
菜鸡harry的博客
08-03 5358
第八章 编程练习答案 1. 一开始没看懂题目意思，百度参考了一下别人的结果。 #include &lt;iostream&gt; using namespace std; int count = 0; void Printf(const char * str, int n = 0);//默认参数 int main() { const char* str = "hello!"...
java语言程序设计基础篇第十三章编程练习题
热门推荐
梦幻的蔷薇色
09-08 1万+
1 2 3 4 /* 我在 java核心技术 里面看到了一个示例代码挺符合这个题目，不过我想吐槽那里面写的好麻烦，满满的全是方法的调用，感觉还不如用c写出来简洁呢 */ 5GeometricObject.java :package yongheng;public abstract class GeometricObject implements Comparable<GeometricObject>
C++ Primer Plus 编程练习源码工程 第13章
10-26
《C++ Primer Plus 编程练习源码工程 第13章》是一个专注于C++学习者提升编程技能的资源集合。这个源码工程包含了作者LeonardoLiuwenbo在阅读《C++ Primer Plus》这本书时所做的各种编程练习，旨在帮助读者深入理解...
C++ Primer Plus 编程练习源码工程 第15章
12-25
《C++ Primer Plus 编程练习源码工程 第15章》是针对C++初学者的一个宝贵资源，它包含了作者LeonardoLiuwenbo在学习《C++ Primer Plus》这本经典教材时所做的编程练习。这个章节聚焦于C++语言的深入特性，旨在通过...
java语言程序设计基础篇第十版第十三章练习标准答案.pdf
10-12
本资源提供了 Java 语言程序设计基础篇第十三章的练习标准答案，涵盖了面向对象编程、集合框架、泛型、方法重写和数组操作等多个知识点。这将有助于读者更好地理解 Java 语言的基本概念和编程技术。
第四章 课后编程练习参考代码-20181
08-04
在本章的课后编程练习中，我们涵盖了多个与数组、算法、数据处理以及基本的编程技巧相关的知识点。以下是对这些知识点的详细说明： 1. **奇偶数调整**： - **用两个数组实现**：这种方法是创建两个新的数组，一个...
第2章Java编程基础ppt课件.ppt
11-12
"Java编程基础知识点总结" 在本篇文章中，我们将对Java编程基础知识点进行总结，涵盖了Java基础知识点、数据类型、变量、运算符、...所有的练习题都进行了详细的解析和分析，帮助读者更好地理解Java编程基础知识点。
第十章 对象和类
yituhuashi的博客
11-17 600
C++跟C相比最重要的改进就是提供了类，这本书到了第十章终于讲这个了。。。而且还是最基础的基础，可见C++博大精深啊，路漫漫其修远兮，吾只能慢慢一点一点求索啊  1. 过程性编程和面向对象编程 学习类肯定得知道为什么有类，类是为了面向对象的编程，区别于老一代面向过程的编程。过程性编程就是首先考虑要遵循的步骤，然后考虑如果一步一步表示这些数据。但是实际情况往往不是一步一步来的，一会跳到这
第十五章（1）
yituhuashi的博客
12-07 420
现在讲的越来越深了，有的时候笔记都不知道怎么记了，很多也只能直接抄书上的。这里尽力吧，原谅我们这些初学者：） 1. 友元 友元现在很熟悉了，如果声明一个函数为一个类的友元，则这个函数可以访问这个类的成员。类也可以将类作为友元，这样友元类的所有方法都可以访问原始类的私有成员和保护成员。 这样有什么作用呢？书中举了一个Tv类和一个Remote类的例子。两个类没有从属关系，更像是朋友关系，这个时候
第九章 编程练习
yituhuashi的博客
11-17 394
编程练习1// golf.cpp #include "golf.h" #include <cstring> #include <iostream>using namespace std; void setgolf(golf & g, const char * name, int hc) { strcpy(g.fullname,name); g.handicap = hc; }int
第十二章 编程练习
yituhuashi的博客
11-24 377
这章开始编程练习都好长，敲都要敲半天。。。 编程练习1//Cow.h #ifndef COW_H_ #define COW_H_ class Cow { private: char name[20]; char * hobby; double weight; public: Cow(); Cow(const char * nm, const char * h
C++primer Plus第2-13章编程练习答案详解
本资源摘要信息将对C++primer plus第2-13章的答案进行详细解读，涵盖了C++语言的基础知识和基本编程实践。 **第二章：开始学习C++** 本章节主要介绍了C++语言的基本概念和语法结构，包括变量、数据类型、运算符、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值