C++ Primer(第五版) 第二章练习答案

C++ Primer(第五版) 第二章练习答案

2.1

/**
 * 位不一样
 * 有无负数
 * 精度不一样
 */ 

2.2

/**
 * double double double 
 * 钱有小数
 */

2.3or2.4

#include 
#include 

int main()
{
     
    unsigned u = 10, u2 = 42;

    std::cout << u2 - u << std::endl;
    std::cout << u - u2 << std::endl;

    std::cout << UINT_MAX - 32 + 1 << std::endl;

    int i = 10, i2 = 42;

    std::cout << i2 - i << std::endl;
    std::cout << i - i2 << std::endl;
    std::cout << i - u << std::endl;
    std::cout << u - i << std::endl;

    return 0;
}

/**
 * 32
 * UINT_MAX - 32 + 1
 * 
 * 32
 * -32
 * 0
 * 0 
 */

2.5

#include 

int main()
{
     
    char a = 'a';
    wchar_t b = L'a';
    const char str[] = "a";
    const wchar_t str2[] = L"a";

    int i1 = 10;
    unsigned i2 = 10u;
    long i3 = 10L;
    unsigned long i3 = 10UL;
    int i4 = 012;
    int i5 = 0xC;

    double d1 = 3.14;
    float d2 = 3.14F;
    long double d3 = 3.14L;

    int f1 = 10;
    unsigned int f2 = 10u;
    double f3 = 10.;
    double f4 = 10e-2; 

    return 0;
}

/**
 * char  wchar_t  const char []  const wchar_t []
 * int  unsigned  long  unsigned long  int  int
 * double  float  long double
 * int  unsigned  double  double
 */

2.6

#include 

int main()
{
     
    int month = 9, day = 7;

    int /* month = 09, */ day = 07;

    return 0;
}

/**
 * 十进制和八进制
 * 八进制 0-7 没有 9
 *

2.7

#include 

int main()
{
     
    std::cout << "Who goes with F\145rgus?\012";

    auto i1 = 3.14e1L;
    // float i2 = 1024f;
    auto i3 = 3.14L;

    return 0;
}


/**
 * \145 = e, \012 = \n
 * 
 * long double  float(没有小数点，错误)  long double
 */

2.8

#include 

int main()
{
     
    std::cout << "2\tM\n";

    return 0;
}

2.9

#include 

int main()
{
     
    // a
    int input_value = 0;
    std::cin >> input_value;

    // b
    double i = {
     3.14};

    // c
    double salary = 9999.99, wage = salary;

    // d
    double i = 3.14;

    return 0;
}

2.10

#include 
#include 

std::string global_str;
int global_int;

int main()
{
     
    int local_int;
    std::string local_str;

    std::cout << global_str << std::endl;
    std::cout << global_int << std::endl;
    std::cout << local_int << std::endl;
    std::cout << local_str << std::endl;

    return 0;
}

/**
 * string类构造函数初始化的空字符串
 * 全局变量自动初始化为0
 * 局部变量未定义
 * string类构造函数初始化的空字符串
 */

2.11

#include 

extern int ix = 1024;
int iy;  
extern int iz;

/**
 * 警告: ix已初始化并声明为extern
 * 声明并定义
 * 声明
 */

int main()
{
     

    return 0;
}

2.12

/**
 * double    关键字
 * catch-22  中横线
 * 1_or_2    数字开头
 */

2.13

#include 

int i = 42;

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

    printf("%d\n", j);

    return 0;
}

2.14

#include 

int main()
{
     
    int i = 100, sum = 0;
    for (int i = 0; i != 10; ++i)
        sum += i;

    std::cout << i << " " << sum << std::endl;

    return 0;
}


/**
 * 100 45
 */

2.15

/**
 * (b)  int &rval1 = 1.01;  非常量引用的初始值必须为左值 
 * 
 * (d)  int &rval3;  声明为引用但未初始化
 */

2.16

#include 

int main()
{
     
    int i = 0, &r1 = i;
    double d = 0, &r2 = d;

    r2 = 3.14159;
    r2 = r1;
    i = r2;
    r1 = d;

    return 0;
}

/**
 * 全部合法
 */

2.17

#include 

int main()
{
     
    int i, &ri = i;
    i = 5;
    ri = 10;

    std::cout << i << " " << ri << std::endl;

    return 0;
}

/**
 * 10 10
 */

2.18

#include 

int main()
{
     
    int *pi = nullptr, a = 10;

    pi = &a;
    printf("%d\n", *pi);
    printf("%d\n", a);

    *pi = 20;
    printf("%d\n", *pi);
    printf("%d\n", a);


    return 0;
}

2.19

/**
 * 指针是对象，引用不是
 */

2.20

#include 

int main()
{
     
    int i = 42;
    int *p1 = &i;
    *p1 = *p1 * *p1;

    std::cout << *p1 << std::endl;

    return 0;
}

/**
 * 定义 i = 42, 
 * p1 指向 i,
 * *p1 = 42 * 42
 */

2.21

int main()
{
     
    int i = 0;

    // 指针类型不匹配
    double *dp = &i;
    // 指针类型不匹配
    int *ip = i;

    int *p = &i;

    return 0;
}

2.22

int main() 
{
     
    int *p = nullptr;

    // 指针 != nullptr 为 true
    if (p) {
      }
    // 指向对象 != 0 为 true
    if (*p) {
      }

    return 0;
}

2.23

/**
 * 不能 因为即使指向非法对象，有时候也能正常得到结果
 */

2.24

int main()
{
     
    int i = 42;
    // void* 指向任何类型地址
    void *p = &i;
    // 类型不匹配
    long *lp = &i;

    return 0;
}

2.25

#include 

int main()
{
     
#if 0
    int i = 42;
    int *p;
    int *&r = p;

    r = &i;
    printf("%d\n", *r);    
    printf("%d\n", *p);    

    printf("%p\n", r);    
    printf("%p\n", p);    
    printf("%p\n", &i);    
#endif
    // 指向int的指针  int  引用绑定 i
    int *ip, i, &r = i;

    // int  指针指向空
    int i, *ip = 0;

    // 指针  int
    int *ip, ip2;

    return 0;
}

2.26

#include 

int main()
{
     
    // 没初始化
    const int buf;

    int cnt = 0;
    const int sz = cnt;

    // const 限定
    ++cnt; ++sz;

    return 0;
}

2.27

#include 

int main()
{
     
    // 非常量引用的初始值必须为左值
    // int i = -1, &r = 0;

    // const int i2 = 10;
    // const int i2, 则不合法
    // int *const p2 = &i2;

    // 合法
    // const int i = -1, &r = 0;

    // 合法
    // const int *const p3 = &i2;

    // 合法
    // const int *p1 = &i2;

    // 引用要初始值
    // const int &const r2;

    // 合法
    // const int i2 = i, &r = i;

    return 0;
}

2.28

#include 

int main()
{
     
    // 常量 变量 "cp" 需要初始值设定项
    int i, *const cp;
    // 常量 变量 "p2" 需要初始值设定项
    int *p1, *const p2;
    // 常量 变量 "ic" 需要初始值设定项
    const int ic, &r = ic;
    // 常量 变量 "p3" 需要初始值设定项
    const int *const p3;
    // 不是常量指针不需要初始值 合法
    const int *p;

    return 0;
}

2.29

#include 

int main()
{
     
    // 常量 变量 "cp" 需要初始值设定项
    int i, *const cp;
    // 常量 变量 "p2" 需要初始值设定项
    int *p1, *const p2;
    // 常量 变量 "ic" 需要初始值设定项
    const int ic, &r = ic;
    // 常量 变量 "p3" 需要初始值设定项
    const int *const p3;
    // 不是常量指针不需要初始值 合法
    const int *p;

    // 合法 常量赋值给变量
    i = ic;
    // 不能将 "const int *" 类型的值分配到 "int *" 类型的实体 
    p1 = p3;
    // 不能将 "const int *" 类型的值分配到 "int *" 类型的实体
    p1 = ⁣
    // p3 常量指针
    p3 = ⁣
    // p2 常量指针
    p2 = p1;
    // const限定
    ic = *p3;

    return 0;
}

2.30

#include 

int main()
{
     
    int i = 0;

    // 顶层const
    const int v2 = 0;
    int v1 = v2;
    int *p1 = &v1, &r1 = v1;
    // 底层const      指向常量的常量指针    底层const
    const int *p2 = &v2, *const p3 = &i, &r2 = v2;

    return 0;
}

2.31

#include 

int main()
{
     
    int i = 0;

    // 顶层const
    const int v2 = 0;
    int v1 = v2;
    int *p1 = &v1, &r1 = v1;
    // 底层const      指向常量的常量指针    底层const
    const int *p2 = &v2, *const p3 = &i, &r2 = v2;

    // 合法 常量赋值给变量
    r1 = v2;
    // 不能将 "const int *" 类型的值分配到 "int *" 类型的实体
    p1 = p2; p2 = p1;
    // 不能将 "const int *" 类型的值分配到 "int *" 类型的实体
    p1 = p3; p2 = p3;

    return 0;
}

2.32

#include 

int main()
{
     
    int null = 0, *p = null;
    
    int null = 0, *p = nullptr;

    return 0;
}

2.33or34

#include 

int main()
{
     
    int i = 10;
    // 顶层             底层
    const int ci = i, &cr = ci;


    auto a = i;

    auto b = ci;
    auto c = cr;
    auto d = &i;
    auto e = &ci;

    const auto f = ci;

    auto &g = ci;
    // auto &h = 42;
    const auto &j = 42;

    auto k = ci, &l = i;
    auto &m = ci, *p = &ci;

    // auto &n = i, *p2 = &ci;

    std::cout << a << std::endl;
    std::cout << b << std::endl;
    std::cout << c << std::endl;

    a = 42;  // int 正确
    b = 42;  // int 正确
    c = 42;  // int 正确
    // d = 42;  // int * 指针
    // e = 42;  // const int * 指向常量的指针
    // g = 42;  // const int & 不能修改


    std::cout << a << std::endl;
    std::cout << b << std::endl;
    std::cout << c << std::endl;


    return 0;
}

2.35

#include 

int main()
{
     
    // 顶层const
    const int i = 42;
    // int (忽略顶层const, 保留底层const)
    auto j = i; 
    // 常量引用 (可以不用加const)
    const auto &k = i;  /* auto &k = i; */
    // 对常量取地址是底层const
    auto *p = &i;
    // (cosnt) int       const int &
    const auto j2 = i, &k2 = i;

    return 0;
}

2.36

#include 

int main()
{
        
    int a = 3, b = 4;
    // int
    decltype(a) c = a;
    // int &
    decltype((b)) d = a;
    ++c;
    ++d;
    // 4 4 4 4
    std::cout << &a << std::endl;
    std::cout << &b << std::endl;
    std::cout << &c << std::endl;
    std::cout << &d << std::endl;
    
    printf("%p\n", &a);
    printf("%p\n", &b);
    printf("%p\n", &c);
    printf("%p\n", &d);

    return 0;
}

2.37

#include 

int main()
{
     
    int a = 3, b = 4;
    // int 3
    decltype(a) c = a;
    // int & 3  (不执行赋值)
    decltype(a = b) d = a;

    printf("%d %d %d %d\n", a, b, c, d);

    return 0;
}

2.38

#include 

int main()
{
     
    /**
     * decltype 保留顶层const和引用
     * auto 丢弃顶层const和引用
     */

    const int a = 10, &b = a;

    // int
    auto c1 = a;
    // const int
    decltype(a) c2 = a;

    // int
    auto d1 = b;
    // const int &
    decltype(b) d2 = b;

    return 0;
}

2.39

#include 

struct Foo {
      }

int main()
{
     


    return 0;
}

/**
 * [2_39.cpp 2021-02-17 09:53:32.462]
,,2_39.cpp:3:15: error: expected ';' after struct definition
 struct Foo { }
               ^
               ;
*/

2.40

#ifndef SALES_DATA
#define SALES_DATA

#include 
#include 


struct Sales_data {
     
    // 书号
    std::string bookNo;
    // 售卖单位
    unsigned units_sold = 0;
    // 收入
    double revenue = 0.0;
};

#endif

2.41or42

#include "2_40.h"
#include 
#include 
#include 
#include 

#if 0
/**
 * 1_20练习
 */
int main()
{
     
    std::vector<Sales_data> data;
    Sales_data temp;

    // 输入书名
    while (std::cin >> temp.bookNo)
    {
     
        // 输入售卖单位 和 收入
        std::cin >> temp.units_sold;
        std::cin >> temp.revenue;

        data.push_back(temp);
    }

    for (auto &i : data)
    {
     
        std::cout << i.bookNo << ", "
                  << i.units_sold << ", "
                  << i.revenue << std::endl;
    }

    return 0;
#elif 0
/**
 * 1.21练习
 */
int main()
{
     
    Sales_data data1, data2;

    while (true)
    {
     
        std::cin >> data1.bookNo >> data1.units_sold >> data1.revenue;
        std::cin >> data2.bookNo >> data2.units_sold >> data2.revenue;

        if (data1.bookNo == data2.bookNo)
        {
     
            std::cout << data1.bookNo << ", "
                      << data1.units_sold + data2.units_sold << ", "
                      << data1.revenue + data2.revenue << std::endl;
            break;
        }
        else
        {
     
            std::cerr << "Re enter" << std::endl;
        }
    }



    return 0;
}
#elif 0
/**
 * 1_22练习
 */
int main()
{
     
    std::map<std::string, Sales_data> datas;
    Sales_data temp;

    // 输入
    while (std::cin >> temp.bookNo >> temp.units_sold >> temp.revenue)
    {
     
        // 没找到即不在 map 中
        if (datas.find(temp.bookNo) == datas.end())
        {
     
            // 插入
            datas.insert(std::pair<std::string, Sales_data>(temp.bookNo, temp));
        }
        else // 计算总和
        {
     
            datas[temp.bookNo].units_sold += temp.units_sold;
            datas[temp.bookNo].revenue += temp.revenue;
        }
    }

    for (const auto &i : datas)
        std::cout << i.first << ": "
                  << i.second.units_sold << " "
                  << i.second.revenue << std::endl;

    return 0;
}
#elif 0
/**
 * 1_23
 */
int main()
{
     
    std::map<std::string, size_t> datas;
    Sales_data temp;

    // 输入
    while (std::cin >> temp.bookNo >> temp.units_sold >> temp.revenue)
        // 同一本书加一
        ++datas[temp.bookNo];

    for (const auto &i : datas)
        std::cout << i.first << " : "
                  << i.second << std::endl;

    return 0;
}
#elif 0
/**
 * 1_24
 */
int main()
{
     
    std::map<std::string, std::vector<Sales_data>> datas;
    Sales_data temp;

    // 输入
    while (std::cin >> temp.bookNo >> temp.units_sold >> temp.revenue)
    {
     
        // 不在 map 中
        if (datas.find(temp.bookNo) == datas.end())
        {
     
            // 插入
            datas.insert(std::pair<std::string, std::vector<Sales_data>>(temp.bookNo, std::vector<Sales_data>()));
            datas[temp.bookNo].push_back(temp);
        }
        else
        {
     
            datas[temp.bookNo].push_back(temp);
        }
    }

    for (auto &i : datas)
    {
     
        std::cout << i.first << " -> "
                  << i.second.size() << std::endl;
        for (auto &j : i.second)
            std::cout << j.bookNo << " "
                      << j.units_sold << " "
                      << j.revenue << std::endl;
    }

    return 0;
}
#elif 1
/**
 * 1_25
 */
int main()
{
     
    Sales_data total;

    // 输入
    if (std::cin >> total.bookNo >> total.units_sold >> total.revenue)
    {
     
        Sales_data trans;
        // 输入
        while (std::cin >> trans.bookNo >> trans.units_sold >> trans.revenue)
        {
     
            // 判断书名是否相同
            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 << 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 << std::endl;

    }
    else // 输入失败
    {
     
        std::cerr << "No data?!" << std::endl;
        return -1;
    }

    return 0;
}

#endif