一页纸 C++ 手册

常见的程序结构

#include <iostream>
// include 是“包含”的意思, 表示引入输入输出流的头文件
// iostream = i + o + stream = input + output + stream = 表示 input-stream 输入流和 output-stream 输出流

using namespace std;
// namespace 命名空间
// std = standard 标准
// C++ 标准程序库中的所有标识符都被定义在一个名为 std 的 namespace 中

int main(){

	// 一系列操作
	int a; //定义变量
	cin>>a; //获取键盘输入, 存入变量

	cout<<a; //输出
	
    return 0;
}

数据类型

int    i   = 42;      // 整型
double d   = 3.14;    // 浮点
char   c   = 'A';     // 字符
bool   ok  = true;    // 布尔
std::string s = "Hi"; // 字符串 (需 <string>)
auto   x   = 1'000;   // 自动推断类型 (C++14 数字分隔)

变量与常量

int a = 3;           // 变量
const double PI = 3.1415; // 常量
constexpr int SZ = 64;    // 编译期常量 (C++11)

操作符

算术操作符

1 + 2;   // 加
5 - 3;   // 减
4 * 2;   // 乘
9 / 2;   // 除 (4)
7 % 3;   // 取余 (1)
int n = 5;
++n;     // 前置自增 (6)

逻辑操作符

true && false; // 与
true || false; // 或
!true;         // 非

比较操作符

3 == 3;   // 等于
3 != 4;   // 不等
5 > 2;    // 大于
2 <= 2;   // 小于等于

字符串操作符

std::string s1 = "Hello";
std::string s2 = " C++";
std::string s3 = s1 + s2;   // 拼接 "Hello C++"
size_t len = s3.size();     // 长度 7

优先级

2 + 3 * 4;      // 14
(2 + 3) * 4;    // 20
!false && true; // true

常用容器

数组的操作 (std::vector)

#include <vector>
std::vector<int> v = {1,2,3};
v.push_back(4);        // [1,2,3,4]
int first = v.front(); // 1
v.pop_back();          // 删除最后一个元素
for(int n : v) {
    std::cout << n << " ";
}

字符串的操作

#include <string>
std::string str = "Hello";
str.append(" World"); // "Hello World"
str.substr(0,5);       // "Hello"
if(str.find("lo") != std::string::npos) {
    std::cout << "found";
}

输入 & 输出

// C++使用"流"来输入输出. <<是流的插入运算符, >>是流提取运算符
// cin 表示输入
// cout 表示输出

#include <iostream> // 引入包含输入输出流的头文件

using namespace std; // 标准程序库所在的命名空间

int main()
{
   int n;

   // 在显示器中显示
   cout << "输入你最喜欢的数字:\n";
   
   // 获取键盘输入, 存储到 n 变量中
   cin >> n;

   // cout也提供了格式化功能,即按照你设定的格式输出的功能
   cout << "你最喜欢的数字是 " << n << "\n";

}

判断流程

#include <iostream>
using namespace std;

int main(){
    int a,b;
    cin>>a>>b;
    
    if (a > b) {
        cout<<"第一个数大于第二个数";
    } else if (a < b){
        cout<<"第一个数小于第二个数";
    } else {
        cout<<"两个数相等";
    }

	return 0;
}

循环流程

#include <iostream>

using namespace std;
int main() {
    for (int i=1; i<=10; i++){
        cout<<i<<endl;
    }

	return 0;
}

定义函数

#include <iostream>

using namespace std;

// 定义函数
// 注意: 下面函数定义时给参数c设置了默认值
// 默认参数必须放在所有常规参数的后面
int add(int a, int b, int c = 0)
{
    return a + b + c;
}

int main()
{
    int n1, n2, sum;
    
    cin>>n1>>n2; //获取输入

	// 调用函数, 并传入参数
	// 注意, 这里没有提供第3个参数, 所以函数会使用定义时的默认值
    sum1 = add(n1, n2);
    // 注意, 这里提供了第3个参数
    sum2 = add(n1, n2, -1);

	cout<<"第一个结果是 " + sum1
	cout<<"第二个结果是 " + sum2
    
    return 0;
}

// 匿名函数 / Lambda (C++11)
auto mul = [](int x, int y){ return x * y; };
int r = mul(2, 3); // 6

// 作用域示例
auto outer = [](){
    int x = 10;
    auto inner = [&](){ return x + 1; }; // 捕获外部变量
    return inner(); // 11
};

字符串拼接

#include <string>

using namespace std; // 字符串也在std命名空间( 标准库 )中 

string myString = "Hello";
string myOtherString = " World";

// + 用于连接字符串
cout << myString + myOtherString; // "Hello World"
cout << myString + " You"; // "Hello You"

类 & 对象

#include <iostream>

// 声明一个类
// 类通常在头文件( .h或.hpp )中声明
class Dog {
    // 成员变量和成员函数默认情况下是私有( private )的. 
    std::string name;
    int weight;

// 在这个标签之后, 所有声明都是公有( public )的, 
// 直到重新指定"private:"( 私有继承 )或"protected:"( 保护继承 )为止
public:

    // 默认的构造器
    Dog();

    // 这里是成员函数声明的一个例子. 
    // 可以注意到, 我们在此处使用了std::string, 而不是using namespace std
    // 语句using namespace绝不应当出现在头文件当中. 
    void setName(const std::string& dogsName);

    void setWeight(int dogsWeight);

    // 如果一个函数不对对象的状态进行修改, 
    // 应当在声明中加上const. 
    // 这样, 你就可以对一个以常量方式引用的对象执行该操作. 
    // 同时可以注意到, 当父类的成员函数需要被子类重写时, 
    // 父类中的函数必须被显式声明为_虚函数( virtual )_. 
    // 考虑到性能方面的因素, 函数默认情况下不会被声明为虚函数. 
    virtual void print() const;

    // 函数也可以在class body内部定义. 
    // 这样定义的函数会自动成为内联函数. 
    void bark() const { std::cout << name << " barks!\n" }

    // 除了构造器以外, C++还提供了析构器. 
    // 当一个对象被删除或者脱离其定义域时, 它的析构函数会被调用. 
    // 这使得RAII这样的强大范式( 参见下文 )成为可能. 
    // 为了衍生出子类来, 基类的析构函数必须定义为虚函数. 
    virtual ~Dog();

}; // 在类的定义之后, 要加一个分号

// 类的成员函数通常在.cpp文件中实现. 
void Dog::Dog()
{
    std::cout << "A dog has been constructed\n";
}

// 对象( 例如字符串 )应当以引用的形式传递, 
// 对于不需要修改的对象, 最好使用常量引用. 
void Dog::setName(const std::string& dogsName)
{
    name = dogsName;
}

void Dog::setWeight(int dogsWeight)
{
    weight = dogsWeight;
}

// 虚函数的virtual关键字只需要在声明时使用, 不需要在定义时重复
void Dog::print() const
{
    std::cout << "Dog is " << name << " and weighs " << weight << "kg\n";
}

void Dog::~Dog()
{
    std::cout << "Goodbye " << name << "\n";
}

int main() {
    Dog myDog; // 此时显示"A dog has been constructed"
    myDog.setName("Barkley");
    myDog.setWeight(10);
    myDog.print(); // 显示"Dog is Barkley and weighs 10 kg"
    return 0;
} // 显示"Goodbye Barkley"

// 继承: 

// 这个类继承了Dog类中的公有( public )和保护( protected )对象
class OwnedDog : public Dog {

    void setOwner(const std::string& dogsOwner)

    // 重写OwnedDogs类的print方法. 
    // 如果你不熟悉子类多态的话, 可以参考这个页面中的概述: 
    // http://zh.wikipedia.org/wiki/%E5%AD%90%E7%B1%BB%E5%9E%8B

    // override关键字是可选的, 它确保你所重写的是基类中的方法. 
    void print() const override;

private:
    std::string owner;
};

// 与此同时, 在对应的.cpp文件里: 

void OwnedDog::setOwner(const std::string& dogsOwner)
{
    owner = dogsOwner;
}

void OwnedDog::print() const
{
    Dog::print(); // 调用基类Dog中的print方法
    // "Dog is <name> and weights <weight>"

    std::cout << "Dog is owned by " << owner << "\n";
    // "Dog is owned by <owner>"
}

异常处理

// 标准库中提供了一些基本的异常类型
// 参见http://en.cppreference.com/w/cpp/error/exception
// 但是, 其他任何类型也可以作为一个异常被拋出
#include <exception>

// 在_try_代码块中拋出的异常可以被随后的_catch_捕获
try {
    throw std::exception("A problem occurred");
}
// 如果拋出的异常是一个对象, 可以用常量引用来捕获它
catch (const std::exception& ex)
{
  std::cout << ex.what();
// 捕获尚未被_catch_处理的所有错误
} catch (...)
{
    std::cout << "Unknown exception caught";
    throw; // 重新拋出异常
}