命名空间和模块化编程——C++（40、41、42）

命名空间和模块化编程

模块化编程

模块化：把程序划分成多个组成部分（即所谓的模块）。这是通过把程序代码分散到多个文件里，等编译程序时再把那些文件重新组合在一起实现的。

头文件

• 一般情况下都应该把自定义的头文件和其余的程序文件放在同一个子目录里，或者在主程序目录下专门创建一个子文件夹来集中存放它们。

• 同文件应该只包含最必要的代码，比如纸声明一个类或一组彼此相关的函数。

• 在C++中导入头文件格式：

    #include"abc.h"
  

• 如果头文件与主程序文件在同一个子目录下，则可以这么写

    #include "./fishc.h"
    #include ".\\fishc.h"
    ./  表示的是当前目录（linux）
    .\  表示的也是当前目录（Windows）
    但是在编译器里面，\表示是转义字符，所以要表达 "\",需要 \\
  

• 头文件在主程序文件上一级目录

    ..
    如：
    #include "..\\fishc.h"
  

• 头文件在上一级文件夹目录里的abc文件夹内

    include " ..\\abc\\fishc.h"
  

• 头文件所在的文件夹abc与主程序文件在同一目录下

    #include "abc\\fishc.h"
  

创建实现文件

• 头文件里面对类进行声明，实现文件里面对类进行实现

• 一次使用多个文件需要创建一个工程，再把这些文件添加进去，使用工程里的编译器将它们链接起来。

命名空间

• 命名空间其实就是由用户定义的范围，同一个命名空间里的东西只要在这个命名空间里具有独一无二的名字就行了。

• 例如：

    namespace author
    {
    	std::string person;
    }
    namespace programmer
    {
    	std::string person;
    }
  

  两者由于在不同的命名空间，所以并不会出现冲突。

• 命名空间的使用

    1.域作用符
    2.using namespace
    3.用using指令只把所需要的特定命名从命名空间里面提取到全局作用域。
    	- using std::cout;
    	- cout << "I am you.\n";
  

代码实现

• 文件夹存放
  

1/3 main.cpp

#include <iostream>
#include <cmath>
#include"rational.h"

using namespace std;



int main()
{
    Fenshu a(2,4),b(1,2),c;
    c=a+b;
    a.print();
    cout << "加上" << endl;
    b.print();
    cout << "的结果为：" << endl;
    c.print();

    a.print();
    cout << "减去" << endl;
    b.print();
    cout << "的结果为：" << endl;
    c=a-b;
    c.print();

    c=a*b;
    a.print();
    cout << "乘上" << endl;
    b.print();
    cout << "的结果为：" << endl;
    c.print();

    c=a/b;
    a.print();
    cout << "除去" << endl;
    b.print();
    cout << "的结果为：" << endl;
    c.print();




    return 0;
}

2/3 rational.cpp

#include <iostream>
#include <cmath>
#include "cpp.h"

using namespace std;

Fenshu::Fenshu()
{
    num=0;
    denum=0;
}
Fenshu::Fenshu(int num_in,int denum_in)
{
    num=num_in;
    denum=denum_in;
    normalize();
}
//normalize()对分数进行简化操作包括：
//1.只允许分子为负数，如果分母为负数则把负数挪到分子部分，如1/-2==-1/2
//2.利用欧几里德算法(辗转求余原理)将分数进行简化:2/10 => 1/5
void Fenshu::normalize()
{
    if(denum<0)
    {
        num=-num;
        denum=-denum;
    }
                    //用欧几里得算法求最大公约数：a
    int a=abs(num);
    int b=abs(denum);
    while(b>0)
    {
        int t=a%b;
        a=b;
        b=t;
    }
    num/=a;
    denum/=a;
}

Fenshu Fenshu::operator +(Fenshu &in)
{
    Fenshu temp;
    temp.num=num*in.denum+denum*in.num;
    temp.denum=in.denum*denum;
    return temp;
}
Fenshu Fenshu::operator -(Fenshu &in)
{
/*      num=-num;                 //法1：不好用：会改变num 的值，后面不好输出
    return operator +(in);*/
    Fenshu temp;
    temp.num=(-num)*in.denum+denum*in.num;
    temp.denum=in.denum*denum;
    return temp;    }
Fenshu Fenshu::operator *(Fenshu &in)
{
    Fenshu temp;
    temp.num=num*in.num;
    temp.denum=in.denum*denum;
    return temp;
}
Fenshu Fenshu::operator /(Fenshu &in)
{
    Fenshu temp;
    temp.num=num*in.denum;
    temp.denum=in.denum*num;
    return temp;
}
void Fenshu::print()
{
    normalize();

    if(num==0)                       //分子是0,结果就是0
    {
        cout << "0" << endl;
    }
    else if(denum==1)
    {
        cout << num << endl;
    }
    else

    cout << num << "/" << denum << endl;
}

3/3 rational.h

//Ration.h
//Create by la vie

//这个头文件用来声明有理数类(Rational class)
//类里面对四则运算进行重载，以实现分数运算
#ifndef RATIONAL_H
#define RATIONAL_H

#include "iostream"

class Fenshu
{
public:
    Fenshu();
    Fenshu(int num_in,int denum_in);
    void print();
    Fenshu operator +(Fenshu &in);
    Fenshu operator -(Fenshu &in);
    Fenshu operator *(Fenshu &in);
    Fenshu operator /(Fenshu &in);
private:
    int num;
    int denum;
    void normalize();
};

#endif // RATIONAL_H