第十二章 编程练习

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

这章开始编程练习都好长，敲都要敲半天。。。
编程练习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 * ho, double wt);
    Cow(const Cow &c);
    ~Cow();
    Cow & operator=(const Cow & c);
    void ShowCow() const;
};
#endif

//Cow.cpp
#include "Cow.h"
#include <cstring>
#include <iostream>
using namespace std;

Cow::Cow()
{
    strcpy(name,"");
    hobby = new char[1];
    hobby[0] = '\0';
    weight = 0;
}
Cow::Cow(const char * nm, const char * ho, double wt)
{
    strcpy(name, nm);
    hobby = new char[strlen(ho)+1];
    strcpy(hobby, ho);
    weight = wt;
}
Cow::Cow(const Cow &c)
{
    strcpy(name, c.name);
    hobby = new char[strlen(c.hobby)+1];
    strcpy(hobby, c.hobby);
    weight = c.weight;
}

Cow::~Cow(void)
{
    delete [] hobby;
}

Cow & Cow::operator=(const Cow & c)
{
    if (this == &c)
        return *this;
    strcpy(name, c.name);
    delete [] hobby;
    hobby = new char[strlen(c.hobby)+1];
    strcpy(hobby, c.hobby);
    weight = c.weight;
    return *this;
}
void Cow::ShowCow() const
{
    cout << "Cow's name is "<< name
        << "; Cow's hobby is " << hobby
        << "; Cow's weight is " << weight
        << endl;
}
//main.cpp
#include "Cow.h"
#include <iostream>

int main()
{
    {
        Cow cow1;
        Cow cow2("yellow cow", "sleep", 2000);
        Cow cow3(cow2);
        cow1 = cow2;
        cow1.ShowCow();
        cow2.ShowCow();
        cow3.ShowCow();
    }
    system("pause");
    return 0;
}

编程练习2
这里的两个string的加法运算符重载可以好好品味一下

//string2.h
#ifndef STRING2_H_
#define STRING2_H_
#include <iostream>
using std::ostream;
using std::istream;

class String
{
private:
    char *str;
    int len;
    static int num_Strings;
    static const int CLNLIM = 80;
public:
    String();
    ~String();
    String(const char *s);
    String(const String &);
    int length () const {return len;}

    String & operator=(const String &);
    String & operator=(const char *);
    char & operator[] (int i);
    const char & operator[] (int i) const;

    friend bool operator<(const String &st1, const String &st2);
    friend bool operator>(const String &st1, const String &st2);
    friend bool operator==(const String &st1, const String &st2);
    friend String operator+(const String &st1, const String &st2);

    friend ostream & operator<<(ostream & os, const String & st);
    friend istream & operator>>(istream & is, String & st);

    void StringLow();
    void StringUp();
    int has(char c);
};
#endif

//string2.cpp
#include "String2.h"
#include <cstring>
using std::cin;
using std::cout;

int String::num_Strings = 0;
String::String(void)
{
    len = 4;
    str = new char[1];
    str[0] = '\0';
    num_Strings++;
}


String::~String(void)
{
    --num_Strings;
    delete [] str;
}

String::String(const char *s)
{
    len = std::strlen(s);
    str = new char[len+1];
    std::strcpy(str, s);
    num_Strings++;
}
String::String(const String &st)
{
    num_Strings++;
    len = st.len;
    str = new char[len+1];
    std::strcpy(str, st.str);
}

String & String::operator=(const String &st)
{
    if (this==&st)
        return *this;
    delete [] str;
    len = st.len;
    str = new char[len+1];
    std::strcpy(str, st.str);
    return *this;
}
String & String::operator=(const char *s)
{
    delete [] str;
    len = std::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
{
    return str[i];
}

bool operator<(const String &st1, const String &st2)
{
    return (std::strcmp(st1.str, st2.str) < 0);
}
bool operator>(const String &st1, const String &st2)
{
    return st2 < st1;
}
bool operator==(const String &st1, const String &st2)
{
    return (std::strcmp(st1.str, st2.str) == 0);
}
String operator+(const String &st1, const String &st2)
{
    String s;
    s.len = st1.len + st2.len;
    s.str = new char[s.len + 1];
    strcpy(s.str, st1.str);
    strcat(s.str, st2.str);
    return s;
}

ostream & operator<<(ostream & os, const String & st)
{
    os << st.str;
    return os;
}
istream & operator>>(istream & is, String & st)
{
    char temp[String::CLNLIM];
    is.get(temp, String::CLNLIM);
    if(is)
        st = temp;
    while (is && is.get() != '\n')
        continue;
    return is;
}

void String::StringLow()
{
    for(int i=0;i<len;i++)  
        str[i]=tolower(str[i]);  
}
void String::StringUp()
{
    for(int i=0;i<len;i++)  
        str[i]=toupper(str[i]);  
}

int String::has(char c)
{
    int num = 0;
    for(int i=0;i<len;i++) 
    {
        if (str[i]==c)
            num++;
    }
    return num; 
}
//main.cpp
#include <iostream>
using namespace std;
#include "String2.h"

int main()
{
    String s1(" and I am a C++ student.");
    String s2 = "Please enter your name: ";
    String s3;
    cout << s2;
    cin >> s3;
    //s2 = s1+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 in it.\n";
    s1 = "red";

    String rgb[3] = {String(s1), String("green"), String("blue")};
    cout << "Enter the name of a primary 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;
}

编程练习3

//Stock.h
#ifndef STOCK_H_
#define STOCK_H_
#include <iostream>
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 *co, long n = 0, double pr = 0.0);
    ~Stock();
    void buy(long num, double price);
    void sell(long num, double price);
    void update(double price);
    const Stock &topval(const Stock &s) const;
    friend std::ostream &operator<<(std::ostream &os, const Stock &s);
};
#endif

//Stock.cpp
#include "Stock.h"

Stock::Stock()
{
    company = new char[1];
    company[0] = '\0';
    shares = 0;
    share_val = 0;
    set_tot();
}

Stock::~Stock()
{
    delete [] company;
}

Stock::Stock(const char *co, long n, double pr)
{
    int len = strlen(co);
    company = new char[len+1];
    strcpy(company, co);
    if (n < 0)
    {
        std::cout << "Number of shares can't be negative; "
            << company << " shares set to 0.\n";
        shares = 0;
    }
    else
        shares = n;
    share_val = pr;
    set_tot();
}

void Stock::buy(long num, double price)
{
    if (num < 0)
    {
        std::cout << "Number of shares purchased can't be negative. "
            << "Transaction is aborted. \n";
    }
    else
    {
        shares += num;
        share_val = price;
        set_tot();
    }
}
void Stock::sell(long num, double price)
{
    if (num < 0)
    {
        std::cout << "Number of shares sold can't be negative. "
            << "Transaction is aborted.\n";
    }
    else if (num > shares)
    {
        std::cout << "You can't sell more than you have! "
            << "Transaction is aborted.\n";
    }
    else
    {
        shares -= num;
        share_val = price;
        set_tot();
    }
}
void Stock::update(double price)
{
    share_val = price;
    set_tot();
}
const Stock & Stock::topval(const Stock &s) const
{
    if (s.total_val > total_val)
        return s;
    else
        return *this;
}
std::ostream &operator<<(std::ostream &os, const Stock &s)
{
    std::ios_base::fmtflags orig = os.setf(std::ios_base::fixed, std::ios_base::floatfield);
    std::streamsize prec = os.precision(3);

    os << "Company: " << s.company << "  Shares: " << s.shares << '\n';
    os << "  Share Price: $" << s.share_val;
    os.precision(2);
    os << "  Total Worth: $" << s.total_val << '\n';

    os.setf(orig, std::ios_base::floatfield);
    os.precision(prec);
    return os;
}
//main.cpp
#include "stock.h"
#include <iostream>

const int STKS = 4;

int main()
{
    Stock stocks[STKS] = {
        Stock("NanoSmart", 12, 20.0),
        Stock("Boffo Objects", 200, 2.0),
        Stock("Monolithic, Obelisks", 130, 3.25),
        Stock("Fleep Enterprises", 60, 6.5)
    };
    std::cout << "Stock holdings:\n";
    int st;
    for (st = 0; st < STKS; ++st)
        std::cout << stocks[st];
    const Stock *top = &stocks[0];
    for (st = 1; st < STKS; ++st)
        top = &top->topval(stocks[st]);
    std::cout << "\nMost valuable holding: \n";
    std::cout << (*top);
    system("PAUSE");
    return 0;
}

编程练习4

//Stack.h
#ifndef STACK_H_
#define STACK_H_

#include <iostream>
typedef unsigned long Item;
class Stack
{
private:
    enum { MAX = 10};
    Item *pitems;
    int size;
    int top;
public:
    Stack(int n = MAX);
    Stack(const Stack &st);
    ~Stack();
    bool isempty() const;
    bool isfull() const;
    bool push(const Item &item);
    bool pop(Item &item);
    Stack &operator=(const Stack &st);

};
#endif
//Stack.cpp
#include "Stack.h"

Stack::Stack(int n)
{
    pitems = new Item[1];
    pitems[0] = '\0';
    size = n;
    top = 0;;
}

Stack::Stack(const Stack &st)
{
    pitems = new Item(st.size);
    size = st.size;
    for (top = 0; top < size; ++top)
        pitems[top] = st.pitems[top];
}
Stack::~Stack(void)
{
    delete [] pitems;
}

bool Stack::isempty() const
{
    return top == 0;
}
bool Stack::isfull() const
{
    return top == size;
}

bool Stack::push(const Item &item)
{
    if (isfull())
        return false;
    pitems[top++] = item;
    return true;
}
bool Stack::pop(Item &item)
{
    if (isempty())
        return false;
    --top;
    return true;
}
Stack & Stack::operator=(const Stack &st)
{
    if (this == &st)
        return *this;
    pitems = new Item(st.size);
    size = st.size;
    for (top = 0; top < size; ++top)
        pitems[top] = st.pitems[top];
    return *this;
}
//main.cpp
#include "stack.h"

int main()
{
    Stack s(10);

    std::cout << s.isempty() << std::endl;
    s.push(100);
    std::cout << s.isempty() << std::endl;

    system("pause");
    return 0;
}

编程练习5,可以直接用书中的例子来测试了, 编程练习6 稍微更改一下主函数再添加一个queue对象然后添加一些操作即可,这里就不贴出来了.但是这是一个很好的队列的练习;在读完本书之后可以回过头来好好分析一下.

yituhuashi
关注
专栏目录
C Primer Plus(第6版) 第十二章 编程练习参考答案
weixin_51614848的博客
02-27 586
C Primer Plus(第6版) 第十二章 编程练习参考答案 编译环境：Microsoft Visual Studio 2019 备注：本文留作作者自用，如有错误敬请指出 （针对Microsoft Visual Studio 2019的一些特性对答案进行了修改） 编程练习 1.不使用全局变量,重写程序清单12.4。 #include<stdio.h> #include<stdlib.h> int main(void) { int units = 0; printf("How
《C Primer Plus》第六版 第十二章编程练习答案
11-27
### 《C Primer Plus》第六版 第十二章编程练习答案解析 #### 练习1: 猜数字游戏 在本练习中，程序设计了一个简单的猜数字游戏，目标是让用户猜测一个预设的数字（本例中为56），直到猜对为止。 - **程序结构与...
C.Primer.Plus(第六版)第12章 编程练习
mmdnxh的博客
07-17 484
//12.1// cow.h #ifndef COW__H__ #define COW__H__ class Cow { private: static const int N = 20; char name[N]; char *hobby; double weight; public: Cow(); Cow(const char* nm,const
C PRIMER PLUS第六版 第十二章编程练习
o707191418的博客
08-21 2273
1. #include &lt;stdio.h&gt; void critic(int * num); int main(void) { int units = 0; printf("How many pounds to a firkin of butter?\n"); scanf("%d",&amp;units); while(units != 56) ...
C Primer Plus 第十二章 编程练习 1-8题
qazaq408的博客
03-09 603
第1题#include&lt;stdio.h&gt; int critic(void); int main(void) { int realResult; printf("Please Try To Input Any INteger:\n"); scanf("%d",&amp;realResult); while(realResult != 56) realResult...
C++ primer plus 第六版 第十二章 编程练习答案
菜鸡harry的博客
08-14 3669
第十二章 编程练习答案 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（第六版）》（24）（第十二章 类和动态内存分配 编程题和答案）...
weixin_30336061的博客
12-26 241
1.对于下面的类声明： class Cow { private: char name[20]; char * hobby; double weight; public: Cow(); Cow(const char * nm, const char* ho, double w...
C Primer Plus第十二章编程练习答案
最新发布
sakura0908的博客
05-29 1050
学完C语言之后，我就去阅读《C Primer Plus》这本经典的C语言书籍，对每一章的编程练习题都做了相关的解答，仅仅代表着我个人的解答思路，如有错误，请各位大佬帮忙点出！
C Primer Plus 第12章编程练习
weixin_44500921的博客
05-16 155
1. 2. 3. 4. 5. 6. 7. 8.
C Primer Plus 第十二章编程练习解析与解答
"《C Primer Plus》第六版的第十二章编程练习提供了两个示例程序，分别涉及到循环控制和用户输入验证以及不同单位之间的转换。第一个程序是一个简单的猜数字游戏，用户需要猜一个预设的数值，直到猜对为止。第二个...
向双链表中插入节点C和指针第十二章编程练习6
04-30
本编程练习6的主题是向双链表中插入节点，特别是节点C。在这个练习中，我们需要理解双链表的结构，创建新节点，以及在适当位置正确地插入新节点。 首先，我们来详细解释双链表的基本概念。双链表的每个节点由三部分...
C++primer plus第六版课后编程练习答案12.1
qq_25301067的博客
12-03 291
#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); Cow(const Cow &c); ~Cow(); Cow &operat
第十章 对象和类
yituhuashi的博客
11-17 616
C++跟C相比最重要的改进就是提供了类，这本书到了第十章终于讲这个了。。。而且还是最基础的基础，可见C++博大精深啊，路漫漫其修远兮，吾只能慢慢一点一点求索啊  1. 过程性编程和面向对象编程 学习类肯定得知道为什么有类，类是为了面向对象的编程，区别于老一代面向过程的编程。过程性编程就是首先考虑要遵循的步骤，然后考虑如果一步一步表示这些数据。但是实际情况往往不是一步一步来的，一会跳到这
第十五章（1）
yituhuashi的博客
12-07 436
现在讲的越来越深了，有的时候笔记都不知道怎么记了，很多也只能直接抄书上的。这里尽力吧，原谅我们这些初学者：） 1. 友元 友元现在很熟悉了，如果声明一个函数为一个类的友元，则这个函数可以访问这个类的成员。类也可以将类作为友元，这样友元类的所有方法都可以访问原始类的私有成员和保护成员。 这样有什么作用呢？书中举了一个Tv类和一个Remote类的例子。两个类没有从属关系，更像是朋友关系，这个时候
第九章 编程练习
yituhuashi的博客
11-17 411
编程练习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-25 377
继承很好理解了，如果我们开发了一个水果的类，我们可以继续开发一个苹果的子类或者橙子的子类。苹果和橙子的子类都可以继承水果类的特性和方法。那么这个继承是怎么实现的，哪些可以继承哪些不能继续，苹果和橙子之间又是什么关系，让我们带着这些问题来看这章。 1. 一个简单的基类 从一个类（水果）派生出另一个类（苹果，橙子）时，原始类（水果）称为基类，继承类称为派生类（苹果，橙子）。书中给了一个简单
第十四章 编程练习（2）
yituhuashi的博客
12-06 342
编程练习4//Person.h #ifndef PERSON_H_ #define PERSON_H_#include <string> #include <iostream> class Person { private: std::string name; protected: const std::string &GetName() const { return name; }
第十五章 编程练习
yituhuashi的博客
12-13 333
编程练习1//tv.h #ifndef TV_H_ #define TV_H_#include <iostream> class Tv { public: friend class Remote; enum {Off, On}; enum {MinVal, MaxVal = 20}; enum {Antenna, Cable}; enum {TV, DVD};
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值