适合具备 C 语言基础的 C++ 教程之一

 [[381386]]

引言

C 语言通常被认为是一种面向过程的语言，因为其本身的特性更容易编写面向过程的代码，当然也不排除使用 C 语言编写面向过程的代码，比如 Linux 的源代码以及现在很火的国产物联网操作系统 RT-Thread，其内核的实现方式都是使用 C 语言实现的面向对象的代码。相比于 C 语言来说，C++ 更能够实现面向对象的程序设计，其具有的特性也要比 C 语言要多的多。下面假设有这样一个需求。

现要描述两个人的信息，姓名，职业，年龄，并输出。

我们首先先使用 C 语言的设计思路实现这个功能。

C语言描述

如果使用 C 语言来描述上面这个问题，大部分都会想到使用结构体来完成这个要求，写出的程序也就如下所示：

#include <stdio.h> 
 
struct person 
{ 
    char *name; 
    int age; 
    char *work; 
}; 
 
int main(int argc, char** aggv) 
{ 
    struct person persons[] = { 
        {"wenzi",24,"programer"}, 
        {"jiao", 22,"teacher"}, 
    }; 
 
    char i; 
    for (i = 0; i < 2; i++) 
    { 
        printf("name is:%s,age is:%d,work is:%s\n",persons[i].name,persons[i].age,persons[i].work); 
    } 
} 

上述这是比较初级的写法，如果对 C 语言了解的更多一点的人在写这段程序的时候，会使用函数指针的方式将代码写的更加巧妙，代码如下所示：

#include <stdio.h> 
 
struct person 
{ 
    char *name; 
    int age; 
    char *work; 
 
    void (*printInfo)(struct person *per); 
}; 
 
void printInfo(struct person *per) 
{ 
    printf("The people's name is:%s,age is:%d,work is:%s\n",per->name,per->age,per->work); 
} 
 
 
int main(int argc, char** argv) 
{ 
    struct person per[2]; 
 
    per[0] = {"wenzi",18,"programer",printInfo}; 
    per[1] = {"jiaojiao",18,"teacher",printInfo}; 
 
    per[0].printInfo(&per[0]); 
    per[1].printInfo(&per[1]); 
} 

使用了函数指针的方式来书写这个程序，程序也变得更加简介了，主函数里也少了 for循环。

C++ 的引入

那除此之外，还有更好的书写方式么，这个时候就要引入 C++ 的特性了，上述代码中在执行函数时都传入了参数，那要如何做才能将上述中的参数也省略去呢，且看如下的代码：

#include <stdio.h> 
 
struct person 
{ 
    char *name; 
    int age; 
    char *work; 
 
    void prinfInfo(void) 
    { 
         printf("The people's name is:%s,age is:%d,work is:%s\n",name,age,work);        
    } 
}; 
 
int main(int argc, char** argv) 
{ 
    struct person persons[] = { 
        {"wenzi", 18,"program"}, 
        {"jiao", 18, "teacher"}, 
    }; 
 
    persons[0].prinfInfo(); 
    persons[1].prinfInfo(); 
 
    return 0; 
} 

上述代码中使用了 C++ 的特性，在结构体中定义了函数，然后也就可以直接调用函数了，跟上面 C 语言的代码相比较，它没了实参，而且代码看起来也比 C 语言更加简洁了。

实际在 C++ 中它具有自己独有的一套机制来实现上述的代码，也就是即将说明的 class,有了 class 之后，我们就可以这样书写代码：

#include <stdio.h> 
 
class person 
{ 
public: 
    char * name; 
    int age; 
    char * work; 
 
    void printInfo(void) 
    { 
        printf("The people's name is:%s,age is:%d,work is:%s\n",name,age,work);  
    } 
} 
 
int main(int argc, char** argv) 
{ 
    person persons[] = { 
        {"wenzi", 18,"program"}, 
        {"jiao", 18, "teacher"}, 
    }; 
 
    persons[0].prinfInfo(); 
    persons[1].prinfInfo(); 
 
    return 0; 
} 

上述就是关于 C++ 的一个简单的引入过程。

C++ 数据访问控制

但是为了能够改变类里的数据，但是又要使得这个改变不要越界，避免胡乱地改变，我们可以这样来定义这个类：

#include <stdio.h> 
#include <iostream> 
 
class Person 
{ 
private: 
    char *name; 
    int age; 
    char *work; 
 
public: 
    void PrintInfo(void) 
    { 
        cout << "name is:" << name << "age = "<< age << "work is:"<< work <<endl; 
    } 
}; 

这样定义一个类之后，类里面的数据成员就变成了私有的，不能够在外部进行访问，比如下面这样子就是错误的：

int main(int argc, char ** argv) 
{ 
    Person per; 
    per.age = 10; // error 
} 

上述这样进行数据的访问就是错误的，那么要如何进行访问呢，我们可以定义这样一个成员函数进行数据的读写，比如下面的代码所示：

#include <stdio.h> 
#include <iostream> 
 
using namespace std; 
 
class Person 
{ 
private: 
    char *name; 
    int age; 
    char *work; 
 
public: 
    void PrintInfo(void) 
    { 
        cout << "name is:" << name << ",age = "<< age << ",work is:"<< work <<endl; 
    } 
 
    void setName(char *n) 
    { 
        name = n; 
    } 
 
    int setAge(int a) 
    { 
        if (a < 0 || a > 150) 
        { 
            age = 0; 
            return 0; 
        } 
        age = a; 
    } 
}; 

这样定义了类之后，就可以访问私有成员了，比如下面这样进行：

int main(int argc, char **argv) 
{ 
    Person per; 
    per.setName("wenzi"); 
    per.setAge(24); 
    per.PrintInfo(); 
 
    return 0; 
} 

上述代码加入了 private 访问控制符，通过在类里面定义成员函数的方式，能够对私有成员进行读写。

this 指针

再来看上述的代码，我们可以看到在书写 setName 和 setAge这两个函数的时候，形参写的是 char *n 和 int a，这样子给人的感觉就不是那么的直观，如果写成 char *name 和 char *age 呢，比如成员函数是像下面这样子编写的。

void setName(char *name) 
{ 
    name = name; 
} 
 
int setAge(int age) 
{ 
    if (age < 0 || age > 150) 
    { 
         age = 0; 
         return 0; 
    } 
        age = age; 
} 

上述代码也很容易看出问题，根据 C 语言的就近原则，name = name没有任何意义，这个时候就需要引入 this 指针。引入 this 指针之后的代码如下所示：

#include <iostream> 
#include <stdio.h> 
 
using namespace std;  
 
class Person { 
private: 
    char *name; 
    int age; 
    char *work; 
 
public: 
    void setName(char *name) 
    { 
        this->name = name; 
    } 
    int setAge(int age) 
    { 
        if (age < 0 || age > 150) 
        { 
            this->age = 0; 
            return -1; 
        } 
        this->age = age; 
        return 0; 
    } 
    void printInfo(void) 
    { 
        cout << "name =" << name << ", age =" << age << endl; 
    } 
}; 
 
int main(int argc, char **argv) 
{ 
    Person per; 
    per.setName("wenzi"); 
    per.setAge(25); 
    per.printInfo(); 
} 

在上述代码中，引入了 this 指针，通过上述代码也可以非常清楚它的意思，就是代表当前实例化的对象，能够指向当前实例化对象的成员。

程序结构

上述代码中，成员函数是在类里面实现的，这样使得整个类看着十分的臃肿，我们可以按照如下的方式进行书写：

#include <stdio.h> 
 
class Person 
{ 
private: 
    char *name; 
    int age; 
    char *work; 
 
public: 
    void SetName(char *name); 
    int SetAge(int age;) 
    void PrintInfo(void); 
} 
 
void Person::SetName(char *name) 
{ 
    this->name = name; 
} 
 
void Person::SetAge(int age) 
{ 
    this->age = age; 
} 
 
void Person::PrintInfo(void) 
{ 
    cout << "name = " << name << "age = " << age << endl; 
} 

通过在类外面实现我们的成员函数，看起来要更为简洁一些，上述就是代码的实现形式。

多文件

上述代码中，我们都是将代码写在一个文件中，这样当代码量很大的时候，如果代码都是在一个文件里，那么会使得代码难以阅读，这个时候，我们就会将代码分别放在几个文件中来进行管理，比如实现上述相同的功能，我们的代码结构如下图所示：

image-20210110120503456

其中 main.cpp文件中的内容如下所示：

#include <stdio.h> 
#include "person.h" 
 
int main(int argc, char **argv) 
{ 
    Person per; 
 
    //per.name = "zhangsan"; 
    per.setName("zhangsan"); 
    per.setAge(200); 
    per.printInfo(); 
 
    return 0; 
}   

可以看到在上述 main.cpp中包含了 #include "person.h"头文件，实际上是在 person.h文件中定义了 person类，person.h文件的内容如下：

#ifndef __PERSON_H__ 
#define __PERSON_H__ 
 
class Person { 
private: 
    char *name; 
    int age; 
    char *work; 
 
public: 
    void setName(char *name); 
    int setAge(int age); 
    void printInfo(void); 
}; 
 
#endif 

然后，在 person.cpp中定义了成员函数：

#include <stdio.h> 
#include "person.h" 
 
void Person::setName(char *name) 
{   
    this->name = name; 
} 
 
int Person::setAge(int age) 
{ 
    if (age < 0 || age > 150) 
    { 
        this->age = 0; 
        return -1; 
    } 
    this->age = age; 
    return 0; 
} 
 
void Person::printInfo(void) 
{ 
    printf("name = %s, age = %d, work = %s\n", name, age, work);  
} 

在有了上述三个文件之后，要如何进行编译呢，这个时候就需要写一个 Makefile文件，接下来简单介绍一下 Makefile语法。

Makefile

总的来说 Makefile的规则核心就如下所示：

target ... :prerequisites 
command 
... 
... 

target也就是一个目标文件，可以是Object File,也可以是执行文件。还可以是一个标签

prerequisites就是要生成那个target所需要的文件或者是目标

command就是make所要执行的命令(任意的Shell)

说了核心的东西，来看我们当前所编写的 Makefile文件，Makefile文件如下所示：

person: main.o person.o 
    g++ -o $@ $^ 
 
%.o : %.cpp 
    g++ -c -o $@ $< 
 
clean: 
    rm -f *.o person     

在这里所要明确的一点是这样的，就是在 Makefile中，必须使用 Tab 键来进行缩进。然后，需要明确的一个概念是，要使得代码能够执行，需要经过 编译 -> 链接 -> 执行，这三个过程才能够运行，编译是把源文件编译成中间代码，这个中间代码在 UNIX 是 .o 文件，然后再把大量的 .o 文件合成可执行文件，这个过程就是 链接，最后，执行我们链接好的可执行文件。

我们来看上述这个 Makefile文件，person是最终的可执行文件，然后，要生成这个可执行文件，需要 main.o文件和 person.o文件,然后执行这个操作需要的是第二条命令，g++ -o $@ $^,其中 $@ 表示的是目标文件，$^表示的是所有依赖文件。

然后，紧接着看第三条，%.o : %.cpp,这里表示的是通配符，表示的是所有的 .o 文件和所有的 .cpp 文件，意思就是说要生成的所有的 .o 文件依赖于 .cpp 文件，然后，执行的命令是 g++ -c -o $@ $<其中表示的是第一个依赖文件。

最后，我们需要清楚，在编译过程中，生成了一些中间文件以及可执行文件，如果我们想要清除掉当前生成的文件，那么只需要执行 make clean就可以清除掉生成的 .o文件以及 person文件。

函数重载

C++ 不允许变量重名，但是对于函数来说，可以允许重载，只要函数的参数不同即可，这样就完成了函数的重载，直接来看一段关于函数重载的代码：

#include <iostream> 
 
using namespace std; 
 
int add(int a, int b) 
{ 
    cout<<"add int+int"<<endl; 
    return a+b; 
} 
 
int add(int a, int b, int c) 
{ 
    cout<<"add int+int+int"<<endl; 
    return a+b+c; 
} 
 
double add(double a, double b) 
{ 
    cout<<"add double+double"<<endl; 
    return a+b; 
} 
 
double add(int a, double b) 
{ 
    cout<<"add int+double"<<endl; 
    return (double)a+b; 
} 
 
double add(double b, int a) 
{ 
    cout<<"add double+int"<<endl; 
    return (double)a+b; 
} 
 
 
int main(int argc, char **argv) 
{ 
    add(1, 2); 
    add(1, 2, 3); 
    add(1.0, 2.0); 
    add(1, 2.0); 
    add(1.0, 2); 
 
    return 0; 
} 

代码很简单，就是两数相加的一个运算，但是两数相加的形参不一样，有的形参是两个整型的相加，还有是一个整型和浮点数的相加，因为 C++ 重载的功能，因此，得以定义多个函数名相同但是形参和返回值都不同的函数，从而在主函数实现了不同类型数的相加。

引用和指针

在 C语言中是没有引用的，在 C++ 中引用的提出也使得之前在 C 语言中必须使用指针的操作，现在可以使用引用完成了，但是引用又不是指针，简单来说，引用是一个变量的别名，也就是“绰号”，对于这个别名的操作也就完全等同于被引用变量的操作。为了看是否真的是别名，我们来实验这样一段代码：

#include <iostream> 
 
using namespace std; 
 
int main(int argc,char **argv) 
{ 
    int m; 
    m = 10;  
 
    int &n = m; 
 
    int *p = &m; 
    int *p1 = &n; 
 
    cout << "n =" << n << endl; 
    cout << "p =" << p << endl; 
    cout << "p1 =" << p1 << endl; 
 
    return 0;  
 
} 

上述这段代码中输出的就是 n 的值，和 m 以及 n 变量的地址，我们来看输出的内容：

image-20210112235421638

可以看到代码中虽然是对 m 进行了赋值，但是在输出 n 的时候，输出的是 m 的值，也就是说在这里对于 n 的操作是完全等同于 m 的，紧接着，我们来证实 n 是否是 m 的别名，那么我们就来看 n 和 m 的地址，可以看到我们输出的两个变量的地址也是完全一致的，这也就证实了我们的说法。

接下来，看一段指针，引用，常规形参的一段代码，代码如下所示：

#include <iostream> 
 
using namespace std; 
 
int add_one(int a) 
{ 
    a = a+1; 
    return a; 
} 
 
int add_one(int *a) 
{ 
    *a = *a + 1; 
    return *a; 
} 
 
int add_one_ref(int &b) 
{ 
    b = b+1; 
    return b; 
} 
 
int main(int argc, char **argv) 
{ 
    int a = 99; 
        int &c = a; 
    cout<<add_one(a)<<endl; 
    cout<<"a = "<<a<<endl; 
 
    cout<<add_one(&a)<<endl; 
    cout<<"a = "<<a<<endl; 
 
    cout<<add_one_ref(a)<<endl; 
    cout<<"a = "<<a<<endl; 
 
        c++; 
 
    cout<<"a = "<<a<<endl; 
    cout<<"c = "<<c<<endl; 
 
    return 0; 

根据上述对于引用的阐述，我们直接给出运行结果，运行结果如下所示：

image-20210113000240223

具体的计算过程就不再这里赘述了。

小结

OK，上述就是关于 C++ 的一个简单的引入的过程以及其涉及到的一部分有别于C语言的语法，本教程将持续连载，欢迎各位朋友关注~

本小节所涉及的代码可以通过百度云链接的方式获取：链接：https://pan.baidu.com/s/1RWPXiqiFCVApcfTdaHyDgw

提取码：j9hd

本文转载自微信公众号「wenzi嵌入式软件」，可以通过以下二维码关注。转载本文请联系wenzi嵌入式软件公众号。