• 发文
  • 评论
  • 微博
  • 空间
  • 微信

适合具备 c 语言基础的 c 入门教程(一)-利来app官方下载

wenzi 嵌入式软件 2021-02-08 21:38 发文

引言

c 语言通常被认为是一种面向过程的语言,因为其本身的特性更容易编写面向过程的代码,当然也不排除使用 c 语言编写面向过程的代码,比如 linux 的源代码以及现在很火的国产物联网操作系统 rt-thread,其内核的实现方式都是使用 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:%sn",persons[i].name,persons[i].age,persons[i].work);
    }
}

上述这是比较初级的写法,如果对 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:%sn",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 

struct person
{
   char *name;
   int age;
   char *work;

   void prinfinfo(void)
   {
        printf("the people's name is:%s,age is:%d,work is:%sn",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 

class person
{
public:
   char * name;
   int age;
   char * work;

   void printinfo(void)
   {
       printf("the people's name is:%s,age is:%d,work is:%sn",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

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

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

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

#include 
#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 <    }

   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;
}    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 
#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 指针,通过上述代码也可以非常清楚它的意思,就是代表当前实例化的对象,能够指向当前实例化对象的成员。

程序结构

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

#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

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

#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文件的内容如下:

#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 
#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 = %sn", 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 [email protected] $^

%.o : %.cpp
   g -c -o [email protected] $<

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 

using namespace std;

int add(int a, int b)
{
   cout<<"add int int"<    return a b;
}

int add(int a, int b, int c)
{
   cout<<"add int int int"<    return a b c;
}

double add(double a, double b)
{
   cout<<"add double double"<    return a b;
}

double add(int a, double b)
{
   cout<<"add int double"<    return (double)a b;
}

double add(double b, int a)
{
   cout<<"add double int"<    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 

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 

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<    cout<<"a = "<
   cout<    cout<<"a = "<
   cout<    cout<<"a = "<
       c ;

   cout<<"a = "<    cout<<"c = "<
   return 0;
}

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

image-20210113000240223

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

小结

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

声明:本文为ofweek维科号作者发布,不代表ofweek维科号立场。如有侵权或其他问题,请及时联系利来国际下载举报。
2
评论
评论

相关阅读

暂无数据

wenzi 嵌入式软件

分享在嵌入式学习方面的心得,涉及...

热门文章排行榜
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

举报文章问题

×
  • 营销广告
  • 重复、旧闻
  • 格式问题
  • 低俗
  • 标题夸张
  • 与事实不符
  • 疑似抄袭
  • 我有话要说
确定 取消

举报评论问题

×
  • 淫秽色情
  • 营销广告
  • 恶意攻击谩骂
  • 我要吐槽
确定 取消

用户登录×