关于c++:Y-分钟速成-C

8次阅读
共计 8980 个字符，预计需要花费 23 分钟才能阅读完成。
源代码下载：learncpp-cn.cpp
C++ 是一种零碎编程语言。用它的发明者，Bjarne Stroustrup 的话来说，C++ 的设计指标是：
成为“更好的 C 语言”
反对数据的形象与封装
反对面向对象编程
反对泛型编程
C++ 提供了对硬件的严密管制（正如 C 语言一样），可能编译为机器语言，由处理器间接执行。与此同时，它也提供了泛型、异样和类等高层性能。尽管 C ++ 的语法可能比某些呈现较晚的语言更简单，它依然失去了人们的青睞—— 性能与速度的均衡使 C ++ 成为了目前利用最宽泛的零碎编程语言之一。
////////////////
// 与 C 语言的比拟
////////////////

// C++_简直_是 C 语言的一个超集，它与 C 语言的根本语法有许多相同之处，// 例如变量和函数的申明，原生数据类型等等。// 和 C 语言一样，在 C ++ 中，你的程序会从 main()开始执行，// 该函数的返回值该当为 int 型，这个返回值会作为程序的退出状态值。// 不过，大多数的编译器（gcc，clang 等）也承受 void main() 的函数原型。//（参见 http://en.wikipedia.org/wiki/Exit_status 来获取更多信息）int main(int argc, char** argv)
{
    // 和 C 语言一样，命令行参数通过 argc 和 argv 传递。// argc 代表命令行参数的数量，// 而 argv 是一个蕴含“C 语言格调字符串”（char *）的数组，// 其中每个字符串代表一个命令行参数的内容，// 首个命令行参数是调用该程序时所应用的名称。// 如果你不关怀命令行参数的值，argc 和 argv 能够被疏忽。// 此时，你能够用 int main()作为函数原型。// 退出状态值为 0 时，示意程序执行胜利
    return 0;
}

// 然而，C++ 和 C 语言也有一些区别：// 在 C ++ 中，字符字面量的大小是一个字节。sizeof('c') == 1

// 在 C 语言中，字符字面量的大小与 int 雷同。sizeof('c') == sizeof(10)


// C++ 的函数原型与函数定义是严格匹配的
void func(); // 这个函数不能承受任何参数

// 而在 C 语言中
void func(); // 这个函数能承受任意数量的参数

// 在 C ++ 中，用 nullptr 代替 C 语言中的 NULL
int* ip = nullptr;

// C++ 也能够应用 C 语言的规范头文件，// 然而须要加上前缀“c”并去掉开端的“.h”。#include <cstdio>

int main()
{printf("Hello, world!\n");
    return 0;
}

///////////
// 函数重载
///////////

// C++ 反对函数重载，你能够定义一组名称雷同而参数不同的函数。void print(char const* myString)
{printf("String %s\n", myString);
}

void print(int myInt)
{printf("My int is %d", myInt);
}

int main()
{print("Hello"); // 解析为 void print(const char*)
    print(15); // 解析为 void print(int)
}

///////////////////
// 函数参数的默认值
///////////////////

// 你能够为函数的参数指定默认值，// 它们将会在调用者没有提供相应参数时被应用。void doSomethingWithInts(int a = 1, int b = 4)
{// 对两个参数进行一些操作}

int main()
{doSomethingWithInts();      // a = 1,  b = 4
    doSomethingWithInts(20);    // a = 20, b = 4
    doSomethingWithInts(20, 5); // a = 20, b = 5
}

// 默认参数必须放在所有的惯例参数之后。void invalidDeclaration(int a = 1, int b) // 这是谬误的！{
}


///////////
// 命名空间
///////////

// 命名空间为变量、函数和其余申明提供了拆散的的作用域。// 命名空间能够嵌套应用。namespace First {
    namespace Nested {void foo()
        {printf("This is First::Nested::foo\n");
        }
    } // 完结嵌套的命名空间 Nested
} // 完结命名空间 First

namespace Second {void foo()
    {printf("This is Second::foo\n")
    }
}

void foo()
{printf("This is global foo\n");
}

int main()
{
    // 如果没有特地指定，就从“Second”中获得所需的内容。using namespace Second;

    foo(); // 显示“This is Second::foo”First::Nested::foo(); // 显示“This is First::Nested::foo”::foo(); // 显示“This is global foo”}

////////////
// 输出 / 输入
////////////

// C++ 应用“流”来输入输出。<< 是流的插入运算符，>> 是流提取运算符。// cin、cout、和 cerr 别离代表
// stdin（规范输出）、stdout（规范输入）和 stderr（规范谬误）。#include <iostream> // 引入蕴含输出 / 输入流的头文件

using namespace std; // 输入输出流在 std 命名空间（也就是规范库）中。int main()
{
   int myInt;

   // 在规范输入（终端 / 显示器）中显示
   cout << "Enter your favorite number:\n";
   // 从规范输出（键盘）取得一个值
   cin >> myInt;

   // cout 也提供了格式化性能
   cout << "Your favorite number is" << myInt << "\n";
   // 显示“Your favorite number is <myInt>”cerr << "Used for error messages";
}

/////////
// 字符串
/////////

// C++ 中的字符串是对象，它们有很多成员函数
#include <string>

using namespace std; // 字符串也在 std 命名空间（规范库）中。string myString = "Hello";
string myOtherString = "World";

// + 能够用于连贯字符串。cout << myString + myOtherString; // "Hello World"

cout << myString + "You"; // "Hello You"

// C++ 中的字符串是可变的，具备“值语义”。myString.append("Dog");
cout << myString; // "Hello Dog"


/////////////
// 援用
/////////////

// 除了反对 C 语言中的指针类型以外，C++ 还提供了_援用_。// 援用是一种非凡的指针类型，一旦被定义就不能从新赋值，并且不能被设置为空值。// 应用援用时的语法与原变量雷同：// 也就是说，对援用类型进行解援用时，不须要应用 *；// 赋值时也不须要用 & 来取地址。using namespace std;

string foo = "I am foo";
string bar = "I am bar";


string& fooRef = foo; // 建设了一个对 foo 的援用。fooRef += ". Hi!"; // 通过援用来批改 foo 的值
cout << fooRef; // "I am foo. Hi!"

// 这句话的并不会扭转 fooRef 的指向，其成果与“foo = bar”雷同。// 也就是说，在执行这条语句之后，foo == "I am bar"。fooRef = bar;

const string& barRef = bar; // 建设指向 bar 的常量援用。// 和 C 语言中一样，（指针和援用）申明为常量时，对应的值不能被批改。barRef += ". Hi!"; // 这是谬误的，不能批改一个常量援用的值。///////////////////
// 类与面向对象编程
///////////////////

// 无关类的第一个示例
#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>"
}

/////////////////////
// 初始化与运算符重载
/////////////////////

// 在 C ++ 中，通过定义一些非凡名称的函数，// 你能够重载 +、-、*、/ 等运算符的行为。// 当运算符被应用时，这些非凡函数会被调用，从而实现运算符重载。#include <iostream>
using namespace std;

class Point {
public:
    // 能够以这样的形式为成员变量设置默认值。double x = 0;
    double y = 0;

    // 定义一个默认的结构器。// 除了将 Point 初始化为 (0, 0) 以外，这个函数什么都不做。Point() {};

    // 上面应用的语法称为初始化列表，// 这是初始化类中成员变量的正确形式。Point (double a, double b) :
        x(a),
        y(b)
    {/* 除了初始化成员变量外，什么都不做 */}

    // 重载 + 运算符
    Point operator+(const Point& rhs) const;

    // 重载 += 运算符
    Point& operator+=(const Point& rhs);

    // 减少 - 和 -= 运算符也是有意义的，但这里不再赘述。};

Point Point::operator+(const Point& rhs) const
{
    // 创立一个新的点，// 其横纵坐标别离为这个点与另一点在对应方向上的坐标之和。return Point(x + rhs.x, y + rhs.y);
}

Point& Point::operator+=(const Point& rhs)
{
    x += rhs.x;
    y += rhs.y;
    return *this;
}

int main () {Point up (0,1);
    Point right (1,0);
    // 这里应用了 Point 类型的运算符“+”// 调用 up（Point 类型）的“+”办法，并以 right 作为函数的参数
    Point result = up + right;
    // 显示“Result is upright (1,1)”cout << "Result is upright (" << result.x << ',' << result.y << ")\n";
    return 0;
}

///////////
// 异样解决
///////////

// 规范库中提供了一些根本的异样类型
//（参见 http://en.cppreference.com/w/cpp/error/exception）// 然而，其余任何类型也能够作为一个异样被拋出
#include <exception>

// 在_try_代码块中拋出的异样能够被随后的_catch_捕捉。try {
    // 不要用 _new_关键字在堆上为异样调配空间。throw std::exception("A problem occurred");
}
// 如果拋出的异样是一个对象，能够用常量援用来捕捉它
catch (const std::exception& ex)
{std::cout << ex.what();
// 捕捉尚未被_catch_解决的所有谬误
} catch (...)
{
    std::cout << "Unknown exception caught";
    throw; // 从新拋出异样
}

///////
// RAII
///////

// RAII 指的是“资源获取就是初始化”（Resource Allocation Is Initialization），// 它被视作 C ++ 中最弱小的编程范式之一。// 简略说来，它指的是，用构造函数来获取一个对象的资源，// 相应的，借助析构函数来开释对象的资源。// 为了了解这一范式的用途，让咱们思考某个函数应用文件句柄时的状况：void doSomethingWithAFile(const char* filename)
{
    // 首先，让咱们假如所有都会顺利进行。FILE* fh = fopen(filename, "r"); // 以只读模式关上文件

    doSomethingWithTheFile(fh);
    doSomethingElseWithIt(fh);

    fclose(fh); // 敞开文件句柄
}

// 可怜的是，随着错误处理机制的引入，事件会变得复杂。// 假如 fopen 函数有可能执行失败，// 而 doSomethingWithTheFile 和 doSomethingElseWithIt 会在失败时返回错误代码。//（尽管异样是 C ++ 中处理错误的举荐形式，// 然而某些程序员，尤其是有 C 语言背景的，并不认可异样捕捉机制的作用）。// 当初，咱们必须查看每个函数调用是否胜利执行，并在问题产生的时候敞开文件句柄。bool doSomethingWithAFile(const char* filename)
{FILE* fh = fopen(filename, "r"); // 以只读模式关上文件
    if (fh == nullptr) // 当执行失败是，返回的指针是 nullptr
        return false; // 向调用者汇报谬误

    // 假如每个函数会在执行失败时返回 false
    if (!doSomethingWithTheFile(fh)) {fclose(fh); // 敞开文件句柄，防止造成内存透露。return false; // 反馈谬误
    }
    if (!doSomethingElseWithIt(fh)) {fclose(fh); // 敞开文件句柄
        return false; // 反馈谬误
    }

    fclose(fh); // 敞开文件句柄
    return true; // 批示函数已胜利执行
}

// C 语言的程序员通常会借助 goto 语句简化下面的代码：bool doSomethingWithAFile(const char* filename)
{FILE* fh = fopen(filename, "r");
    if (fh == nullptr)
        return false;

    if (!doSomethingWithTheFile(fh))
        goto failure;

    if (!doSomethingElseWithIt(fh))
        goto failure;

    fclose(fh); // 敞开文件
    return true; // 执行胜利

failure:
    fclose(fh);
    return false; // 反馈谬误
}

// 如果用异样捕捉机制来批示谬误的话，// 代码会变得清晰一些，然而依然有优化的余地。void doSomethingWithAFile(const char* filename)
{FILE* fh = fopen(filename, "r"); // 以只读模式关上文件
    if (fh == nullptr)
        throw std::exception("Could not open the file.");

    try {doSomethingWithTheFile(fh);
        doSomethingElseWithIt(fh);
    }
    catch (...) {fclose(fh); // 保障出错的时候文件被正确敞开
        throw; // 之后，从新抛出这个异样
    }

    fclose(fh); // 敞开文件
    // 所有工作顺利完成
}

// 相比之下，应用 C ++ 中的文件流类（fstream）时，// fstream 会利用本人的析构器来敞开文件句柄。// 只有来到了某一对象的定义域，它的析构函数就会被主动调用。void doSomethingWithAFile(const std::string& filename)
{
    // ifstream 是输出文件流（input file stream）的简称
    std::ifstream fh(filename); // 关上一个文件

    // 对文件进行一些操作
    doSomethingWithTheFile(fh);
    doSomethingElseWithIt(fh);

} // 文件曾经被析构器主动敞开

// 与下面几种形式相比，这种形式有着_显著_的劣势：// 1. 无论产生了什么状况，资源（此例当中是文件句柄）都会被正确敞开。//    只有你正确应用了析构器，就_不会_因为遗记敞开句柄，造成资源的透露。// 2. 能够留神到，通过这种形式写进去的代码非常简洁。//    析构器会在后盾敞开文件句柄，不再须要你来操心这些琐事。// 3. 这种形式的代码具备异样安全性。//    无论在函数中的何处拋出异样，都不会妨碍对文件资源的开释。// 纯粹的 C ++ 代码该当把 RAII 的应用扩大到各种类型的资源上，包含：// - 用 unique_ptr 和 shared_ptr 治理的内存
// - 各种数据容器，例如规范库中的链表、向量（容量主动扩大的数组）、散列表等；//   当它们脱离作用域时，析构器会主动开释其中贮存的内容。// - 用 lock_guard 和 unique_lock 实现的互斥