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

前言

在上一则教程中,适合着重地阐述了构造函数以及析构函数的具备C教相关概念,这也是语言基C++中非常重要的两个概念之一。在今天的础的程教程中,笔者将继续叙述 C++相对于 C语言来说不同的适合点,将详细叙述命名空间,具备C教静态成员,语言基友元函数以及运算符重载这几个知识点。础的程

C++ 命名空间

命名空间的适合存在是为了区分不同库的相同的函数名,用一个简单的具备C教例子来说明这个问题就是在 windows的文件系统中,不同文件夹下可以有相同名字的语言基文件,相同文件夹下因为这相同文件处在不同的础的程范围内,用 C++ 说白了也就是适合处在不同的命名空间中。文件系统的具备C教一个结构图:

文件系统框图

定义命名空间

命名空间的服务器托管定义使用的是关键字 namespace,后跟命名空间的语言基名称,如下所示:

namespace namespace_name{      // 代码声明 } 

为了调用带有命名空间的函数或者变量,需要在前面加上命名空间的名称,如下所示:

name::code   // code 可以是变量或者是函数 

例子

下面通过一个例子来说明命名空间的概念,首先,我们具有两个类,一个是 Dog ,一个是 Person,而这个时候,有两个函数具有相同的名字,都要输出不同的信息,这个时候,就有必要使用到命名空间的概念。首先,我们在 dog.h 里面定义一个 dog 类,代码如下所示:

#ifndef __DOG_H__ #define __DOG_H__ namespace C{  class Dog{  private:     char *name;     int age; public:     void setName(char *name);     int setAge(int age);     void printInfo(void); }; void printVersion(void); } #endif 

然后,紧接着来看 dog.cpp 里面的内容。代码如下所示:

#include "dog.h" namespace C{      void Dog::setName(char *name)     {          this->name = name;     }     int Dog::setAge(int age)     {          if (age < 0 || age > 20)         {              this->age = 0;             return -1;         }         this->age = age;         return 0;     }     void Dog::printInfo(void)     {          printf("name = %s, age = %d\n",name,age);     }     void printersion(void)     {          printf("Dog v1");     } } 

OK ,香港云服务器看完了 Dog 的代码,我们紧接着来看 Person 的代码,代码如下所示:

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

紧接着就是 Person.cpp 的代码,具体的代码如下所示:

namespace A {  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);  } void printVersion(void) {      printf("Person v1\n"); } } 

上述就是 所定义的两个类,我们紧接着来看 main.cpp 的代码:

int main(int argc, char **argv) {      A::Person per;     per.setName("zhangsan");     per.setAge(16);     per.printInfo();     C::Dog dog;     dog.setName("wangcai");     dog.setAge(1);     dog.printInfo();     A::printVersion();     C::printVersion();     return 0 } 

在最后的倒数第二行和倒数第三行,我们可以看到如果这个时候,没有命名空间的存在,那么就完全不能够分辨 printVersion这个函数,加上了命名空间之后,就能够分辨出来了。

静态成员

在上述代码的基础上,我们在主函数定义了如何几个变量,代码如下所示:

#include <stdio.h> int main(int argc, char **argv) {      Person per1;     Person per2;     Person per3;     Person per4;     Person *per5 = new Person[10]; } 

那我们要如何知道我们定义几个 Person 对象呢,可以这样去做,我们创建一个 cnt变量,然后在每个构造函数执行的过程中让 cnt加一,代码如下所示:

#include <iostream> #include <string.h> #include <unistd.h> class Person {  private:     int cnt;     char *name;     int age;     char *work; public:     Person()     {          name = NULL;         work = NULL;         cnt++;     }     Person(char *name)     {          this->name = new char[strlen(name) + 1];         strcpy(this->name, name);         this->work = NULL;         cnt++;     }     Person(char *name, int age, char *work = "none")     {          this->name = new char[strlen(name) + 1];         strcpy(this->name, name);         this->work = new char[strlen(work) + 1];         strcpy(this->work, work);         cnt++;     }     ~Person()     {          if (this->name)         {              cout << "name is:" << name << endl;             delete this->name;         }         if (this->work)         {               cout << "work is:" << work << endl;             delete this->work;         }     } }; 

但是如果这么写的话存在一个问题,就是我们想要实现的高防服务器功能是看有几个实例化 Person 对象,那么这个计数量cnt应该是属于 Person类的,具体的关系如下图所示:

但是上述的代码中,cnt是属于 Person的实例化对象的,那要如何做才能使得 cnt属于 Person类的实例化对象呢,这个时候,我们需要将 cnt定义为 static类的,这样子,cnt就是属于 Person类的了,定义的代码如下所示:

class Person {  private:     char *name;     int age;     char *work;     static int cnt; }; 

那么我们要如何得到 cnt 的值呢,可以编写一个函数,但是同样的,我们编写的函数要是属于整个 Person类的,那应该如何去做呢,同样的办法,我们在前面加上 static,代码如下所示:

#include <stdio.h> #include <iostream> class Person {  private:     char *name;     int age;     char *work;     static int cnt; public:     static int getcount(void)     {          return cnt;     } }; 

有了 getcount函数,我们就可以调用它,然后将其打印出来,方法如下所示:

#include <iostream> int main(int argc, char *argv) {      Person per1;     Person per2;     Person *per5 = new Person[10];     count << "person number = " << Person:getcount() << endl; } 

最后,还存在一个问题,因为我们在 cnt上加了 static,那么当前的 cnt就是属于 Person类的,这样一来,那么就是说 cnt的值还没有分配空间,那么要如何分配空间呢,我们需要在主函数开始之前对 cnt进行定义和初始化,代码如下所示:

int Person::cnt = 0;     /* 定义*/ 

这样的话,就可以知道 cnt的值了,下面是运行的结果:

这样,就知道了 Person 类的实例化次数。那为什么要把 int Person::cnt = 0放在 main函数的最开始呢,这是因为要在 main所有实例化对象定义之前就要将其初始化完成。

友元函数

首先,我们有这样一个需求,需要实现两个类的相加,下面是写出来的代码:

#include <iostream> #include <string.h> #include <unistd.h> using namespace std; class Point {  private:     int x;     int y; public:     Point(){ }     Point(int x, int y) : x(x), y(y) { }     void setX(int x)     {          this->x = x;     }     void setY(int y)     {          this->y = y;     }     int getX(void)     {          return x;     }     int getY(void)     {          return y;     } }; Point add(Point &p1, Point &p2) {      Point n;     n.setX(p1.getX() + p2.getX());     n.setY(p1.getY() + p2.getY());      return n; } int main(int argc, char **argv) {      Point p1(1, 2);     Point p2(2, 4);     Point result = add(p1,p2);     cout << "the result is:" << "(" << result.getX() << "," << result.getY() << ")"<< endl;     return 0; } 

上述代码中存在一个缺点就是说,我们在进行 add()函数编写的时候,用到了两次 getX()和 getY(),这样就显得代码看起来十分的臃肿,所以也就有了如下的更改方式,我们可以将 Point add(Point &p1, Point &p2)函数设置成友元,那么在这样的基础上,就可以直接访问到 p1和 p2里面的成员,换句通俗的话来将,就是说,我把你当做朋友,你就获得了一些权限,更改的代码如下所示:

class Point {  private:     int x;     int y; public:   Point(){ }   Point(int x, int y) : x(x),y(y){ }   friend Point add(Point &p1, Point &p2);   }; Point add(Point &p1, Point &p2) {      Point n;     n.x = p1.x + p2.x;     n.y = p2.x + p2.y;     return n; } 

声明成友元之后,在函数里就可以访问到类里面的私有数据成员,大大简化了代码量。

运算符重载

上述介绍友元的时候,我们将两个实例化的对象进行相加,使用的是 C 语言的思路,但是对于 C++来说,其具备运算符重载的特性,也就是能够重载一个+号运算符用于类的相加。为了展开这个知识点,依旧先从之前学习 C语言时的角度去看这个问题,我们之前学习 C语言的时候,我们会接触到这样一个概念,就是++p 和 p++,比如有如下所示的代码:

int a = 1; int b; b = ++a; 

上述代码的意思分解一下是这样子的:

int a = 1; int b; a = a + 1; b = a; 

这样一来,b的结果就是 2。但是如果像下面这样子的代码:

int a = 1; int b; b = a++; 

上面的代码分解一下,就是下面这样子的:

int a = 1; int b; b = a; a = a++; 

这样子,运行后 b的结果是 1。

现在我们要来实现这个前 ++和后 ++的运算符重载,实现类里面成员的++,继续沿用上述的代码,基于 Point类,我们来编写重载的函数,代码如下所示:

Point operator++(Point &p) /* 引用节省内存 */ {      p.x = p.x + 1;     p.y = p.y + 1;     return p; } 

前 ++和后 ++的运算符一致,然而在重载函数中,是通过形参的不同来进行重载函数的,因此,我们在编写后 ++的重载函数的时候,需要新增一个参数,比如下面的代码:

Point operator++(Point &p, int a) {      Point n;     n = p;     p.x = p.x + 1;     p.y = p.y + 1;     return n; } 

上述的重载函数,因为都操作了类里面的私有数据成员,因此,必须将其声明为友元。下面是代码实现:

class Point {  private:     int x;     int y; public:   Point(){ }   Point(int x, int y) : x(x), y(y){ }   friend Point operator++(Point &p);   friend Point operator++(Point &p, int a);   void printfInfo(void)   {        cout << "(" << x << "," << y << ")" << endl;   } }; 

需要注意的一点是,上述的形参里面使用的是 p的引用,为什么要使用引用是因为引用传入的是地址,占四个字节的大小,但是如果传入的不是引用,那么就要占用整个类那么大的大小。这样做也就节省了存储空间。

紧接着,我们来编写主函数的代码:

int main(int argc, char **argv) {      Point p1(1, 2);     Point p2(3, 4);     Point n;     n = ++p1;     n.printfInfo();     cout << "
滇ICP备2023000592号-31