C++ Primer第5版 第二章课后练习

练习2.1

C++ 语言规定short 和 int 至少 16 位, long 至少32位, long long 至少64位.
带符号类型可以表示整数、负数或0, 无符号类型则仅能表示大于等于0的值
The C and C++ standards do not specify the representation of float, double and long double. It is possible that all three implemented as IEEE double-precision.
C 和 C++标准没有指定float、double和long double的表示形式。这三种都有可能为 IEEE 双精度。

练习2.2
使用double或者是float

练习2.3

32
4294967264
32
-32
0
0

练习2.4

练习2.5

(a)字符字面值,宽字符型字面值,字符串字面值，宽字符型字符串字面值

(b)带符号整型，无符号整型，长整型，无符号长整型，八进制整型（可能是带符号也可能是无符号），十六进制整型（可能是带符号也可能是无符号）

(c)浮点类型字面值，单精度浮点类型（float），扩展精度浮点数（long double）

(d)整型，无符号整型，浮点数，浮点数

练习2.6

有区别，第一组定义了两个十进制整数9和7，第二组第一个数是无效的八进制数，第二个是八进制数7.

练习2.7

(a)转义序列，\145为e，\012为换行；
(b)3.41e1L: 扩展精度浮点数，为31.4；
(c)1024f：单精度浮点数；
(d)3.14L: 扩展精度浮点数3.14

练习2.8

#include  <iostream>
 
int main()
{
    std::cout << "2\115\012";
    std::cout << "2\t\x4d\012";
 
    return 0;
}

练习2.9

(a)std::cin >> int input_value;

　　为默认初始化的整型input_value赋值。input_value还未初始化，无法赋值，错误类型为error C2062: 意外的类型“int”，改成

　　int input_value;
　　std::cin >> input_value;

(b)int i = {3.14};

　　为整型使用浮点型进行列表初始化。可能存在丢失信息的风险，所以无法执行，错误类型为error C2397: 从“double”转换到“int”需要收缩转换

　　double i = {3.14};

(c)double salary = wage = 9999.99;

　　wage先被定义并赋值，随后被用于初始化salary。wage未被初始化，所以无法被定义，错误类型为error C2065: “wage”: 未声明的标识符

　　double wage;
　　double salary = wage = 9999.99;

(d)int i=3.14;

　　为整型使用浮点型进行初始化。警告，有隐式转化，i值为3。

　　double i=3.14;

练习2.10

std::string global_str;//global_str非显式地初始化为一个空串
int global_int;//global_int被初始化为0
int main()
{
    int local_int;//local_int其值未定义
    std::string local_str;//local_str非显式地初始化为一个空串
}

练习2.11

extern int ix = 1024;//包含显式初始化的声明即成为定义
int iy;//声明并定义iy
extern int iz;//声明iz而非定义iz

练习2.12

int double = 3.14;//非法，double为关键字，不能作为变量名
int _;
int catch - 22;//非法，变量名只能包含字母、数字、下划线
int 1_or_2 = 1;//非法，不能以数字开头
double Double = 3.14;

练习2.13

j=100

练习2.14

合法，输出100 45

练习2.15

(a)合法，用float初始化int变量，可能会有精度丢失，会有警告

(b)不合法，引用类型的初始值必须是一个对象

(c)合法

(d)不合法，引用必须被初始化

练习2.16

(a)合法，为d赋值3.14159

(b)合法，与d=i执行结果一样，但含隐式转换

(c)合法，与i=d执行结果一样，但含隐式转换

(d)合法，与i=d执行结果一样，但含隐式转换

练习2.17

10 10

练习2.18

#include  <iostream>
 
int main()
{
    int i = 1024, *ri = &i;
    std::cout << i << " " << ri << std::endl;
    *ri = 0;
    ri = 0;
    std::cout << i << " " << ri << std::endl;
}

练习2.19

引用在定义时必须初始化，而指针可不初始化；引用本身并非一个对象，一旦定义了引用，就无法令其再帮定到另外的对象，而指针本身就是一个对象，可以进行赋值来修改其存放的地址就可以指向一个新的对象。

练习2.20

    int i = 42;
    int* p = &i;//p被初始化，存有i的地址
    *p = *p * *p;//计算i的平方

练习2.21

(1）double* dp = &i;//非法，不能用int型的变量初始化doube指针
(2）int* ip = i;//非法，不能用int值初始化指针，note: 从整型强制转换为指针类型要求 reinterpret_cast、C 样式强制转换或函数样式强制转换
(3）int* p = &i;//合法

练习2.22

if (p);//如果指针存放的地址值不为0
if (*p);//如果所指对象的值为不为0

练习2.23

不能，指针的值之只是它指向的对象的地址，而地址里面的内容是否合法需要人为判断。

练习2.24

不能用long型的变量初始化int指针，但是void指针类型可以存放任意对象的地址

练习2.25

(a)ip是指向int的指针，i是int，r是对i的引用

(b)i是int，ip是指向int的指针，且所指对象的值为0

(c)ip是指向int的指针，ip2是int

练习2.26

(a)不合法，buf是一个未经初始化的常量

(b)合法

(c)合法

(d)不合法，不能在const对象上执行改变其内容的操作

练习2.27

(a)不合法，引用初始化必须与一个对象绑定

(b)合法，p2是一个指向int的常量指针，初始化为指向i2，储存地址不能改变

(c)合法，r为对const的引用，引用初始化必须与一个常量对象绑定

(d)合法，p3是一个指向常量的常量指针，不论是p3所指的对象值还是p3自己存储的那个地址都不能改变

(e)合法，p1位对const的指针，初始化对象应为常量，或者说自以为指向常量

(f)不合法，r2为对const的引用，引用初始化必须与一个常量对象绑定

(g)合法

练习2.28

(a)不合法，cp为常量指针，初始化对象应为常量

(b)不合法，p2为常量指针，初始化对象应为常量

(c)不合法，ic为常量对象，必须初始化

(d)不合法，p3是一个指向常量的常量指针，必须初始化

(e)合法，p为对const的指针，初始化对象应为常量，但是存储地址可以改变

练习2.29

(a)合法，利用一个对象去初始化另一个对象则它们是不是const都无关紧要

(b)不合法，不能把指向非常量的指针指向常量

(c)不合法，不能把指向非常量的指针指向常量

(d)不合法，p3是一个指向常量的常量指针，不论是p3所指的对象值还是p3自己存储的那个地址都不能改变

(e)不合法，p2是一个常量指针，p2自己存储的那个地址不能改变

(f)ic是常量对象，不能在对象上执行改变其内容的操作

练习2.30

const int v2 = 0;// v2是顶层const
int v1 = v2;// 非const
int* p1 = &v1, & r1 = v1; // 非const
const int* p2 = &v2, * const p3 = &i, & r2 = v2;//p2是底层const,p3既是顶层const也是底层const,r2是底层const

练习2.31

r1 = v2;//合法，拷贝v2的值，v2是顶层const，对此操作无影响
p1 = p2; p2 = p1;//不合法，拷贝p2的值给p1时，p2是底层const，p1不是底层const
p1 = p3; p2 = p3;//不合法，拷贝p3的值给p1时，p3包含底层const，p1不是底层const

练习2.32

不合法，null是一个指向整型的指针，不能用整型来为其赋值。

int null = 0, * p = &null;

练习2.33

d非法：d是一个整型指针
e非法：e是一个指向整数常量的指针
g非法：g是一个整型常量引用

练习2.34

int i = 0, & r = i;
auto a = r;
const int ci = i, & cr = ci;
auto b = ci;
auto c = cr;
auto d = &i;
auto e = &ci;
auto& g = ci;
 
    a = 42;
b = 42;
c = 42;
std::cout << a << b << c << std::endl;
 
d = 42;
e = 42;
g = 42;

练习2.35

j是一个整数

k是一个对整型常量的常量引用

p指向整型常量的指针

j2是一个整型常量

k2是一个对整型常量的常量引用

练习2.36

a ，b 整型

c 整型

d 整型引用

a=4,b=4,c=4,d=4

练习2.37

a ，b 整型

c 整型

d 整型引用

a=3,b=4,c=3,d=3

练习2.38

相同点：都通过已知变量或表达式的类型来指定类型。如：int i = 2； auto j = i; decltype(i) j = i; 两者相同。

　　例子：

int i = 2;
auto j = i;
decltype(i) k = i;

不同点：（1）auto会忽略顶层const，但decltype不会。

​ （2）auto定义变量必须有初始值，但decltyple不一定

　　例子：

const int i = 2;
auto j = i;
decltype(i) k = i;

练习2.39

源.cpp(3): error C2628: “Foo”后面接“int”是非法的(是否忘记了“;”?)
源.cpp(4): error C3874: “main”的返回类型应为“int”而非“Foo”
源.cpp(5): error C2440: “return”: 无法从“int”转换为“Foo”
源.cpp(5): note: 无构造函数可以接受源类型，或构造函数重载决策不明确

练习2.40

struct Sales_data {
    std::string bookNo;
    unsigned units_sold = { 0 };
    double revenue = { 0.0 };
};

练习2.41

struct Sales_data {
    std::string bookNo;
    unsigned units_sold = { 0 };
    double revenue = { 0.0 };
};
int main()
{
    Sales_data data;
    double price;
    while (std::cin >> data.bookNo >> data.units_sold >> price) {
        data.revenue = data.units_sold * price;
        std::cout << "Record:" << data.bookNo << " " << data.units_sold << " " << data.revenue << std::endl;
    }
}

#include  <iostream>
struct Sales_data {
    std::string bookNo;
    unsigned units_sold = { 0 };
    double revenue = { 0.0 };
};
int main()
{
    Sales_data data1,data2;
    double price;
    if (std::cin >> data1.bookNo >> data1.units_sold >> price) {
        data1.revenue = data1.units_sold * price;
    }
    if (std::cin >> data2.bookNo >> data2.units_sold >> price) {
        data2.revenue = data2.units_sold * price;
    }
    if (data1.bookNo == data2.bookNo) {
        unsigned totalCnt = data1.units_sold + data2.units_sold;
        double totalRevenue = data1.revenue + data2.revenue;
        std::cout << data1.bookNo << " " << totalCnt << " " << totalRevenue << std::endl;
        return 0;
    }
    else {
        return -1;
    }
}

#include  <iostream>
struct Sales_data {
    std::string bookNo;
    unsigned units_sold = { 0 };
    double revenue = { 0.0 };
};
int main()
{
    Sales_data data1,data2;
    unsigned totalCnt = 0;
    double totalRevenue = 0.0;
    double price;
    while (std::cin >> data1.bookNo >> data1.units_sold >> price) {
        data1.revenue = data1.units_sold * price;
        totalCnt += data1.units_sold;
        totalRevenue += data1.revenue;
    }
    std::cout << data1.bookNo << " " << totalCnt << " " << totalRevenue << std::endl;
    return 0;
}

#include  <iostream>
struct Sales_data {
    std::string bookNo;
    unsigned units_sold = { 0 };
    double revenue = { 0.0 };
};
int main()
{
    Sales_data data1,data2;
    double price;
    if (std::cin >> data1.bookNo >> data1.units_sold >> price) {
        data1.revenue = data2.units_sold * price;
        int cnt = 1;
        while (std::cin >> data2.bookNo >> data2.units_sold >> price) {
            data1.revenue = data2.units_sold * price;
            if (data1.bookNo == data2.bookNo)
                cnt++;
            else {
                std::cout << data1.bookNo << " " << cnt << std::endl;
                cnt = 1;
                data1 = data2;
            }
        }
        std::cout << data1.bookNo << " " << cnt << std::endl;
    }
    return 0;
}

练习 2.42

#ifndef SALES_DATA_H
#define SALES_DATA_H
#include <string>
struct Sales_data {
    std::string bookNo;
    unsigned units_sold = { 0 };
    double revenue = { 0.0 };
};
#endif // !SALES_DATA_H