文章详情

短信预约-IT技能 免费直播动态提醒

请输入下面的图形验证码

提交验证

短信预约提醒成功

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

2024-12-03 11:37

关注

引言

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

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

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

C语言描述

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

  1. #include  
  2.  
  3. struct person 
  4.     char *name
  5.     int age; 
  6.     char *work
  7. }; 
  8.  
  9. int main(int argc, char** aggv) 
  10.     struct person persons[] = { 
  11.         {"wenzi",24,"programer"}, 
  12.         {"jiao", 22,"teacher"}, 
  13.     }; 
  14.  
  15.     char i; 
  16.     for (i = 0; i < 2; i++) 
  17.     { 
  18.         printf("name is:%s,age is:%d,work is:%s\n",persons[i].name,persons[i].age,persons[i].work); 
  19.     } 

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

  1. #include  
  2.  
  3. struct person 
  4.     char *name
  5.     int age; 
  6.     char *work
  7.  
  8.     void (*printInfo)(struct person *per); 
  9. }; 
  10.  
  11. void printInfo(struct person *per) 
  12.     printf("The people's name is:%s,age is:%d,work is:%s\n",per->name,per->age,per->work); 
  13.  
  14.  
  15. int main(int argc, char** argv) 
  16.     struct person per[2]; 
  17.  
  18.     per[0] = {"wenzi",18,"programer",printInfo}; 
  19.     per[1] = {"jiaojiao",18,"teacher",printInfo}; 
  20.  
  21.     per[0].printInfo(&per[0]); 
  22.     per[1].printInfo(&per[1]); 

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

C++ 的引入

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

  1. #include  
  2.  
  3. struct person 
  4.     char *name
  5.     int age; 
  6.     char *work
  7.  
  8.     void prinfInfo(void) 
  9.     { 
  10.          printf("The people's name is:%s,age is:%d,work is:%s\n",name,age,work);        
  11.     } 
  12. }; 
  13.  
  14. int main(int argc, char** argv) 
  15.     struct person persons[] = { 
  16.         {"wenzi", 18,"program"}, 
  17.         {"jiao", 18, "teacher"}, 
  18.     }; 
  19.  
  20.     persons[0].prinfInfo(); 
  21.     persons[1].prinfInfo(); 
  22.  
  23.     return 0; 

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

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

  1. #include  
  2.  
  3. class person 
  4. public
  5.     char * name
  6.     int age; 
  7.     char * work
  8.  
  9.     void printInfo(void) 
  10.     { 
  11.         printf("The people's name is:%s,age is:%d,work is:%s\n",name,age,work);  
  12.     } 
  13.  
  14. int main(int argc, char** argv) 
  15.     person persons[] = { 
  16.         {"wenzi", 18,"program"}, 
  17.         {"jiao", 18, "teacher"}, 
  18.     }; 
  19.  
  20.     persons[0].prinfInfo(); 
  21.     persons[1].prinfInfo(); 
  22.  
  23.     return 0; 

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

C++ 数据访问控制

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

  1. #include  
  2. #include  
  3.  
  4. class Person 
  5. private: 
  6.     char *name
  7.     int age; 
  8.     char *work
  9.  
  10. public
  11.     void PrintInfo(void) 
  12.     { 
  13.         cout << "name is:" << name << "age = "<< age << "work is:"<< work <
  14.     } 
  15. }; 

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

  1. int main(int argc, char ** argv) 
  2.     Person per; 
  3.     per.age = 10; // error 

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

  1. #include  
  2. #include  
  3.  
  4. using namespace std; 
  5.  
  6. class Person 
  7. private: 
  8.     char *name
  9.     int age; 
  10.     char *work
  11.  
  12. public
  13.     void PrintInfo(void) 
  14.     { 
  15.         cout << "name is:" << name << ",age = "<< age << ",work is:"<< work <
  16.     } 
  17.  
  18.     void setName(char *n) 
  19.     { 
  20.         name = n; 
  21.     } 
  22.  
  23.     int setAge(int a) 
  24.     { 
  25.         if (a < 0 || a > 150) 
  26.         { 
  27.             age = 0; 
  28.             return 0; 
  29.         } 
  30.         age = a; 
  31.     } 
  32. }; 

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

  1. int main(int argc, char **argv) 
  2.     Person per; 
  3.     per.setName("wenzi"); 
  4.     per.setAge(24); 
  5.     per.PrintInfo(); 
  6.  
  7.     return 0; 

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

this 指针

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

  1. void setName(char *name
  2.     name = name
  3.  
  4. int setAge(int age) 
  5.     if (age < 0 || age > 150) 
  6.     { 
  7.          age = 0; 
  8.          return 0; 
  9.     } 
  10.         age = age; 

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

  1. #include  
  2. #include  
  3.  
  4. using namespace std;  
  5.  
  6. class Person { 
  7. private: 
  8.     char *name
  9.     int age; 
  10.     char *work
  11.  
  12. public
  13.     void setName(char *name
  14.     { 
  15.         this->name = name
  16.     } 
  17.     int setAge(int age) 
  18.     { 
  19.         if (age < 0 || age > 150) 
  20.         { 
  21.             this->age = 0; 
  22.             return -1; 
  23.         } 
  24.         this->age = age; 
  25.         return 0; 
  26.     } 
  27.     void printInfo(void) 
  28.     { 
  29.         cout << "name =" << name << ", age =" << age << endl; 
  30.     } 
  31. }; 
  32.  
  33. int main(int argc, char **argv) 
  34.     Person per; 
  35.     per.setName("wenzi"); 
  36.     per.setAge(25); 
  37.     per.printInfo(); 

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

程序结构

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

  1. #include  
  2.  
  3. class Person 
  4. private: 
  5.     char *name
  6.     int age; 
  7.     char *work
  8.  
  9. public
  10.     void SetName(char *name); 
  11.     int SetAge(int age;) 
  12.     void PrintInfo(void); 
  13.  
  14. void Person::SetName(char *name
  15.     this->name = name
  16.  
  17. void Person::SetAge(int age) 
  18.     this->age = age; 
  19.  
  20. void Person::PrintInfo(void) 
  21.     cout << "name = " << name << "age = " << age << endl; 

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

多文件

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

image-20210110120503456

 

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

  1. #include  
  2. #include "person.h" 
  3.  
  4. int main(int argc, char **argv) 
  5.     Person per; 
  6.  
  7.     //per.name = "zhangsan"
  8.     per.setName("zhangsan"); 
  9.     per.setAge(200); 
  10.     per.printInfo(); 
  11.  
  12.     return 0; 
  13. }   

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

  1. #ifndef __PERSON_H__ 
  2. #define __PERSON_H__ 
  3.  
  4. class Person { 
  5. private: 
  6.     char *name
  7.     int age; 
  8.     char *work
  9.  
  10. public
  11.     void setName(char *name); 
  12.     int setAge(int age); 
  13.     void printInfo(void); 
  14. }; 
  15.  
  16. #endif 

然后,在 person.cpp中定义了成员函数:

  1. #include  
  2. #include "person.h" 
  3.  
  4. void Person::setName(char *name
  5. {   
  6.     this->name = name
  7.  
  8. int Person::setAge(int age) 
  9.     if (age < 0 || age > 150) 
  10.     { 
  11.         this->age = 0; 
  12.         return -1; 
  13.     } 
  14.     this->age = age; 
  15.     return 0; 
  16.  
  17. void Person::printInfo(void) 
  18.     printf("name = %s, age = %d, work = %s\n"name, age, work);  

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

Makefile

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

  1. target ... :prerequisites 
  2. command 
  3. ... 
  4. ... 

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

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

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

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

  1. person: main.o person.o 
  2.     g++ -o $@ $^ 
  3.  
  4. %.o : %.cpp 
  5.     g++ -c -o $@ $< 
  6.  
  7. clean: 
  8.     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++ 不允许变量重名,但是对于函数来说,可以允许重载,只要函数的参数不同即可,这样就完成了函数的重载,直接来看一段关于函数重载的代码:

  1. #include  
  2.  
  3. using namespace std; 
  4.  
  5. int add(int a, int b) 
  6.     cout<<"add int+int"<
  7.     return a+b; 
  8.  
  9. int add(int a, int b, int c) 
  10.     cout<<"add int+int+int"<
  11.     return a+b+c; 
  12.  
  13. double add(double a, double b) 
  14.     cout<<"add double+double"<
  15.     return a+b; 
  16.  
  17. double add(int a, double b) 
  18.     cout<<"add int+double"<
  19.     return (double)a+b; 
  20.  
  21. double add(double b, int a) 
  22.     cout<<"add double+int"<
  23.     return (double)a+b; 
  24.  
  25.  
  26. int main(int argc, char **argv) 
  27.     add(1, 2); 
  28.     add(1, 2, 3); 
  29.     add(1.0, 2.0); 
  30.     add(1, 2.0); 
  31.     add(1.0, 2); 
  32.  
  33.     return 0; 

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

引用和指针

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

  1. #include  
  2.  
  3. using namespace std; 
  4.  
  5. int main(int argc,char **argv) 
  6.     int m; 
  7.     m = 10;  
  8.  
  9.     int &n = m; 
  10.  
  11.     int *p = &m; 
  12.     int *p1 = &n; 
  13.  
  14.     cout << "n =" << n << endl; 
  15.     cout << "p =" << p << endl; 
  16.     cout << "p1 =" << p1 << endl; 
  17.  
  18.     return 0;  
  19.  

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

image-20210112235421638

 

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

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

  1. #include  
  2.  
  3. using namespace std; 
  4.  
  5. int add_one(int a) 
  6.     a = a+1; 
  7.     return a; 
  8.  
  9. int add_one(int *a) 
  10.     *a = *a + 1; 
  11.     return *a; 
  12.  
  13. int add_one_ref(int &b) 
  14.     b = b+1; 
  15.     return b; 
  16.  
  17. int main(int argc, char **argv) 
  18.     int a = 99; 
  19.         int &c = a; 
  20.     cout<
  21.     cout<<"a = "<
  22.  
  23.     cout<
  24.     cout<<"a = "<
  25.  
  26.     cout<
  27.     cout<<"a = "<
  28.  
  29.         c++; 
  30.  
  31.     cout<<"a = "<
  32.     cout<<"c = "<
  33.  
  34.     return 0; 

 

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

image-20210113000240223

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

小结

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

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

提取码:j9hd

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

 

 

 

来源:wenzi嵌入式软件内容投诉

免责声明:

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题
  • 2024年上半年信息系统项目管理师第二批次真题及答案解析(完整版)

    难度     813人已做
    查看
  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看
  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看
  • 2024年上半年软考高项第一、二批次真题考点汇总(完整版)

    难度     435人已做
    查看
  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机
位置:首页-资讯-后端开发
咦!没有更多了?去看看其它编程学习网 内容吧
首页课程
资料下载
问答资讯