C ++ Primer (第五版) 第七章习题练习

发布时间:2023-08-17 16:30

学习笔记所用
本文部分内容参考了:C++Primer第五版——习题答案+详解(完整版)
7.4-7.5

#include 
#include 
using namespace std;

struct Person {
	string name;
	string address;
	string getname() const {
		return name;
	}
	string getaddress() const {
		return address;
	}
};
应该是const因为这两个函数体内都不会改变this所指的对象

7.8

因为read会修改Sales_data对象的数据成员,而print不会。

7.9

#include 
#include 
using namespace std;

struct Person {	
	string name;
	string address;
	string getname() const {//返回名称
		return name;
	}
	string getaddress() const {//返回地址
		return address;
	}
	
};

istream& read(istream&, Person&);
ostream& print(ostream&, Person&);

istream& read(istream& is, Person& P) {
	is >> P.name >> P.address;
	return is;
}
ostream& print(ostream& os, Person& P) {
	os << P.name << " " << P.address;
	return os;
}

7.10

如果data1读取成功,并且data2读取成功则为true

7.11

#include 
#include "Sales_data.h"
//#include "Person.h"
using namespace std;

int main()
{
    Sales_data S1;
    print(cout, S1) << endl;
    Sales_data S2("adad");
    print(cout, S2) << endl;
    Sales_data S3("adad",3,3);
    print(cout, S3) << endl;
    Sales_data S4(cin);
    print(cout, S4) << endl;
    return 1;
}

7.12

#include 
using namespace std;
struct Sales_data {    
    string bookNo;
    unsigned units_sold = 0;
    double revenue = 0.0;

    Sales_data() = default;
    Sales_data(const string &s) :bookNo(s) {}
    Sales_data(const string &s,unsigned n,double p):bookNo(s),units_sold(n),revenue(p*n){}
    Sales_data(istream &in) {//这里不能用read,因为read还没有定义
        double price = 0;
        in >> this->bookNo >> this->units_sold >> price;
        this->revenue = price * this->units_sold;
    }
    
    string isbn() const {
        return bookNo;
    }
    Sales_data& combine(const Sales_data&);
    double avg_price() const;    
};

7.14

Sales_data() : units_sold(0) , revenue(0){};

7.15

Person() = default;
	Person(string a):address(a){}
	Person(string n,string a):name(n),address(a){}
	Person(istream& is) {
		is >> this->name >> this->address;
	}

7.16

没有限定。
不想被外部访问的代码部分定义在private之后,否则定义在public之后

7.17

区别就是在第一个访问说明符之前默认的访问权限不同.

7.18
来源于C++Primer第五版 第七章习题答案(11~20)

封装实现了类的接口和实现的分离,隐藏了类的实现细节,用户只能接触到类的接口。

优点:

隐藏类的实现细节;
让使用者只能通过程序规定的方法来访问数据;
可以方便的加入存取控制语句,限制不合理操作;

类自身的安全性提升,只能被访问不能被修改;

类的细节可以随时改变,不需要修改用户级别的代码;

7.19

将两个数据成员设为privata,其余的设置为public

7.20

在类非成员函数想要调用private部分的时候有用。
缺点:相当于private没有了,这样封装的优点就也没有了

7.21

#include 
using namespace std;
class Sales_data { 
    friend Sales_data add(const Sales_data&, const Sales_data&);
    friend ostream& print(ostream&, const Sales_data&);
    friend istream& read(istream&, Sales_data&);
public:
    Sales_data() = default;
    Sales_data(const string & s) :bookNo(s) {}
    Sales_data(const string & s, unsigned n, double p) :bookNo(s), units_sold(n), revenue(p * n) {}
    Sales_data(istream&);
    string isbn() const {
        return bookNo;
    }
    Sales_data& combine(const Sales_data&);
private:
    string bookNo;
    unsigned units_sold = 0;
    double revenue = 0.0;    
    double avg_price() const;    
};
//Sales_data的非成员接口函数
Sales_data add(const Sales_data&, const Sales_data&);
ostream& print(ostream&, const Sales_data&);
istream& read(istream&, Sales_data&);

Sales_data::Sales_data(istream& is) {
    read(is, *this);
}

double Sales_data::avg_price() const {//返回售出书籍的平均价格
    if (units_sold)
        return revenue / units_sold;
    else
        return 0;
}
Sales_data& Sales_data::combine(const Sales_data& rhs) {
    units_sold += rhs.units_sold;
    revenue += rhs.revenue;
    return *this;
}
istream& read(istream &is, Sales_data &item) {
    double price = 0;
    is >> item.bookNo >> item.units_sold >> price;
    item.revenue = price * item.units_sold;
    return  is;
}
ostream& print(ostream &os, const Sales_data &item) {
    os << item.isbn() << " " << item.units_sold << " " << item.revenue << " " << item.avg_price();
    return os;
}
Sales_data add(const Sales_data &lhs, const Sales_data &rhs) {
    Sales_data sum = lhs;
    sum.combine(rhs);; return sum;
}

7.22

#include 
#include 
using namespace std;

class Person {
	friend istream& read(istream&, Person&);
	friend ostream& print(ostream&, Person&);
	string name;
	string address;
public:
	Person() = default;
	Person(string a):address(a){}
	Person(string n,string a):name(n),address(a){}
	Person(istream& is) {
		is >> this->name >> this->address;
	}
	string getname() const {//返回名称
		return name;
	}
	string getaddress() const {//返回地址
		return address;
	}
	
};

istream& read(istream&, Person&);
ostream& print(ostream&, Person&);

istream& read(istream& is, Person& P) {
	is >> P.name >> P.address;
	return is;
}
ostream& print(ostream& os, Person& P) {
	os << P.name << " " << P.address;
	return os;
}

7.23-7.24

	class Screen {
public:
	typedef string::size_type pos;
	Screen() = default;
	Screen(pos ht, pos wd) :height(ht), width(wd), contents(ht* wd,' ') {}
	Screen(pos ht, pos wd, char c) :height(ht), width(wd), contents(ht* wd, c) {}
private:
	pos cursor = 0;
	pos height = 0, width = 0;
	string contents;
};

7.25

只有内置类型和string类型可以依赖于操作的默认版本

7.26

inline double Sales_data::avg_price() const {//返回售出书籍的平均价格
    if (units_sold)
        return revenue / units_sold;
    else
        return 0;
}

7.27

XXXXXXXXXXXXXXXXXXXX#XXXX
XXXXXXXXXXXXXXXXXXXX#XXXX

7.28-7.29

XXXXXXXXXXXXXXXXXXXX#XXXX
XXXXXXXXXXXXXXXXXXXXXXXXX

7.30

1:当需要将一个对象作为整体引用而不是引用对象的一个成员时,使用this,则该函数返回对调用该函数的对象的引用。 

2:可以非常明确地指出访问的是调用该函数的对象的成员,且可以在成员函数中使用与数据成员同名的形参。 
 
3:可以使用myScreen.move(4, 0).set('#').display(cout)这种连续调用。  

缺点:不必要使用,代码多余。

7.31

#ifndef XY
#define XY
class Y;
class X {
    Y* py = nullptr;
};
class Y {
    X x;
};

#endif // !XY

7.33

Screen::pos Screen::size() const {
	return height * width;
}
` ``
**7.36**

```cpp
//将base改为i
struct X{
	X(int i,int j):base(i),rem(i%j){}
	int rem,base;
};

7.37

Sales_data(istream&);
Sales_data() = default;
Sales_data(const string & s) :bookNo(s) {}

7.38

7.37第一个构造函数

7.39

不合法,会出现二义性。

7.43

struct NoDefault {
    int a;
    NoDefault(int x) :a(x) { cout << 1 << endl; };
};

struct C {
    NoDefault x;
    C(int a) :x(a) { cout << 2 << endl; };
    
};
C a(1);//会输出 1 2

7.44

不合法,值的量不够,并且NoDefault没有默认初始化,不能进行值初始化

7.45

合法,会进行值初始化

7.56

类的静态成员:是类的成员,与类本身直接相关,而不是与类的各个对象保持关联。
优点: 1:静态类型成员可以是不完全类型
	  2:静态成员可以作为默认实参。

7.57

#pragma once
#include "iostream"
using namespace std;

class Account {
public:
	void calculate() { amount += amount * interestRate; }
	static double rate() { return interestRate; }
	static void rate(double);
private:
	std::string owner;
	double amount;
	static double interestRate;
	static double initRate();
};

void Account::rate(double newRate) {
	interestRate = newRate;
}

ItVuer - 免责声明 - 关于我们 - 联系我们

本网站信息来源于互联网,如有侵权请联系:561261067@qq.com

桂ICP备16001015号