C++ 备忘清单

#include <iostream>
int main() {
    std::cout << "Hello Quick Reference\n";
    return 0;
}

编译运行

$ g++ hello.cpp -o hello
$ ./hello
Hello Quick Reference

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;

int age {25};      // 自 C++11
std::cout << age;  // 打印 25

int num;
std::cout << "Type a number: ";
std::cin >> num;
std::cout << "You entered " << num;

int a = 5, b = 10;
std::swap(a, b);
// 输出: a=10, b=5
std::cout << "a=" << a << ", b=" << b;

// 整数交换的奇技淫巧
(x ^= y), (y ^= x), (x ^= y);
// 注意！ 以下操作会造成  undefined behavior
x ^= y ^= x ^= y;

// C++中的单行注释
/* 这是一个多行注释
    在 C++ 中 */

if (a == 10) {
    // do something
}

查看: 条件

for (int i = 0; i < 10; i++) {
    std::cout << i << "\n";
}

查看: 循环 Loops

int i = 1;
int& ri = i; // ri 是对 i 的引用
ri = 2; // i 现在改为 2
std::cout << "i=" << i;
i = 3;   // i 现在改为 3
std::cout << "ri=" << ri;

ri 和 i 指的是相同的内存位置

#include <iostream>
namespace ns1 {int val(){return 5;}}
int main()
{
    std::cout << ns1::val();
}

#include <iostream>
namespace ns1 {int val(){return 5;}}
using namespace ns1;
using namespace std;
int main()
{
    cout << val();
}

名称空间允许名称下的全局标识符

std::array<int, 3> marks; // 定义
marks[0] = 92;
marks[1] = 97;
marks[2] = 98;
// 定义和初始化
std::array<int, 3> marks = {92, 97, 98};
// 有空成员
std::array<int, 3> marks = {92, 97};
std::cout << marks[2]; // 输出: 0

┌─────┬─────┬─────┬─────┬─────┬─────┐
| 92  | 97  | 98  | 99  | 98  | 94  |
└─────┴─────┴─────┴─────┴─────┴─────┘
   0     1     2     3     4     5

std::array<int, 6> marks = {
  92, 97, 98, 99, 98, 94
};
// 打印第一个元素
std::cout << marks[0];
// 将第 2 个元素更改为 99
marks[1] = 99;
// 从用户那里获取输入
std::cin >> marks[2];

char ref[5] = {'R', 'e', 'f'};
// 基于范围的for循环
for (const int &n : ref) {
    std::cout << std::string(1, n);
}
// 传统的for循环
for (int i = 0; i < sizeof(ref); ++i) {
    std::cout << ref[i];
}

     j0   j1   j2   j3   j4   j5
   ┌────┬────┬────┬────┬────┬────┐
i0 | 1  | 2  | 3  | 4  | 5  | 6  |
   ├────┼────┼────┼────┼────┼────┤
i1 | 6  | 5  | 4  | 3  | 2  | 1  |
   └────┴────┴────┴────┴────┴────┘

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] << " ";
    }
}
// 输出: 1 2 3 4 5 6 6 5 4 3 2 1

if (a == 10) {
    // do something
}

int number = 16;
if (number % 2 == 0)
{
    std::cout << "even";
}
else
{
    std::cout << "odd";
}
// 输出: even

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?";

           ┌── True ──┐
Result = Condition ? Exp1 : Exp2;
           └───── False ─────┘

int x = 3, y = 5, max;
max = (x > y) ? x : y;
// 输出: 5
std::cout << max << std::endl;

int x = 3, y = 5, max;
if (x > y) {
    max = x;
} else {
    max = y;
}
// 输出: 5
std::cout << max << std::endl;

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;
}

int i = 0;
while (i < 6) {
    std::cout << i++;
}
// 输出: 012345

int i = 1;
do {
    std::cout << i++;
} while (i <= 5);
// 输出: 12345

for (int i = 0; i < 10; i++) {
    if (i % 2 == 0) {
        continue;
    }
    std::cout << i;
} // 输出: 13579

while (true) { // true or 1
    std::cout << "无限循环";
}

for (;;) {
    std::cout << "无限循环";
}

for(int i = 1; i > 0; i++) {
    std::cout << "infinite loop";
}

#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;
}

for (int n : {1, 2, 3, 4, 5}) {
    std::cout << n << " ";
}
// 输出: 1 2 3 4 5

std::string hello = "Quick Reference.ME";
for (char c: hello)
{
    std::cout << c << " ";
}
// 输出: Q u i c k R e f . M E

int password, times = 0;
while (password != 1234) {
    if (times++ >= 3) {
        std::cout << "Locked!\n";
        break;
    }
    std::cout << "Password: ";
    std::cin >> password; // input
}

for (int i = 0, j = 2; i < 3; i++, j--){
    std::cout << "i=" << i << ",";
    std::cout << "j=" << j << ";";
}
// 输出: i=0,j=2;i=1,j=1;i=2,j=0;

std:: string s = "hello world";
for(auto c: s){
    std:: cout << c << " ";
}
// 输出: h e l l o   w o r l d

#include <iostream>
int add(int a, int b) {
    return a + b;
}
int main() {
    std::cout << add(10, 20);
}

add 是一个接受 2 个整数并返回整数的函数

void fun(string a, string b) {
    std::cout << a + " " + b;
}
void fun(string a) {
    std::cout << a;
}
void fun(int a) {
    std::cout << a;
}

#include <iostream>
#include <cmath> // 导入库

int main() {
    // sqrt() 来自 cmath
    std::cout << sqrt(9);
}

// 创建方式1：使用 make_unique (C++14)
auto p1 = std::make_unique<int>(42);

// 创建方式2：直接构造
std::unique_ptr<int> p2(new int(42));

// 访问资源
std::cout << *p1 << std::endl;
*p1 = 100;

// 获取原始指针（不转移所有权）
int* raw = p1.get();

// 释放所有权并返回原始指针
int* released = p1.release();
// p1 现在为 nullptr

// 替换管理的对象
p1.reset(new int(50));

// 创建方式1：使用 make_shared
auto sp1 = std::make_shared<int>(42);

// 创建方式2：直接构造
std::shared_ptr<int> sp2(new int(42));

// 复制和共享所有权
std::shared_ptr<int> sp3 = sp1;
std::cout << sp1.use_count(); // 输出: 2

// 访问资源
std::cout << *sp1 << std::endl;
*sp1 = 100; // 所有指向该资源的shared_ptr都会看到这个修改

// 重置指针
sp1.reset(); // sp1变为nullptr，引用计数减1

std::shared_ptr<int> sp = std::make_shared<int>(42);
std::weak_ptr<int> wp = sp;

// 检查引用对象是否存在
if (auto locked = wp.lock()) {
    std::cout << *locked << std::endl; // 输出: 42
} else {
    std::cout << "对象已被销毁" << std::endl;
}

// 检查是否过期
bool is_expired = wp.expired(); // false

// 获取引用计数
std::cout << wp.use_count(); // 输出: 1

// 当所有shared_ptr都被销毁时
sp.reset();
if (wp.expired()) {
    std::cout << "对象已被销毁" << std::endl;
}

struct Node {
    std::string name;
    std::shared_ptr<Node> next;
    // 使用weak_ptr避免循环引用
    std::weak_ptr<Node> parent;
    
    Node(const std::string& n) : name(n) {}
    ~Node() { std::cout << "销毁: " << name << std::endl; }
};

// 创建循环引用
void createCycle() {
    auto node1 = std::make_shared<Node>("Node1");
    auto node2 = std::make_shared<Node>("Node2");
    
    node1->next = node2;
    node2->parent = node1; // 使用weak_ptr避免循环引用
    
    // 函数结束时，node1和node2会被正确销毁
    // 如果parent也是shared_ptr，则会造成内存泄漏
}

g++编译选项：-std=c++11。包含头文件：

• #include <thread>：C++多线程库
• #include <mutex>：C++互斥量库
• #include <future>：C++异步库

thread my_thread;
// 阻塞
my_thread.join();
// 非阻塞
my_thread.detach();

// 获取当前线程ID
std::this_thread::get_id();
// 使当前线程休眠一段指定时间
std::this_thread::sleep_for();
// 使当前线程休眠到指定时间
std::this_thread::sleep_until();
// 暂停当前线程的执行，让别的线程执行
std::this_thread::yield();

void threadFunction() {
  // 线程函数体
  std::cout << "From thread" << std::endl;
}

int main() {
  // 创建线程并开始执行线程函数
  std::thread t(threadFunction);
  
  // 等待线程执行完毕
  t.join();
  
  return 0;
}

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;
}

int main() {
  int data = 42;
  std::thread t([data]() {
      // Lambda 表达式作为线程函数
      std::cout << "Received value: " << data << std::endl;
  });
  t.join();
  return 0;
}

#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;
}

#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;
}

#include "iostream"
#include <iostream>

#define FOO
#define FOO "hello"
#undef FOO

#if VERSION == 2.0
  #error Unsupported
  #warning Not really supported
#endif

#define DEG(x) ((x) * 57.29)

#define DST(name) name##_s name##_t
DST(object);   #=> object_s object_t;

#define STR(name) #name
char * a = STR(object);   #=> char * a = "object";

#define LOG(msg) console.log(__FILE__, __LINE__, msg)
#=> console.log("file.txt", 3, "hey")

• if
• elif
• else
• endif
• ifdef
• ifndef
• define
• undef
• include
• line
• error
• pragma
• defined
• __has_include
• __has_cpp_attribute
• export
• import
• module