第2章 变量和基本类型

2.1 基本内置类型

2.1

一个Int至少和一个short一样大，一个long至少和一个int一样大，一个long long 至少和一个long一样大；无符号类型只能表示大于等于0的数，而有符号类型可以表示负数；float表示单精度，double表示双精度。

2.2

利率：double
本金：long long
付款：long long

2.3

32
2 ^ 32 - 32

32
-32
0
0

2.4

#include<iostream>
int main()
{
    unsigned u = 10, u2 = 42;
    std::cout << u2 - u << std::endl;
    std::cout << u - u2 << 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;
}

2.5

(a): char , wchar_t, char*, wchar_t*
(b): int, unsigned int, long, unsigned long, 8进制, 16进制
©: double, float, long double
(d): int, unsigned int, double, 科学计数法

2.6

有区别，以0开头的数字表示八进制，但是09是无效的八进制数。

2.7

(a): \145表示什么，我还不知道… ，/012表示换页
(b): 使用科学计数法的long double类型值31.4
©: float类型的值1024.0
(d): long double类型的值3.14

2.8

#include<iostream>
int main()
{
    std::cout << "2M\n" << std::endl;
    std::cout << "2\tM" << std::endl;
    return 0;
}

2.2 变量

2.9

(a): 非法定义。在请求命令行输入时不能定义值的类型且变量名不能为int。
int input_value = 0;
std::cin >> input_value;
(b): 非发定义。把浮点数转化为整数会丢失数据。
int i = (3.14);
©: 非法定义。一个值只能初始化一个变量。
double salary = 9999.99, wage = 9999.99;
(d): 合法。虽然丢失了部分值。

2.10

golbal_str为空字符串
global_int为0
local_int不被初始化
local_str不被初始化

(a): 定义
(b): 声明并定义
©: 声明

2.12

(a): 非法
(b): 合法
©: 非法
(d): 非法
(e): 合法

2.13

100

2.14

合法，输出：100 45

2.3 复合类型

2.15

(a): 合法
(b): 非法,引用只能绑定在对象上
©: 合法
(d): 非法，引用必须初始化

2.16

(a): 合法，将d赋值为3.14159
(b): 合法，将i的值扩展为double赋值给d
©: 合法，将d的值转化为int赋值给i
(d): 合法，将d的值转化为int赋值给i

2.17

10 10

2.18

#include<iostream>
int main()
{
    int i = 10;
    int *p = &i;
    p = 0;
    *p = 0;
    return 0;
}

2.19

引用：不是一个对象，必须初始化，引用只能绑定到一个对象上
指针：是一个对象，可以不用初始化，在它的生命周期中可以先后指向不同的对象。

2.20

将i的值乘以2

2.21

(a): 非法，指针只能指向同类型的对象
(b): 非法，指针指向同类型对象时必须有&
©: 合法。

2.22

(a): 如果指针不是空指针，条件成立
(b): 如果指针指向的对象的值不是0，条件成立

2.23

2.24

void类型指针可以指向任意类型指针，但是long类型指针只能指向long类型的对象

2.25

(a): ip是指向int类型的指针， i是int类型的变量， r是int类型的引用
(b): i是int类型的变量，ip是指向int类型的空指针
©: ip是指向Int类型的指针，ip2是int类型的变量

2.4 const限定符

2.26

(a): 非法，buf是一个未经初始化的常量
(b): 合法
©: 合法
(d): 非法，sz的值不能被改变

2.27

(a):i合法,r非法，引用必须绑定到对象上
(b): 合法
©: i合法，r合法
(d): 合法
(e): 合法
(f): 非法，常量引用必须初始化
(g): i合法，r合法

2.28

(a): i为int类型，cp为指向int类型的常量指针，非法，常量指针必须初始化
(b): p1为指向Int类型的指针，p2为指向int类型的常量指针，非法，常量指针必须初始化
©: ic为int类型的常量，非法，必须初始化。r为绑定到ic上的常量引用
(d): p3为指向int常量的常量指针，非法，常量指针必须初始化
(e): p为指向int常量的指针

2.29

(a): 合法
(b): 非法，常量指针不能赋值给一个非常量指针
©: 非法，常量不能赋值给一个指向非常量的指针
(d): 非法，常量指针只能指向原来的对象
(e): 非法，常量指针只能指向原来的对象
(f): 非法，整数常量的值无法被修改

2.30

v2: 顶层const
p2: 底层const
p3: 靠近的const为顶层const,比较远的const为底层const

2.31

r1 = v2: 合法，顶层const不受影响
p1 = p2: 非法，不能将常量指针的值分配到非常量指针，必须具有相同的底层const
p2 = p1: 合法
p1 = p3: 合法，顶层const不受影响
p3 = p1: 合法

2.32

非法，int类型的值不能用于初始化int *类型的值
constexpr int null = 0, *p = null;

2.5 处理类型

2.33

a = 42: 合法
b = 42: 合法
c = 42: 合法
d = 42: 非法，不能将int类型的值分配到int *类型
e = 42:非法，不能将int类型的值分配到const int *类型
g = 42: 非法，表达式左边必须是可修改的左值

2.34

#include<iostream>
int main()
{
    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;
    const auto f = ci;
    auto &g = ci;
    a = 42;
    b = 42;
    c = 42;
    d = 42;   //非法
    e = 42;   //非法
    g = 42;   //非法
    return 0;
}

2.35

j为int类型；k为const int &；p为const int *；j2为const int；k2为const int &

2.36

c：int类型，值为4
d：int &类型，值为4

2.37

c：int类型，值为3
d：int &类型，值为3

2.38

auto是通过编译器计算变量的初始值来推断类型回的，decltype同样也是通过编译器来分析表达式进而得到它的类型，但是它不用将表达式的值计算出来。
编译器推断出来的auto类型有可能和初始值类型不同，比如对于顶层const，auto会忽略顶层const性质，但是decltype是保留下来的。
与auto不一样，decltype的结果类型与表达式形答式有密切关系。比如decltype()内层没有括号，那么得到的类型就是变量的类型，如果有多层括号decltype(())那么返回的就是引用。

2.6 自定义数据结构