加载中...

C++

其中 Y=c++

源代码下载： learncpp-cn.cpp

C++是一种系统编程语言。用它的发明者， Bjarne Stroustrup的话来说，C++的设计目标是：

  • 成为“更好的C语言”
  • 支持数据的抽象与封装
  • 支持面向对象编程
  • 支持泛型编程

C++提供了对硬件的紧密控制（正如C语言一样）， 能够编译为机器语言，由处理器直接执行。 与此同时，它也提供了泛型、异常和类等高层功能。 虽然C++的语法可能比某些出现较晚的语言更复杂，它仍然得到了人们的青睐—— 功能与速度的平衡使C++成为了目前应用最广泛的系统编程语言之一。

  1. ////////////////
  2. // 与C语言的比较
  3. ////////////////
  5. // C++_几乎_是C语言的一个超集，它与C语言的基本语法有许多相同之处，
  6. // 例如变量和函数的声明，原生数据类型等等。
  8. // 和C语言一样，在C++中，你的程序会从main()开始执行，
  9. // 该函数的返回值应当为int型，这个返回值会作为程序的退出状态值。
  10. // 不过，大多数的编译器（gcc，clang等）也接受 void main() 的函数原型。
  11. // （参见 http://en.wikipedia.org/wiki/Exit_status 来获取更多信息）
  12. int main(int argc, char** argv)
  13. {
  14.     // 和C语言一样，命令行参数通过argc和argv传递。
  15.     // argc代表命令行参数的数量，
  16.     // 而argv是一个包含“C语言风格字符串”（char *）的数组，
  17.     // 其中每个字符串代表一个命令行参数的内容，
  18.     // 首个命令行参数是调用该程序时所使用的名称。
  19.     // 如果你不关心命令行参数的值，argc和argv可以被忽略。
  20.     // 此时，你可以用int main()作为函数原型。
  22.     // 退出状态值为0时，表示程序执行成功
  23.     return 0;
  24. }
  26. // 然而，C++和C语言也有一些区别：
  28. // 在C++中，字符字面量的大小是一个字节。
  29. sizeof('c') == 1
  31. // 在C语言中，字符字面量的大小与int相同。
  32. sizeof('c') == sizeof(10)
  34. // C++的函数原型与函数定义是严格匹配的
  35. void func(); // 这个函数不能接受任何参数
  37. // 而在C语言中
  38. void func(); // 这个函数能接受任意数量的参数
  40. // 在C++中，用nullptr代替C语言中的NULL
  41. int* ip = nullptr;
  43. // C++也可以使用C语言的标准头文件，
  44. // 但是需要加上前缀“c”并去掉末尾的“.h”。
  45. #include <cstdio>
  47. int main()
  48. {
  49.     printf("Hello, world!\n");
  50.     return 0;
  51. }
  53. ///////////
  54. // 函数重载
  55. ///////////
  57. // C++支持函数重载，你可以定义一组名称相同而参数不同的函数。
  59. void print(char const* myString)
  60. {
  61.     printf("String %s\n", myString);
  62. }
  64. void print(int myInt)
  65. {
  66.     printf("My int is %d", myInt);
  67. }
  69. int main()
  70. {
  71.     print("Hello"); // 解析为 void print(const char*)
  72.     print(15); // 解析为 void print(int)
  73. }
  75. ///////////////////
  76. // 函数参数的默认值
  77. ///////////////////
  79. // 你可以为函数的参数指定默认值，
  80. // 它们将会在调用者没有提供相应参数时被使用。
  82. void doSomethingWithInts(int a = 1, int b = 4)
  83. {
  84.     // 对两个参数进行一些操作
  85. }
  87. int main()
  88. {
  89.     doSomethingWithInts();      // a = 1,  b = 4
  90.     doSomethingWithInts(20);    // a = 20, b = 4
  91.     doSomethingWithInts(20, 5); // a = 20, b = 5
  92. }
  94. // 默认参数必须放在所有的常规参数之后。
  96. void invalidDeclaration(int a = 1, int b) // 这是错误的！
  97. {
  98. }
  100. ///////////
  101. // 命名空间
  102. ///////////
  104. // 命名空间为变量、函数和其他声明提供了分离的的作用域。
  105. // 命名空间可以嵌套使用。
  107. namespace First {
  108.     namespace Nested {
  109.         void foo()
  110.         {
  111.             printf("This is First::Nested::foo\n");
  112.         }
  113.     } // 结束嵌套的命名空间Nested
  114. } // 结束命名空间First
  116. namespace Second {
  117.     void foo()
  118.     {
  119.         printf("This is Second::foo\n")
  120.     }
  121. }
  123. void foo()
  124. {
  125.     printf("This is global foo\n");
  126. }
  128. int main()
  129. {
  130.     // 如果没有特别指定，就从“Second”中取得所需的内容。
  131.     using namespace Second;
  133.     foo(); // 显示“This is Second::foo”
  134.     First::Nested::foo(); // 显示“This is First::Nested::foo”
  135.     ::foo(); // 显示“This is global foo”
  136. }
  138. ////////////
  139. // 输入/输出
  140. ////////////
  142. // C++使用“流”来输入输出。<<是流的插入运算符，>>是流提取运算符。
  143. // cin、cout、和cerr分别代表
  144. // stdin（标准输入）、stdout（标准输出）和stderr（标准错误）。
  146. #include <iostream> // 引入包含输入/输出流的头文件
  148. using namespace std; // 输入输出流在std命名空间（也就是标准库）中。
  150. int main()
  151. {
  152.    int myInt;
  154.    // 在标准输出（终端/显示器）中显示
  155.    cout << "Enter your favorite number:\n";
  156.    // 从标准输入（键盘）获得一个值
  157.    cin >> myInt;
  159.    // cout也提供了格式化功能
  160.    cout << "Your favorite number is " << myInt << "\n";
  161.    // 显示“Your favorite number is <myInt>”
  163.     cerr << "Used for error messages";
  164. }
  166. /////////
  167. // 字符串
  168. /////////
  170. // C++中的字符串是对象，它们有很多成员函数
  171. #include <string>
  173. using namespace std; // 字符串也在std命名空间（标准库）中。
  175. string myString = "Hello";
  176. string myOtherString = " World";
  178. // + 可以用于连接字符串。
  179. cout << myString + myOtherString; // "Hello World"
  181. cout << myString + " You"; // "Hello You"
  183. // C++中的字符串是可变的，具有“值语义”。
  184. myString.append(" Dog");
  185. cout << myString; // "Hello Dog"
  187. /////////////
  188. // 引用
  189. /////////////
  191. // 除了支持C语言中的指针类型以外，C++还提供了_引用_。
  192. // 引用是一种特殊的指针类型，一旦被定义就不能重新赋值，并且不能被设置为空值。
  193. // 使用引用时的语法与原变量相同：
  194. // 也就是说，对引用类型进行解引用时，不需要使用*；
  195. // 赋值时也不需要用&来取地址。
  197. using namespace std;
  199. string foo = "I am foo";
  200. string bar = "I am bar";
  202. string& fooRef = foo; // 建立了一个对foo的引用。
  203. fooRef += ". Hi!"; // 通过引用来修改foo的值
  204. cout << fooRef; // "I am foo. Hi!"
  206. // 这句话的并不会改变fooRef的指向，其效果与“foo = bar”相同。
  207. // 也就是说，在执行这条语句之后，foo == "I am bar"。
  208. fooRef = bar;
  210. const string& barRef = bar; // 建立指向bar的常量引用。
  211. // 和C语言中一样，（指针和引用）声明为常量时，对应的值不能被修改。
  212. barRef += ". Hi!"; // 这是错误的，不能修改一个常量引用的值。
  214. ///////////////////
  215. // 类与面向对象编程
  216. ///////////////////
  218. // 有关类的第一个示例
  219. #include <iostream>
  221. // 声明一个类。
  222. // 类通常在头文件（.h或.hpp）中声明。
  223. class Dog {
  224.     // 成员变量和成员函数默认情况下是私有（private）的。
  225.     std::string name;
  226.     int weight;
  228. // 在这个标签之后，所有声明都是公有（public）的，
  229. // 直到重新指定“private:”（私有继承）或“protected:”（保护继承）为止
  230. public:
  232.     // 默认的构造器
  233.     Dog();
  235.     // 这里是成员函数声明的一个例子。
  236.     // 可以注意到，我们在此处使用了std::string，而不是using namespace std
  237.     // 语句using namespace绝不应当出现在头文件当中。
  238.     void setName(const std::string& dogsName);
  240.     void setWeight(int dogsWeight);
  242.     // 如果一个函数不对对象的状态进行修改，
  243.     // 应当在声明中加上const。
  244.     // 这样，你就可以对一个以常量方式引用的对象执行该操作。
  245.     // 同时可以注意到，当父类的成员函数需要被子类重写时，
  246.     // 父类中的函数必须被显式声明为_虚函数（virtual）_。
  247.     // 考虑到性能方面的因素，函数默认情况下不会被声明为虚函数。
  248.     virtual void print() const;
  250.     // 函数也可以在class body内部定义。
  251.     // 这样定义的函数会自动成为内联函数。
  252.     void bark() const { std::cout << name << " barks!\n" }
  254.     // 除了构造器以外，C++还提供了析构器。
  255.     // 当一个对象被删除或者脱离其定义域时，它的析构函数会被调用。
  256.     // 这使得RAII这样的强大范式（参见下文）成为可能。
  257.     // 为了衍生出子类来，基类的析构函数必须定义为虚函数。
  258.     virtual ~Dog();
  260. }; // 在类的定义之后，要加一个分号
  262. // 类的成员函数通常在.cpp文件中实现。
  263. void Dog::Dog()
  264. {
  265.     std::cout << "A dog has been constructed\n";
  266. }
  268. // 对象（例如字符串）应当以引用的形式传递，
  269. // 对于不需要修改的对象，最好使用常量引用。
  270. void Dog::setName(const std::string& dogsName)
  271. {
  272.     name = dogsName;
  273. }
  275. void Dog::setWeight(int dogsWeight)
  276. {
  277.     weight = dogsWeight;
  278. }
  280. // 虚函数的virtual关键字只需要在声明时使用，不需要在定义时重复
  281. void Dog::print() const
  282. {
  283.     std::cout << "Dog is " << name << " and weighs " << weight << "kg\n";
  284. }
  286. void Dog::~Dog()
  287. {
  288.     cout << "Goodbye " << name << "\n";
  289. }
  291. int main() {
  292.     Dog myDog; // 此时显示“A dog has been constructed”
  293.     myDog.setName("Barkley");
  294.     myDog.setWeight(10);
  295.     myDog.printDog(); // 显示“Dog is Barkley and weighs 10 kg”
  296.     return 0;
  297. } // 显示“Goodbye Barkley”
  299. // 继承：
  301. // 这个类继承了Dog类中的公有（public）和保护（protected）对象
  302. class OwnedDog : public Dog {
  304.     void setOwner(const std::string& dogsOwner)
  306.     // 重写OwnedDogs类的print方法。
  307.     // 如果你不熟悉子类多态的话，可以参考这个页面中的概述：
  308.     // http://zh.wikipedia.org/wiki/%E5%AD%90%E7%B1%BB%E5%9E%8B
  310.     // override关键字是可选的，它确保你所重写的是基类中的方法。
  311.     void print() const override;
  313. private:
  314.     std::string owner;
  315. };
  317. // 与此同时，在对应的.cpp文件里：
  319. void OwnedDog::setOwner(const std::string& dogsOwner)
  320. {
  321.     owner = dogsOwner;
  322. }
  324. void OwnedDog::print() const
  325. {
  326.     Dog::print(); // 调用基类Dog中的print方法
  327.     // "Dog is <name> and weights <weight>"
  329.     std::cout << "Dog is owned by " << owner << "\n";
  330.     // "Dog is owned by <owner>"
  331. }
  333. /////////////////////
  334. // 初始化与运算符重载
  335. /////////////////////
  337. // 在C++中，通过定义一些特殊名称的函数，
  338. // 你可以重载+、-、*、/等运算符的行为。
  339. // 当运算符被使用时，这些特殊函数会被调用，从而实现运算符重载。
  341. #include <iostream>
  342. using namespace std;
  344. class Point {
  345. public:
  346.     // 可以以这样的方式为成员变量设置默认值。
  347.     double x = 0;
  348.     double y = 0;
  350.     // 定义一个默认的构造器。
  351.     // 除了将Point初始化为(0, 0)以外，这个函数什么都不做。
  352.     Point() { };
  354.     // 下面使用的语法称为初始化列表，
  355.     // 这是初始化类中成员变量的正确方式。
  356.     Point (double a, double b) :
  357.         x(a),
  358.         y(b)
  359.     { /* 除了初始化成员变量外，什么都不做 */ }
  361.     // 重载 + 运算符
  362.     Point operator+(const Point& rhs) const;
  364.     // 重载 += 运算符
  365.     Point& operator+=(const Point& rhs);
  367.     // 增加 - 和 -= 运算符也是有意义的，但这里不再赘述。
  368. };
  370. Point Point::operator+(const Point& rhs) const
  371. {
  372.     // 创建一个新的点，
  373.     // 其横纵坐标分别为这个点与另一点在对应方向上的坐标之和。
  374.     return Point(x + rhs.x, y + rhs.y);
  375. }
  377. Point& Point::operator+=(const Point& rhs)
  378. {
  379.     x += rhs.x;
  380.     y += rhs.y;
  381.     return *this;
  382. }
  384. int main () {
  385.     Point up (0,1);
  386.     Point right (1,0);
  387.     // 这里使用了Point类型的运算符“+”
  388.     // 调用up（Point类型）的“+”方法，并以right作为函数的参数
  389.     Point result = up + right;
  390.     // 显示“Result is upright (1,1)”
  391.     cout << "Result is upright (" << result.x << ',' << result.y << ")\n";
  392.     return 0;
  393. }
  395. ///////////
  396. // 异常处理
  397. ///////////
  399. // 标准库中提供了一些基本的异常类型
  400. // （参见http://en.cppreference.com/w/cpp/error/exception）
  401. // 但是，其他任何类型也可以作为一个异常被拋出
  402. #include <exception>
  404. // 在_try_代码块中拋出的异常可以被随后的_catch_捕获。
  405. try {
  406.     // 不要用 _new_关键字在堆上为异常分配空间。
  407.     throw std::exception("A problem occurred");
  408. }
  409. // 如果拋出的异常是一个对象，可以用常量引用来捕获它
  410. catch (const std::exception& ex)
  411. {
  412.   std::cout << ex.what();
  413. // 捕获尚未被_catch_处理的所有错误
  414. } catch (...)
  415. {
  416.     std::cout << "Unknown exception caught";
  417.     throw; // 重新拋出异常
  418. }
  420. ///////
  421. // RAII
  422. ///////
  424. // RAII指的是“资源获取就是初始化”（Resource Allocation Is Initialization），
  425. // 它被视作C++中最强大的编程范式之一。
  426. // 简单说来，它指的是，用构造函数来获取一个对象的资源，
  427. // 相应的，借助析构函数来释放对象的资源。
  429. // 为了理解这一范式的用处，让我们考虑某个函数使用文件句柄时的情况：
  430. void doSomethingWithAFile(const char* filename)
  431. {
  432.     // 首先，让我们假设一切都会顺利进行。
  434.     FILE* fh = fopen(filename, "r"); // 以只读模式打开文件
  436.     doSomethingWithTheFile(fh);
  437.     doSomethingElseWithIt(fh);
  439.     fclose(fh); // 关闭文件句柄
  440. }
  442. // 不幸的是，随着错误处理机制的引入，事情会变得复杂。
  443. // 假设fopen函数有可能执行失败，
  444. // 而doSomethingWithTheFile和doSomethingElseWithIt会在失败时返回错误代码。
  445. // （虽然异常是C++中处理错误的推荐方式，
  446. // 但是某些程序员，尤其是有C语言背景的，并不认可异常捕获机制的作用）。
  447. // 现在，我们必须检查每个函数调用是否成功执行，并在问题发生的时候关闭文件句柄。
  448. bool doSomethingWithAFile(const char* filename)
  449. {
  450.     FILE* fh = fopen(filename, "r"); // 以只读模式打开文件
  451.     if (fh == nullptr) // 当执行失败是，返回的指针是nullptr
  452.         return false; // 向调用者汇报错误
  454.     // 假设每个函数会在执行失败时返回false
  455.     if (!doSomethingWithTheFile(fh)) {
  456.         fclose(fh); // 关闭文件句柄，避免造成内存泄漏。
  457.         return false; // 反馈错误
  458.     }
  459.     if (!doSomethingElseWithIt(fh)) {
  460.         fclose(fh); // 关闭文件句柄
  461.         return false; // 反馈错误
  462.     }
  464.     fclose(fh); // 关闭文件句柄
  465.     return true; // 指示函数已成功执行
  466. }
  468. // C语言的程序员通常会借助goto语句简化上面的代码：
  469. bool doSomethingWithAFile(const char* filename)
  470. {
  471.     FILE* fh = fopen(filename, "r");
  472.     if (fh == nullptr)
  473.         return false;
  475.     if (!doSomethingWithTheFile(fh))
  476.         goto failure;
  478.     if (!doSomethingElseWithIt(fh))
  479.         goto failure;
  481.     fclose(fh); // 关闭文件
  482.     return true; // 执行成功
  484. failure:
  485.     fclose(fh);
  486.     return false; // 反馈错误
  487. }
  489. // 如果用异常捕获机制来指示错误的话，
  490. // 代码会变得清晰一些，但是仍然有优化的余地。
  491. void doSomethingWithAFile(const char* filename)
  492. {
  493.     FILE* fh = fopen(filename, "r"); // 以只读模式打开文件
  494.     if (fh == nullptr)
  495.         throw std::exception("Could not open the file.");
  497.     try {
  498.         doSomethingWithTheFile(fh);
  499.         doSomethingElseWithIt(fh);
  500.     }
  501.     catch (...) {
  502.         fclose(fh); // 保证出错的时候文件被正确关闭
  503.         throw; // 之后，重新抛出这个异常
  504.     }
  506.     fclose(fh); // 关闭文件
  507.     // 所有工作顺利完成
  508. }
  510. // 相比之下，使用C++中的文件流类（fstream）时，
  511. // fstream会利用自己的析构器来关闭文件句柄。
  512. // 只要离开了某一对象的定义域，它的析构函数就会被自动调用。
  513. void doSomethingWithAFile(const std::string& filename)
  514. {
  515.     // ifstream是输入文件流（input file stream）的简称
  516.     std::ifstream fh(filename); // 打开一个文件
  518.     // 对文件进行一些操作
  519.     doSomethingWithTheFile(fh);
  520.     doSomethingElseWithIt(fh);
  522. } // 文件已经被析构器自动关闭
  524. // 与上面几种方式相比，这种方式有着_明显_的优势：
  525. // 1\. 无论发生了什么情况，资源（此例当中是文件句柄）都会被正确关闭。
  526. //    只要你正确使用了析构器，就_不会_因为忘记关闭句柄，造成资源的泄漏。
  527. // 2\. 可以注意到，通过这种方式写出来的代码十分简洁。
  528. //    析构器会在后台关闭文件句柄，不再需要你来操心这些琐事。
  529. // 3\. 这种方式的代码具有异常安全性。
  530. //    无论在函数中的何处拋出异常，都不会阻碍对文件资源的释放。
  532. // 地道的C++代码应当把RAII的使用扩展到各种类型的资源上，包括：
  533. // - 用unique_ptr和shared_ptr管理的内存
  534. // - 各种数据容器，例如标准库中的链表、向量（容量自动扩展的数组）、散列表等；
  535. //   当它们脱离作用域时，析构器会自动释放其中储存的内容。
  536. // - 用lock_guard和unique_lock实现的互斥

扩展阅读：

http://cppreference.com/w/cpp 提供了最新的语法参考。

可以在 http://cplusplus.com 找到一些补充资料。

还没有评论.