c++primer第五版第二章习题

冷不防 2022-05-24 05:14 217阅读 0赞

2.9

a、(输入时才定义是不合法的)不正确，需在cin之前定义input\_value

std::cin >> int input\_value;==>int **input\_value=0;std::cin>>input\_value;**

b、i强制类型转换成3

int i=\{3.14\};==>int i=3;数据发送丢失  报错：从“double”转换到“int”需要收缩转换

c、wage未定义

double salary =wage=9999.99;其中wage未定义

d、i会被强制类型转换成3

int i=3.14;==>warning C4244 : “初始化” : 从“double”转换到“int”，可能丢失数据

需要注意的就是类型转换的问题，还有变量使用之前需要先定义声明

//2.10
    //这里涉及到的就是默认初始化的问题
    //如果在定义变量时没有指定初值，那么变量会被默认初始化。
    //三条性质：1、定义在任何函数体外的变量会被初始化为0。   2、定义在函数体内部的变量不会被初始化。 3、类的对象未被初始化，则初值由类决定。
    //所以第一个变量是一个空字符串，第二个变量是0，第三个变量不确定，第四个变量因为在std作用域内，而std作用域内有其定义，所以是个空字符串
    std::string global_str;
    int global_int;
    int main()
    {
    	int local_int;
    	std::string local_str;
    
    
    	system("pause");
    	return 0;
    }

//2.11  
//涉及知识点：  
//声明：使得名字为程序所知，如果想使用该变量，则必须实现包含其声明。声明会确定变量的名字和类型。  
//定义：创建于名字关联的实体。定义会申请存储空间，可能会赋予初始值。  
//如果想声明一个变量而不想定义它，那么可以在变量名前加extern关键字。  
//所以1、定义   2、定义  3、声明   
//如果想声明一个变量而非定义它,就在变量名前添加关键字extern,而且不要显式地初始化变量  
extern int iz;//声明iz而非定义  
extern int ix = 1024;//extern语句如果包含初始值就不再是声明，而是定义了  
int iy;//声明并定义j  
//变量能且只能被定义一次,但是可以被多次声明

2.12

字母+数字+下划线（必须以字母或者下划线开头）

C++中关于变量命名的规范：

1：能体现变量的实际意义

2：变量名一般采用小写字母

3：用户自定义类名一般以大写字母开头

4：多个单词定义的变量名应有区分Student\_loan   而不是  Studentloan

a:错误：使用关键字double作为变量名

b:正确

c:错误：无效字符“—”

d:错误：不能以数字开头

e:正确（但是不好）

2.13

新建局部变量会覆盖同名的全局变量

j=100

int i = 42;
    int main()
    {
    	int i = 100;//新建局部变量i，覆盖全局变量i
    	int j = i;//100 
    
    	system("pause");
    	return 0;
    }

2.14

合法，与上题类似

但不同的是：显示访问i变量会访问到全局变量上  std::cout<<

i = 100   sum = 45

int i = 100, sum = 0;
    int main()
    {
    	for (int i = 0; i < 10; i++)
    	{
    		sum += i;//内层作用域没有重新定义sum 定义i只是局部变量,只作用于for循环体内
    	}
    	cout << i << " " << sum << endl;// 100 45
    
    	system("pause");
    	return 0;
    }

所以程序中不要出现同名变量

//2.15  
//所谓引用：它只是为存在的对象所起的另外一个名字。它不是一个对象，没有实际的地址  
int value = 10;  
int &My\_value = value;   //引用，在定义引用的时候会将引用和它的初始值绑定在一起，而不是简单的赋值  
int My\_value = 5;        //将5赋给了My\_value和value  
int Her\_value = My\_value; //相当于将value赋给了Her\_value  
int &My\_value = 10;       //错误：引用类型的初始值必须是一个对象  
double vvalue = 40.6;  
int &My\_value = vvalue;   //错误：引用类型的初始值必须是int型对象  引用的类型都要和与之绑定的对象严格匹配

int i = 0, &r1 = i;
    double d = 0, &r2 = d;
    
    int main()
    {
    	r2 = 3.1415;
    	r2 = r1;//int==>double ok
    	i = r2;//会报警告,从double=>int 丢失数据
    	r1 = d;//会报警告,从double=>int 丢失数据
    
    	system("pause");
    	return 0;
    }

int i = 0, &r1 = i;
    double d = 0, &r2 = d;
    
    int main()
    {
    	i = 5; r1 = 10;
    	cout << i << " " << r1 << endl;// 10 10

//2.18  
// 先简单的了解一下指针：它和引用类似也实现了与其他对象之间的间接访问.  
// 定义指针类型的变量通常是：int \*P     P是变量名，加\*号指的是其是一个int类型的指针。  
// 指针类型也需要和匹配对象类型严格吻合  
int a;  
int \*p1 = &a;//初始值为a的地址  
int \*p2 = p1;//初始值为int类型对象的指针-p2指针指向p1  
  
  
int i = 10;  
int &j = i;//&符号紧随类型名出现 它是声明的一部分 j是一个引用  
int \*p;//\*符号紧随类型名出现 它是声明的一部分 p是一个指针  
p = &i;//&符号出现在表达式之中,是一个取地址符号  
\*p = i;//\*符号出现在表达式之中,是一个解引用符  
int &j2 = \*p;//&是声明的一部分 \*解引用符

//2.20
    	//这段代码首先定义了一个int型的变量i，并赋初值42，随后定义了一个int型指针，初始值为i的地址，*P在表达式中，指的就是解操作符，而中间的*是乘的意思，所以作用就是将i改变为42 * 42。
    	//要注意的就是*这个符号的多重含义
    	int i = 42;//定义一个int型的变量i
    	int *p1 = &i;//定义一个int型指针 初始值为i的地址
    	*p1 = *p1 * *p1;//*p1=42*42;

2.21

1：非法定义，类型不一致

int i = 0;

a)double \*dp=&i;//类型不匹配

2：非法定义，没有取址操作符

b)int \*ip=i;//不能把int变量直接给int型指针

c)int \*p=&i;//对哦

3：合法定义。

2.22

if(p)//p所指是否为空指针

if(\*p)//p所指的对象内容-也就是p所指的内存空间中所储存的值是否为0

2.23 不可以，指针是否有效还不知道呢！！！得先看他是否有效的指针，然后才判断是否指向一个合法的对象

2.24   因为lp的类型不是int，而void定义了一个 空指针，可以接受任意类型的对象。

2.25

1:ip是一个int类指针型的，i是一个int型的变量，r是一个int型的引用。

2;i是一个int型的变量，ip是一个空指针。

3：ip是一个int类型的指针，ip2是一个int类型的变量。

2.26

涉及知识点：const表示的不可改变的量！：const用在变量定义时的类型前表示该变量不可改变，注意：该变量必须初始化（可以在运行时初始化）。

a:不合法，变量未初始化。

b:合法

c:合法

d:不合法，变量sz是一个const变量，不能被改变。

2.27

涉及知识点：

指针与const：1：指向常量的指针：要想存放变量的地址，必须使用指向常量的指针：const int \*p

2:常量指针：指针自身是一个对象，不可变。int \*const p = &pi   （常量指针必须初始化！！！）

3：指向常量的常量指针。const  int \*const p (不仅指针本身不可变，指针所指对象也不可变)

引用与const：

将引用定义为常量：const int &i

a:引用r的赋值对象必须是一个对象，所以不合法

b:合法，将p2设为一个常量指针，初始化为i2对象的地址

c:合法，将i设为常量，r设置为常量的引用（注意const   int   &r = 0  是正确的，但是int  &r = 0是不正确的）

d:合法，p3为指向常量的常量指针，初始值为i2的地址

e:合法，p1为指向常量的指针，初始值为i2的地址

f:使用不合法

g:合法，正常的赋值

2.28

**指向常量的指针不能用于改变所指对象的值，要想存放常量对象的地址，只能使用指向常量的指针**

a:不合法，常量指针cp未初始化

int i,\*const cp;

b:不合法，常量指针p2未初始化

int \*p1,\*const p2;

c:不合法，常量ic未初始化

const int ic,&r=ic;

d:不合法，常量指针p3未初始化

常量指针必须初始化

const int \*const p3 = &pi；===》p3是一个指向常量对象的常量指针

e:合法

2.29

a:合法

b:不合法，const int 和 int 不是一个类型，指向常量的指针在赋值时必须类型一致

c:和b相同

d:不合法，p3是一个常量指针，不能被再次赋值   常量指针必须初始化 而且初始化完成，它的值就不能再改变

e:不合法，p2是一个常量指针，不能被再次赋值

f:不合法，ic是个常量，不能被再次赋值

指向常量的指针 --没有规定所指的对象必须是一个常量 所谓指向常量的指针仅仅要求不能通过该指针改变对象的值

2.4.3顶层const

int i=0;

int \*const p1 = &i;//不能改变p1的值，这是个顶层const  
const int ci=42;//不能改变ci的值 这是个顶层const

const int \*p2 = &ci;//允许改变p2的值，但是p2所指的内存空间也就是ci是不能改变-常量 底层const

2.30

涉及知识点：

顶层const:指的是本身不可以被改变。

底层const:指的是自身所指对象不可以被改变

用于声明引用的const都是底层const

v2是顶层const；

p2是底层const；

p3最左是底层，右侧是顶层const；

const int \*const p3 =p2;//靠左是底层const 靠右的const是顶层const

其他都不是const;

2.31

知识点：顶层const的拷贝不受限制，但是底层const的拷贝的对象必须具有相同的底层const资格。一般来说：非常量可以赋值给常量，反之则不行

答案：

a:合法；

b:不合法，p1是非常量，p2是常量，不能进行赋值操作；

c:合法；

d:不合法，p3既是底层也是顶层const，所以都得考虑到；

e:合法；

2.32

指向空的指针可以用nullptr或0带代替

所以该式可表达为：\*p = nullptr;

const int \*p=nullptr;//p是一个指针整型常量的指针

constexpr int \*q=nullptr;//q是一个指向整数的常量指针

p是一个指向常量的指针 q是一个常量指针 其中关键在于constexpr把它所定义的对象置为了顶层const

2.33

知识点一：使用类型别名：C++中可以定义一个类型的别名，有两种方式

1：使用typedef

\[cpp\]  [view plain][]   [copy][view plain]

1.  **typedef** **double** wages;  //wages就成为了double的别名  
2.  **typedef** wages base ,\*p;  //base 成了double的别名（同义词），p成了double \*的同义词（double类型的指针）

2：使用别名名称

\[cpp\]  [view plain][]   [copy][view plain]

1.  **using**  SI = Sales\_item; //  SI 成为了Sales\_item的别名

知识点二：auto 类型说明符：当我们不知道变量表达式的类型时，可以使用auto让编译器为我们决定表达式的类型

\[cpp\]  [view plain][]   [copy][view plain]

1.  auto a = b+c; //编译器会为我们判别类型  
2.  auto a = 0, b = 3.14;  //错误，auto语句中的类型必须一致。

知识点三：auto会自动忽略掉顶层const，而底层const会被保留。

知识点四：auto定义的变量必须有初始值。

2.36

知识点：decltype：希望从表达式的类型推断出想要定义的变量的类型，该操作返回操作数的类型。

\[cpp\]  [view plain][]   [copy][view plain]

1.  decltype(f)  sum = s; //sum的类型就是f的返回类型

decltyoe(（variable）)（注意是双层括号）的结果永远是引用，而decltyoe(variable)结果只有当variable本身就是一个引用才是一个引用

decltype(())双层括号表示引用（注意引用必须初始化）

a是int类型   4

b是int类型   4

c是int类型   4

d是int &类型    4

全是4！！！！！！！！！！！

2.37

知识点：赋值的表达式语句本身是一种引用：

a int 3;

b int 4;

c int 3;

d int & 3;

decltype(a = b) d =a;====>int &d=a;

2.38

主要的区别有两点：

1：如果使用引用类型，auto会识别为其所指对象的类型，decltype则会识别为引用的类型。

2：decltype(())双括号的差别。

\[cpp\]  [view plain][]   [copy][view plain]

1.  **int** i = 0, &r = i;  
2.  // same  
3.  auto a = i;  
4.  decltype(i) b = i;  
5.  // different  
6.  auto c = r;  
7.  decltype(r) d = i;  ===>int &d=i;===> decltype((i)) d = i;
8.

[view plain]: https://blog.csdn.net/misayaaaaa/article/details/53239233#