C++Prime 第二章

第二章

练习2.1

1. 区别是所占字节数可能不同，也就是在机器中存储的位数不同

2. 带符号类型和无符号类型本质是对字节的解释方式不同，表现形式为带符号类型可以有负值，且正值最大值减半。

3. 精度不同，代价不同。float精度低，相应的运算快。

练习2.2

略

练习2.3、2.4

#include<iostream>
using namespace std;
int main()
{
	
	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;

	return 0;
}

练习2.5，2.6,2.7略

练习2.8

#include<iostream>
using namespace std;
int main()
{
	cout << "2\115\n";//条件1
	cout << "2\t\115\n";//条件2
	return 0;
}

练习2.9、2.10

略

练习2.11

（a） extern int ix = 1024; //定义

（b） int iy;                       //定义 

（c）extern int iz;             //声明

练习2.12

略了略了

练习2.13

100

练习2.14

合法。

 

练习2.15

（a）int ival = 1.01;  //合法                                                      （c）合法 

（b）int& rval1 = 1.01； //不合法，不能引用字面值                 （d）不合法，引用必须赋初值

练习2.16

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

(a) r2 = 3.14159;   合法。给r2赋值

(b) r2 = r1;  合法。给double 型的r2赋值了int型的r1

(c) i = r2;   合法，但是是缩窄转换，下同。

(d) r1 = d;  合法。

练习2.17

10 10

练习2.18

#include <iostream>
using namespace std;
int main()
{
	int num1 = 1, num2 = 2;
	int* p = &num1;// p 最初指向了num1
	cout << "p指向num1，其值为：" << *p << endl;
	*p = 11111;
	cout<<"更改后，"
		<<"p所指对象的值为：" << *p << endl;
	p = &num2;
	cout << "此时p指向了num2，值为" << *p << endl;

	return 0;
}

练习2.19

相同：都是间接引用另一个对象。

区别：指针是一个对象（占用额外存储空间），引用不是对象，只是一个别名。

           指针可以不初始化，引用必须初始化。

           指针可指向任意位置，引用只与最初的对象绑定，不可更改。

练习2.20

先平方i，后结果保存给i。

练习2.21  2.22  2.23 2.24略

练习2.25

（a）int* ip, i, &r = i;   //ip是int型指针，i是int型， r是int型的引用

（b）int i, *ip = 0;      // i 是int型，ip是指针

（c）int *ip,ip2;       //ip是指针，ip2是int型。

练习2.27

(a) int i = -1, &r = 0 ; 不合法，r不能引用字面值       （b）int *const p2 = &i2;   合法。p2是一个常量指针。

(c) const int i = -1, &r = 0; 合法。r是常量引用         （d）const int *const p3 = &i2;   合法。p3是指向常量的常量指针。

(e) const int *p1 = &i2;    合法。p1是指向常量的指针。（f）const int &const r2;   非法。引用必须初始化

(g) const int i2 = i,&r = i;  合法。

练习2.28

int i, *const cp;   不合法，常量指针必须初始化。

int *p1, *const p2;  不合法，同上。

const int ic, &r = ic;  不合法。常量ic未初始化。

const int *const p3; 不合法，常量指针必须初始化。

const int *p; 合法。p是指向常量的指针。

练习2.29

合法：(a)

不合法：（b）不能将const int * 分配到int *

(c) 非指向常量的指针绑定了常量对象，(d) ,(e),常量指针不可以赋值，(f)常量不可以赋值

练习2.30

const int v2 = 0; //顶层const

int v1 = v2;  

int *p1 = &v1, &r1 = v1;

const int *p2 = &v2, *const p3 = &i, &r2 = v2;  //p2是底层，p3是顶层也是底层，r2是底层

练习2.31

r1 = v2 非法。r1是引用，不可赋值。

p1 = p2;非法。不能底层const赋值给非const

p2 = p1;合法。const指针可以指向非const和const。

p1 = p3;非法。不能底层const赋值给非const

p2 = p3;合法。

练习2.32

*p = nullptr;

练习2.33,2.34

略

练习2.35

const int i = 42;   i是整型常量

auto j = i;     j是整型变量

const auto &k = i;    k是常量引用

auto *p = &i;const int *

const auto j2 = i, &k2 = i; j2是整型常量，k2是常量引用

 

练习2.36

int a = 3,b = 4; //all int

decltype(a) c = a;  //c是int

decltype((b)) d = a;  d是int &，绑定到了a

++c;++d;  //c最终是4，d最终是4，a == b  ==  4,

练习2.37

int a = 3, b = 4;// a,b : int

decltye(a)  c = a;// c : int

decltype(a = b) d = a；// d : int &

练习2.38

区别1：auto会忽略顶层const，decltype返回的类型包括顶层const和引用在内

区别2：decltype的结果类型与表达式形式密切相关。

例子1：int i = 1; auto j = i; //decltype(j) = i;    这种指定的类型相同

例子2：const int &i = 1; auto j = i;  //此时j是int &型。 decltype(i)  j = i; j是const int&  （区别1）

练习2.39

报错

练习2.40

struct Sales_data
{
    int bookId;//书编号
    std::stirng bookName;//书名
    std::string author; //作者
    int price;  //单价
    std::string publish;//出版商
};

2.41  2.42略