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

[[381911]]

前言

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

C++ 命名空间

命名空间的存在是为了区分不同库的相同的函数名，用一个简单的例子来说明这个问题就是在 windows的文件系统中，不同文件夹下可以有相同名字的文件，相同文件夹下因为这相同文件处在不同的范围内，用 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 << "**********************" << endl; 
    Point n2; 
    n2 = p2++; 
    n2.printfInfo(); 
} 

下面是代码的运行结果：

通过运行结果可以知道，我们实现了前 ++和 后++的效果。

小结

上述便是本次教程分享的内容，其中提到了运算符重载这一知识点还包含很多的应用，本次只是简单地用一个例子进行了介绍，下期教程将详细介绍运算符重载地其他内容，本次的分享到这里就结束咯~

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