第二章 处理数据

c++ 变量分类：

• 基本类型

       算数类型

• • 整型
    • 符号整型 signed char，short，int，long，long long
    • 无符号整型 char，unsigned short，unsigned int，unsigned long，unsigned long long
    • bool类型
    • wchar_t，char16_t，char32_t
  • 浮点型 、
    • float，double，long double

        指针类型

• • 空类型 void
• 复合类型
  • 数组
  • 字符串
  • 结构体
  • 共用体（联合体）
  • 指针类型
  • 模板类

1、简单变量

1.1变量名

命名规则：

1. 名称只能用字母、数字、下划线
2. 名称第一个字符不能为数字
3. 区分大小写
4. 不能使用c++关键字做名称
5. 以两个下划线（__）及下划线+大写字母（_B）打头的名称保留给实现（编译器及其使用的资源）使用
6. 以一个下划线打头的名称被保留给实现，用作全局标识符（使用后编译器不会报错，但会导致行为的不确定性，不知道结果会是什么）
7. c++对名称长度没有限制，但有些平台有长度限制

1.2 整型

1.2.1基本整型：

1. char
2. short 至少16位
3. int 至少与short一样长
4. long 至少32位 且至少与int一样长
5. long long 至少64位 且至少与long一样长

每种类型又分为signed和unsigned。

每种类型最多能够表示4种不同的整数宽度（用于描述存储整数时使用的内存量，使用的内存量越多，则越宽）

1.2.2 位和字节

位（bit）是计算机内存的基本单位，8位内存块可设置256种不同组合（unsigned 可表示0~255，signed 可表示-128~127），16位可以有65536种不同组合......

字节（byte）通常指8位的内存单元。是描述计算机内存量的度量单位（1KB = 1024byte  1MB = 1024KB）。

c++中的字节 由至少能够容纳实现的基本字符集 的相邻位组成，即每个字节必须能够表示 采用的字符集中 最大的字符。通常ASCII字符集和EBCDIC字符集 字符集包含的字符数<256 所以用8位容纳即可，而Unicode编码比较大，因此实现需使用16bit，甚至32bit的字节。

1.2.3 字节大小对可移植性的影响

当前很多系统都使用最小长度 即short 16位，long 32位 但对int提供多种选择 其宽度可以是 16位、24wei、32位甚至可以是 64位（这时long至少也为64位）。

通常在老式pc机中int为 16位，windows中int为32位（与long相同）。这可能在将c++程序从一种环境移植到另一种环境时（包括统一系统的不同编译器）时引发问题。

可通过sizeof运算符来返回类型或变量的长度，单位为字节（不同系统中字节表示的位数可能不同，在一个系统中，2个字节的int 可能是16位（8bit = 1byte），在另一个系统中，可能是32位（16bit = 1byte））。

在climits头文件中，包含了关于整型限制的信息：

    

climits文件中的实现：

#define INT_MAX 32767

        #define 为预处理器编译指令，表示在编译前，先将INT_MAX 替换为 32767 后再编译。#define 也可定义自己的符号常量，它为C中遗留下来的，c++中可通过const关键字来创建符号常量，故不常使用#define。但是，被设计成同时用于C和C++的头文件，必须用#define.

练习：查看climits中的限制信息

#include <iostream>
#include<climits>

int main(){
    using namespace std;

    short n_short = SHRT_MAX;
    int n_int = INT_MAX;
    long n_long = LONG_MAX;
    long long n_longlong = LLONG_MAX;

    cout<< "short size is " << sizeof(n_short) << " bytes." << endl;
    cout<< "SHRT_MAX is " << SHRT_MAX << endl;  ///16位 signed short 所能表示的最大值 32767
    cout<< "int size is " << sizeof(n_int) << " bytes." << endl;
    cout<< "INT_MAX is " << INT_MAX << endl;  ///32位 signed int 所能表示的最大值 2147483647
    cout<< "long size is " << sizeof(n_long) << " bytes." << endl;
    cout<< "LONG_MAX is " << LONG_MAX << endl;  ///32位 signed long 所能表示的最大值 2147483647
    cout<< "long long size is " << sizeof(n_longlong) << " bytes." << endl;
    cout<< "LLONG_MAX is " << LLONG_MAX << endl;  ///64位 signed long long 所能表示的最大值 9,223,372,036,854,775,807‬
    cout<< endl;
    cout<< "short size is " << sizeof(short) << " bytes." << endl;
    cout<< "int size is " << sizeof(int) << " bytes." << endl;
    cout<< "long size is " << sizeof(long) << " bytes." << endl;
    cout<< "long long size is " << sizeof(long long) << " bytes." << endl;
    return 0;
}

1.2.4 初始化

警告：一定要对变量初始化，否则其值不确定--为其相应内存单元在创建变量前所保存的值。

初始化方式：

int a = 7;
int a{7};
int a = {7};
int a = {};   //括号内不包含任何东西，此时变量将被初始化为0

使用{}有助于更好地防范类型转换错误！！

1.3 无符号类型

#include <iostream>
#include <climits>

int main(){
    using namespace std;
    short sam = SHRT_MAX;
    unsigned short sue = sam;
    cout << "short sam = SHRT_MAX  unsigned short sue = sam" << endl;
    cout << "sam = " << sam << "   sue = " << sue << endl;
    cout << "After + 1 :" << endl;
    sam += 1;
    sue += 1;
    cout << "sam = " << sam << "   sue = " << sue << endl;
    cout << endl;
    short sam2 = SHRT_MIN;
    unsigned short sue2 = 0;
    cout << "short sam2 = SHRT_MIN  unsigned short sue2 = 0" << endl;
    cout << "sam2 = " << sam2 << "   sue2 = " << sue2 << endl;
    cout << "After - 1 :" << endl;
    sam2 -= 1;
    sue2 -= 1;
    cout << "sam2 = " << sam2 << "   sue2 = " << sue2 << endl;
    return 0;
}

1.4进制

一般int型为自然长度（指计算机处理起来效率最高的长度）一般选int类型。

c++可以以三种不同的计数方式来书写整数：10进制、8进制、16进制。以前面1~2位来标识数字常量的基数若第一位为1~9表示10进制；如果第一位是0第二位为1~7表示8进制；如果前两位为0x或0X表示16进制。但其存储方式均为2进制。

输出16进制： cout<<hex<<...

输出8进制：cout<<oct<<...

输出10进制：cout<<dec<<...

#include <iostream>
int main(){
    using namespace std;
    int chest = 42;
    int waist = 42;
    int inseam = 42;
    cout << "chest = " << chest << endl;
    cout << hex << "waist = " << waist <<endl;
    cout << oct << "inseam = " << inseam << endl;
    cout << dec << "inseam = " << inseam << endl;
    return 0;
}

1.5char类型：字符和小整数

char专为存储字符而设计。char类型足够长，能够表示计算机系统中所有基本符合（字母、数字、标点）。但char也可以看作是比short更小的整型。

书写字符常量的方式：

‘A’：应单引号括起来

'n'：表示换行符

‘"’：表示”字符

‘\’：表示字符

”n“：字符串表示法

通用字符名

c++除了支持一个基本的源字符集（由标准美国键盘上的字符和数字、C语言中使用的符号（如=、{、}等）以及一些其他字符（换行符、空格等））

通用字符集的用法类似与转义序列。可以以u或U打头，u后面是8个16进制位，U后面是16个十六进制位。采用Unicode和ISO 10646 编码。

Unicode和ISO10646

Unicode可表示109000多种符号和90多个手写符号，且还在不断发展。

他给每个字符指定一个编号--码点：U-222B (U表示是一个Unicode编码，222B表示字符的16进制编号)

ISO10646 是由国际标准化组织ISO建立的一套编码标准两套标准是同步的。

signed char 和 unsigned char

char在默认情况下，既不是无符号的，也不是有符号的，这个由c++的实现（编译器的实现）决定

char ch1;
signed char ch2;
unsigned char ch3;

若char作为数值类型，unsigned char 范围通常为0-255，而signed char 范围为 -128~127。例如一个char类型的变量要表示200，有的系统可以，有的系统不行，而unsigned char 则一定可以。

wchar_t、char16_t、char32_t

wchar_t(宽字符类型)：是一种整数类型，有足够的空间表示系统使用的最大扩展字符集。这种类型与底层的（underlying 类型）的长度和符号属性相同。对底层类型的选择取决于实现。因此在一个系统中可能是unsigned short，在另一个系统中可能是int。

iostream头文件的最新版提供了wcin和wcout，用于处理wcha_t.

wchar_ t bob = L'P'; //把字母P的wchar_t版本存储在bob中
wcout << L"tall" << endl; //把tall的wchar_t版本输出

char16_t char32_t

char16_t 是无符号的长16位，char32_t 是无符号的长32位。c++11使用前缀u表示char16_t

（如：u'C', u"hello"）；使用U表示char32_t（如U'R', U”hello“）。char16_t与/u00F6形式的通用字符名匹配，char32_t与/U0000222B形式的通用字符名匹配。

char16_t  ch1 = u'q'；
char32_t ch2 = U'U0000222B'

1.5 bool类型

在计算中，bool变量的值可以是true 或 false。bool类型出现前，c++将非0解释为true，将0解释为false。

2 const 限定符

常量的定义方法：

1、#define （符号常量--预处理器方法）

#define MONTHS 12

2、const关键字

const int Months = 12; //首字母大写用于区分常量和变量

const常量Months 在被初始化后值，再不可改变

注意：如果在声明常量时没有提供值，否则该常量的值将不确定的，且无法更改。

const的优点：1、const能够明确指定类型；2、可通过c++的作用域，将定义限定在函数或文件中 3、可用于数组（可声明数组长度）和结构体等复杂类型。

3 浮点数

浮点数可以表示带小数部分的数字，如果数字很大，无法用long表示，也可用浮点类型表示。

计算机将小数分为两部分存储，一部分表示值，另一部分对值进行放大和缩小

例如：34.1245和34124.5 可以把他们表示为0.341245（基准值）和 100、100000（缩放因子）

缩放因子的作用是移动小数点位置。浮点就是指小数点可移动！

c++内部表示浮点数的方法与此相同，只不过它基于二进制，缩放因子是2的幂次，不是10的幂次

3.1 书写浮点数

c++有两种写浮点数的方式：

1、标准小数点法

12.34

0.00023

8.0（即使小数点后为0，小数点也会确保该数字以浮点格式存储）

2、E表示法

2.53e+8 / 2.53E+8

8.33E-4

7E5 = 7*10⁵

-18.32E13

9.11e-31 = 9.11*10﹣³¹

E表示法适合非常大或非常小的数

3.2 浮点类型

c++浮点有3种类型

• float
• double
• long double

有效位：指数字中有意义的位，有效位数不依赖于小数点的位置

14179 有效位为5位，若将其写为 14000 有效位变为2位 因为结果经过四舍五入精确到了千位，这种情况下后三位只不过是占位符。若写成 14.179*10³ 有效位仍然为5位

c++对有效位的要求是：float至少32位，double至少48位且不少于float，long double 不少于double。通常float为32位，double为64位，long double 为80/96/128位。指数范围至少是-37~37。可以从cfloat（c语言） 或 float.h（c++）中找到系统的限制

#include <iostream>
#include <float.h>

int main(){
    using namespace std;
    cout << "DBL_DIG = " << DBL_DIG << "  FLT_DIG = " << FLT_DIG << "  LDBL_DIG = " << LDBL_DIG << endl << endl;
    //通常cout会删除结尾的0，cout.setf将覆盖这种行为
    cout.setf(ios_base::fixed, ios_base::floatfield);
    float tub = 10.0/3.0;
    double mint = 10.0/3.0;
    const float million = 1.0e6;

    cout << "tub = " << tub << endl;
    cout << "tub * million = " << tub * million << endl;
    cout << "10 * tub * million = " << 10 * tub * million << endl;
    cout << endl;
    cout << "mint = " << mint << endl;
    cout << "mint * million = " << mint * million << endl;
    cout << "10 * mint * million = " << 10 * mint * million << endl;
    cout << "10 * 10 * mint * million = " << 10 * 10 * mint * million << endl;
    cout << "10 * 10 *10 * mint * million = " << 10 * 10 * 10 * mint * million << endl;
    cout << "10 * 10 *10 * 10 * mint * million = " << 10 * 10 * 10 * 10 * mint * million << endl;
    return 0;
}

cout打印6位小数，此时float和double都是精确的，而float有效值为7位，因此7位小数后与正常值有了误差而double类型的有效值为15位，因此在第15位后就与正常值有了偏差，第16位是刚好碰巧。

3.3 浮点常量

默认情况下浮点常量存储为double类型；若要使用float类型，可使用f/F后缀；若要使用long double类型 可使用l/L后缀

1.234 //double

1.234f //float

1，234L //long double

3.4 浮点数的优缺点

与整数相比浮点数有两大优点：

1、float可以表示整数之间的值

2、有缩放因子，使其可以表示更大的数

缺点：

浮点数通常比整数运算慢，且精度将降低

#include <iostream>

int main(){
    using namespace std;
    float a = 3.34E+22F;
    float b = a + 1.0f;

    cout  << "a = " << a << endl;
    cout << "b - a = " << b - a << endl;
    return 0;
}

a为小数点左边有23位的数字，+1 就是在第23位+1，但float类型只有7位有效数字，所以在第23位+1对a的大小不会产生影响。

3.4 算数运算符

 

3.4.1运算符优先级和结合性

1、优先级：求模运算符应该是%

2、结合性

当优先级不同是，由优先级决定执行顺序，当优先级相同时，由结合性（从左到右还是从右到左）决定执行顺序

3.4.2 除法分支

除法运算符的行为取决于操作数的类型

若两个都是整数    结果的小数部分将被丢弃

若有一个是浮点数   结果为浮点数，小数部分会保留

若两个都是float  结果为float

若两个都是double  结果为double

！！！浮点常量默认情况下为double类型

c++通过上下文分析来进行不同类型的除法运算，这种使用相同符号进行多种操作的方法叫运算符重载（operater overloading）。c++还允许扩展运算符重载，以便用户自定义类

3.4.3 类型转换

1、自动类型转换--初始化和赋值时的转换

1. 将一种算术类型赋值给另一种算数类型的变量时，c++将自动类型转换
2. 表达式中包含不同的类型时，c++将对值进行转换
3. 将参数传递给函数时，c++将根据形参类型对实参类型进行转换

将取值范围较小的值赋值给取值范围较大的值通常不会有问题，但是反之会有问题：

将0赋给bool类型时会被转换为false，非0将被转化为true

将浮点类型赋值给整型时：1、小数部分会被去掉（是截取而不是四舍五入）；2、如果浮点数太大，结果不确定（根据实现不同而不同）；3、int 无法存储float的 3.0E12，这会导致c++没有对结果进行定义的情况产生，这种系统中，int的结果为1634811904 或大约1.6E09（不同编译器显示的值可能不同）；4、当讲整数变量初始化为浮点值时，有的编译器会警告

2、自动类型转换--以{}方式初始化时的转换

以{}方式初始化称为 列表初始化 常用于给复杂数据类型提供值列表。

列表初始化 不允许缩窄，允许扩宽

3、自动类型转换--表达式中的转换

• 在表达式中，c++会将bool（true=1， false=0）、char、unsigned char、signed char、short 转换为int，称为整型提升，有利于计算机提高计算速度
• 若short 比int短，则unsigned short 将被转化为int
• wchar_t 将被转为一下类型中第一个足够表达wchar_t 取值范围的类型，int、unsigned int、long、unsigned long
• 不同类型的变量进行运算时，较小的类型将被转换为较大的类型

4、自动类型转换--传递参数时的转换

由c++函数原型控制，也可以取消原型对参数传递的控制（不好！！）

若取消，c++将对char和short应用整型提升，将float提升为double；

5、手动类型转换--强制类型转换

c++允许强制类型转换机制显示的进行类型转换。

格式：

int thron;
(long)thron //c语言格式
long(thron) //c++格式

cout << long(thron) + 5 << endl

• 强制类型转换不会改变变量本身，只会创建一个新的，指定类型的值，可在表达式中使用

c++还引入了4个强制类型转换运算符:(详细在第15章介绍)

      static_cast<type> (expr)

      dynamic_cast<type> (expr)

      reinterpret_cast<type> (expr)

      const_cast<type> (expr)

char ch = 'a';
cout << static_cast<int>(ch) << endl;

使用强制类型转换的原因：

• 有些值被存储为double类型，但要用他们计算得到一个int类型

注意：先类型转换再计算 和 先计算再类型转换 得到的结果可能不同！！

• 使一种格式的数据能满足不同的期望 如既可以显示编码，又可以显示字符

3.4.4 c++ 11 中的 auto声明（详见第9章）

c++重新定义了auto的含义

c语言中：auto 是一个关键字，声明一个变量为自动变量（默认变量即为自动变量）（相对于变量的存储类型即：静态类型变量（static ）、寄存器类型变量（register）和外部类型变量（extern）言）。

c++11中：若在初始化声明时使用关键字auto，不指定变量类型，编译前会把类型设置成与初始值相同的类型（支持标准库STL中的类型）。

auto n = 100;    //n为int型
auto x = 1.5；   //x为double型
auto y = 1.3e12L //y为long double型
///该方式常用于复杂类型中
//c++98
std::vector<double> scores;
std::vector<double>::iterator pv = scores.begin();
//c++11 可写为
std::vector<double> scores;
auto pv = scores.begin();

 

 

 

 

 

 

 

 

 

 

 

 

 

最后

以上就是疯狂宝马为你收集整理的读c++primer笔记第二章 处理数据1、简单变量2 const 限定符的全部内容，希望文章能够帮你解决读c++primer笔记第二章 处理数据1、简单变量2 const 限定符所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。