【c++ primer 第五版习题集】第二章答案

Azxcc0

已于 2022-08-15 16:14:51 修改

阅读量485

点赞数 1

分类专栏： c++ primer笔记文章标签： c++ 算法开发语言学习

于 2022-08-14 16:26:17 首次发布

本文链接：https://blog.csdn.net/qq_51931826/article/details/126330039

版权

c++ primer笔记专栏收录该内容

38 篇文章 14 订阅

订阅专栏

第二章变量和基本类型

题目带有*表示有难度

练习2.1

类型 int、long、long long 和 short 的区别是什么？无符号类型和带符号类型的区别是什么？float 和 double的区别是什么？

解：

C++ 规定 short 和 int 至少16位，long 至少32位，long long 至少64位。带符号类型能够表示正数、负数和 0 ，而无符号类型只能够表示 0 和正整数。

练习2.2

计算按揭贷款时，对于利率、本金和付款分别应选择何种数据类型？说明你的理由。

解：

使用double。需要进行浮点计算。

练习2.3

读程序写结果。

//当只出现unsigned 时，默认变量类型为unsigned int (亲测)
unsigned u = 10, u2 = 42;
cout << u2 - u << endl;
cout << u - u2 << endl;
int i = 10, i2 = 42;
cout << i2 - i << endl;
cout << i - i2 << endl;
cout << i - u << endl;
cout << u - i << endl;

解：

输出：

32
4294967264		(加上了模)
32
-32
//以下是把有符号转换成无符号
0
0

练习2.4

编写程序检查你的估计是否正确，如果不正确，请仔细研读本节直到弄明白问题所在。

练习2.5

指出下述字面值的数据类型并说明每一组内几种字面值的区别：

(a) 'a', L'a', "a", L"a"
(b) 10, 10u, 10L, 10uL, 012, 0xC
(c) 3.14, 3.14f, 3.14L
(d) 10, 10u, 10., 10e-2

解：

(a): 字符字面值，宽字符字面值且类型是wchar_t，字符串字面值，宽字符串字面值。
(b): 十进制整型，十进制无符号整型，十进制长整型，十进制无符号长整型，八进制整型，十六进制整型。
©: double, float, long double
(d): 十进制整型，十进制无符号整型，double, 10e-2是科学计数法表示的浮点数，大小为10*10^-2 = 0.1

练习2.6

下面两组定义是否有区别，如果有，请叙述之：

int month = 9, day = 7;
int month = 09, day = 07;

解：

第一行定义的是十进制的整型，第二行定义的是八进制的整型。但是month变量有误，八进制不能直接写9。

练习2.7

下述字面值表示何种含义？它们各自的数据类型是什么？

(a) "Who goes with F\145rgus?\012"
(b) 3.14e1L
(c) 1024f
(d) 3.14L

解：

(a) Who goes with Fergus?(换行)，字符串类型，\145表示字符e，\012表示换行符
(b) long double，数值上是3.14*10^1 = 31.4
© 无效，因为后缀f只能用于浮点字面量，而1024是整型正确形式应该：1024.f
(d) long double，值为3.14

练习2.8

请利用转义序列编写一段程序，要求先输出 2M，然后转到新一行。修改程序使其先输出 2，然后输出制表符，再输出 M，最后转到新一行。

解：

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

练习2.9

解释下列定义的含义，对于非法的定义，请说明错在何处并将其改正。

(a) std::cin >> int input_value;
(b) int i = { 3.14 };
© double salary = wage = 9999.99;
(d) int i = 3.14;

解：

(a): 输入运算符要求右侧是一个明确的变量名称，而非定义变量的语句，本人起初想投机，在定义变量时候加个括号改变语句的优先级，但是很遗憾，亲测不行，改正后

int input_value = 0;
std::cin >> input_value;

附上投机结果图
投机错误

(b): 用列表初始化内置类型的变量时，如果存在丢失信息的风险，则编译器将报错。

double i = { 3.14 };

©: 在这里wage是未定义的，应该在此之前将其定义。

double wage;
double salary = wage = 9999.99;

(d): 不报错，但是小数部分会被截断。

double i = 3.14;

练习2.10

下列变量的初值分别是什么？

string global_str;
int global_int;
int main()
{
    int local_int;
    string local_str;
}

解：

global_int是全局变量，所以初值为0。
local_int是局部变量并且没有初始化，它的初值是未定义的。
对于string类型的变量来说，因为string类型本身接受无参数的初始化方式，所以不论变量定义在哪里都会被默认初始化为空串

练习2.11

指出下面的语句是声明还是定义：

(a) extern int ix = 1024;
(b) int iy;
© extern int iz;

解：

(a): 定义，虽然加了extern是声明，但是由于初始化了，所以任然被视为是定义
(b): 定义
©: 声明

练习2.12

请指出下面的名字中哪些是非法的？

(a) int double = 3.14;
(b) int _;
© int catch-22;
(d) int 1_or_2 = 1;
(e) double Double = 3.14;

解：

(a), ©, (d) 非法。变量的名字只能由数字、字母和下划线组成，并且不能与c++关键字相同

练习2.13

下面程序中j的值是多少？

int i = 42;
int main()
{
    int i = 100;
    int j = i;
}

解：

j的值是100，局部变量i覆盖了全局变量i。

练习2.14

下面的程序合法吗？如果合法，它将输出什么？

int i = 100, sum = 0;
for (int i = 0; i != 10; ++i)
    sum += i;
std::cout << i << " " << sum << std::endl;

解：

合法。输出是 100 45 。注意for语句内也存在一个作用域

练习2.15

下面的哪个定义是不合法的？为什么？

(a) int ival = 1.01;
(b) int &rval1 = 1.01;
© int &rval2 = ival;
(d) int &rval3;

解：

(b)和(d)不合法，(b)引用必须绑定在对象上，而非字面值常量。(d)引用必须初始化。

练习2.16

结合下面代码片段，下面的赋值然后回答：哪些赋值是不合法的？为什么？哪些赋值是合法的？它们执行了哪些操作？

int i = 0, &r1 = i; 
double d = 0, &r2 = d;

(a) r2 = 3.14159;
(b) r2 = r1;
© i = r2;
(d) r1 = d;

解：

(a): 合法。给r2赋值就是给 d 赋值，值为 3.14159。
(b): 合法。会执行自动转换（int->double）。
©: 合法。会发生小数截取。
(d): 合法。会发生小数截取。

练习2.17

执行下面的代码段将输出什么结果？

int i, &ri = i;
i = 5; 
ri = 10;

cout << i << " " << ri << endl;

解：

输出：10, 10

练习2.18

编写代码分别改变指针的值以及指针所指对象的值。

解：

int a = 0, b = 1;
int *p1 = &a, *p2 = p1;

// change the value of a pointer.
p1 = &b;
// change the value to which the pointer points
*p2 = b;

练习2.19

说明指针和引用的主要区别

解：自己尝试过解答，但是看了答案以后，还是觉得答案写的好

指针“指向”内存中的某个对象，而引用“绑定到”内存中的某个对象，它们都实现了对其他对象的间接访问，二者的区别主要有两方面:
第一，指针本身就是一个对象，允许对指针赋值和拷贝，而且在指针的生命周期内它可以指向几个不同的对象;引用不是一个对象，无法令引用重新绑定到另外一个对象。
第二，指针无须在定义时赋初值，和其他内置类型一样，在块作用域内定义的指针如果没有被初始化，也将拥有一个不确定的值;引用则必须在定义时赋初值。

练习2.20

请叙述下面这段代码的作用。

int i = 42;
int *p1 = &i; 
*p1 = *p1 * *p1;

解：

让指针 pi 指向 i，然后将 i 的值重新赋值为 42 * 42 (1764)。

练习2.21

请解释下述定义。在这些定义中有非法的吗？如果有，为什么？

int i = 0;

(a) double* dp = &i;
(b) int *ip = i;
© int *p = &i;

解：

(a): 非法。不能将一个指向 double 的指针指向 int ，类型不匹配
(b): 非法。不能将 int 变量赋给指针。
©: 合法。

练习2.22

假设 p 是一个 int 型指针，请说明下述代码的含义。

if (p) // ...
if (*p) // ...

解：

指针p作为if语句的条件时，实际检验的是指针本身的值，即指针所指的地址值。如果指针指向一个真实存在的变量，则其值必不为0，此时条件为真;如果指针没有指向任何对象或者是无效指针，则对p的使用将引发不可预计的结果。
解引用运算符*p 作为 if语句的条件时，实际检验的是指针所指的对象内容，在上面的示例中是指针p所指的int值。如果该int值为o，则条件为假;否则，如果该int值不为0，对应条件为真。

练习2.23

给定指针 p，你能知道它是否指向了一个合法的对象吗？如果能，叙述判断的思路；如果不能，也请说明原因。

解：

在C++程序中，应该尽量初始化所有指针，并且尽可能等定义了对象之后再定义指向它的指针。如果实在不清楚指针应该指向何处，就把它初始化为nullptr或者0，这样程序就能检测并知道它有没有指向一个具体的对象了。其中，nullptr是C++11新标准刚刚引入的一个特殊字面值，它可以转换成任意其他的指针类型。在此前提下，判断p是否指向合法的对象，只需把p作为if语句的条件即可，如果p的值是nullptr，则条件为假。反之，条件为真。
如果不注意初始化所有指针而贸然判断指针的值，则有可能引发不可预知的结果。一种处理的办法是把if（p）置于try结构中，当程序块顺利执行时，表示p指向了合法的对象。当程序块出错跳转到catch语句时,表示p没有指向合法的对象。

练习2.24

在下面这段代码中为什么 p 合法而 lp 非法？

int i = 42;
void *p = &i;
long *lp = &i;

解：

void *是从C语言那里继承过来的，可以指向任何类型的对象。
而其他指针类型必须要与所指对象严格匹配。

练习2.25

说明下列变量的类型和值。

(a) int* ip, i, &r = i;
(b) int i, *ip = 0;
(c) int* ip, ip2;

解：

(a): ip 是一个指向 int 的指针, i 是一个 int, r 是 i 的引用。
(b): i 是 int , ip 是一个空指针。
©: ip 是一个指向 int 的指针, ip2 是一个 int。

练习2.26

下面哪些语句是合法的？如果不合法，请说明为什么？

解：

const int buf;      // 不合法, const 对象必须初始化
int cnt = 0;        // 合法
const int sz = cnt; // 合法
++cnt; ++sz;        // 不合法, const 对象不能被改变

练习2.27

下面的哪些初始化是合法的？请说明原因。

解：

int i = -1, &r = 0;         // 不合法,非常量引用不能引用字面值常量0
int *const p2 = &i2;        // 合法，常量指针，p2的值将不会再改变永远指向变量i2
const int i = -1, &r = 0;   // 合法，常量引用可以引用字面值常量
const int *const p3 = &i2;  // 合法
const int *p1 = &i2;        // 合法
const int &const r2;        // 不合法, r2 是引用，引用本身不是对象，所以不能让引用恒定不变
//我的理解是引用本身就是一个顶层const，故而不能再加上顶层const，也就是可以const int &i = j;
//但是不能int & const i = j;
const int i2 = i, &r = i;   // 合法

关于f：gcc 给的报错，翻译是;错误：“const”限定符不能应用于“const int&”，符合本人预期

练习2.28

说明下面的这些定义是什么意思，挑出其中不合法的。

解：

int i, *const cp;       // 不合法, const 指针必须初始化
int *p1, *const p2;     // 不合法, const 指针必须初始化
const int ic, &r = ic;  // 不合法, const int 必须初始化
const int *const p3;    // 不合法, const 指针必须初始化
const int *p;           // 合法.

练习2.29(*)

假设已有上一个练习中定义的那些变量，则下面的哪些语句是合法的？请说明原因。

解：

i = ic;     // 合法, 常量赋值给普通变量(尽底层const有赋值限制，顶层const没有)
p1 = p3;    // 不合法, p3是const不能赋值给普通指针
p1 = &ic;   // 不合法, 普通指针不能指向常量(取地址相当于底层const)
p3 = &ic;   // 不合法, p3 是常量指针不能被赋值(顶层const自身不能被改变，也就是说p3指针只能被初始化，此后可以赋值给别人，但是不能被赋值)
p2 = p1;    // 不合法, p2 是常量指针不能被赋值(顶层const自身不能被改变，也就是说p2指针只能被初始化，此后可以赋值给别人，但是不能被赋值)
ic = *p3;   // 不合法, ic是一个常量不能被赋值(顶层const自身不能被改变，也就是说ic只能被初始化，此后可以赋值给别人，但是不能被赋值)

练习2.30

对于下面的这些语句，请说明对象被声明成了顶层const还是底层const？

const int v2 = 0; 
int v1 = v2;
int *p1 = &v1, &r1 = v1;
const int *p2 = &v2, *const p3 = &i, &r2 = v2;

解：

v2 是顶层const，p2 是底层const，p3 既是顶层const又是底层const，r2 是底层const。

练习2.31

假设已有上一个练习中所做的那些声明，则下面的哪些语句是合法的？请说明顶层const和底层const在每个例子中有何体现。

解：

r1 = v2; // 合法, 顶层const在拷贝时不受影响
p1 = p2; // 不合法, p2 是底层const，如果要拷贝必须要求 p1 也是底层const
p2 = p1; // 合法, int* 可以转换成const int*
p1 = p3; // 不合法, p3 是一个底层const，p1 不是
p2 = p3; // 合法, p2 和 p3 都是底层const，拷贝时忽略掉顶层const

练习2.32

下面的代码是否合法？如果非法，请设法将其修改正确。

int null = 0, *p = null;

解：

非法，null是小写的不是关键字，所以定义int类型的变量null，随后又定义了int*类型的指针，但是一个是变量一个是指针，不能直接赋值，应该取null地址

练习2.33

利用本节定义的变量，判断下列语句的运行结果。

解：

a=42; // a 是 int
b=42; // b 是一个 int,(ci的顶层const在拷贝时被忽略掉了)
c=42; // c 也是一个int
d=42; // d 是一个 int *,所以语句非法
e=42; // e 是一个 const int *, 所以语句非法
g=42; // g 是一个 const int 的引用，引用都是底层const，所以不能被赋值

练习2.34

基于上一个练习中的变量和语句编写一段程序，输出赋值前后变量的内容，你刚才的推断正确吗？如果不对，请反复研读本节的示例直到你明白错在何处为止。

练习2.35

判断下列定义推断出的类型是什么，然后编写程序进行验证。

const int i = 42;
auto j = i; const auto &k = i; auto *p = &i; 
const auto j2 = i, &k2 = i;

解：

j 是 int，k 是 const int的引用，p 是const int *，j2 是const int，k2 是 const int 的引用。

练习2.36

关于下面的代码，请指出每一个变量的类型以及程序结束时它们各自的值。

int a = 3, b = 4;
decltype(a) c = a;
decltype((b)) d = a;
++c;
++d;

解：

c 是 int 类型，值为 4。d 是 int & 类型，绑定到 a，a 的值为 4 。

练习2.37

赋值是会产生引用的一类典型表达式，引用的类型就是左值的类型。也就是说，如果 i 是 int，则表达式 i=x 的类型是 int&。根据这一特点，请指出下面的代码中每一个变量的类型和值。

int a = 3, b = 4;
decltype(a) c = a;
decltype(a = b) d = a;

解：

c 是 int 类型，值为 3。d 是 int& 类型，绑定到 a。值得注意点是，decltype并不实际计算表达式，所以a的值不会发生改变

练习2.38

说明由decltype 指定类型和由auto指定类型有何区别。请举一个例子，decltype指定的类型与auto指定的类型一样；再举一个例子，decltype指定的类型与auto指定的类型不一样。

解：

第一,auto类型说明符用编译器计算变量的初始值来推断其类型,而decltype
虽然也让编译器分析表达式并得到它的类型，但是不实际计算表达式的值。
第二，编译器推断出来的auto类型有时候和初始值的类型并不完全一样，编译
器会适当地改变结果类型使其更符合初始化规则。例如，auto–般会忽略掉顶层
const,而把底层const保留下来。与之相反,decltype会保留变量的顶层const。
第三，与auto不同，decltype的结果类型与表达式形式密切相关，如果变量
名加上了一对括号，则得到的类型与不加括号时会有不同。如果decltype使用的
是一个不加括号的变量，则得到的结果就是该变量的类型;如果给变量加上了一层
或多层括号，则编译器将推断得到引用类型。

练习2.39

编译下面的程序观察其运行结果，注意，如果忘记写类定义体后面的分号会发生什么情况？记录下相关的信息，以后可能会有用。

struct Foo { /* 此处为空  */ } // 注意：没有分号
int main()
{
    return 0;
}。

解：

编译失败

练习2.40

根据自己的理解写出 Sales_data 类，最好与书中的例子有所区别。

struct Sale_data
{
    std::string bookNo;
    std::string bookName;
    unsigned units_sold = 0;
    double revenue = 0.0;
    double price = 0.0;
    //...
}

练习2.41

使用你自己的Sale_data类重写1.5.1节（第20页）、1.5.2节（第21页）和1.6节（第22页）的练习。眼下先把Sales_data类的定义和main函数放在一个文件里。

// 1.5.1

#include <iostream>
#include <string>

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

int main()
{
    Sale_data book;
    double price;
    std::cin >> book.bookNo >> book.units_sold >> price;
    book.revenue = book.units_sold * price;
    std::cout << book.bookNo << " " << book.units_sold << " " << book.revenue << " " << price;

    return 0;
}

// 1.5.2

#include <iostream>
#include <string>

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

int main()
{
    Sale_data book1, book2;
    double price1, price2;
    std::cin >> book1.bookNo >> book1.units_sold >> price1;
    std::cin >> book2.bookNo >> book2.units_sold >> price2;
    book1.revenue = book1.units_sold * price1;
    book2.revenue = book2.units_sold * price2;

    if (book1.bookNo == book2.bookNo)
    {
        unsigned totalCnt = book1.units_sold + book2.units_sold;
        double totalRevenue = book1.revenue + book2.revenue;
        std::cout << book1.bookNo << " " << totalCnt << " " << totalRevenue << " ";
        if (totalCnt != 0)
            std::cout << totalRevenue / totalCnt << std::endl;
        else
            std::cout << "(no sales)" << std::endl;
        return 0;
    }
    else
    {
        std::cerr << "Data must refer to same ISBN" << std::endl;
        return -1;  // indicate failure
    }
}

// 1.6

#include <iostream>
#include <string>

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

int main()
{
    Sale_data total;
    double totalPrice;
    if (std::cin >> total.bookNo >> total.units_sold >> totalPrice)
    {
        total.revenue = total.units_sold * totalPrice;

        Sale_data trans;
        double transPrice;
        while (std::cin >> trans.bookNo >> trans.units_sold >> transPrice)
        {
            trans.revenue = trans.units_sold * transPrice;

            if (total.bookNo == trans.bookNo)
            {
                total.units_sold += trans.units_sold;
                total.revenue += trans.revenue;
            }
            else
            {
                std::cout << total.bookNo << " " << total.units_sold << " " << total.revenue << " ";
                if (total.units_sold != 0)
                    std::cout << total.revenue / total.units_sold << std::endl;
                else
                    std::cout << "(no sales)" << std::endl;

                total.bookNo = trans.bookNo;
                total.units_sold = trans.units_sold;
                total.revenue = trans.revenue;
            }
        }

        std::cout << total.bookNo << " " << total.units_sold << " " << total.revenue << " ";
        if (total.units_sold != 0)
            std::cout << total.revenue / total.units_sold << std::endl;
        else
            std::cout << "(no sales)" << std::endl;

        return 0;
    }
    else
    {
        std::cerr << "No data?!" << std::endl;
        return -1;  // indicate failure
    }
}