C++每日一课（八）

C++算术运算符

C++提供了5种基本的运算符：加、减、乘、除、求模

每种运算符都使用两个值（两个操作数）来计算结果，由运算符加上操作数就构成了表达式

int sum = 100 + 200;

那么这里 100和200都是操作数，+是加法运算符，100+200则是一个表达式，其运算的结果是300并赋值给sum变量

五种基本C++算术运算符

+：加法运算符，对操作数执行加法运算如：1+2等于3

-：减法运算符，对操作数执行减法运算如：2-1等于1

*：乘法运算符，对操作数执行乘法运算如：1*2等于2

/：除法运算符，对操作数执行除法，第一个数除第二个数100/2等于50，注意如果两个操作数都是整数，则结果取的是结果的整数会把小数部分截取掉

%：求模运算符，得到第一个数除以第二个数的余数，注意：该运算符只能应用于整数

如果操作数中一个是负数则结果的符号满足如下规则：(a/b)*b+a%b = a

以上所说的操作数不仅仅只是常量可以用于操作数，变量也是可以用于操作数的

/*
作者：xiesheng
时间：2017-06-24
版本：v1.0
说明：C++中运算符
*/

#include <iostream>

int main() {
using namespace std;

float f, f1;
cout.setf(ios_base::fixed, ios_base::floatfield);

cout << "请输入一个浮点数：";
cin >> f;
cout << "请输入另一个浮点数：";
cin >> f1;

cout << "f=" << f << "; f1=" << f1 << endl;
cout << "f+f1=" << f + f1 << endl;
cout << "f-f1=" << f - f1 << endl;
cout << "f*f1=" << f*f1 << endl;
cout << "f/f1=" << f / f1 << endl;

system("pause");
return 0;
}

请输入一个浮点数：65.12

请输入另一个浮点数：3.15

f=65.120003; f1=3.150000

f+f1=68.270004

f-f1=61.970001

f*f1=205.128021

f/f1=20.673016

请按任意键继续. . .

可以看到float进行相加运算是不靠谱的，C++中对于float只保证6位有效位，如果我们四舍五入成6位结果是正确的

如果需要更高的精度需要选择double、long double

C++运算符的优先级

在复杂的运算过程中一定要考虑到运算符的优先级，否则会得到与你意想不到的结果

int result = 1 + 2 * 3;

在操作数4左右两边都有运算符，那先运算哪个后运算哪个就得看运算符的优先级了

算术运算符遵循通常的代数优先级，先乘除，后加减，因而上面的运算表达式可以理解成是1 + (2 * 3)

当然在表达式中可以使用括号来自定义优先级，首先先算括号内的

C++中的除法

如果除法对应的两个操作数都是整数，则C++将执行整数除法，它将意味着结果的小数部分会被丢弃掉，保证最后的结果是一个整数

如果两个操作数中有一个（或者两个都是）浮点值则结果中的小数部分会被保留，结果也会是一个浮点数

/*
作者：xiesheng
时间：2017-06-24
版本：v1.0
说明：C++中运算符
*/

#include <iostream>

int main() {
using namespace std;
cout.setf(ios_base::fixed, ios_base::floatfield);

cout << "两个整数相除的结果是：9/5 = " << 9 / 5 << endl;
cout << "两个浮点数相除的结果：9.0/5.0 = " << 9.0 / 5.0 << endl;
cout << "整数与浮点数混合相除的结果：9.0/5 = " << 9.0 / 5 << endl;
cout << "double类型相除：1e7/9.0 = " << 1e7 / 9.0 << endl;
cout << "float型相除结果：1e7f/9.0f = " << 1e7f / 9.0f << endl;

system("pause");
return 0;
}

两个整数相除的结果是：9/5 = 1

两个浮点数相除的结果：9.0/5.0 = 1.800000

整数与浮点数混合相除的结果：9.0/5 = 1.800000

double类型相除：1e7/9.0 = 1111111.111111

float型相除结果：1e7f/9.0f = 1111111.125000

请按任意键继续. . .

这里有一个需要注意的地方：浮点常量在默认情况下是double类型的

上面程序中除法运算符表示了3种不同的运算：int除法、float除法、double除法，C++会根据上下文（操作数的类型）来确定运算符的含义

这里使用相同的运算符进行多种操作的过程叫做运算法的重载

C++有多种内置的运算符重载，同时也允许扩展运算符重载来用于用户定义的类

求模运算符

求模运算符返回的整数除法的余数

/*
作者：xiesheng
时间：2017-06-24
版本：v1.0
说明：C++中运算符
*/

#include <iostream>

int main() {

using namespace std;
const int Lbs_per_stn = 14;	//每英石为14磅

int lbs;
cout << "请输入你有多少磅：";
cin >> lbs;
int stone = lbs / Lbs_per_stn;
int pounds = lbs%Lbs_per_stn;
cout << lbs << " pounds are " << stone << " stone." << pounds << " pound(s).\n";

system("pause");
return 0;
}

请输入你有多少磅：181

181 pounds are 12 stone.13 pound(s).

请按任意键继续. . .

类型转换

C++中提供了丰富的类型，可以根据不同的场景需求选择不同的类型，但这也使得操作更复杂了。

由于有11种整型和3种浮点型，因而计算机需要处理大量不同的情况，在处理不同类型计算时更是如此

为了处理这种问题，C++自动执行了

1.把一种算术类型的值赋给另一种算术类型的变量时，C++将对值进行转换

2.表达式中包含不同类型时，C++会自动将值进行转换

3.把参数传给函数时，C++会对值进行转换

初始化和赋值进行转换

C++是可以把一种类型的值赋值给另一种类型的变量，这个时候值会变成接收变量的类型

如果把一个值赋值给更大范围的变量的时候通常是不会有什么问题的，值不会变，仅仅占用字节更多了一点而已

如果把一个值赋值给小范围的变量时则可能会导致精度丢失，有时在超出范围时则会导致结果不确定

把0赋值给bool变量时，将被转换为false,而非零值将被转换为true

/*
作者：xiesheng
时间：2017-06-24
版本：v1.0
说明：C++类型转换
*/

#include <iostream>

int main() {

using namespace std;
cout.setf(ios_base::fixed, ios_base::floatfield);
float f = 3;
int i = 3.12 ;
int i1 = 3.2e15;
cout << "f = " << f << endl;
cout << "i = " << i << endl;
cout << "i1 = " << i1 << endl;

system("pause");
return 0;
}

f = 3.000000

i = 3

i1 = 256376832

请按任意键继续. . .

以{}方式初始化时进行转换

如果是以{}方式进行初始化时进行转换是不可以进行缩窄转换的

比如：int i{3.12};这样程序是不允许的

但是对于放大进行转换是可以，因为这个时候编译器可以正确的存储值

比如 double d{3};这个是可以的

表达式中的转换

当同一个表达式中包含两种不同的算术类型时

1.自动转换，C++会把bool、char、unsigned char、signed char、short转换为int

true转换为1，false转换为0

以上的转换叫做整型提升

如：

short s1 = 1;

short s2 = 2;

short s1+s2;

最后的语句会做两次转换，第一次是把s1、s2转成int型并做计算，第二次会把计算的结果再转回到short

还需要注意提升是是会考虑到类型长度的

如果short 比 int 短，则unsigned short转为int

如果两种类型一样长，则unsigned short转为 unsigned int

以上的规则其实变是在确保在提升时不会有精度的丢失

所以 wchar_t会被提升到下列类型中第一个满足宽度足够存储wchar_t的类型 int 、unsigned int、long、unsigned long

不同的类型进行算术运算时，也会进行一些转换

int 与folat进行计算时，转小的类型会转为转大的类型

1.如果有一个操作数类型是long double,则把另一个操作类转为long double

2.否则如果有一个操作数类型是double，则把另一个操作数转为 double

3.否则如果有一个操作数类型是float,则把另一个操作数转为float

4.否则说明操作数都是整型，这个时候执行整型提升

5.如果两个操作数都是有符号或无符号的，且其中一个操作数的级别比另一个低则转为较高级别的类型

6.如果操作数是一个是有符号一个是无符号，且无符号操作数的级别比有符号操作数高，则把有符号操作数转为无符号操作数类型

7.如果有符号类型可以表砂无符号类型的所有可能取值，则把无符号操作数类型转为有符号操作数的类型

8.否则两个操作数都转为有符号类型的无符号版本

传递参数时的转换

传参时的类型转换，常常是由C++函数原型控制的

强制类型转换

这是一种显示的类型转换机制

有两种写法

(long) i 这是C语言格式

long (i) 这是C++格式

注意：强制类型转换不会修改i变量本身，而是创建一个新的、指定类型的值

static_cast<>：把值从一种数值类型转为另一种数值类型

static_cast<long> (i)

auto声明

C++ 新增了一个工具，可以让编译器根据初始值的类型判断变量的类型，它重新定义了auto的含义

比如：

auto n = 100; //这里n就是int型

auto x = 1.1; //这里x就是double型

auto y = 1.2e12L; //这里yy就是long double型

使用auto时也会存在弊端的

比如：你想把d定义成一个double型，但你的写法如果如下，则d就为了int型

auto d = 0;

所以一般来说会显示的指定类型，这个会比较靠谱