C++实验（七）：多文件组织结构

淡淡的烟草味﹌ 2022-12-19 01:17 173阅读 0赞

### **实验目的** ###

1、学习将C++程序按照不同的模块分割在不同的文件中进行组织。

2、学习编译预处理命令在多文件工程中的使用。

### **实验内容** ###

编写好的程序文件按照不同的模块分割成不同的文件，添加合适的include语句和预编译命令，将其改造为一个多文件工程。具体要求如下。

相关实验中（参见本书前面的实验），实现了复数类的算术运算和输入/输出流的重载，但这些功能在主函数中的测试语句都是放在一个cpp文件里实现的。本实验中要求将这些代码分装在3个文件中，第一个文件complex.h包含Complax的类定义，第二个文件complex.cpp包含Complax类的函数实现，第三个文件test.cpp包含主函数和相关的测试程序。在适当的文件中添加合适include语句和预编译语句（ifndef-define-endif结构），使其成为一个能够正确运行的工程。

### **实验过程** ###

原代码主要实现复数的加减乘、数乘以及取共轭等功能，并重载了输入输出流。代码中将所有函数都定义成了成员函数，并使用了友元函数相关知识。

1.  使用库函数atof()将字符串转换为浮点型数据。
2.  由于需要判断输入是选择退出还是继续，所以用字符串来接收输入，判断是否为q或Q后将字符串转换为double型。

1.  **源代码**

#include<iostream>
    #include<math.h> //strlen函数头文件
    #include"string.h"
    #include<cstdlib>//atof函数头文件
    using namespace std;
     
    class comple{ //定义复数运算类
        private:
            double re;
            double im;
        public:
            comple(double r=0.0, double i=0.0); //带默认参数的构造函数
            ~comple(); //析构函数
            comple operator+(const comple & a) const; //重载运算符+，实现复数相加
            comple operator-(const comple & a) const; //重载运算符-，实现复数相减
            comple operator*(const comple & a) const; //重载运算符*，实现复数相乘
            comple operator~() const; //重载运算符~，求共轭复数
            comple operator*(const double x) const; //重载运算符*，实现复数的数乘
            friend ostream & operator<<(ostream & os, const comple & b); //重载输入流
            friend int operator>>(istream & is, comple & b); //重载输出流
            friend comple operator*(const double x, const comple & b);
            
    };
    
    comple::comple(double r, double i){
        re=r;
        im=i;
    }
    comple::~comple(){}
    
    comple comple::operator+(const comple & a) const{
        comple temp;
        temp.re=re+a.re;
        temp.im=im+a.im;
        return temp;
    }
    
    comple comple::operator-(const comple & a) const{
        comple temp;
        temp.re=re-a.re;
        temp.im=im-a.im;
        return temp;
    }
    
    comple comple::operator*(const comple & a) const{
        comple temp;
        temp.re=re*a.re-im*a.im;
        temp.im=re*a.im+im*a.re;
        return temp;
    }
    
    comple comple::operator~() const{
        comple temp;
        temp.re=re;
        temp.im=-im;
        return temp;
    }
    
    comple comple::operator*(const double x ) const{
        return comple(x*re,x*im);
    }
    
    ostream & operator<<(ostream & os, const comple & b){
        os << "(" <<b.re <<"," <<b.im << "i)";
        return os;    
    }
    
    int operator>>(istream & is, comple & b) {
        double c1,c2;
        char s[80],*str;
        int c,i;
        cout << "real:";
        is >> s;
        c=strlen(s);
        str=s;
        for(i=0;i<c;i++){
        	if(s[i]=='q'||s[i]=='Q') // 判断输入值是否为“Q”或“q”
        	return 0;
        }
        
        if((s[0]>'0')&&(s[0]<'9'))
        	c1=atof(str); //将字符串转换成浮点数
            
        cout << "imaginary:";
        is >> s;
        c=strlen(s);
        str=s;
        for(i=0;i<c;i++){ 
     		if(s[i]=='q'||s[i]=='Q') // 判断输入值是否为“Q”或“q”
       		return 0;
        }
    
        if(s[0]>'0'&&s[0]<'9')
        	c2=atof(str); //将字符串转换成浮点数
          
        b=comple(c1,c2);
        return 1;
    }
    
    comple operator*(double x, const comple & b) {
        return b*x;
    }
    
    int main(){
        comple a(3.0,4.0);
        comple c;
        
        cout << "Enter a complex number (q to quit):\n";
        while(cin >> c){
            cout << "c is " << c << endl;
            cout << "complex conjugate is " << ~c <<endl;
            cout << "a is " << a << endl;
            cout << "a+c is " << a+c << endl;
            cout << "a-c is " << a-c << endl;
            cout << "a*c is " << a*c << endl;
            cout << "2*c is " << 2*c << endl;
            cout << "Enter a complex number (q to quit):\n";
        }
        cout << "Done!\n";
        return 0;
    }

一个较多较复杂的源程序可以划分为多个部分，通常分为一个头文件和两个源代码文件。头文件中通常包含函数原型、用const或者\#define定义的符号常量、类声明、内联函数、结构体声明、模板声明等；第一个源代码文件包含与类、结构体、模板相关的函数代码；第二个源代码文件包含调用与类、结构体、模板相关的函数代码，用于测试运行程序。

本次实验中的代码可以分成三个文件，分别为类声明文件（comple.h文件）、类实现文件（comple.cpp文件）、类的使用文件（main().cpp文件）。将该代码使用多文件结构组织成为一个工程文件，如图所示。

![20201104235043709.png][]

复数运算多文件组织结构

将代码分为三个文件，各文件代码如下所示。

**1****、类声明文件 comple.h**

#ifndef  COMPLEX_H_ 
    #define  COMPLEX_H_
    
    #include<iostream>
    using namespace std;
     
    class comple{
         private:
            double re;
            double im;
        public:
            comple(double r=0.0, double i=0.0); //带默认参数的构造函数
            ~comple(); //析构函数
            comple operator+(const comple & a) const; //重载运算符+，实现复数相加
            comple operator-(const comple & a) const; //重载运算符-，实现复数相减
            comple operator*(const comple & a) const; //重载运算符*，实现复数相乘
            comple operator~() const; //重载运算符~，求共轭复数
            comple operator*(const double x) const; //重载运算符*，实现复数的数乘
            friend ostream & operator<<(ostream & os, const comple & b); //重载输入流
            friend int operator>>(istream & is, comple & b); //重载输出流
            friend comple operator*(const double x, const comple & b);
    };
    #endif

**2****、类实现文件 comple.cpp**

#include"comple.h"
    #include<iostream>
    #include<math.h> //strlen函数头文件
    #include"string.h"
    #include<cstdlib>//atof函数头文件
    using namespace std;
    
    comple::comple(double r, double i){
        re=r;
        im=i;
    }
    
    comple::~comple(){}
    
    comple comple::operator+(const comple & a) const{
        comple temp;
        temp.re=re+a.re;
        temp.im=im+a.im;
        return temp;
    }
    
    comple comple::operator-(const comple & a) const{
        comple temp;
        temp.re=re-a.re;
        temp.im=im-a.im;
        return temp;
    }
    
    comple comple::operator*(const comple & a) const{
        comple temp;
        temp.re=re*a.re-im*a.im;
        temp.im=re*a.im+im*a.re;
        return temp;
    }
    
    comple comple::operator~() const{
        comple temp;
        temp.re=re;
        temp.im=-im;
        return temp;
    }
    
    comple comple::operator*(const double x ) const{
        return comple(x*re,x*im);
    }
    
    ostream & operator<<(ostream & os, const comple & b){
        os << "(" <<b.re <<"," <<b.im << "i)";
        return os;    
    }
    
    int operator>>(istream & is, comple & b) {
        double c1,c2;
        char s[80],*str;
        int c,i;
        cout << "real:";
        is >> s;
        c=strlen(s);
        str=s;
        for(i=0;i<c;i++){
        	if(s[i]=='q'||s[i]=='Q') // 判断输入值是否为“Q”或“q”
        	return 0;
        }
        
        if((s[0]>'0')&&(s[0]<'9'))
        	c1=atof(str); //将字符串转换成浮点数
            
        cout << "imaginary:";
        is >> s;
        c=strlen(s);
        str=s;
        for(i=0;i<c;i++){ 
     		if(s[i]=='q'||s[i]=='Q') // 判断输入值是否为“Q”或“q”
       		return 0;
        }
    
        if(s[0]>'0'&&s[0]<'9')
        	c2=atof(str); //将字符串转换成浮点数
          
        b=comple(c1,c2);
        return 1;
    }
    
    comple operator*(double x, const comple & b) {
        return b*x;
    }

**3****、类的使用文件 main.cpp**

#include <iostream>
    #include"comple.h"
    
    using namespace std;
    
    int main(){
        comple a(3.0,4.0);
        comple c;
        
        cout << "Enter a complex number (q to quit):\n";
        while(cin >> c){
            cout << "c is " << c << endl;
            cout << "complex conjugate is " << ~c <<endl;
            cout << "a is " << a << endl;
            cout << "a+c is " << a+c << endl;
            cout << "a-c is " << a-c << endl;
            cout << "a*c is " << a*c << endl;
            cout << "2*c is " << 2*c << endl;
            cout << "Enter a complex number (q to quit):\n";
        }
        cout << "Done!\n";
        return 0;
    }

**实验总结**

这次实验主要学习C++的多文件组织结构，将一个复杂的程序分为不同的文件用一个工程组织起来。

使用的复数运算的源代码，参考之前的实验代码同时做了改动和注释。代码中重载输入输出流中使用友元函数、处理字符串使用strlen()函数和atof()函数、使用while循环使程序运行设置跳出条件的方法等知识之前学习较少，在本次实验中得以了解学习。

在使用多文件组织C++程序时，注意到几个知识点。

1、使用””和<>包含头文件的区别。包含在<>中，编译器首先查找标准库；包含在””中则首先查找当前工作目录。因此包含自定义头文件，使用””.

2、在头文件中使用\#ifndef(即if not define),\#define,\#endif防止头文件包含多次。意味着仅当前没有使用预处理器编译指令\#define定义名称XXX时，才处理\#ifndef和\#endif之间的语句。

学习C++的多文件组织结构，利用工程可以更方便地编写大型的项目，方便之后的学习和使用。

[20201104235043709.png]: /images/20221120/9e5bc2fca2224e8c86e32af180254ce0.png