Linux-C/C++《C++/1、C++基础》(C++语言特性、面向对象等)

        C++比 C 语言新增的数据类型是布尔类型（bool）。但是在新的 C 语言标准里已经有布尔类型了，但是在旧的 C 语言标准里是没有布尔类型的，编译器也无法解释布尔类型。在传统的 C 语言里，变量初始化时必须在程序的前面定义在前面，而 C++则是可以随用随定义。C++也可以直接初始化，比如 int x(100);这样就直接赋值 x=100，这些都是 C++特性的好处。这里只说这些常用的新特性，其他特性不做描述或者解释了。

        在 C++里，我们使用以 cin 和 cout 代替了 scanf 和 printf。在输入和输出的流程上是不变的，只是关键字变了，用法也变了。

        要说效率上，肯定是 C 语言的 scanf 和 printf 的效率高，但是没有 C++中的 cin 和 cout 使用方便。

        C++的 I/O 语法方式如下。

        cout 语法形式：

cout<<x<<endl;

        x 可以是任意数据类型，甚至可以写成一个表达式，这比 C 语言需要指定数据类型方便多了，endl 指的是换行符，与 C 语言的“\n”效果一样。

错误示例：

cout<<x,y<<endl;

// 在变量间不能用“，”。

正确写法：

cout<<x<<y;    // endl 可流省略，只是一个换行的效果。

cin 语法形式：

cin>>x;

        x 可以是任意数据类型。

拓展，如何输入两个不同的变量。

cin>>x>>y;

1.3  C++之命名空间 namespace

        如下代码第 2 行。using namespace std;同时我们要注意第 1 行，不能写成 iostream.h，有.h 的是非标准的输入输出流，c 的标准库。无.h 的是标准输入输出流就要用命名空间。

#include <iostream>
using namespace std;
int main()
{
    cout << "Hello, World!" << endl;
    return 0;
}

        using 是编译指令，声明当前命名空间的关键词。可以从字面上理解它的意思，using 翻译成使用。这样可以理解成使用命名空间 std。因为 cin 和 cout 都是属于 std 命名空间下的东西，所以使用时必须加上 using namespace std;这句话。cin 和 cout 可以写 std::cin 和 std::cout，“::” 表示作用域，cin 和 cout 是属于 std 命名空间下的东西，这里可以理解成 std 的 cin 和 std 的 cout。

        为什么要使用命名空间？

        有些名字容易冲突，所以会使用命名空间的方式进行区分，具体来说就是加个前缀。比如C++ 标准库里面定义了 vector 容器，您自己也写了个 vector 类，这样名字就冲突了。于是标准库里的名字都加上 std:: 的前缀，您必须用 std::vector 来引用。同理，您自己的类也可以加个自定义的前缀。但是经常写全名会很繁琐，所以在没有冲突的情况下您可以偷懒，写一句using namespace std;，接下去的代码就可以不用写前缀直接写 vector 了。

        从命名空间开始我们就隐隐约约可以看到 C++面向对象的影子了。命名空间在很多 C++库里使用到。有些公司也会自定义自己的 C++库，里面使用了大量的命名空间。从这里我们也可以看出 C++是非常之有条理的，容易管理的，不含糊，易使用的。

        在初学 Qt 时我们是比较少使用命名空间，或者比较少看到命名空间。当然也是可以在 Qt里自定义命名空间，然后与 C++一样正常使用。

        下面通过一个简单的例子来介绍自定义的命名空间和使用自定义的命名空间。在 Ubuntu上我们新建一个目录 02_namespace_example，然后在 02_namespace_example 里新建一个

02_namespace_example.cpp 文件，内容如下。

#include <iostream>
using namespace std;

namespace A
{
    int x = 1;
    void fun() {
        cout<<"A namespace"<<endl;
    }
}
using namespace A;
int main()
{
    fun();
    A::x = 3;
    cout<<A::x<<endl;
    A::fun();
    return 0;
}

        第 4 行，自定义了命名空间 A，里面定义了一个变量 x，并将 x 赋值为 1；定义了一个函数fun()，并在 fun()加了输出打印语句 cout<<"A namespace"<<endl;。

        第 11 行，声明使用命名空间 A。

        第 14 行，在第 11 行声明了命名空间 A 后，才能直接使用 fun();否则要写成 A::fun();

        第 15 行，将 A 命名空间下的 x 重新赋值为 3。

        第 16 行，打印出 A 命名空间下的 x 的值。

        第 17 行，调用 A 命名空间下的 fun()。

        执行下面的指令开始编译。

g++ 02_namespace_example.cpp -o 02_namespace_example

2、C++面向对象

        C++ 在 C 语言的基础上增加了面向对象编程，C++ 支持面向对象程序设计。类是 C++的核心特性，通常被称为用户定义的类型。类用于指定对象的形式，它包含了数据表示法和用于处理数据的方法。类中的数据和方法称为类的成员。函数在一个类中被称为类的成员。

        打个比方说明一下什么是类，比如有一条小狗，小狗有名字叫旺财，旺财的年龄是 2 岁，同时旺财会汪汪的叫，也能跑。我们统称狗这个为类，类是我们抽象出来的，因为狗不只有上面的属性，还有体重，毛发的颜色等等，我们只抽象出几种属性成一个类。具体到哪条狗就叫对象。

        从类中实例化对象分两种方法，一种是从栈中实例化对象，一种是从堆中实例化对象。

        下面以自定义狗类介绍如何自定义类和如何使用对象。

        在 Ubuntu 上编辑一个 03_class_dog_example 目录，在 03_class_dog_example 目录下新建一个 03_class_dog_example.cpp 文件，内容如下。

#include <iostream>
#include <string>
using namespace std;

class Dog
{
    public:
    string name;
    int age;

    void run() {
        cout<<"小狗的名字是:"<<name<<","<<"年龄是"<<age<<endl;
    }
};

int main()
{
    Dog dog1;

    dog1.name = "旺财";
    dog1.age = 2;
    dog1.run();

    Dog *dog2 = new Dog();
    if (NULL == dog2) {
        return 0;
    }
    dog2->name = "富贵";
    dog2->age = 1;
    dog2->run();

    delete dog2;
    dog2 = NULL;
    return 0;
}

        第 5 行，定义了一个 Dog 狗，定义类时，起的类名要尽量贴近这个类，让人一看就明白，您这个类是做什么的。

        第 7 行，访问限定符 public（公有的），此外还有 private（私有的）和 protected（受保护的）。写这个的目的是为了下面我们要调用这些成员，不写访问限定符默认是 private。关于访问限定符，如果是初学者可能会难理解。简单的来说，访问限定符就是设置一个成员变量和成员函数的访问权限而已，初学者暂时不必要深究什么时候应该用 public 和什么时候应该用 private。

        第 8 至 11 行，定义了一个字符串变量 name，整形变量 age。和一个方法 run()。我们在这个 run()里打印相应的狗名和狗的年龄。PS：string 是 C++的数据类型，方便好用，使用频率相当高。

        第 18 行，从栈中实例化一个对象 dog1(可以随意起名字)。

        第 20 至 22 行，为 dog1 的成员变量赋值，dog1 的 name 赋值叫“旺财”，年龄为 2 岁。然后调用 run()方法，打印 dog1 的相关变量的信息。

        第 24 行，从堆中实例化对象，使用关键字 new 的都是从堆中实例化对象。

        第 26 行，从堆中实例化对象需要开辟内存，指针会指向那个内存，如果 new 没有申请内存成功，p 即指向 NULL，程序就自动退出，下面的就不执行了，写这个是为了严谨。

        第 29 至 31 行，和 dog1 一样，为 dog2 的成员赋值。

        第 34 和 35 行，释放内存，将 dog2 重新指向 NULL。

        如果没有语法错误，我们完全可以预测到打印的结果。我们学习 C 语言的结构体，类其实和结构类似，可以说类是结构体的升级版本。

        执行下面的指令开始编译。

g++ 03_class_dog_example.cpp -o 03_class_dog_example

        通过上面的例子我们已经学习了什么是类，和什么是对象。以描述 Dog 为一类（抽象出来的），从 Dog 类中实例出来就是对象（实际事物）。对象拥有 Dog 类里的属性，可以从栈中实例化对象，亦可从堆中实例化对象。类的编写过程和对象的使用过程大致如上了。我们只需要理解这个步骤，明白类的定义和使用即可。

        什么是构造函数？构造函数在对象实例化时被系统自动调用，仅且调用一次。构造函数出现在哪里？前面我们学过类，实际上定义类时，如果没有定义构造函数和析构函数，编译器就会生成一个构造函数和析构函数，只是这个构造和析构函数什么事情也不做，所以我们不会注意到一点。

        构造函数的特点如下：

        （1） 构造函数必须与类名同名；

        （2） 可以重载，（重载？新概念，后面学到什么是重载。）；

        （3） 没有返回类型，即使是 void 也不行。

        什么是析构函数？与构造函数相反，在对象结束其生命周期时系统自动执行析构函数。实际上定义类时，编译器会生成一个析构函数。

        析构函数的特点如下：

        （1） 析构函数的格式为~类名()；

        （2） 调用时释放内存（资源）；

        （3） ~类名()不能加参数；

        （4） 没有返回值，即使是 void 也不行。

        下面我们通过简单的例子来说明构造函数和析构函数的使用。新建一个目录04_structor_example，编辑一个 04_structor_example.cpp 内容如下。

#include <iostream>
#include <string>
using namespace std;

class Dog
{
public:
    Dog();
    ~Dog();
};
int main()
{
    Dog dog;
    cout<<"构造与析构函数示例"<<endl;
    return 0;
}

 Dog::Dog()
{
    cout<<"构造函数执行！"<<endl;
}

Dog::~Dog()
{
    cout<<"析构函数执行！"<<endl;
}

2.1.2 this 指针

        一个类中的不同对象在调用自己的成员函数时，其实它们调用的是同一段函数代码，那么成员函数如何知道要访问哪个对象的数据成员呢？没错，就是通过 this 指针。每个对象都拥有一个 this 指针，this 指针记录对象的内存地址。在 C++中，this 指针是指向类自身数据的指针，简单的来说就是指向当前类的当前实例对象。关于类的 this 指针有以下特点：

        （1） this 只能在成员函数中使用，全局函数、静态函数都不能使用 this。实际上，成员函数默认第一个参数为 T * const this。也就是一个类里面的成员了函数 int func(int p)，func 的原型在编译器看来应该是 int func(T * const this,int p)。

        （2） this 在成员函数的开始前构造，在成员函数的结束后清除。

        （3） this 指针会因编译器不同而有不同的放置位置。可能是栈，也可能是寄存器，甚至全局变量。

        下面以简单的例子来说明 this 的用法。我们还是以狗类为例，按上面的 this 解释，this 只能够在成员函数使用，并可以指向自身数据。我们就可以写这样简单的例子来说明 this 的用法。

        我们在 Qt 里也会遇到 this 这个东西，下面这个例子就很容易解释 Qt 里的 this 指针的用法。

        新建一个目录 05_this_pointer_example，编辑一个 05_this_pointer_example.cpp 内容如下。

#include <iostream>
#include <string>
using namespace std;

class Dog
{
    public:
    string name;
    void func();
};

int main()
{
    Dog dog;
    dog.func();
    return 0;
}

void Dog::func()
{
    this->name = "旺财";
    cout<<"小狗的名字叫："<<this->name<<endl;
}

        第 21 和 22 行，在类的成员函数里使用了 this 指针，并指向了类里的成员 name。先将 name赋值叫“旺财”，然后我们打印 name 的值。

        当程序没有语法错误里我们可以预测打印的结果，就是“小狗的名字叫：旺财”。

        面向对象程序设计中最重要的一个概念是继承。继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。这样做，也达到了重用代码功能和提高执行效率的效果。

        当创建一个类时，您不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基类，新建的类称为派生类。在 Qt 里大量的使用了这种特性，当 Qt 里的类不满足自己的要求时，我们可以重写这个类，就是通过继承需要重写的类，来实现自己的类的功能。

        一个类可以派生自多个类，这意味着，它可以从多个基类继承数据和函数。定义一个派生类，我们使用一个类派生列表来指定基类。类派生列表以一个或多个基类命名，形式如下：

class derived-class: access-specifier base-class

        与类的访问修饰限定符一样，继承的方式也有几种。其中，访问修饰符 access-specifier 是 public、protected 或 private 其中的一个，base-class 是之前定义过的某个类的名称。如果未使用访问修饰符 access-specifier，则默认为 private。

        下面来捋一捋继承的方式，例子都是以公有成员和公有继承来说明，其他访问修饰符和其他继承方式，大家可以在教程外自己捋一捋。这个公有成员和继承方式也没有什么特别的，无非就是不同的访问权限而已，可以这样简单的理解。

        1. 公有继承（public）：当一个类派生继承公有基类时，基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。

        2. 保护继承（protected）： 当一个类派生继承保护基类时，基类的公有和保护成员将成为派生类的保护成员。

        3. 私有继承（private）：当一个类派生继承私有基类时，基类的公有和保护成员将成为派生类的私有成员。

        下面我们还是以狗类为例，在 2.2.1 小节里我们定义的狗类，已经定义了 name，age 和 run() 方法。假设我们不想重写这个狗类，而是新建一个 Animal 类，让狗类去继承这个 Animal 类。假设是公有继承，那么我们是不是可以在狗类实例的对象里去使用继承 Animal 类里的成员呢？带着这个疑问，我们使用下面的例子来说明。

        新建一个目录 06_inherit_example，编辑一个 06_inherit_example.cpp 内容如下。

#include <iostream>
#include <string>
using namespace std;

/*动物类，抽象出下面两种属性，
*颜色和体重，是每种动物都具有的属性
*/
class Animal
{
public:
    /* 颜色成员变量 */
    string color;
    /* 体重成员变量 */
    int weight;
};

/*让狗类继承这个动物类，并在狗类里写自己的属性。
*狗类拥有自己的属性 name，age，run()方法，同时也继承了
*动物类的 color 和 weight 的属性
*/
class Dog : public Animal
{
public:
    string name;
    int age;
    void run();
};

int main()
{
    Dog dog;
    dog.name = "旺财";
    dog.age = 2;
    dog.color = "黑色";
    dog.weight = 120;
    cout<<"狗的名字叫："<<dog.name<<endl;
    cout<<"狗的年龄是："<<dog.age<<endl;
    cout<<"狗的毛发颜色是："<<dog.color<<endl;
    cout<<"狗的体重是："<<dog.weight<<endl;
    return 0;
}

        第 21 行，Animal 作为基类，Dog 作为派生类。Dog 继承了 Animal 类。访问修饰符为 public

（公有继承）。

        C++ 允许在同一作用域中的某个函数和运算符指定多个定义，分别称为函数重载和运算符重载。

        重载声明是指一个与之前已经在该作用域内声明过的函数或方法具有相同名称的声明，但 是它们的参数列表和定义（实现）不相同。

        当您调用一个重载函数或重载运算符时，编译器通过把您所使用的参数类型与定义中的参 数类型进行比较，决定选用最合适的定义。选择最合适的重载函数或重载运算符的过程，称为重载决策。

        在同一个作用域内，可以声明几个功能类似的同名函数，但是这些同名函数的形式参数（指 参数的个数、类型或者顺序）必须不同。我们不能仅通过返回类型的不同来重载函数。在 Qt 源码里，运用了大量的函数重载，所以我们是有必要学习一下什么是函数重载。不仅在 C++， 在其他语言的里，都能看见函数重载。因为需要不同，所以有重载各种各样的函数。

        下面通过一个小实例来简单说明一下函数重载的用法。我们还是以狗类为说明，现在假设 有个需求。我们需要打印狗的体重，分别以整数记录旺财的体重和小数记录旺财的体重，同时 以整数打印和小数打印旺财的体重。那么我们可以通过函数重载的方法实现这个简单的功能。

        新建一个目录 07_func_overloading，编辑一个 07_func_overloading.cpp 内容如下。

#include <iostream>
#include <string>
using namespace std;
class Dog
{
public:
    string name;
    void getWeight(int weight) {
    cout<<name<<"的体重是："<<weight<<"kG"<<endl;
    }

    void getWeight(double weight) {
    cout<<name<<"的体重是："<<weight<<"kG"<<endl;
    }
};
int main()
{
    Dog dog;
    dog.name = "旺财";
    dog.getWeight(10);
    dog.getWeight(10.5);
    return 0;
}

        第 9 行，写了一个方法 getWeight(int weight)，以 int 类型作为参数。

        第 13 行，以相同的函数名 getWeight，不同的参数类型 double weight，这样就构成了函数

重载。

        第 22 行与第 23 行，分别传进参数不同的参数，程序就会匹配不同的重载函数。

        运算符重载的实质就是函数重载或函数多态。运算符重载是一种形式的 C++多态。目的在于让人能够用同名的函数来完成不同的基本操作。要重载运算符，需要使用被称为运算符函数的特殊函数形式，运算符函数形式：operatorp（argument-list），operator 后面的'p'为要重载的运算符符号。重载运算符的格式如下：

<返回类型说明符> operator <运算符符号>(<参数表>)
{
     <函数体>
}

        下面的实例使用成员函数演示了运算符重载的概念。在这里，对象作为参数进行传递，对象 的属性使用 this 运算符进行访问。下面还是以我们熟悉的狗类为例。声明加法运算符用于把两个 Dog 对象相加的体重相加，返回最终的 Dog 对象然后得到第三个 Dog 对象的体重。

        新建一个目录 08_operator_example，编辑一个 08_operator_example.cpp 内容如下。

#include <iostream>
#include <string>
using namespace std;
class Dog
{
public:
    int weight;
    Dog operator+(const Dog &d) {
        Dog dog;
        dog.weight = this->weight + d.weight;
        return dog;
    }

};
int main()
{
    Dog dog1;
    Dog dog2;
    Dog dog3;

    dog1.weight = 10;
    dog2.weight = 20;
    dog3 = dog1 + dog2;
    cout<<"第三只狗的体重是："<<dog3.weight<<endl;
    return 0;
}

2.4 多态

        C++多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数；形成多态必须具备三个条件：

        1. 必须存在继承关系；

        2. 继承关系必须有同名虚函数（其中虚函数是在基类中使用关键字 virtual 声明的函数，在派 生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到该函数）；

        3. 存在基类类型的指针或者引用，通过该指针或引用调用虚函数。这里我们还需要理解两个概念：

        虚函数：

        是在基类中使用关键字 virtual 声明的函数。在派生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到该函数。我们想要的是在程序中任意点可以根据所调用的对象类型来选择调用的函数，这种操作被称为动态链接，或后期绑定。虚函数声明如下：virtualReturnType FunctionName(Parameter) 虚函数必须实现，如果不实现，编译器将报错

        纯虚函数：

        若在基类中定义虚函数，以便在派生类中重新定义该函数更好地适用于对象，但是您在基类中又不能对虚函数给出有意义的实现，这个时候就会用到纯虚函数。纯虚函数声明如下：virtual void funtion1()=0; 纯虚函数一定没有定义，纯虚函数用来规范派生类的行为，即接口。包含纯虚函数的类是抽象类，抽象类不能定义实例，但可以声明指向实现该抽象类的具体类的指针或引用。

        上面那些概念大家可以捋一捋，毕竟 C++概念还是挺多的。为什么说到多态要与虚函数和纯虚函数扯上关系？光说概念没有实例确实难理解。下面我们还是以我们熟悉的狗类和动物类，另外加一个猫类进行多态的讲解。

#include <iostream>
#include <string>
using namespace std;
/* 定义一个动物类 */
class Animal
{
public:
    virtual void run() {
        cout<<"Animal 的 run()方法"<<endl;
    }
};
/* 定义一个狗类，并继承动物类 */
class Dog : public Animal
{
public:
    void run() {
        cout<<"Dog 的 run()方法"<<endl;
    }

};
/* 定义一个猫类，并继承动物类 */
class Cat : public Animal
{
public:
    void run() {
        cout<<"Cat 的 run()方法"<<endl;
    }

};
int main()
{
    /* 声明一个 Animal 的指针对象，注：并没有实例化 */
    Animal *animal;
    /* 实例化 dog 对象 */
    Dog dog;
    /* 实例化 cat 对象 */
    Cat cat;
 
    /* 存储 dog 对象的地址 */
    animal = &dog;
    /* 调用 run()方法 */
    animal->run();

    /* 存储 cat 对象的地址 */
    animal = &cat;
    /* 调用 run()方法 */
    animal->run();
    return 0;
}

2.5 数据封装

#include <iostream>
#include <string>
using namespace std;
class Dog
{
public:
    string name;
     Dog(int i = 0)
    {
        total = i;
    }
    void addFood(int number) {
        total = total + number;
    }
 
    int getFood() {
        return total;
    }
private:
    int total;
};

int main()
{
    Dog dog;
    dog.name = "旺财";
    dog.addFood(3);
    dog.addFood(2);
    cout<<dog.name<<"总共获得了"<<dog.getFood()<<"份食物"<<endl;
 
    return 0;
}

#include <iostream>
using namespace std;

/* 定义一个动物类 */
class Animal
{
public:
    virtual void run() = 0;
};
/* 定义一个狗类，并继承动物类 */
class Dog : public Animal
{
public:
    void run() {
        cout<<"Dog 的 run()方法"<<endl;
    }
};

/* 定义一个猫类，并继承动物类 */
class Cat : public Animal
{
public:
    void run() {
        cout<<"Cat 的 run()方法"<<endl;
    }
};

int main()
{
    /* 实例化 dog 对象 */
    Dog dog;
    /* 实例化 cat 对象 */
    Cat cat;
    /* dog 调用 run()方法 */
    dog.run();
    /* cat 调用 run()方法 */
    cat.run();
 
    return 0;
}