C ++ Primer （第五版） 第七章习题练习

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

#include <iostream>
#include <string>
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 <iostream>
#include <string>
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 <iostream>
#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 <iostream>
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 <iostream>
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 <iostream>
#include <string>
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;
}