C++Primer 第五版第二章变量和基本类型习题详解

最新推荐文章于 2023-11-05 17:36:09 发布

置顶 zzhaiwen

最新推荐文章于 2023-11-05 17:36:09 发布

阅读量359

点赞数

分类专栏： C++ Primer 文章标签： c++

本文链接：https://blog.youkuaiyun.com/zzhaiwen/article/details/107536768

版权

C++ Primer 专栏收录该内容

9 篇文章

订阅专栏

C++Primer 第五版第二章变量和基本类型习题详解

2.1

不同的编译器和系统赋予这些类型的尺寸（内存空间）不同，其中short <= int <= long <= long long
带符号类型可以表示正数、负数或0，无符号类型则仅能表示大于等于0的值。
单精度：6位有效数字；双精度：10位有效数字；

2.2 都选用double双精度浮点类型，这是因为float通常精度不够而且双精度浮点数和单精度浮点数的计算代价相差无几。

2.3
32 4294967264 32 -32 0 0

2.5
（a) char wchar_t char型字符串字面常量 wchar_t型字符串字面常量；区别：字符串 = 字符 + 空字符，分配的内存大小不同
（b) int unsigned int long int unsigned long int int int ；区别：分配的内存大小不同
（c) 默认为double float long double 区别：分配的内存大小不同
(d) int unsigned int double double 区别：分配的内存大小不同

2.6
有区别，一个10进制，一个8进制

2.7
（a）“Who goes with Fergus?”
(b) 31.4
© 1024编译报错，显示invalid suffix “f” on integer constant，在整型常量中使用了不正确的后缀名‘f’，f是浮点常量不想用double而是float时用的，整数的话至少最后加个小数点也行啊 : 1.f 1.0f。
(d) 3.14

2.8

  1 #include <iostream>
  2 using namespace std;
  3 
  4 int main()
  5 {       
  6         cout << "2M" << endl;
  7         cout << "2\tM\n";
  8         
  9         return 0;
 10 }

2.9

  1 #include <iostream>
  2 using namespace std;
  3 
  4 int main()
  5 {
  6         //(a)错误，需修改为：
  7         int input_value;
  8         cin >> input_value;
  9         
 10         int i = {3.14};//(b)正确
 11         
 12         //double salary = wage = 9999.99,变量wage未定义;
 13         //(c)错误，需修改为：
 14         double wage;
 15         double salary = wage = 9999.99;
 16         //(d)正确       
 17         int i2 = 3.14;
 18         
 19         return 0;
 20 };
~

2.10
定义于任何函数体之外的变量被初始化为0，定义在函数体内部的内置类型变量将不被初始化，但是我的g++编译器未报错。

  1 #include <iostream>
  2 using namespace std;
  3 
  4 string global_str;
  5 int global_int;
  6 int main()
  7 {
  8         int local_int;//不被初始化
  9         string local_str;//不被初始化
 10         cout << global_str << endl;//空字符
 11         cout << global_int << endl;//0
 12         cout << local_int << endl;//编译器未报错，为0
 13         cout << local_str << endl;//编译器未报错，为空字符
 14         return 0;
 15 }

2.11

定义
声明并且定义
声明

2.12

  1 #include <iostream>
  2 using namespace std;
  3 
  4 int main()
  5 {
  6         int double = 3.14;//与关键字重名，非法
  7         int _;//合法
  8         int catch-22;//包含非法字符-，非法
  9         int 1_or_2;//必须以下划线和字母开头，非法
 10         double Double = 3.14;//合法
 11         
 12         return 0;
 13 }

2.13

  1 #include <iostream>
  2 
  3 using namespace std;
  4 
  5 int i = 42;
  6 int main()
  7 {
  8         int i = 100;
  9         int j = i;
 10         cout << j  << endl;//j = 100;
 11 
 12         return 0;
 13 }
~

2.14
i = 100, sum = 45;

 1 #include <iostream>
  2 using namespace std;
  3 
  4 int main()
  5 {       
  6         int i = 100, sum = 0;
  7         for (int i = 0; i != 10; ++i)
  8                 sum += i;
  9         cout << i << " " << sum << endl;
 10         
 11         return 0;
 12 }

2.15 4条原则：
1.引用必须初始化；
2.引用类型的初始值必须是个对象，对象是一块能存储数据并具有类型的内存空间，所以不能引用字面值常量；
3.引用本身不是一个对象，所以不能定义引用的引用；
4.一旦定义了引用，就无法令其再绑定到另外的对象，之后每次使用这个引用都是访问它最初绑定的那个对象。

但是，初始化常量引用时允许用任意表达式作为初值，如const int &r = 42,且允许一个常量引用绑定非常量的对象、字面值甚至是个一般表达式，而非常量引用不能指向一个常量对象。
2.16
都是合法的，最后结果i = d = 0;

 1 #include <iostream>
  2 using namespace std;
  3 
  4 int main()
  5 {       
  6         int i = 0, &r1 = i;
  7         double d = 0, &r2 = d;
  8         
  9         r2 = 3.14159;
 10         r2 = r1;
 11         i = r2;
 12         r1 = d;
 13         
 14         cout << i << ", " << d << endl;
 15         
 16         return 0;
 17 }
~

2.19 指针与引用的区别:

指针本身就是一个对象，允许对指针赋值和拷贝，而且在指针的生命周期内它可以先后指向几个不同的对象。
指针无须在定义时赋初值。

2.21

  1 #include <iostream>
  2 
  3 using namespace std;
  4 
  5 int main()
  6 {
  7         int i = 0;
  8         double* dp = &i;//非法，不能自动进行指针类型转换
  9         int *ip = i;//非法，不能把int变量直接赋值给指针
 10         int *p = &i;
 11 
 12         return 0;
 13 }
~

2.22

如果指针p不是一个空指针的话，就执行//
如果指针p所指向的对象的值非零的话，就执行//

2.23

首先判断是否为空指针，用if；
如果是非空指针，那么对该指针进行赋值，从而修改指针所指对象的值，如果编译器通过，则指针指向一个合法的对象。

2.24
void型指针可用于存放任意的地址，而long int 类型指针和int 类型对象不匹配；

2.25

定义了一个int型指针p和int型变量i, r是i的引用；
定义了int型变量i和int型的空指针ip;
定义了一个int型指针ip和int型变量ip2;

2.26
(d)不合法，不能修改sz的值；

2.27
原则：从右向左阅读r的定义，离变量名最近的符号对变量的类型有最直接的影响；

不合法，不是常量引用的初始化必须是一个对象；
定义了一个常量指针，即p2固定指向i2，合法;
合法，常量引用是例外，合法；
p3是一个指向常量对象i2的常量指针，合法；
p1是个指向常量对象i的指针，合法；
r2是一个常量对象的常量引用
7.合法，常量值初始化和常量引用的初始化；

常量引用指的是引用的是个常量对象，不会影响到引用和对象的绑定关系。

***2.28-29***同2.27，2.27写吐了；

2.30 原则：

顶层const表示指针本身是个常量
底层const表示指针所指的对象是一个常量，所以赋值有限制，。

v2是顶层const,v1就只是一个int型常量；指针p1指向v1, r1是v1的引用；指针p2指向v2,是底层const; 指针p3既是顶层const又是底层const, r2是一个常量引用；

2.31

r1 = v2合法
p1 = p2,不合法，p2包含底层const的定义,而p没有，即一般来说，常量不可以转换为非常量；
p2 = p1,合法，一般来说，非常量可以转换为常量；
p1 = p3;合法，p3顶层const的部分不影响；
p2 = p3, 合法，两者指向的对象类型相同，p3顶层const的部分不影响；

2.32

  1 #include <iostream>
  2 
  3 using namespace std;
  4 
  5 int main()
  6 {
  7         int null = 0, *p = null;//错误，不能直接把一个int型变量赋值给指针
  8 
  9         return 0;
 10 }

2.33-2.34
e = 42是错误的，e是一个指向整数常量的指针，不能直接用整数赋值
g = 42是正确的，g是一个整型常量引用，可以绑定非常量的对象、字面值，甚至是一个一般表达式；

2.35
写吐了，后面补上

2.36

a、b、c为int型，d为a的引用
b = 4, c = 4, a = d = 4;

2.37

a、b、c为int型，d为a的引用
b = 4, c = 3, a = d = 3;

2.38
区别：

decltype是从表达式的类型推断出要定义的变量的类型，不会用该表达式的值来初始化变量
decltype是结果类型与表达式形式密切相关

  1 #include <iostream>
  2 using namespace std;
  3 
  4 int main()
  5 {
  6         int a = 0, b;
  7         //相同的情况
  8         decltype(a) c = a;
  9         auto d = a;
 10 
 11         cout << "a的地址： " << &a << endl;
 12         cout << "c的地址： " << &c << endl;
 13         cout << "d的地址： " << &d << endl;
 14 
 15         //不相同的情况
 16         decltype(a = b) e = a;
 17         auto g = (a = b);
 18 
 19         cout << "a的地址： " << &a << endl;
 20         cout << "e的地址： " << &e << endl;
 21         cout << "g的地址： " << &g << endl;
 22 
 23         return 0;
 24 }
~