第十二章编程练习

于 2022-03-26 00:08:25 发布
阅读量139 收藏
点赞数
分类专栏： 《C++ Primer Plus 第6版》之编程练习 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AlexiaDong/article/details/123744950
版权

1.对于下面的声明

class Cow 
{
    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; // display all cow data
};

给这个类提供实现，并编写一个使用所有成员函数的小程序。
实现：
cow.cpp

#include "cow.h"

Cow::Cow()
{
	name[0] = '\0';
	hobby = nullptr;
	weight = 0.0;
}

Cow::Cow(const char* nm, const char* ho, double wt)
{
	strncpy(name,nm,20);
	if (strlen(nm) >= 20)
	{
		name[19] = '\0';
	}

	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()
{
	delete []hobby;
}

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(name, c.name);
	weight = c.weight;
	return *this;
}

void Cow::ShowCow() const
{
	cout << "Name:" << name << " , Hobby:" << hobby << " , Weight:" << weight << endl;
}

main.cpp

    Cow cow1;
    Cow cow2("cow2", "piano", 70);
    Cow cow3(cow2);
    cow1 = cow2;
    cow1.ShowCow();
    cow2.ShowCow();
    cow3.ShowCow();

2.通过完成下面的工作来改进string类声明（即将String1.h升级为String2.h）。
a.对+运算符进行重载，使之可将两个字符串合并为一个。
b.提供一个StringLow()成员函数，将字符串中所有的字母字符转换为小写（别忘了cctype系列字符函数）。
c.提供StringUp()成员函数，将字符串中所有字母字符转换为大写。
d.提供一个这样的成员函数，它接受一个char参数，返回该字符在字符串中出现的次数。
使用下面的程序来测试您的工作：

#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;              // overloaded << operator
    cin >> s3;               // overloaded >> operator
    s2 = "My name is " + s3; // overloaded =, + operators
    cout << s2 << ".\n";
    s2 = s2 + s1;
    s2.stringup(); // converts string to uppercase
    cout << "The string\n" << s2 << "\ncontains " << s2.has('A')
         << " 'A' characters in it.\n";
    s1 = "red"; // String(const char *),
                // then String & operator=(const String&)
    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(); // converts string to lowercase
        for (int i = 0; i < 3; i++)
        {
            if (ans == rgb[i]) // overloaded == operator
            {
                cout << "That's right!\n";
                success = true;
                break;
            }
        }
        if (success)
            break;
        else
            cout << "Try again!\n";
    }
    cout << "Bye\n";
    return 0;
}

实现：
String2.h

#pragma once
#include <cctype>
#include <cstring>
#include <iostream>
using namespace std;

class String
{
private:
    char* str;                    // pointer to string
    int len;                       // length of string
    static int num_strings;        // number of objects
    static const int CINLIM = 80; // cin input limit
public:
    // constructors and other methods
    String(const char* s);       // constructor
    String();                     // default constructor
    String(const String&);       // copy constructor
    ~String();                    // destructor
    int length() const { return len; }
    // overloaded operator methods
    String& operator=(const String&);
    String& operator=(const char*);
    char& operator[](int i);
    const char& operator[](int i) const;
    // overloaded operator friends
    friend bool operator<(const String& st, const String& st2);
    friend bool operator>(const String& st1, 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);
    // static function
    static int HowMany();
    //新增函数
    friend String operator+(const char*s, const String& st);
    String operator+(const String& st);
    void StringLow();
    void StringUp();
    int Has(const char ch);
};

String2.cpp

#include "string2.h"

int String::num_strings = 0;

// static method
int String::HowMany()
{
    return num_strings;
}

// class methods
String::String(const char* s)   // construct String from C string
{
    len = std::strlen(s);        // set size
    str = new char[len + 1];     // allot storage
    std::strcpy(str, s);         // initialize pointer
    num_strings++;               // set object count
}

String::String()                 // default constructor
{
    len = 4;
    str = new char[1];
    str[0] = '\0'; // default string
    num_strings++;
}

String::String(const String& st)
{
    num_strings++;            // handle static member update
    len = st.len;             // same length
    str = new char[len + 1]; // allot space
    std::strcpy(str, st.str); // copy string to new location
}

String::~String()  // necessary destructor
{
    --num_strings; // required
    delete []str; // required
}

// overloaded operator methods

    // assign a String to a String
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;
}

// assign a C string to a String
String& String::operator=(const char* s)
{
    delete[] str;
    len = std::strlen(s);
    str = new char[len + 1];
    std::strcpy(str, s);
    return *this;
}

// read-write char access for non-const String
char& String::operator[](int i)
{
    return str[i];
}

// read-only char access for const String
const char& String::operator[](int i) const
{
    return str[i];
}

// overloaded operator friends

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);
}
// simple String output
ostream& operator<<(ostream& os, const String& st)
{
    os << st.str;
    return os;
}

// quick and dirty String input
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;
}
//新增函数
String operator+(const char* s, const String& st)
{
    String temp;
    temp.len = strlen(s) + st.len;
    temp.str = new char[temp.len + 1];
    strcpy(temp.str, s);
    strcat(temp.str, st.str);
    return temp;
}

String String::operator+(const String& st)
{
    String temp;
    temp.len = len + st.len;
    temp.str = new char[temp.len + 1];
    strcpy(temp.str, str);
    strcat(temp.str, st.str);
    return temp;
}

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(const char ch)
{
    int count = 0;
    for (int i = 0; i < len; i++)
    {
        if (str[i] == ch)
        {
            count++;
        }
    }
    return count;
}

3.新编写程序清单10.7和程序清单10.8描述的stock类，使之使用动态分配的内存，而不是string类对象来存储股票名称。另外，使用重载的operator<<()定义代替show()成员函数。再使用程序清单10.9测试新的定义程序。
实现：
Stock1.h

#pragma once
#include <iostream>
#include <cstring>
using namespace std;

class Stock
{
private:
    char* company;//original:string company
    int shares;
    double share_val;
    double total_val;
    void set_tot() { total_val = shares * share_val; }
public:
    Stock();   // default constructor
    Stock(const char* co, long n = 0, double pr = 0.0);
    ~Stock(); // do-nothing destructor
    void buy(long num, double price);
    void sell(long num, double price);
    void update(double price);
    //void show()const;
    const Stock& topval(const Stock& s) const;
    friend ostream& operator<<(ostream &os, const Stock&s);
};

Stock1.cpp

#include "Stock1.h"

// constructors
Stock::Stock() // default constructor
{
    company = nullptr;//delete可以释放空指针
    shares = 0;
    share_val = 0.0;
    total_val = 0.0;
}

Stock::Stock(const char* co, long n /*= 0*/, double pr /*= 0.0*/)
{
    company = new char[strlen(co) + 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();
}

// class destructor
Stock::~Stock() // quiet class destructor
{
    delete []company;
}

// other methods
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)
{
    using std::cout;
    if (num < 0)
    {
        cout << "Number of shares sold can’t be negative. "
            << "Transaction is aborted.\n";
    }
    else if (num > shares)
    {
        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();
}

//void Stock::show() const
//{
//    using std::cout;
//    using std::ios_base;
//    // set format to #.###
//    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 << " Share Price: $" << share_val;
//    // set format to #.##
//    cout.precision(2);
//    cout << " Total Worth: $" << total_val << '\n';
//
//    // restore original format
//    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;
}

ostream& operator<<(ostream& os, const Stock& s)
{
    cout << "company:" << s.company <<", hares:" << s.shares << ", share_val:" << s.share_val<< ", total_val:" << s.total_val << endl;
    return os;
}

main.cpp

#include "Stock1.h"

const int STKS = 4;
int main()
{
    // create an array of initialized objects
    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++)
        cout << stocks[st];
    // set pointer to first element
    const Stock* top = &stocks[0];
    for (st = 1; st < STKS; st++)
        top = &top->topval(stocks[st]);
    // now top points to the most valuable holding
    std::cout << "\nMost valuable holding:\n";
    cout << *top;

    return 0;
}

4.请看下面程序清单10.10定义的Stack类的变量：

#pragma once
typedef unsigned long Item;

class Stack
{
private:
    enum { MAX = 10 }; // constant specific to class
    Item items[MAX]; // holds stack items
    int top; // index for top stack item
public:
    Stack();
    bool isempty() const;
    bool isfull() const;
    // push() returns false if stack already is full, true otherwise
    bool push(const Item& item); // add item to stack
    // pop() returns false if stack already is empty, true otherwise
    bool pop(Item& item); // pop top into item
};

正如私有成员声明的，这个类使用动态分配的数组来保存栈项。请重新编写方法，以适应这种新的表示法，并编写一个程序来演示所有的方法，包括复制构造函数和赋值构造函数。
实现：
stack.h

#pragma once
typedef unsigned long Item;

class Stack
{
private:
    enum { MAX = 10 }; // constant specific to class
    Item* pitems;
    int size;
    int top; // index for top stack item
public:
    Stack(int n = MAX);
    Stack(const Stack& st);
    ~Stack();
    bool isempty() const;
    bool isfull() const;
    // push() returns false if stack already is full, true otherwise
    bool push(const Item& item); // add item to stack
    // pop() returns false if stack already is empty, true otherwise
    bool pop(Item& item); // pop top into item
    Stack& operator=(const Stack& st);
};

stack.cpp

#include "stack.h"

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

bool Stack::isfull() const
{
    return top == MAX;
}

bool Stack::push(const Item& item)
{
    if (top < MAX)
    {
        pitems[top++] = item;
        return true;
    }
    else
        return false;
}

bool Stack::pop(Item& item)
{
    if (top > 0)
    {
        item = pitems[--top];
        return true;
    }
    else
        return false;
}

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

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

Stack::~Stack()
{
    delete []pitems;
}

Stack& Stack::operator=(const Stack& st)
{
    if (this == &st)
    {
        return *this;
    }

    delete []pitems;

    pitems = new Item[st.size];
    for (int i = 0; i < st.size; i++)
    {
        pitems[i] = st.pitems[i];
    }
    size = st.size;
    top = st.top;
    return *this;
}

main.cpp

#include "stack.h"

const int SIZE = 5;
int main()
{
    Stack st(SIZE);
	Item item;
	for (int i = 0; i < SIZE; i++)
	{
		cout << "Enter number you want to push to stack:" << endl;
		cin >> item;
		while (cin.get() != '\n');
		st.push(item);
	}

	Stack st_new(st);
	for (int i = 0; i < SIZE; i++)
	{
		st_new.pop(item);
		cout << item << " is poped!" << endl;
	}


    return 0;
}
NDWET
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
unsigned long long类型与long long类型
Skyline
05-02 4万+
最近做题的时候，经常遇到范围是2^63，取模2^64的这种题目。遇到这种限制条件时就要想到用unsigned long long类型。 可以简洁地声明为typedef unsigned long long ull。这样，如果ull类型的整数溢出了，就相当于取模2^64了。因为ull的范围是[0,2^64-1]。 而ll的范围是[-2^63,2^63-1]，因为有符号的第63位表示“正负”而不表
P35-c++中的代码重用-04类模板详细介绍，涵盖类模板所有知识点
梦悦foundation
02-25 302
文章目录1. 类模板2. 定义类模板3. 使用模板类4. 深入探讨模板类1.不正确地使用指针栈 1. 类模板 继承(公有、私有或保护)和包含并不总是能够满足重用代码的需要。例如, Stack类(参见第10章)和 Queue类(参见第12章)都是容器类( container class),容器类设计用来存储其他对象或数据类型。 例如,第10章的 Stack类设计用于存储 unsigned long值。可以定义专门用于存储 double 值或 string对象的 Stack类, 除了保存的对象类型不同外,这两种
C++Primer Plus笔记——第十章 对象和类及课后编程练习答案
YukinoAI的博客
09-30 577
目录 本章小结 程序清单 创建一个Stock类（version 1） 创建一个Stock类（version 2），增加了构造函数和析构函数 创建一个Stock类（version 3），使用了*this指针 创建一个抽象数据类型(ADT)--stack类 课后编程习题答案 本章小结        面向对象编程强调的是程序如何表示数据。使用OOP方法解决编程问题的第一步是根据它程序...
第 10 章 对象和类
Briwisdom的博客
10-17 205
cat /proc/cpuinfo 查看cpu free -m 查看内存
类模板template ＜class T＞
weixin_43294620的博客
02-07 5869
类模板template ＜class T＞ 类模板： 类模板是对一批仅仅成员数据类型不同的类的抽象，使用类模板可以极大地提高编程的效率。例如对于以下这个类： typedef unsigned long Item; class Stack { private: enum {MAX=10};//作用域内枚举，这里使用枚举的MAX只是一个符号名称，在作用域为整个类的代码中遇到时，将用10来代替 //注意在此处使用const int MAX = 10;是不行的，因为声明类只是描述了对象的形式，并没有创建对
解决typedef unsigned long long DDWORD; 在VC下编译不过问题。
wcg_jishuo的专栏
01-16 5439
http://www.byvoid.com/blog/c-int64/ C/C++的64位整型 計算機技術 Add comments4,177 views 在C/C++中，64为整型一直是一种没有确定规范的数据类型。现今主流的编译器中，对64为整型的支持也是标准不一，形态各异。一般来说，64位整型的定义方式有long long和__int64两种(VC还支持_int
《C Primer Plus》第六版 第十二章编程练习答案
11-27
《C Primer Plus》第六版 第十二章编程练习答案，亲测编译运行通过！
向双链表中插入节点C和指针第十二章编程练习6
04-30
本编程练习6的主题是向双链表中插入节点，特别是节点C。在这个练习中，我们需要理解双链表的结构，创建新节点，以及在适当位置正确地插入新节点。 首先，我们来详细解释双链表的基本概念。双链表的每个节点由三部分...
单链表节点个数计数pointer on c第十二章编程练习1
04-30
"Pointer on C"是一本经典的C语言编程教材，第十二章可能详细介绍了链表及其操作。在这个练习中，我们将实现一个C程序，该程序能够接收一个单链表并返回链表中的节点总数。 首先，我们需要理解单链表的基本概念。...
冒泡法反序排列无序单链表C和指针第十二章编程练习4
04-30
这个练习来自第十二章的编程任务，适用于VC6.0编译环境，并且源代码已经过详细注释，便于理解。 首先，让我们了解单链表的基本概念。单链表是一种线性数据结构，其中的每个元素（节点）包含两个部分：数据域，用于...
12.9-4
雎然的博客
05-02 128
总结1：Stack::Stack( )new Item[1] Stack::Stack(int n) { /*错误写法： pitems = new Item[1]; pitems[0] = '\0'; size = 0; top = 0;*/ pitems = new Item[n]; for (int i = 0; i < n; i++) { pitems[i] =...
（一二〇）抽象数据类型
weixin_34014555的博客
01-19 127
抽象数据类型（abstractdatatype,ADT），是以通用的方式描述数据类型，而没有引入语言或实现细节。 程序员常常通过定义类，来表示更通用的概念，而对于抽象数据类型，使用类是一种非常好的方式。 当类概念使用ADT方法时，一般是这样做： ①私有部分必须表示数据存储的方式。例如，可以使用常规数组、动态分配数组或更高级的数据结构（如链...
C++ Primer Plus 书之--C++ 模板类
c1392851600的专栏
12-25 404
定义模板类 先看一个之前自定义的Stack类 // 别名 typedef unsigned long Item; class Stack { private: enum {MAX = 10}; Item items[MAX]; int top; public: Stack(); bool isempty() const; bool isfull() const; bool...
c++ Primer Plus读书笔记——类模板
FlayHigherGT的博客
11-08 203
下面是一段类声明: typedef unsigned long Item class Stack { private: enum { MAX = 10 }; Item items[MAX]; int top; public: Stack(); bool isempty() const; bool isfull() const; bool...
《java语言程序设计与数据结构》编程练习答案（第二十六章）
最新发布
03-16
很抱歉，我作为AI语言模型无法提供《java语言程序设计与数据结构》编程练习答案（第二十六章）的答案。建议您自行查阅相关资料或参考教材进行学习和练习。同时，也提醒您不要依赖答案，应该通过自己的思考和实践来提高编程能力。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值