[C++ 面试基础知识总结] 变量和基本类型

[C++ 面试基础知识总结] 变量和基本类型

参考书籍：《C++ Primer》

目录

10与010的区别

#include <iostream>
using namespace std;

int main(int argc, const char * argv[]) {
    int x = 010, y = 10;
    cout << "x=" << x << " y=" << y << endl;
    return 0;
}

执行上述代码的结果为：

x=8 y=10

原因是在C++中，以0开头的整数表示八进制数，以0x或0X开头的代表十六进制数，八进制中的10等于十进制中的8。

变量初始化的4种形式

int x = 0;
int x = {0};
int x(0);
int x{0};

以上4条语句都可以将x初始化等于0，其中使用了花括号的两种形式是C++ 11的新特性，被称为列表初始化，在为对象赋新值时也可以采取同样的办法。列表初始化形式的一个重要特点是，初始值存在丢失信息风险的时候，编译器会报错：

long double pi = 3.1415926536
//报错，因为存在丢失信息的风险
int a{pi}, b = {pi};
//可以执行，但确实丢失了部分信息
int c(pi), d = pi;

变量的作用域

#include <iostream>
using namespace std;

int i = 40;
int main(int argc, const char * argv[]) {
    // insert code here...
    int i = 100;
    int j = i;
    int k = ::i;
    cout << j << endl;
    cout << k << endl;
    return 0;
}

执行上述代码结果：

100
40

在main()函数外定义的i为全局变量，拥有全局作用域，声明之后在整个程序范围内可用。而在main()函数中定义的i为局部变量，拥有块作用域，只在main()函数内可用。在内层作用域中新建局部变量i会覆盖全局变量i，所以j的值为局部变量i的值100，而采用：：i的方式可以显示地访问全局变量i，所以k的值为全局变量i的值40。

引用与指针

&和*的多重含义：

int i = 0;
// &是声明的一部分，r是一个指向i的引用（改变r的值也会改变i的值）
int &r = i;
// *是声明的一部分，p是一个未初始化的指针
int *p;
// &是一个取地址符，将i的地址赋给p，即p为指向i的指针
p = &i;
// *是一个解引用符，将p指向的变量的值赋为1
*p = 1;
// &是声明的一部分，*是解引用符，r2是一个指向指针p指向的变量的引用
int &r2 = *p;

复合类型

// 定义两个int型指针p1,p2
int *p1, *p2;
// 定义int型指针p1，int型变量p2
int* p1, p2;

int i = 0;
// p是一个指向int型数的指针
int *p = &i;
// pp是一个指向int型指针的指针
int **pp = &p;
// r是一个指向int型指针的引用
int *&r = p

const限定符

const的引用

const定义的对象为常量，任何试图对常量进行赋值的行为都会报错，由于const对象定义后就不能修改，所以必须初始化。

int i = 0;
const int j = 0;

// 正确，引用和其指向的对象都为常量
const int &r1 = j;
// 错误，r1是对常量的引用，不能赋值
r1 = 2;
// 错误，不能用非常量引用指向一个常量对象
int &r2 = j;
// 正确，可以用常量引用指向一个非常量对象，但不能通过修改r3的值来修改i的值
const int &r3 = i;
// 正确，常量引用可以绑定到一个普通int对象上
const int &r4 = 0; 
// 错误，非常量引用不能绑定到一个普通int对象上
int &r5 = 0;

常量指针和指向常量的指针

int i = 0;
const int j = 0；

// p1为常量指针，一直指向i，可以修改i的值
int *const p1 = &i;
// p2为指向常量的指针，可以修改p2的指向，但不能修改指向对象的值
const int *p2 = &j;
// p3为指向常量的常量指针，一直指向j，且不能用p3去修改j的值
const int *const p3 = &j;

修饰指针的const为顶层const，而修饰指针或引用指向的对象的const为底层const

int i = 0;
const int j = 0；

// 顶层const
int *const p1 = &i;
// 底层const
const int *p2 = &j;
// 前一个为底层const，后一个为顶层const
const int *const p3 = &j;

当执行对象的拷贝操作时，顶层const不受影响，而底层const却有限制，只能允许将非常量转换为常量。

constexpr

constexpr是C++ 11中的新类型，以便由编译器来验证变量值是否是一个常量表达式（数据类型和初始值均为常量）。

// 不是常量表达式，x类型不常量
int x = 0;
// 不是常量表达式，初始值x不是常量
const int i = x;
// 是常量表达式，j类型和初始值均为常量
const int j = 0;

// 正确，等价于 const int k = 0;
constexpr int k = 0;
// 编译器报错，x不是常量，不是常量表达式
constexpr int l = x;

用constexpr定义指针时，初始值必须是nullptr，0或存储于某个固定地址的对象。且修饰符只对指针有效，与所指对象无关。

// 指向常量的指针
const int *p = nullptr;
// 常量指针 等价于 int *const p = nullptr;
constexpr int *q = nullptr;

类型别名

用typedef可自定义类型名

// ptr是char*的同义词
typedef char *ptr;
// p是常量指针,等价于char *const p = 0，而不是const char *p = 0;
const ptr p = 0;

在C++ 11中，有一种新方法自定义类型名:

using ptr = char*;

auto类型

auto类型是C++ 11引入的新类型说明符，由编译器去分析表达式所属的类型（类似Swift中的let，var），为了让编译器能通过初始值推算变量的类型，auto定义的变量必须有初始值。
使用一条auto语句声明多个变量时必须保证所有变量的基本数据类型相同。

//正确，i为整数，p为整型指针，基本类型相同
auto i = 0, *p = &i;
//错误，a为整数，b为浮点数，基本类型不同
auto a = 1, b = 2.5

auto声明指针或引用时一般会忽略顶层const，只保留底层const，如希望推断类型是一个顶层const，需要明确指出。

const int i = 0;
//b是一个整数变量（i的顶层const被忽略）
auto b = i;
//c是一个指向整数常量的引用（对常量取地址是一种底层const）
auto c = &i;
//d是一个整数常量
const auto d = i;

decltype类型

decltype的作用是选择并返回操作数的数据类型(包括顶层const和引用)。

const int i = 0， &r = i， *p = &i;
// x类型为const int
decltype(i) x = 0;
// y类型为const int& ，y绑定到x上
decltype(r) y = x;
// 错误，z类型为const int&，引用必须初始化
decltype(r) z;
// 错误，解引用指针得到的类型是引用类型，所以这里m的类型是int&，而不是int，必须初始化
decltype(*p) m;
// 错误，decltype用双层括号时得到的结果永远是引用，所以这里n的类型是int&，而不是int，必须初始化
decltype((i)) n;

头文件保护符

“#define”指令把一个名字设定为预处理变量。
“#ifdef”当且仅当变量已定义时为真，”#ifndef”当且仅当变量未定义时为真，一旦检查结果为真，则执行后续操作直至遇到”#endif”指令为止。

#ifndef PEOPLE_H
#define PEOPLE_H
struct People {
    std::string name;
    bool male;
};
#endif

用这些功能就可以防止重复包含发生。
注意：预处理变量包括头文件保护符必须唯一，为了避免与程序中其他实体发生名字冲突，一般全部大写。