1 const限定符的初始化#

1. 初始化后不能再赋值

例如：

1
const int bufSize = 512;
2
int const bufSize = 512;  // 等价写法
3
bufSize = 512;  // 错误

2. 定义时必须初始化

例如：

1
const int i = get_size();  // 可以，运行时取得初始值
2
const int j = 42;          // 可以
3
const int k;               // 错误，缺少初始值

2 如何用 const 修饰对象？#

顶层 const：限制对象本身。

底层 const：限制通过指针或引用访问的对象。

1. 修饰指针

例如：

1
int x = 1, y = 2;
2

3
const int* p1 = &x;       // 指向常量的指针：不能通过 p1 改 x，但 p1 可指向别处
4
int const* p2 = &x;       // 同上，等价
5

6
int* const p3 = &x;       // 常量指针：p3 不能指向别处，但可以通过 p3 改 x
7
const int* const p4 = &x; // 既不能改所指对象，也不能改指针本身
8

9
// *p1 = 3;   // 错误
10
p1 = &y;      // 正确
11

12
*p3 = 3;      // 正确
13
// p3 = &y;   // 错误

const int* p：指向常量的指针，底层const，p可变，*p不可变；

int* const p：常量指针，顶层const，p不可变，*p可变；

const int* const p：都不可变。

2. 修饰引用

例如：

1
int x = 1;
2
const int& r = x;
3
// r = 2;          // 错误
4

5
const int& r2 = 42; // 可以绑定临时量，生命周期被延长
6

7
void print(const std::string& s); // 函数参数

3 constexpr与const的区别是什么？#

定义：constexpr 是一个关键字，用它声明变量，就是要求这个变量在编译时确定初始值(常量表达式)，并且以后不能修改。

这里的常量表达式，就是值不会改变，而且编译时就能算出的表达式。

例如：

1
constexpr int max_files = 20;         // 合法，编译时知道是 20
2
constexpr int limit = max_files + 1;  // 合法，编译时能算出 21
3

4
int x;
5
std::cin >> x;
6
constexpr int sz = x * 2;    // 错误，运行时才知道结果
7
const int sz = x * 2;     // 合法

const 只保证只读，不保证编译期；constexpr 保证可用于编译期常量表达式。

在指针的声明中：

例如：

1
constexpr int i = 42;
2
int j = 0;
3

4
constexpr const int *p = &i;
5
constexpr int *p1 = &j;
6

7
p1 = nullptr;  // 错误，修改的是指针保存的地址
8
*p1 = 10;      // 合法，修改的是 j 的值

constexpr 让指针自身成为常量，不会自动给所指对象加上 const。

p1 的地址必须在编译时确定，但 j 的值仍然可以改变。

1 什么是类型别名？#

定义：类型别名给已有类型起一个新名字，不会创建新类型，只是让代码更可读、更好维护。

基本语法：

1
// C 风格，C++ 也支持
2
typedef 原类型 别名;
3

4
// C++11 起推荐
5
using 别名 = 原类型;

1. 用 typedef 定义别名

例如：

1
typedef double wages;
2
typedef wages base, *p;

第一行使 wages 成为 double 的别名。

第二行中的 base 也是 double 的别名，p 则是 double* 的别名。

2. 用 using 定义别名

例如：

1
using SI = Sales_item;
2
SI item;  // 一个 Sales_item 变量

3. const 修饰指针别名时

例如：

1
typedef char *pstring;
2

3
const pstring cstr = 0;  // 等同于 char* const cstr = 0
4
const pstring *ps;    // 等同于 char* const* ps;
5

6
const char *cstr = 0;  // 等同于 const char* cstr = 0

pstring 代表的类型是 char*，所以const pstring 是带有顶层 const 的指针类型。

2 auto 类型说明符#

定义：auto 让编译器根据初始化式推导变量类型，变量必须初始化。

1. 处理指针

例如：

1
const int ci = i, &cr = ci;
2

3
auto b = ci;   // int
4
auto c = cr;   // int
5
auto d = &i;   // int*
6
auto e = &ci;  // const int*

e 可以改指向，但不能通过 e 修改它指向的 const int类型的变量。

如果希望新变量本身也是常量：const auto f = ci;

2. 处理引用

例如：在 auto 后写 &，定义的就是引用。

1
auto &g = ci;        // g 是 const int&
2
auto &h = 42;        // 错误：普通引用不能绑定到字面值
3
const auto &j = 42;  // 正确：常量引用可以绑定到字面值

3 什么是值类别？#

定义：值类别是 C++ 用来描述一个表达式是否代表一个具有明确身份的对象，以及它的资源是否可以被移动。

组合成：

1
                 expression
2
                /          \
3
           glvalue         rvalue
4
          /       \       /      \
5
      lvalue     xvalue  xvalue   prvalue

例如：

1
int x = 1;
2
int* p = &x;
3
int& lr = x;
4

5
// 左值
6
x;          // lvalue
7
* p;        // lvalue
8
lr;         // lvalue
9
++x;        // lvalue
10

11
// 亡值
12
std::move(x);            // xvalue
13
static_cast<int&&>(x);   // xvalue
14

15
// 纯右值
16
42;         // prvalue
17
x + 1;      // prvalue
18
x++;        // prvalue
19
&x;         // prvalue

展开收起

4 decltype 类型说明符#

定义：decltype 是 C++11 引入的类型说明符，作用是在编译期推导一个表达式的精确类型，但不会真正求值这个表达式。

基本语法：

1
decltype(表达式)
2
decltype(auto)   // C++14

如果表达式是 左值 lvalue，decltype(e) 得到 T&

如果表达式是 亡值 xvalue，decltype(e) 得到 T&&

如果表达式是 纯右值 prvalue，decltype(e) 得到 T

例如：

1
int x = 0;
2
const int cx = 1;
3
int& rx = x;
4

5
decltype(x) a;          // int
6
decltype(cx) b = 2;     // const int
7
decltype(rx) c = x;     // int&，必须初始化
8

9
decltype((x)) d = x;    // int&，注意多了一层括号
10

11
decltype(x + 1) e = 3;  // int，x+1 是纯右值
12

13
decltype(++x) f = x;    // int&，前置 ++ 返回左值
14
decltype(x++) g = 4;    // int，后置 ++ 返回纯右值

因为 x 是未加括号的变量名，得到声明类型 int；而 (x) 是一个左值表达式，所以得到 int&。

例如：声明变量类型

1
int a = 1;
2
double b = 2.0;
3

4
decltype(a + b) c = 3.0; // c 是 double

例如：decltype(auto)

1
int x = 0;
2

3
decltype(auto) r = (x); // int&
4
decltype(auto) v = x;   // int

decltype(auto) 会按 decltype 的规则推导返回类型，能保留引用和 const。

例如：不求值获取表达式类型

1
int func();
2

3
decltype(func()) x; // x 是 int，但不会调用 func()

与auto的不同：

1 如何定义类和数据成员？#

定义：在 C++ 中，类用 class 或 struct 定义，数据成员就是写在类里面的变量。

基本语法：

1
class 类名 {
2
访问修饰符:
3
    数据类型 成员名;
4
    成员函数；
5
}; // 注意最后有分号

例如：定义Sales_data类

1
#include <string>
2

3
struct Sales_data {
4
    std::string bookNo;
5
    unsigned units_sold = 0;
6
    double revenue = 0.0;
7
};

struct 后面是类名 Sales_data。花括号内是类体。其中的三个变量称为数据成员，它们决定每个 Sales_data 对象包含哪些数据。

或使用class来定义：

例如：

1
#include <iostream>
2
#include <string>
3

4
class Student {
5
private:              // 私有数据成员，类外不能直接访问
6
    int id_;
7
    std::string name_;
8
    double score_;
9

10
public:               // 公有成员函数，类外可以调用
11
    Student(int id, std::string name, double score)
12
        : id_(id), name_(std::move(name)), score_(score) {}
13

14
    void print() const {
15
        std::cout << id_ << " " << name_ << " " << score_ << std::endl;
16
    }
17
};

展开收起

访问控制：

• public：类外可访问

• private：只有类内和友元可访问

• protected：类内和派生类可访问

class 默认访问权限是 private，struct 默认是 public。

1
class A {
2
    int x;   // 默认 private
3
};
4

5
struct B {
6
    int y;   // 默认 public
7
};

2 如何使用类和数据成员？#

3 如何编写自己的头文件？#

定义：头文件本质是一种数据结构的接口声明，类通常定义在头文件中。

头文件.h的基本写法：

1
#ifndef MY_MATH_H
2
#define MY_MATH_H
3

4
// 头文件内容
5

6
#endif

上述三行为头文件保护符的写法，或用#pragma once，用来防止同一个源文件多次包含这个头文件，上述是更标准可移植的写法。

例如：Sales_data.h

1
#ifndef SALES_DATA_H
2
#define SALES_DATA_H
3

4
#include <string>
5

6
struct Sales_data {
7
    std::string bookNo;
8
    unsigned units_sold = 0;
9
    double revenue = 0.0;
10
};
11

12
#endif

4 为什么需要头文件保护符？#

定义：头文件保护符是用来防止同一个头文件在同一个翻译单元中被多次包含的一组预处理指令。

例如：一个头文件可能被多次包含。

1
#include <string>
2
#include "Sales_data.h"

而 Sales_data.h 自己又包含 <string>。

其他头文件也可能间接包含 Sales_data.h。如果类定义被重复放入同一个源文件，编译器会看到多个相同的类定义并报错。