提供基本语法和方法的 C++ 快速参考备忘单
入门
hello.cpp
1
2
3
4
5
| #include <iostream>
int main() {
std::cout << "Hello Quick Reference\n";
return 0;
}
|
编译运行
1
2
3
| $ g++ hello.cpp -o hello
$ ./hello
Hello Quick Reference
|
变量
1
2
3
4
5
6
7
8
| int number = 5;
float f = 0.95;
double PI = 3.14159;
char yes = 'Y';
std::string s = "ME";
bool isRight = true;
const float RATE = 0.8;
|
1
2
| int age {25};
std::cout << age;
|
原始数据类型
| 数据类型 |
大小 |
范围 |
int |
4 bytes |
-231 到 231-1 |
float |
4 bytes |
N/A |
double |
8 bytes |
N/A |
char |
1 byte |
-128 到 127 |
bool |
1 byte |
true / false |
void |
N/A |
N/A |
wchar_t |
2 到 4 bytes |
1 个宽字符 |
用户输入
1
2
3
4
| int num;
std::cout << "Type a number: ";
std::cin >> num;
std::cout << "You entered " << num;
|
交换
1
2
3
4
5
6
7
8
9
| int a = 5, b = 10;
std::swap(a, b);
std::cout << "a=" << a << ", b=" << b;
(x ^= y), (y ^= x), (x ^= y);
x ^= y ^= x ^= y;
|
注释
If 语句
查看: 条件
循环
1
2
3
| for (int i = 0; i < 10; i++) {
std::cout << i << "\n";
}
|
查看: 循环 Loops
函数
1
2
3
4
5
6
7
8
9
10
11
| #include <iostream>
void hello();
int main() {
hello();
}
void hello() {
std::cout << "Hello Quick Reference!\n";
}
|
查看: 函数 Functions
引用
1
2
3
4
5
6
| int i = 1;
int& ri = i;
ri = 2;
std::cout << "i=" << i;
i = 3;
std::cout << "ri=" << ri;
|
ri 和 i 指的是相同的内存位置
命名空间
1
2
3
4
5
6
| #include <iostream>
namespace ns1 {int val(){return 5;}}
int main()
{
std::cout << ns1::val();
}
|
1
2
3
4
5
6
7
8
| #include <iostream>
namespace ns1 {int val(){return 5;}}
using namespace ns1;
using namespace std;
int main()
{
cout << val();
}
|
名称空间允许名称下的全局标识符
C++ 数组
定义
1
2
3
4
5
6
7
8
9
| std::array<int, 3> marks;
marks[0] = 92;
marks[1] = 97;
marks[2] = 98;
std::array<int, 3> = {92, 97, 98};
std::array<int, 3> marks = {92, 97};
std::cout << marks[2];
|
操控
1
2
3
4
| ┌─────┬─────┬─────┬─────┬─────┬─────┐
| 92 | 97 | 98 | 99 | 98 | 94 |
└─────┴─────┴─────┴─────┴─────┴─────┘
0 1 2 3 4 5
|
1
2
3
4
5
6
7
8
9
| std::array<int, 6> marks = {
92, 97, 98, 99, 98, 94
};
std::cout << marks[0];
marks[1] = 99;
std::cin >> marks[2];
|
展示
1
2
3
4
5
6
7
8
9
| char ref[5] = {'R', 'e', 'f'};
for (const int &n : ref) {
std::cout << std::string(1, n);
}
for (int i = 0; i < sizeof(ref); ++i) {
std::cout << ref[i];
}
|
多维
1
2
3
4
5
6
| j0 j1 j2 j3 j4 j5
┌────┬────┬────┬────┬────┬────┐
i0 | 1 | 2 | 3 | 4 | 5 | 6 |
├────┼────┼────┼────┼────┼────┤
i1 | 6 | 5 | 4 | 3 | 2 | 1 |
└────┴────┴────┴────┴────┴────┘
|
1
2
3
4
5
6
7
8
9
| int x[2][6] = {
{1,2,3,4,5,6}, {6,5,4,3,2,1}
};
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 6; ++j) {
std::cout << x[i][j] << " ";
}
}
|
C++ 条件
If Clause
1
2
3
4
5
6
7
8
9
10
| int number = 16;
if (number % 2 == 0)
{
std::cout << "even";
}
else
{
std::cout << "odd";
}
|
Else if 语句
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| int score = 99;
if (score == 100) {
std::cout << "Superb";
}
else if (score >= 90) {
std::cout << "Excellent";
}
else if (score >= 80) {
std::cout << "Very Good";
}
else if (score >= 70) {
std::cout << "Good";
}
else if (score >= 60)
std::cout << "OK";
else
std::cout << "What?";
|
运算符
关系运算符
| :– |
– |
a == b |
a 等于 b |
a != b |
a 不等于 b |
a < b |
a 小于 b |
a > b |
a 大于 b |
a <= b |
a 小于或等于 b |
a >= b |
a 大于或等于 b |
赋值运算符
| 范例 |
相当于 |
a += b |
Aka a = a + b |
a -= b |
Aka a = a - b |
a *= b |
Aka a = a * b |
a /= b |
Aka a = a / b |
a %= b |
Aka a = a % b |
逻辑运算符
| Example |
Meaning |
exp1 && exp2 |
Both are true (AND) |
| `exp1 |
|
!exp |
exp is false (NOT) |
位运算符
| Operator |
Description |
a & b |
Binary AND |
| `a |
b` |
a ^ b |
Binary XOR |
a ~ b |
Binary One’s Complement |
a << b |
Binary Shift Left |
a >> b |
Binary Shift Right |
三元运算符
1
2
3
| ┌── True ──┐
Result = Condition ? Exp1 : Exp2;
└───── False ─────┘
|
1
2
3
4
| int x = 3, y = 5, max;
max = (x > y) ? x : y;
std::cout << max << std::endl;
|
1
2
3
4
5
6
7
8
| int x = 3, y = 5, max;
if (x > y) {
max = x;
} else {
max = y;
}
std::cout << max << std::endl;
|
switch 语句
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| int num = 2;
switch (num) {
case 0:
std::cout << "Zero";
break;
case 1:
std::cout << "One";
break;
case 2:
std::cout << "Two";
break;
case 3:
std::cout << "Three";
break;
default:
std::cout << "What?";
break;
}
|
C++ 循环
While
1
2
3
4
5
| int i = 0;
while (i < 6) {
std::cout << i++;
}
|
Do-while
1
2
3
4
5
| int i = 1;
do {
std::cout << i++;
} while (i <= 5);
|
Continue 语句
1
2
3
4
5
6
| for (int i = 0; i < 10; i++) {
if (i % 2 == 0) {
continue;
}
std::cout << i;
}
|
无限循环
1
2
3
| while (true) {
std::cout << "无限循环";
}
|
1
2
3
| for (;;) {
std::cout << "无限循环";
}
|
1
2
3
| for(int i = 1; i > 0; i++) {
std::cout << "infinite loop";
}
|
for_each (C++11 起)
1
2
3
4
5
6
7
8
9
10
| #include <iostream>
int main()
{
auto print = [](int num) {
std::cout << num << std::endl;
};
std::array<int, 4> arr = {1, 2, 3, 4};
std::for_each(arr.begin(), arr.end(), print);
return 0;
}
|
基于范围 (C++11 起)
1
2
3
4
| for (int n : {1, 2, 3, 4, 5}) {
std::cout << n << " ";
}
|
1
2
3
4
5
6
| std::string hello = "Quick Reference.ME";
for (char c: hello)
{
std::cout << c << " ";
}
|
中断语句
1
2
3
4
5
6
7
8
9
| int password, times = 0;
while (password != 1234) {
if (times++ >= 3) {
std::cout << "Locked!\n";
break;
}
std::cout << "Password: ";
std::cin >> password;
}
|
Several variations
1
2
3
4
5
| for (int i = 0, j = 2; i < 3; i++, j--){
std::cout << "i=" << i << ",";
std::cout << "j=" << j << ";";
}
|
auto
1
2
3
4
5
| std:: string s = "hello world";
for(auto c: s){
std:: cout << c << " ";
}
|
C++ 函数
参数和返回
1
2
3
4
5
6
7
| #include <iostream>
int add(int a, int b) {
return a + b;
}
int main() {
std::cout << add(10, 20);
}
|
add 是一个接受 2 个整数并返回整数的函数
重载
1
2
3
4
5
6
7
8
9
| void fun(string a, string b) {
std::cout << a + " " + b;
}
void fun(string a) {
std::cout << a;
}
void fun(int a) {
std::cout << a;
}
|
内置函数
1
2
3
4
5
6
7
| #include <iostream>
#include <cmath>
int main() {
std::cout << sqrt(9);
}
|
Lambda 表达式
Lambda 表达式可以在函数内定义，可以理解为在函数内定义的临时函数。格式：
1
| auto func = []() -> return_type { };
|
[]为捕获列表，能够捕获其所在函数的局部变量
对于引用捕获，需要在捕获的变量前添加&：
1
2
| string str("hello world!");
auto func = [&str]() -> return_type { };
|
如果变量太多，需要编译器根据我们编写的代码自动捕获，可以采用隐式捕获的方式。
() 是参数列表，我们只需要按照普通函数的使用方法来使用即可
return_type 是函数的返回类型，-> return_type 可以不写，编译器会自动推导
{} 中的内容就是函数体，依照普通函数的使用方法使用即可
此处给出一个 Lambda 表达式的实际使用例子(当然可以使用 str::copy):
1
2
3
4
5
6
7
8
|
std::vector<int> vec({1, 2, 3, 4, 5});
std::for_each(vec.begin(), vec.end(),
[](int& ele) -> void
{
std::cout << ele
<< " ";
});
|
C++多线程
多线程介绍
g++编译选项：-std=c++11。包含头文件：
#include <thread>：C++多线程库#include <mutex>：C++互斥量库#include <future>：C++异步库
线程的创建
以普通函数作为线程入口函数：
1
2
3
4
5
| void entry_1() { }
void entry_2(int val) { }
std::thread my_thread_1(entry_1);
std::thread my_thread_2(entry_2, 5);
|
以类对象作为线程入口函数：
1
2
3
4
5
6
7
8
9
10
11
| class Entry
{
void operator()() { }
void entry_function() { }
};
Entry entry;
std::thread my_thread_1(entry);
std::thread my_thread_2(&Entry::entry_function, &entry);
|
以lambda表达式作为线程入口函数：
1
2
3
4
| std::thread my_thread([]() -> void
{
});
|
线程的销毁
1
2
3
4
5
| thread my_thread;
my_thread.join();
my_thread.detach();
|
this_thread
1
2
3
4
5
6
7
8
|
std::this_thread::get_id();
std::this_thread::sleep_for();
std::this_thread::sleep_until();
std::this_thread::yield();
|
锁
#include <mutex>
锁的基本操作
创建锁
上锁
解锁
尝试上锁：成功返回true，失败返回false
解锁
更简单的锁 —— std::lock_guard<Mutex>
构造时上锁，析构时解锁
1
2
| std::mutex m;
std::lock_guard<std::mutex> lock(m);
|
额外参数：std::adopt_lock：只需解锁，无需上锁
1
2
3
4
|
m.lock();
std::lock_guard<mutex> lock(m,
std::adopt_lock);
|
unique_lock<Mutex>
构造上锁，析构解锁
1
2
| std::mutex m;
std::unique_lock<mutex> lock(m);
|
std::adopt_lock
只需解锁，无需上锁
1
2
3
4
|
m.lock();
std::unique_lock<mutex> lock(m,
std::adopt_lock);
|
std::try_to_lock
尝试上锁，可以通过std::unique_lock<Mutex>::owns_lock()查看状态
1
2
3
4
5
6
7
8
9
10
| std::unique_lock<mutex> lock(m,
std::try_to_lock);
if (lock.owns_lock())
{
}
else
{
}
|
std::defer_lock
绑定锁，但不上锁
1
2
3
4
| std::unique_lock<mutex> lock(m,
std::defer_lock);
lock.lock();
lock.unlock();
|
std::unique_lock<Mutex>::release
返回所管理的mutex对象指针，释放所有权。一旦释放了所有权，那么如果原来互斥量处于互斥状态，程序员有责任手动解锁。
std::call_once
当多个线程通过这个函数调用一个可调用对象时，只会有一个线程成功调用。
1
2
3
4
5
| std::once_flag flag;
void foo() { }
std::call_once(flag, foo);
|
std::condition_variable
创建条件变量
1
| std::condition_variable cond;
|
等待条件变量被通知
1
2
3
4
5
6
7
8
| std::unique_lock<std::mutex>
lock;
extern bool predicate();
cond.wait(lock);
cond.wait(lock, predicate);
|
wait不断地尝试重新获取并加锁该互斥量，如果获取不到，它就卡在这里并反复尝试重新获取，如果获取到了，执行流程就继续往下走wait在获取到互斥量并加锁了互斥量之后：
- 如果
wait被提供了可调用对象，那么就执行这个可调用对象：
- 如果返回值为
false，那么wait继续加锁，直到再次被 notified
- 如果返回值为
true，那么wait返回，继续执行流程
- 如果
wait没有第二个参数，那么直接返回，继续执行
std::condition_variable::notify_one
notify_one 唤醒一个调用 wait 的线程。注意在唤醒之前要解锁，否则调用 wait 的线程也会因为无法加锁而阻塞。
std::condition_variable::notify_all
唤醒所有调用 wait 的线程。
获取线程的运行结果
#include <future>
创建异步任务
1
2
3
4
5
6
7
| double func(int val);
std::future<double> result =
std::async(func, 5);
|
获取异步任务的返回值
等待异步任务结束，但是不获取返回值：
获取异步任务的返回值：
注：
get()返回右值，因此只可调用一次- 只要调用上述任意函数，线程就会一直阻塞到返回值可用（入口函数运行结束）
std::async 的额外参数
额外参数可以被放在 std::async 的第一个参数位置，用于设定 std::async 的行为：
std::launch::deferred：入口函数的运行会被推迟到std::future<T>::get()或者std::future<T>::wait()被调用时。此时调用线程会直接运行线程入口函数，换言之，不会创建子线程std::launch::async：立即创建子线程，并运行线程入口函数std::launch::deferred | std::launch::async：默认值，由系统自行决定
返回值的状态
让当前线程等待一段时间（等待到指定时间点），以期待返回值准备好：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| extern double foo(int val) {}
std::future<double> result =
async(foo, 5);
std::future_status status;
status = result.wait_for(
std::chrono::seconds(1)
);
status = result.wait_for(
std::chrono::now() +
std::chrono::seconds(1)
);
|
在指定的时间过去后，可以获取等待的结果：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
if (status ==
std::future_status::ready)
{
}
else if (status ==
std::future_status::timeout)
{ }
else if (status ==
std::future_status::deferred)
{ }
|
多个返回值
如果要多次获取结果，可以使用std::shared_future，其会返回结果的一个拷贝。
1
| std::shared_future<T> result;
|
对于不可拷贝对象，可以在std::shared_future中存储对象的指针，而非指针本身。
创建线程
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| void threadFunction() {
std::cout << "From thread" << std::endl;
}
int main() {
std::thread t(threadFunction);
t.join();
return 0;
}
|
传递参数给线程函数
1
2
3
4
5
6
7
8
9
10
11
| void threadFunction(int value) {
std::cout << "Received value: " << value << std::endl;
}
int main() {
int data = 42;
std::thread t(threadFunction, data);
t.join();
return 0;
}
|
使用Lambda表达式创建线程
1
2
3
4
5
6
7
8
9
| int main() {
int data = 42;
std::thread t([data]() {
std::cout << "Received value: " << data << std::endl;
});
t.join();
return 0;
}
|
处理线程间的同步：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| #include <mutex>
std::mutex mtx;
void threadFunction() {
std::lock_guard<std::mutex> lock(mtx);
std::cout << "Thread safe output." << std::endl;
}
int main() {
std::thread t1(threadFunction);
std::thread t2(threadFunction);
t1.join();
t2.join();
return 0;
}
|
使用std::async启动异步任务：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| #include <future>
int taskFunction() {
return 42;
}
int main() {
std::future<int> fut = std::async(std::launch::async, taskFunction);
int result = fut.get();
std::cout << "Result: " << result << std::endl;
return 0;
}
|
C++ 预处理器
预处理器
Includes
1
2
| #include "iostream"
#include <iostream>
|
Defines
1
2
3
| #define FOO
#define FOO "hello"
#undef FOO
|
If
1
2
3
4
5
6
7
| #ifdef DEBUG
console.log('hi');
#elif defined VERBOSE
...
#else
...
#endif
|
Error
1
2
3
4
| #if VERSION == 2.0
#error Unsupported
#warning Not really supported
#endif
|
宏
1
| #define DEG(x) ((x) * 57.29)
|
令牌连接
1
2
| #define DST(name) name##_s name##_t
DST(object); #=> object_s object_t;
|
字符串化
1
2
| #define STR(name) #name
char * a = STR(object); #=> char * a = "object";
|
文件和行
1
2
| #define LOG(msg) console.log(__FILE__, __LINE__, msg)
#=> console.log("file.txt", 3, "hey")
|
各种各样的
转义序列
| 转义序列 |
说明 |
\b |
退格键 |
\f |
换页 |
\n |
换行 |
\r |
返回 |
\t |
水平制表符 |
\v |
垂直制表符 |
\\ |
反斜杠 |
\' |
单引号 |
\" |
双引号 |
\? |
问号 |
\0 |
空字符 |
关键字
预处理器
另见
