【信息存储】
程序将找到一块能够存储整数的内存,将该内存单元标记为braincount,并将5复制到该内存单元中;然后,您可在程序中使用braincount来访问该内存单元。
int braincount{5};
int braincount = {5};
int braincount = 5; //存储一个整数,并使用名称braincount来表示该整数的值
【变量命名规则】
- 在名称中只能使用字母字符、数字和下划线(_)。
- 名称的第一个字符不能是数字。
- 区分大写字符与小写字符。
- 不能将C++关键字用作名称。
- 以两个下划线或下划线和大写字母打头的名称被保留给实现(编译器及其使用的资源)使用。 以一个下划线开头的名称被保留给实现,用作全局标识符。
- C++对于名称的长度没有限制,名称中所有的字符都有意义,但有些平台命名方案有长度限制。
【整型变量的长度】
- short至少16位;
- int至少与short一样长;
- long至少32位,且至少与int一样长;
- long long至少64位,且至少与long一样长。
可以使用sizeof()函数查看各数据类型在内存中占多少个字节
#include <iostream>
#include <climits> //定义了符号常量来表示类型的限制
int main(void)
{
int n_int = INT_MAX;
short n_short = SHRT_MAX;
long n_long = LONG_MAX;
long long n_llong = LLONG_MAX;
//sizeof不是函数,是运算符。sizeof查看类型所占用的内存大小必须加括号,查看变量可以不加括号。
cout << "int is " << sizeof(int) << " bytes." << endl;
cout << "Maximum values: " << n_int << endl;
cout << "short is " << sizeof n_short << " bytes." << endl;
cout << "Maximum values: " << n_short << endl;
cout << "long is " << sizeof(long) << " bytes." << endl;
cout << "Maximum values: " << n_long << endl;
cout << "long long is " << sizeof n_llong << " bytes." << endl;
cout << "Maximum values: " << n_llong << endl;
return 0;
}
输出:
整型从最小到最大依次是:
bool、 char、 signed char、unsigned char、 short、 unsigned short、 int、 unsigned int、 long、 unsigned long以及C++11新增的long long和unsigned long long。
为什么C++有多种整型?
有多种整型类型,可以根据特定需求选择最适合的类型。 例如,可以使用short来存储空格,使用long来确保存储容量,也可以寻找可提高特定计算的速度的类型。
【整型溢出】
int main(void)
{
short sam = SHRT_MAX;
unsigned short sue = sam;
cout << "short sam = SHRT_MAX;\t unsigned short sue = sam;" << endl;
cout << "sam = " << sam << ",\t\t sue = " << sue << endl;
sam = sam+1; //溢出
sue = sue+1;
cout << "sam +1 = " << sam << ",\t sue + 1 = " << sue << endl;
return 0;
}
输出:
原因:
该程序将一个short变量(sam)和一个unsigned short变量(sue)分别设置为最大的short值,在我们的系统上,是32767。然后,将这些变量的值都加1。这对于sue来说没有什么问题,因为新值仍比无符号整数的最大值小得多;但sam的值从32767变成了-32768! 同样,对于sam,将其设置为0并减去1, 也不会有问题; 但对于无符号变量sue,将其设置为0并减去后,它变成了65535。可以看出,这些整型变量的行为就像里程表。如果超越了限制,其值将为范围另一端的取值(参见图3.1)。C++确保了无符号类型的这种行为; 但C++并不保证符号整型超越限制(上溢和下溢)时不出错,而这正是当前实现中最为常见的行为。
【cout输出同一数据的不同进制表达形式】
#include <iostream>
using namespace std;
int main(void)
{
int a;
cout << "请输入一个整数 a = ";
cin >> a;
cout << oct << "a 的8进制:" << a << endl;
cout << hex << "a 的16进制:" << a << endl;
cout << dec << "a 的10进制:" << a << endl; //默认也是十进制输出
return 0;
}
输出:
【char字符在内存中的存储和读取】
#include <iostream>
using namespace std;
int main(void)
{
char ch = 'M'; //在内存中ch是以ASCII码值77存储
int i = ch; //并没有类型不匹配,把ch内存中的77读取出来赋给整型
//cout发现ch是char类型,就把内存中的77变为对应的字符显示出来
cout << "The ASCII code for " << ch << " is " << i << endl;
ch = ch+1;
i = ch;
cout << "ch + 1 后:" << endl;
cout << "The ASCII code for " << ch << " is " << i << endl;
cout.put('M'); //通过类对象cout来使用函数put( )
cout << endl;
cout << 'M' << endl;
return 0;
}
输出:
如何使用C++来找出编码88表示的字符?
char c = 88;
cout << c << endl; // char type prints as character
cout.put(char(88)); // put() prints char as character
cout << char(88) << endl; // new-style type cast value to char
cout << (char)88 << endl; // old-style type cast value to char
【浮点数的表示】
1、小数点的形式;例如:float a=12.345;
2、E表示法;例如:float a=1.2e-10;
C和C++对于有效位数的要求是,float至少32位,double至少48位,且不少于float,long double至少和double一样多。这三种类型的有效位数可以一样多。然而,通常,float为32位,double为64位,long double为80、96或128位。另外,这3种类型的指数范围至少是-37到37。
常量为float类型,请使用f或F后缀。对于long double类型,可使用l或L后缀(由于l看起来像数字1,因此L是更好的选择) 。
auto b = 8.25f / 2.5; //2.5默认double,则b也是double类型。
auto a = 12.345678L; //a默认为long double类型
cout << a << endl; //输出为12.3456,因为浮点数在系统中只显示了6位有效位
【double和float精度之间的差异】
#include <iostream>
using namespace std;
int main(void)
{
cout.setf(ios_base::fixed, ios_base::floatfield); //浮点数显示到小数点后六位
float tub = 10.0 / 3.0;
const float million = 1.0e6; //定义一个float类型的[常量]
cout << "tub = " << tub << endl;
cout << "A million tubs = " << tub * million << endl;
double mint = 10.0 / 3.0;
cout << "mint = " << mint << endl;
cout << "A million mint = " << mint * million << endl;
return 0;
}
输出:
原因:
tub和mint都被初始化为10.0/3.0—3.333333333333333333……由于cout打印6位小数, 因此tub和mint都是精确的。 但当程序将每个数乘以一百万后, tub在第7个3之后就与正确的值有了误差。 tub在7位有效位上还是精确的(该系统确保float至少有6位有效位, 但这是最糟糕的情况) 。 然而, double类型的变量显示了13个3, 因此它至少有13位是精确的。 由于系统确保15位有效位, 因此这就没有什么好奇怪的了。 另外, 将tub乘以一百万, 再乘读取包含文件以10后, 得到的结果不正确, 这再一次指出了float的精度限制。
【浮点数在内存中的存储方式】
通常float为32位(二进制),float至少有6位有效位(十进制)。
例如:8.25在内存中的表示:
整数部分:1000
小数部分: 01
0.25*2=0.5 --- 0
0.5*2 =1 --- 1
8.25的二进制表示为:1000.01
8.25的二进制科学计数法表示为:1.00001*(2^3)
符号位:0(正数为0,负数为1)
指数:127(固定偏移)+3 = 130 ----> 10000010(130的二进制)
小数:00001
所以合起来8.25在内存中表示为:0 10000010 00001000000000000000000一位符号位 + 23位小数位 = 24位二进制数据位 ---> 6位十进制数据位
【浮点运算的速度通常比整数运算慢,且精度将降低】
#include <iostream>
using namespace std;
int main(void)
{
float a = 2.34e22;
float b = a + 1.0;
cout << "a = " << a << endl;
cout << "b = a + 1.0 = " << b << endl;
cout << "b - a = " << b-a << endl; //=0,按理说应该=1的。但是......
/*2.34E+22是一个小数点左边有23位的数字。加上1,就是在第23位加1。
但float类型只能表示数字中的前6位或前7位,因此修改第23位对这个值不会有任何影响。*/
return 0;
}
输出:
【算术运算符】
- + 运算符对操作数执行加法运算。例如,4+20等于24。
- - 运算符从第一个数中减去第二个数。例如,12-3等于9。
- * 运算符将操作数相乘。例如,28*4等于112。
- / 运算符用第一个数除以第二个数。例如,13/5等于2。
如果两个操作数都是整数, 则结果为商的整数部分。例如,17/3等于5,小数部分被丢弃(不进行四舍五入)。
其中一个是浮点数,结果也是浮点数。例如,17.0/3等于5.66667(四舍五入,六位有效数字)。 - % 运算符求模。也就是说,它生成第一个数除以第二个数后的余数。例如,19%6为1,因为19是6的3倍余1。两个操作数必须都是整型,将该运算符用于浮点数将导致编译错误。如果其中一个是负数,则结果的符号满足如下规则:(a/b)*b + a%b = a。
优先级:类似于数学运算。
【强制类型转换】
- (typeName) value;
- typeName (value);
- Static_cast <typeName> (value);
以上三种方法都可以,例如:
cout << (int) 12.6 <<endl; //把12.6强制转换成int类型,只截取整数部分,输出12
cout << float (12.3456789) <<endl; //把12.3456789强制转换成float类型,四舍五入,输出12.3457
将long值赋给float变量在数值范围内会导致舍入误差。
而把浮点数赋值给整数在数值范围内只会截取整数部分,不进行四舍五入。