一页纸 C++ 手册

基于 Learn X in Y minutes (opens new window)进行修改

常见的程序结构

  1. #include <iostream>
  2. // include 是“包含”的意思, 表示引入输入输出流的头文件
  3. // iostream = i + o + stream = input + output + stream = 表示 input-stream 输入流和 output-stream 输出流
  5. using namespace std;
  6. // namespace 命名空间
  7. // std = standard 标准
  8. // C++ 标准程序库中的所有标识符都被定义在一个名为 std 的 namespace 中
  10. int main(){
  12.     // 一系列操作
  13.     int a; //定义变量
  14.     cin>>a; //获取键盘输入, 存入变量
  16.     cout<<a; //输出
  18.     return 0;
  19. }

输入 & 输出

  1. // C++使用"流"来输入输出. <<是流的插入运算符, >>是流提取运算符
  2. // cin 表示输入
  3. // cout 表示输出
  5. #include <iostream> // 引入包含输入输出流的头文件
  7. using namespace std; // 标准程序库所在的命名空间
  9. int main()
  10. {
  11.    int n;
  13.    // 在显示器中显示
  14.    cout << "输入你最喜欢的数字:\n";
  16.    // 获取键盘输入, 存储到 n 变量中
  17.    cin >> n;
  19.    // cout也提供了格式化功能,即按照你设定的格式输出的功能
  20.    cout << "你最喜欢的数字是 " << n << "\n";
  22. }

判断流程

  1. #include <iostream>
  2. using namespace std;
  4. int main(){
  5.     int a,b;
  6.     cin>>a>>b;
  8.     if (a > b) {
  9.         cout<<"第一个数大于第二个数";
  10.     } else if (a < b){
  11.         cout<<"第一个数小于第二个数";
  12.     } else {
  13.         cout<<"两个数相等";
  14.     }
  16.     return 0;
  17. }

循环流程

  1. #include <iostream>
  3. using namespace std;
  4. int main() {
  5.     for (int i=1; i<=10; i++){
  6.         cout<<i<<endl;
  7.     }
  9.     return 0;
  10. }

定义函数

  1. #include <iostream>
  3. using namespace std;
  5. // 定义函数
  6. // 注意: 下面函数定义时给参数c设置了默认值
  7. // 默认参数必须放在所有常规参数的后面
  8. int add(int a, int b, int c = 0)
  9. {
  10.     return a + b + c;
  11. }
  13. int main()
  14. {
  15.     int n1, n2, sum;
  17.     cin>>n1>>n2; //获取输入
  19.     // 调用函数, 并传入参数
  20.     // 注意, 这里没有提供第3个参数, 所以函数会使用定义时的默认值
  21.     sum1 = add(n1, n2);
  22.     // 注意, 这里提供了第3个参数
  23.     sum2 = add(n1, n2, -1);
  25.     cout<<"第一个结果是 " + sum1
  26.     cout<<"第二个结果是 " + sum2
  28.     return 0;
  29. }

字符串拼接

  1. #include <string>
  3. using namespace std; // 字符串也在std命名空间( 标准库 )中 
  5. string myString = "Hello";
  6. string myOtherString = " World";
  8. // + 用于连接字符串
  9. cout << myString + myOtherString; // "Hello World"
  10. cout << myString + " You"; // "Hello You"

类 & 对象

  1. #include <iostream>
  3. // 声明一个类
  4. // 类通常在头文件( .h或.hpp )中声明
  5. class Dog {
  6.     // 成员变量和成员函数默认情况下是私有( private )的. 
  7.     std::string name;
  8.     int weight;
  10. // 在这个标签之后, 所有声明都是公有( public )的, 
  11. // 直到重新指定"private:"( 私有继承 )或"protected:"( 保护继承 )为止
  12. public:
  14.     // 默认的构造器
  15.     Dog();
  17.     // 这里是成员函数声明的一个例子. 
  18.     // 可以注意到, 我们在此处使用了std::string, 而不是using namespace std
  19.     // 语句using namespace绝不应当出现在头文件当中. 
  20.     void setName(const std::string& dogsName);
  22.     void setWeight(int dogsWeight);
  24.     // 如果一个函数不对对象的状态进行修改, 
  25.     // 应当在声明中加上const. 
  26.     // 这样, 你就可以对一个以常量方式引用的对象执行该操作. 
  27.     // 同时可以注意到, 当父类的成员函数需要被子类重写时, 
  28.     // 父类中的函数必须被显式声明为_虚函数( virtual )_. 
  29.     // 考虑到性能方面的因素, 函数默认情况下不会被声明为虚函数. 
  30.     virtual void print() const;
  32.     // 函数也可以在class body内部定义. 
  33.     // 这样定义的函数会自动成为内联函数. 
  34.     void bark() const { std::cout << name << " barks!\n" }
  36.     // 除了构造器以外, C++还提供了析构器. 
  37.     // 当一个对象被删除或者脱离其定义域时, 它的析构函数会被调用. 
  38.     // 这使得RAII这样的强大范式( 参见下文 )成为可能. 
  39.     // 为了衍生出子类来, 基类的析构函数必须定义为虚函数. 
  40.     virtual ~Dog();
  42. }; // 在类的定义之后, 要加一个分号
  44. // 类的成员函数通常在.cpp文件中实现. 
  45. void Dog::Dog()
  46. {
  47.     std::cout << "A dog has been constructed\n";
  48. }
  50. // 对象( 例如字符串 )应当以引用的形式传递, 
  51. // 对于不需要修改的对象, 最好使用常量引用. 
  52. void Dog::setName(const std::string& dogsName)
  53. {
  54.     name = dogsName;
  55. }
  57. void Dog::setWeight(int dogsWeight)
  58. {
  59.     weight = dogsWeight;
  60. }
  62. // 虚函数的virtual关键字只需要在声明时使用, 不需要在定义时重复
  63. void Dog::print() const
  64. {
  65.     std::cout << "Dog is " << name << " and weighs " << weight << "kg\n";
  66. }
  68. void Dog::~Dog()
  69. {
  70.     std::cout << "Goodbye " << name << "\n";
  71. }
  73. int main() {
  74.     Dog myDog; // 此时显示"A dog has been constructed"
  75.     myDog.setName("Barkley");
  76.     myDog.setWeight(10);
  77.     myDog.print(); // 显示"Dog is Barkley and weighs 10 kg"
  78.     return 0;
  79. } // 显示"Goodbye Barkley"
  81. // 继承: 
  83. // 这个类继承了Dog类中的公有( public )和保护( protected )对象
  84. class OwnedDog : public Dog {
  86.     void setOwner(const std::string& dogsOwner)
  88.     // 重写OwnedDogs类的print方法. 
  89.     // 如果你不熟悉子类多态的话, 可以参考这个页面中的概述: 
  90.     // http://zh.wikipedia.org/wiki/%E5%AD%90%E7%B1%BB%E5%9E%8B
  92.     // override关键字是可选的, 它确保你所重写的是基类中的方法. 
  93.     void print() const override;
  95. private:
  96.     std::string owner;
  97. };
  99. // 与此同时, 在对应的.cpp文件里: 
  101. void OwnedDog::setOwner(const std::string& dogsOwner)
  102. {
  103.     owner = dogsOwner;
  104. }
  106. void OwnedDog::print() const
  107. {
  108.     Dog::print(); // 调用基类Dog中的print方法
  109.     // "Dog is <name> and weights <weight>"
  111.     std::cout << "Dog is owned by " << owner << "\n";
  112.     // "Dog is owned by <owner>"
  113. }

异常处理

  1. // 标准库中提供了一些基本的异常类型
  2. // 参见http://en.cppreference.com/w/cpp/error/exception
  3. // 但是, 其他任何类型也可以作为一个异常被拋出
  4. #include <exception>
  6. // 在_try_代码块中拋出的异常可以被随后的_catch_捕获
  7. try {
  8.     throw std::exception("A problem occurred");
  9. }
  10. // 如果拋出的异常是一个对象, 可以用常量引用来捕获它
  11. catch (const std::exception& ex)
  12. {
  13.   std::cout << ex.what();
  14. // 捕获尚未被_catch_处理的所有错误
  15. } catch (...)
  16. {
  17.     std::cout << "Unknown exception caught";
  18.     throw; // 重新拋出异常
  19. }