电子工程师技术服务社区
公告
登录
|
注册
首页
技术问答
厂商活动
正点原子
板卡试用
资源库
下载
文章
社区首页
文章
适合具备 C 语言基础的 C++ 入门教程(一)持续连载ing
分 享
扫描二维码分享
适合具备 C 语言基础的 C++ 入门教程(一)持续连载ing
C++
wenzi 嵌入式软件
关注
发布时间: 2021-02-08
丨
阅读: 535
# 引言 C 语言通常被认为是一种面向过程的语言,因为其本身的特性更容易编写面向过程的代码,当然也不排除使用 C 语言编写面向过程的代码,比如 Linux 的源代码以及现在很火的国产物联网操作系统 RT-Thread,其内核的实现方式都是使用 C 语言实现的面向对象的代码。相比于 C 语言来说,C++ 更能够实现面向对象的程序设计,其具有的特性也要比 C 语言要多的多。下面假设有这样一个需求。 > 现要描述两个人的信息,姓名,职业,年龄,并输出。 我们首先先使用 C 语言的设计思路实现这个功能。 ## C语言描述 如果使用 C 语言来描述上面这个问题,大部分都会想到使用结构体来完成这个要求,写出的程序也就如下所示: ```c #include
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 语言了解的更多一点的人在写这段程序的时候,会使用函数指针的方式将代码写的更加巧妙,代码如下所示: ```c #include
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++ 的特性了,上述代码中在执行函数时都传入了参数,那要如何做才能将上述中的参数也省略去呢,且看如下的代码: ```c++ #include
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 之后,我们就可以这样书写代码: ```c++ #include
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++ 数据访问控制 但是为了能够改变类里地数据,但是又要使得这个改变不要越界,避免胡乱地改变,我们可以这样来定义这个类: ```c++ #include
#include
class Person { private: char *name; int age; char *work; public: void PrintInfo(void) { cout << "name is:" << name << "age = "<< age << "work is:"<< work <
#include
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 <
150) { age = 0; return 0; } age = a; } }; ``` 这样定义了类之后,就可以访问私有成员了,比如下面这样进行: ```c++ 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` 呢,比如成员函数是像下面这样子编写的。 ```c++ 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 指针之后的代码如下所示: ```c++ #include
#include
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 指针,通过上述代码也可以非常清楚它的意思,就是代表当前实例化的对象,能够指向当前实例化对象的成员。 ## 程序结构 上述代码中,成员函数是在类里面实现的,这样使得整个类看着十分的臃肿,我们可以按照如下的方式进行书写: ```c++ #include
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](https://i.loli.net/2021/01/10/92MsewzJF7kfYpl.png) 其中 `main.cpp`文件中的内容如下所示: ```c++ #include
#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`文件的内容如下: ```c++ #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`中定义了成员函数: ```c++ #include
#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`的规则核心就如下所示: ```makefile target ... :prerequisites command ... ... ``` target也就是一个目标文件,可以是Object File,也可以是执行文件。还可以是一个标签 prerequisites就是要生成那个target所需要的文件或者是目标 command就是make所要执行的命令(任意的Shell) 说了核心的东西,来看我们当前所编写的 `Makefile`文件,`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++ 不允许变量重名,但是对于函数来说,可以允许重载,只要函数的参数不同即可,这样就完成了函数的重载,直接来看一段关于函数重载的代码: ```c++ #include
using namespace std; int add(int a, int b) { cout<<"add int+int"<
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](https://i.loli.net/2021/01/12/5MbgB9YCusIEheT.png) 可以看到代码中虽然是对 m 进行了赋值,但是在输出 n 的时候,输出的是 m 的值,也就是说在这里对于 n 的操作是完全等同于 m 的,紧接着,我们来证实 n 是否是 m 的别名,那么我们就来看 n 和 m 的地址,可以看到我们输出的两个变量的地址也是完全一致的,这也就证实了我们的说法。 接下来,看一段指针,引用,常规形参的一段代码,代码如下所示: ```c++ #include
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<
本小节所涉及的代码可以通过百度云链接的方式获取:链接:https://pan.baidu.com/s/1RWPXiqiFCVApcfTdaHyDgw 提取码:j9hd
原创作品,未经权利人授权禁止转载。详情见
转载须知
。
举报文章
点赞
(
0
)
wenzi 嵌入式软件
关注
评论
(0)
登录后可评论,请
登录
或
注册
相关文章推荐
MK-米客方德推出工业级存储卡
Beetle ESP32 C3 蓝牙数据收发
Beetle ESP32 C3 wifi联网获取实时天气信息
开箱测评Beetle ESP32-C3 (RISC-V芯片)模块
正点原子数控电源DP100测评
DP100试用评测-----开箱+初体验
Beetle ESP32 C3环境搭建
【花雕体验】16 使用Beetle ESP32 C3控制8X32位WS2812硬屏之二
X
你的打赏是对原创作者最大的认可
请选择打赏IC币的数量,一经提交无法退回 !
100IC币
500IC币
1000IC币
自定义
IC币
确定
X
提交成功 ! 谢谢您的支持
返回
我要举报该内容理由
×
广告及垃圾信息
抄袭或未经授权
其它举报理由
请输入您举报的理由(50字以内)
取消
提交