2.1 基本内置类型

包括

• 算术类型
• 空类型(void)

2.1.1 算术类型

• 整型
  包括了char和bool
• 浮点型

算术类型所占的大小在不同机器上有所差别

类型	h含义	最小尺寸（字节）
bool		未定义
char		1
wchar_t	宽字符	2
char16_t	Unicode字符	2
char32_t	Unicode字符	4
short		2
int		2
long		4
long long		8
float		6位有效数字
double		10位有效数字
long double		10位有效数字

带符号类型和无符号类型

• singed
• unsinged
  只能表示大于等于0的数

对于char（注意）

• char
  具体为有符号还是无符号由编译器决定
• singed char
• unsigned char

类型选择的建议

• 非负选用unsigned
• 若数值超过了int的范围，选用long long, 因为long一般情况下和int大小一样
• char不要用于算术运算， 因为它在有些机器上是有符号的，一些是无符号的
• 浮点运算用double, float精度不够，且通常float和double的计算代价相差不大

2.1.2 类型转换

• bool 非bool类型
  • true 1
  • false 0
• 非bool类型 bool
  • 0 false
  • 非0 true
• 赋给无符号数超出范围的值
  结果为该值对能表示的最大值取模后的余数
• 赋给有符号数超出范围的值
  结果是未知的

含有无符号类型的表达式

• 同时含有无符号类型和有符号类型的时候，有符号类型会转换成无符号类型
• 从无符号数中减去一个数，必须保证结果非负
• 无符号数做for循环计数变量也会出现问题
  当u为0时，--u得到的是取模后的余数，为正数，而不会是-1

for(unsigned int u = 10;u >= 10;--u)
  cout << u << endl;
//改为
while(u > 0)
{
  u--;//必须先减再输出
  cout << u << endl;
}

2.1.3 字面值常量

每个字面值常量都对应一种数据类型，字面值常量的形式和值决定了它的数据类型

整型和浮点型字面值

整型

• 进制问题
  • 20---十进制
  • 024---八进制（0开头）
  • 0x14---十六进制(0x开头)
• 符号问题
  • 十进制字面值是带符号数
  • 八进制和十六进制数字面值可能是带符号数也可能是无符号的
• 类型问题
  • 十进制字面值为int, long, long long中能容下它的最小的一个
  • 八进制和十六进制字面值为int, unsigned int, long, unsigned long, long long, unsigned long long中能容纳其数值的最小的一个
  • short没有字面值

浮点型

• 浮点型字面值是double

字符和字符串字面值

• 字符字面值

  ‘a’

• 字符串字面值

  "abc"

转义序列

常用的有

• \n换行
• \t制表符

指定字面值的类型

字符和字符串字面值前缀

前缀	含义	类型
u	Unicode16字符	char16_t
U	Unicode32字符	char32_t
L	宽字符	wchar_t
u8	UTF-8字符串(用于字符串)	char

整型浮点型字面值后缀

后缀	含义	类型
u or U	unsigned能匹配的最小类型	无符号
l or L	至少为long	long
ll or LL	至少为long long	long long
f or F	float	float
l or L(浮点型)	long double	long double

布尔字面值和指针字面值

布尔

• true
• false

指针

• nullptr

2.2 变量

2.2.1 变量定义

初始值

double price = 109.99;

列表初始化(C++11)

//等价于 int sold = 0;
int sold = {0};
int sold{0};
int sold(0);

默认初始化

• 内置类型的全局变量

  初始化为0

• 内置类型的局部变量

  不被初始化

2.2.2 变量声明和定义的关系

为了支持分离式编译（拆分为多个文件）， C++将声明和定义区分开来。要在多个文件里使用同一个变量，必须将声明和定义分离。

声明(Declaration)

使得名字为程序所知（可以声明别处定义过的变量，进行使用）

定义(Definition)

负责创建与名字关联的实体

extern int i; //只声明而不定义i
int j; //声明并且定义j
extern double pi = 3.14 //extern语句如果包含初始值就不再只是声明，包括了定义（函数体内部这么做会报错）

2.2.3 标识符

• 不能为保留字
• 必须以下划线或者字母开头
• 不能连续出现两个下划线
• 不能下划线紧接着大写字母开头
• 定义在函数体外的标识符不能以下划线开头

2.2.4 名字的作用域

• 定义于所有花括号之外的为全局作用域

  在整个程序范围内都可以使用

• 定义在花括号内拥有块作用域

  只在该花括号内有效

• 嵌套的作用域

  int a = 1;
  void func1()
  {
      int a = 2;
      cout << a << endl;
      //输出2,内层覆盖外层作用域
      cout << ::a << endl;
      //输出1,使用域操作符来使用全局变量
  }
  

2.3 复合类型

复合类型指基于其他类型定义的类型。

2.3.1 引用

引用为对象其了另外一个名字。使用&d来定义引用类型

int a = 100;
int &ref = a;//ref 指向 a
//int &ref;错误，引用必须被初始化

• 引用必须被初始化（绑定）

• 无法令引用重新绑定到另外一个对象

• 引用本身不是一个对象， 不能定义引用的引用

• 引用的类型必须与其绑定的对象严格匹配

• 引用只能绑定在对象上，不能绑定在字面值上

  int &ref = 10;//错误
  

2.3.2 指针

指针是指向另外一种类型的复合类型，通过*d来定义

int a = 1;
int *pointer = &a;

指针与引用的区别

• 指针本身是一个对象
• 指针可以先后指向不同的对象
• 指针不需要赋初值
• 由于引用不是对象， 所以不能定义指向引用的指针

获取对象的地址

通过取地址运算符&

指针也需要与其被指对象的类型严格匹配（有两个例外的情况）

int a = 1;
int *pointer = &a;//取地址运算符&

空指针与野指针

• 空指针即为nullptr,不指向任何对象

  int *p1 = nullptr;//为C++11新标准
  int *p2 = 0;//也是空指针
  int *p3 = NULL;//NULL是一个预处理变量，不属于命名空间std,由预处理器负责管理，可以直接使用
  

• 野指针即未被初始化的指针（指向未知地址）

利用指针访问对象

使用解引用符*

int a = 1;
int *pointer = &a;//取地址运算符&
cout << *pointer << endl;

其他指针操作

• 非空指针可以转化为true, 空指针转化为false

  int *p1 = nullptr;
  if(p1)
  {
      cout << "p1 is not nullptr" << endl;
  }
  

• 指针比较

  通过==来比较两个指针(两个指针都为空，也是相等)

void*指针

可以存放任意类型对象的地址，但是在使用时必须进行类型转换才能使用

int a = 1;
void *p1 = &a;//合法
cout << *p1 << endl;//不合法
int *p2 = (int *)p1;
cout << *p1 << endl;//合法

2.3.3 理解复合类型的声明

变量的声明

• 由基本数据类型 + 声明符组成，声明符中可以加上类型修饰符

int *p;
int a;
int &ref = a;
// *, &在这里为类型修饰符

指向指针的指针

通过*的个数来区别指针的级别

int a = 1;
int *pi = &a;//一级指针
int **pii = π//二级指针
//也是由于使用了不同的类型修饰符

绑定指针的引用

由于指针是对象，所以可以用引用绑定指针

int i = 42;
int *p = &i;
int *&ref = p;//绑定int *指针的引用

2.4 const限定符

const限定符用来声明常量值

• const变量一旦声明不可改变值
• const变量必须赋初值

const int bufsize = 512;

const作用域

默认情况下，const对象仅在文件内有效

若想要让const对象在其他文件中也能访问到，必须在定义和声明时都添加extern关键字

extern const int bufsize = 125;//定义也要加上extern

extern const int bufsize;//声明加上extern

2.4.1 const的引用

可以将const对象绑定到引用上， 但是该引用必须也用const修饰

const int a = 125;
const int &ref = a;

初始化和对const的引用

在两种情况下，引用绑定的对象可以不和引用类型匹配

• 常量引用绑定的对象能够转化为引用的类型
• 允许一个常量引用（注意必须是被const修饰的引用）绑定非常量对象

int i = 42;//非常量对象
const int &ref1 = i;//绑定非常量对象，注意必须为const
double dval = 3.14;//浮点数
const int &ref2 = dval;//绑定类型不匹配的对象，但是浮点数可以转化为int
/*
实际上发生的事情为,创建了一个临时变量，该引用绑定到了该临时变量上
如果该引用不是const的，修改该引用修改的是临时变量，而不是原来的变量，所以必须为const的
const int temp = dval;
const int &ref2 = temp;
*/

2.4.2 指针和const

类似于常量引用，一样可以定义指向常量的指针,但是指针必须用const修饰

const double pi = 3.14;
double *ptr = π //错误，必须用const修饰
const double *ptr = π

const指针

代表的意思为不能改变该指针所指向的对象.注意const的位置

int *const pointer;

const指针必须初始化

int a = 0;
int b = 0;
const int *ptr = &a;
ptr = &b; //错误

2.4.3 顶层const

顶层const

对于指针来说表示指针本身是个常量

一般的，顶层const可以表示任意的对象是常量

底层const

对于指针来说表示指针所指的对象是个常量

一般的，底层const则与指针和引用等符合类型的基本类型部分有关（所指的东西）

2.4.4 constexpr和常量表达式

常量表达式指不会改变，且在编译过程中就能计算得到的表达式

• 字面值是常量表达式
• 常量表达式初始化的const对象也是常量表达式

constexpr常量

c++11新标准规定， 可以用constexpr来声明一个常量表达式变量（是一个常量）

constexpr int mf = 20; //是常量表达式
constexpr int m1 = size();//不是常量表达式，不行

字面值类型

• 自定义类， IO库， string类型不属于字面值类型不能定义为constexpr
• 指针类型变量要定义为constexpr必须满足
  • 要么被初始化为nullptr
  • 要么是存储于某个固定地址中的对象
    • 定义于函数体内的变量一般来说不是存储在固定的地址
    • 定义于所有函数体外的对象地址固定不变

指针和constexpr

用constexpr修饰指针，表达的意思使该指针为常量指针(即该指针本身不能改变)

2.5 类型别名

使用类型别名可以简化类型书写

2.5.1 类型别名

typedef

typedef double wages; //wages i = 0.0; 即为声明一个double类型的变量
typedef int *p;//p为int *的同义词
typedef int p[10];//p为int arr[10]的同义词

别名声明(c++11)

using SI = Sales_item; //SI是Sales_item的同义词

指针、常量和类型别名

typedef int *p;//p为int *的同义词
const p i = 0; //i为指向char的常量指针（注意不是指向常量 的指针）

不能简单的将类型别名替换为他原来的名字

const int *i = 0;//这就变成了指向const int常量的指针了，而不是常量指针

2.5.2 auto类型说明符

C++11新标准允许用auto类型说明符让编译器替我们去分析表达式所属的类型

int i1 = 0;
float i2 = 1.2;
auto var = i1 + i2;//var为float

复合类型、常量和auto

编译器推断出来的类型和初始值类型有时不完全一样，编译器会做适当的调整

• 使用引用来初始化时，会使用被引用的对象的类型作为auto的类型

  int i = 0, &r = i;
  auto a = r;//a的类型为int 而不是 int &
  

• auto会忽略顶层const, 保留底层const

  const int ci = i, &cr = ci;
  auto b = ci;//b为int, 忽略了顶层const
  auto c = cr;//c为int, cr为引用这时候要看所引用对象，而const int ci为顶层const所以忽略const
  auto d = &i;//d为int *
  auto e = &ci;//e是const int * ???????这里不怎么理解
  

如果希望推断出auto类型为顶层const,可以加上const

const auto f = ci;

还可以将引用类型设置为auto

auto &g = ci;

2.5.3 decltype类型指示符