《C++ Primer Plus》第三章 处理数据 ——Part 2

浮点数

• 浮点数的表示

  • 使用标准小数点表示法。
  • 使用科学计数法。d.dddE+n

• 浮点数有三种类型：duble、float、long double。

• double的有效数位是15，float的有效数位是6-7.

浮点的使用和储存

变量类型总结

运算符

算数运算符

算数运算符包括加、减、乘、除、模数运算

• 当两个整型相除时，结果的小数部分被舍弃。
• 负数的取模运算
• 取模运算只限于整数和整数。

按位运算符

运算符+赋值

逻辑运算符

递增、递减运算符

• i++和++i的区别

// plus_one.cpp -- the increment operator
#include <iostream>
int main()
{
	using std::cout;
	int a = 20;
	int b = 20;

	cout << "a   = " << a << ":   b = " << b << "\n";
	cout << "a++ = " << a++ << ": ++b = " << ++b << "\n";
	cout << "a   = " << a << ":   b = " << b << "\n";
	return 0;
}

输出结果：

a   = 20:   b = 20
a++ = 20: ++b = 21
a   = 21:   b = 21

表达式和优先级

运算符与操作数构成表达式。

• 表达式的优先级
  • 先计算小括号里面的值。
  • 之后根据优先级计算。
  • 最后从左到右运算。

优先级

优先级	运算符
1	i++,i--
2	!,~,+i(正号),-i(负号),++i,--i,
3	*，/，%
4	+，-
5	<<,>>
6	<,<=,>,>=
7	==,!=
8	&
9	^
10	|
11	&&
12	||
13	=和所有的运算符＋赋值

类型转换

初始化和赋值进行的转换

在语句typename1 A = typename2 B语句中，系统会先将B转换为type1后再赋值给A，B的类型和值不变。
在语句typename1 A = x中，如果x的类型和A的类型不同，会先将x转换为和A相同的类型后在赋值给A。

// assign.cpp -- type changes on assignment
#include <iostream>
int main()
{
	using namespace std;
	cout.setf(ios_base::fixed, ios_base::floatfield);
	float tree = 3;     // int converted to float
	int guess = 3.9832; // float converted to int
	int debt = 7.2E12;  // result not defined in C++
	cout << "tree = " << tree << endl;
	cout << "guess = " << guess << endl;
	cout << "debt = " << debt << endl;
	return 0;
}

输出结果：

tree = 3.000000
guess = 3
debt = 1634811904 //不可预测

利用{}的转换

利用{}的转换比较受限制，列表初始化不允许缩窄，及{}中的数据类型大小必须小于将要赋给的数据的类型大小（const常量除外），并且{}中的值必须已初始化。
利用{}的转换不能从浮点型转换位整型，可以从整型转换为浮点型。

下面是可行的：

long long ch = { 1 };
//
int x = 12;
long long y = { x };
//
char ch = { true };		//int(ch) == 1
//
const long long x = 5;
int y = { x };
//
double x = { 123 };

下面是不可行的：

short x = { 1234567891023 };//需要缩窄
//
long long x = 1;
int y = { x };//类型发生缩窄
//
short x;
int y = { x };//x未初始化
//
const double x = 3.14;
int y = {x};
int c = {2.12};//从浮点转换为整型

表达式中的转换

将不同类型进行算数运算时，C++会先根据一定的规则转换为同一种类型进行计算，之后在转换为需要输出的类型，进行赋值。

隐式转换

1、隐式转换
C在以下四种情况下会进行隐式转换:
1、算术运算式中，低类型能够转换为高类型。
2、赋值表达式中，右边表达式的值自动隐式转换为左边变量的类型，并赋值给他。
3、函数调用中参数传递时，系统隐式地将实参转换为形参的类型后，赋给形参。
4、函数有返回值时，系统将隐式地将返回表达式类型转换为返回值类型，赋值给调用函数。

2、算数运算的隐式转换
算数运算中，首先有如下类型转换规则：
1、字符必须先转换为整数(C语言规定字符类型数据和整型数据之间可以通用) 。
2、short型转换为int型(同属于整型) 。
3、float型数据在运算时一律转换为双精度(double)型，以提高运算精度(同属于实型) 。
其次，有下面的规则。
当不同类型的数据进行操作时，应当首先将其转换成相同的数据类型，然后进行操作，转换规则是由低级向高级转换。

————————————————
版权声明：本文为CSDN博主「鱼思故渊」的原创文章，遵循 CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/yusiguyuan/article/details/41643819

隐式转换的详细规则在《C++　Primer　Plus》64页的校验表中.
简单的说，如果两个操作数有浮点类型，会转换为浮点类型，如果都为整型，按照从低级向高级的原则转换为同一种类型。

强制类型转换

通用格式：typename(value);或(typename)value;。

// typecast.cpp -- forcing type changes
#include <iostream>
int main()
{
    using namespace std;
    int auks, bats, coots;

    // the following statement adds the values as double,
    // then converts the result to int
    auks = 19.99 + 11.99;

    // these statements add values as int
    bats = (int) 19.99 + (int) 11.99;   // old C syntax
    coots = int (19.99) + int (11.99);  // new C++ syntax
    cout << "auks = " << auks << ", bats = " << bats;
    cout << ", coots = " << coots << endl;

    char ch = 'Z';
    cout << "The code for " << ch << " is ";    // print as char
    cout << int(ch) << endl;                    // print as int
    cout << "Yes, the code is ";
    cout << static_cast<int>(ch) << endl;       // using static_cast
   // cin.get();
    return 0; 
}

输出结果：

auks = 31, bats = 30, coots = 30
The code for Z is 90
Yes, the code is 90