devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C++ Primer（第五版习题答案）_c++prime节后习题答案

作者：你好赵伟 | 2024-05-02 00:23:34

赞

踩

c++prime节后习题答案

第一章：

  • 习题1.23 

    

  1. #include<iostream>
  2. #include"Sales_item.h"
  3. using namespace std;
  4. int main()
  5. {
  6.     Sales_item trans1, trans2;
  7.     int sum = 1;
  8.     if(cin >> trans1)
  9.     {
  10.         while (cin >> trans2)
  11.         {
  12.             if(compareIsbn(trans1,trans2))
  13.             { 
  14.                 sum++;
  15.             }
  16.             else{
  17.                 cout << trans1.isbn() << "共有 " << sum << "条记录" << endl;
  18.                 trans1 = trans2;
  19.                 sum = 1;
  20.             }
  21.         }
  22.         
  23.     }
  24.     cout << trans1.isbn()   << "共有 " << sum << "条记录" << endl;
  25. }
  • 习题1.24

   输入信息进行测试

  • 习题1.25
  1. #include<iostream>
  2. #include"Sales_item.h"
  3. using namespace std;
  4. int main()
  5. {
  6.     Sales_item trans, total;
  7.     if(cin >> total)
  8.     {
  9.         while (cin >> trans)
  10.         {
  11.             if(compareIsbn(trans,total))
  12.             {
  13.                 total = total + trans;
  14.             }
  15.             else{
  16.                 cout << total << endl;
  17.                 total = trans;
  18.             }
  19.         }
  20.     }
  21.     else{
  22.         cout << "No data?!" << endl;
  23.         return -1;
  24.     }
  25.     cout << total << endl;
  26. }

第二章

练习2.1

**1. 整数数据类型：**
- `int`: 通常是编译器默认的整数类型，其大小在不同系统上可能有所不同，但通常至少占用 2 字节（16 位）内存。
- `long`: 通常比 int 大，占用内存更多，常用于需要更大范围整数存储的情况，至少占用 4 字节（32 位）内存。
- `long long`: 通常比 long 更大，适用于需要更大范围整数存储的情况，至少占用 8 字节（64 位）内存。
- `short`: 通常占用较少内存，至少占用 2 字节，用于节省内存的情况。然而，由于其范围较小，可能会导致数值溢出。

**2. 无符号类型和带符号类型：**
- 带符号类型表示正数、负数和零，可以存储正、负或零值。
- 无符号类型只能存储非负值，它们没有负数范围。这允许您存储更大的正整数，但不适合需要负数的情况。

**3. 浮点数数据类型：**
- `float`: 是单精度浮点数，通常占用 4 字节，可以存储大约 7 位有效数字。适用于一般的浮点数计算。
- `double`: 是双精度浮点数，通常占用 8 字节，可以存储大约 15-16 位有效数字。通常比 float 更精确，适用于需要更高精度的浮点数计算。

练习2.2

利率： 百分比 小数 ---double

本金 ： int足够，如果你有很多钱，也可以用long

付款 ： 可能带小数 ，double

练习2.3

32 4294967264 32 -32 0 0

练习 2.4

  1. #include<iostream>
  2. using namespace std;
  3. int main()
  4. {
  5.     unsigned u = 10, u2 = 42;
  6.     if((u2-u) == 32)
  7.     cout << u2 - u << endl; //猜测答案 32
  8.     if((u-u2) == 4294967264)
  9.     cout << u - u2 << endl;// 猜测答案 4294967264
  10.     int i = 10, i2 = 42;
  11.     if((i2 - i) == 32)  
  12.     cout << i2 - i << endl;//猜测答案 32
  13.     if((i - i2)==-32)
  14.     cout << i - i2 << endl;//猜测答案 -32
  15.     if((i - u)==0)
  16.     cout << i - u << endl;//猜测答案 0
  17.     if((u-i)==0)
  18.     cout << u - i << endl;//猜测答案 0
  19. }

练习2.5

（a) 单个字符a 宽字符 a  a字符串  宽字符串a

（b）整数10 无符号型10 long 类型 10 无符号long类型 10 八进制10 十六进制10

（c）小数 单浮点数 双浮点数

（d）整数10 无符号型10 浮点数10 0.10 浮点数

练习2.6

第一个是十进制，第二个是八进制，且第二组第一个定义有问题，超过了8进制表示范围

练习2.7

（a）输出那段字符串                  字符串

（b）  3.14 指数分隔符 long long类型                浮点数

（c）1024           单浮点数

（d）3.14    long double

练习2.8

  1. #include<iostream>
  2. using namespace std;
  3. int main()
  4. {
  5.     cout << "2\115\n";
  6.     cout << "2\t\115\n";
  7. }

练习2.9

（a） cin 接受的是一个对象  int input_value; cin >> input_value;

  (c) wage未定义 double wage=9999.99； double salary = wage；

练习2.10

globa_str 空串

global_int 整型

{

local_int 未定义

local_str 0

}

练习2.11

（a）定义

（b）定义

（c）声明

练习2.12

(a) double 关键字

(c) - 没这个

(d) 数字开头

---------------

接下来的代码我将以答案加讲解的方式进行回答，目前创作者正在进行备考，之前的暂时不进行更改，以后有时间会逐渐完善....

练习2.13

j 的值 为100，外面的i是全局变量，而函数体内又重新定义了局部变量i，局部i的优先级比全局高，所以j赋值为100；

question？如果我想赋值为42，怎么做呢？

answer: int  j = ::i; // 加上全局作用域就好啦！

练习2.14

for 循环里的int只在for循环里有用，所以 输出的值为原来的i 100 和 后面的sum和45

练习2.15

（b）引用必须是对象，不能是字面值

（d）引用必须初始化

练习2.16

（a）合法，对r2指向的对象，因为r2引用嘛，绑定在了d上，实际上是对d把值赋值为3.14159

（b）合法，int 转换为 double ，d赋值为0

（c）合法，对i 进行赋值为0 ，double转int ，整数截取

（d）合法，同上

练习2.17

输出结果为： 10 10

ri 是对 i的引用，动ri 等价于动 i 所以两个值的应该一样，结果为最后一次操作赋值

练习2.18

  1. #include<iostream>
  2. using namespace std;
  3. int main()
  4. {
  5.     int i = 0;
  6.     int j = 1;
  7.     int *p = &i, *q = &j;
  8.     //更改指针的值
  9.     p = q;
  10.     //更改指针所指对象的值
  11.     *q = 2;
  12.     cout << *p << endl;
  13.     //理论基础: 等号左边是你修改的值，更改指针你就左边放指针变量，更改所指对象你就解除引用
  14. }

  练习2.19

指针可以改变自身值，他可以切换对象，并且指针也是一个对象，但是引用只是一个对象的别名，并且绑定了不能改变，他也不是一个对象，可以理解引用为一个对象的别称，本质还是他自己

练习2.20

定义变量i = 42，定义指针指向对象i，解引用 * p 指向的对象为 i， 然后 将i 赋值为 i * i 

练习2.21

（a） 非法，指针的定义要严格遵守类型匹配，指向double才行

（b）非法，丢了取值符，我知道你想定义为空指针，但是抱歉 ，0可以，i为0不可以

（c）合法

练习2.22

// p指针不为空条件成立

// p指向的int 值不为0，条件成立

练习2.23

不能，因为首先要确定这个指针是不是合法的，才能判断它所指向的对象是不是合法的。

练习2.24

void * 类型指针可以指向任何对象，但是 其他类型必须严格类型匹配

练习2.25

（a） ip 指向int类型的指针，i int 类型变量 ，r对i的引用

（b）i int类型变量，p 空指针

（c）ip int类型指针，ip2int类型变量

练习2.26

（a）不合法，const修饰的变量必须初始化

（b）合法

（c）如果cnt定义了，合法

（d）sz常量不能改变值，不合法

练习2.27

（a）不合法，引用r指向的对象呢？

（b）合法

（c）合法

（d）合法

（e）合法

（f）不合法 对常量的引用初始化

（g）合法

练习2.28

（a）定义变量i，常数指针cp，不合法，初始化呢?

（b）定义int类型指针p1，常指针 指向 int类型的p2,不合法，初始化呢？

（c）常数 ic，不初始化，不对。对常数ic的引用

（d）定义指向常数类型的常指针p3，常指针初始化

（e）合法

练习2.29

（a）合法，赋值而已，又不改变常量ic值，没问题。

（b）不合法，指向类型不一样

（c）不合法，类型不一样

（d）不合法，不可以改变指针指向

（e）不合法，不可以改变指针指向

（f）不合法，常量不能改变值

练习2.30

v2 底层const

p2 底层const p3 既有底层也有顶层

练习2.31

r1 = r2 合法，r1对变量v1的引用，可以改变值

p1 = p2 不合法 p2指向常量，p1不是

p2 = p1 合法，可以转换

p1 = p3 不合法，指针类型不匹配

p2 = p3 合法，p2 和 p3 都是底层const，拷贝时忽略掉顶层const

习题2.32

不合法，将*p = null，改为*p = &null

习题2.33

a = 42 //int

b = 42 //int

c= 42 //int

d = 42 //这不行啊，老哥你是指针

e = 42 //指针

g = 42 /ci是常量不能改变

习题2.34

  1. #include <iostream>
  2. using namespace std;
  3. int main()
  4. {
  5. 	int i = 0, &r = i;
  6. 	auto a = r;   // a是一个整数（r是i的别名，而i是以一个整数）
  7.  
  8. 	const int ci = i, &cr = ci;
  9. 	auto b = ci; // b是一个整数（ci的顶层const特性被忽略掉了）
  10. 	auto c = cr; // c是一个整数（cr是ci的别名，ci本身是一个顶层const）
  11. 	auto d = &i; // d是一个整型指针（整数的地址就是指向整数的指针）
  12. 	auto e = &ci; // e是一个指向整数常量的指针（对常量对象去地址是一种底层const）
  13.  
  14. 	const auto f = ci; // ci的推演类型是int，f是const int
  15. 	auto &g = ci; // g是一个整型常量引用，绑定到ci
  16.  
  17. 	cout << a << endl;
  18. 	cout << b << endl;
  19. 	cout << c << endl;
  20. 	cout << d << endl;
  21. 	cout << e << endl;
  22. 	cout << f << endl;
  23. 	cout << g << endl;
  24. 	cout << "--------------" << endl;
  25. 	a = 42; b = 42; c = 42; //d = 42; e = 42; g = 42;
  26.  
  27. 	cout << a << endl;
  28. 	cout << b << endl;
  29. 	cout << c << endl;
  30. 	cout << d << endl;
  31. 	cout << e << endl;
  32. 	cout << f << endl;
  33. 	cout << g << endl;
  34.  
  35. 	return 0;
  36. }

练习2.35

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

练习2.36

a int 4

b int 4

c int 4

d 引用 4

练习2.37

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

练习2.38

decltype 处理顶层const和引用的方式与 auto不同，decltype会将顶层const和引用保留起来

  1. int i = 0, &r = i;
  2. //相同
  3. auto a = i;
  4. decltype(i) b = i;
  5.  
  6. //不同 d 是一个 int&
  7. auto c = r;
  8. decltype(r) d = r;

练习2.39

提示应输入分号

练习2.40

  1. struct Sale_data
  2. {
  3.     std::string bookNo;
  4.     std::string bookName;
  5.     unsigned units_sold = 0;
  6.     double revenue = 0.0;
  7.     double price = 0.0;
  8. }

练习2.41

  1. #include <iostream>
  2. #include <string>
  3.  
  4. struct Sale_data
  5. {
  6.     std::string bookNo;
  7.     unsigned units_sold = 0;
  8.     double revenue = 0.0;
  9. };
  10.  
  11. int main()
  12. {
  13.     Sale_data book;
  14.     double price;
  15.     std::cin >> book.bookNo >> book.units_sold >> price;
  16.     book.revenue = book.units_sold * price;
  17.     std::cout << book.bookNo << " " << book.units_sold << " " << book.revenue << " " << price;
  18.  
  19.     return 0;
  20. }
  21.  
  22. //分隔
  23.  
  24. #include <iostream>
  25. #include <string>
  26.  
  27. struct Sale_data
  28. {
  29.     std::string bookNo;
  30.     unsigned units_sold = 0;
  31.     double revenue = 0.0;
  32. };
  33.  
  34. int main()
  35. {
  36.     Sale_data book1, book2;
  37.     double price1, price2;
  38.     std::cin >> book1.bookNo >> book1.units_sold >> price1;
  39.     std::cin >> book2.bookNo >> book2.units_sold >> price2;
  40.     book1.revenue = book1.units_sold * price1;
  41.     book2.revenue = book2.units_sold * price2;
  42.  
  43.     if (book1.bookNo == book2.bookNo)
  44.     {
  45.         unsigned totalCnt = book1.units_sold + book2.units_sold;
  46.         double totalRevenue = book1.revenue + book2.revenue;
  47.         std::cout << book1.bookNo << " " << totalCnt << " " << totalRevenue << " ";
  48.         if (totalCnt != 0)
  49.             std::cout << totalRevenue / totalCnt << std::endl;
  50.         else
  51.             std::cout << "(no sales)" << std::endl;
  52.         return 0;
  53.     }
  54.     else
  55.     {
  56.         std::cerr << "Data must refer to same ISBN" << std::endl;
  57.         return -1;  // indicate failure
  58.     }
  59. }

练习2.42

Sale_data.h

  1. struct Sale_data
  2. {
  3.     std::string bookNo;
  4.     std::string bookName;
  5.     unsigned units_sold = 0;
  6.     double revenue = 0.0;
  7.     double price = 0.0;
  8. }
  1. #include <iostream>
  2. #include "Sale_data.h"
  3.  
  4. int main()
  5. {
  6. 	Sales_data book;
  7. 	double price;
  8. 	std::cin >> book.bookNo >> book.units_sold >> price;
  9. 	book.CalcRevenue(price);
  10. 	book.Print();
  11.  
  12. 	return 0;
  13. }
  1. #include <iostream>
  2. #include "Sale_data.h"
  3.  
  4. int main()
  5. {
  6. 	Sales_data book1, book2;
  7. 	double price1, price2;
  8. 	std::cin >> book1.bookNo >> book1.units_sold >> price1;
  9. 	std::cin >> book2.bookNo >> book2.units_sold >> price2;
  10. 	book1.CalcRevenue(price1);
  11. 	book2.CalcRevenue(price2);
  12.  
  13. 	if (book1.bookNo == book2.bookNo)
  14. 	{
  15. 		book1.AddData(book2);
  16. 		book1.Print();
  17. 		return 0;
  18. 	}
  19. 	else
  20. 	{
  21. 		std::cerr << "Data must refer to same ISBN" << std::endl;
  22. 		return -1;  
  23. 	}
  24. }
  1. #include <iostream>
  2. #include "Sale_data.h"
  3.  
  4. int main()
  5. {
  6. 	Sales_data total;
  7. 	double totalPrice;
  8. 	if (std::cin >> total.bookNo >> total.units_sold >> totalPrice)
  9. 	{
  10. 		total.CalcRevenue(totalPrice);
  11. 		Sales_data trans;
  12. 		double transPrice;
  13. 		while (std::cin >> trans.bookNo >> trans.units_sold >> transPrice)
  14. 		{
  15. 			trans.CalcRevenue(transPrice);
  16. 			if (total.bookNo == trans.bookNo)
  17. 			{
  18. 				total.AddData(trans);
  19. 			}
  20. 			else
  21. 			{
  22. 				total.Print();
  23. 				total.SetData(trans);
  24. 			}
  25. 		}
  26. 		total.Print();
  27. 		return 0;
  28. 	}
  29. 	else
  30. 	{
  31. 		std::cerr << "No data?!" << std::endl;
  32. 		return -1;  
  33. 	}
  34. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/521265
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号