命名空间和模块化编程2，重点有实例和C++预处理器

创建实现文件

回到Rational这个例子，来进一步实现模块化编程。

- rational.h头文件包含Rational类的声明，但不包含这个类的实现代码。

- 这种分割可能刚开始接触的朋友觉得有点奇怪，但在视线中非常普遍。

- 因为把接口（函数的原型）和实现（函数体的定义）分开是对代码进行模块化的基本原则之一。

头文件的重要性不仅体现在可以告诉编译器某个类、结构或函数竟有着怎样的行为，还体现在它们可以把这些消息告诉程序员。

作为程序员，你只需看到函数的声明就可以了解到你需要知道的一切：函数的名字，它的返回值类型和它的输入参数的类型和数量。

知道了这些东西，你就可以使用那个函数了，而根本用不着关心塔到底是如何工作的。

编译器就不同了，它必须读取某个类或函数的实现代码。

现在我们就演示下rational这个程序如何分开和拼凑成一个完整的程序。

头文件

//Rational.h
//Create by 孙浩天

//这个头文件声明了有理数类(Rational class)
//类里对四则运算进行重载，以实现分数运算

#include <iostream>

class Rational
{
public:
	Rational(int num, int denom);  //num表示分子，denom表示分母

	Rational operator+(Rational rhs); //rhs = right hand side表示重载右边的参数
	Rational operator-(Rational rhs);
	Rational operator*(Rational rhs);
	Rational operator/(Rational rhs);

	void print();

private:
	void normalize(); //负责对分数的简化处理

	int numerator;    //分子
	int denominator;  //分母

	friend std::ostream& operator<<(std::ostream& os, Rational f);
};

rational.cpp

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

Rational::Rational(int num, int denom)
{
	numerator = num;
	denominator = denom;

	normalize();
}

//normalize()对分数进行简化操作包括：
//1. 只允许分子为负数，如果分母为负数则把负数挪到分子部分，如1/-2 == -1/2
//2. 利用欧几里得算法（辗转求余原理）将分数进行简化，如2/10 => 1/5
void Rational::normalize()
{
	//确保分母为正
	if (denominator < 0)
	{
		numerator = -numerator;
		denominator = -denominator;
	}

	//欧几里得算法
	int a = abs(numerator);
	int b = abs(denominator);

	//求出最大公约数
	while (b > 0)
	{
		int t = a % b;
		a = b;
		b = t;
	}

	//分子、分母分别除以最大公约数得到最简化分数
	numerator /= a;
	denominator /= a;
}

Rational Rational::operator+(Rational rhs)
{
	int a = numerator;
	int b = denominator;
	int c = rhs.numerator;
	int d = rhs.denominator;

	int e = a * d + b * c;
	int f = b * d;

	return Rational(e, f);
}

Rational Rational::operator-(Rational rhs)
{
	rhs.numerator = -rhs.numerator;
	return operator+(rhs);
}

Rational Rational::operator*(Rational rhs)
{
	int a = numerator;
	int b = denominator;
	int c = rhs.numerator;
	int d = rhs.denominator;

	int e = numerator * rhs.numerator;
	int f = denominator * rhs.denominator;

	return Rational(e, f);
}

Rational Rational::operator/(Rational rhs)
{
	int t = rhs.numerator;
	rhs.numerator = rhs.denominator;
	rhs.denominator = t;

	return operator*(rhs);
}

void Rational::print()
{
	if (numerator % denominator == 0)
	{
		std::cout << numerator / denominator;
	}
	else
	{
		std::cout << numerator << "/" << denominator;
	}
}

main.cpp

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


int main()
{
	Rational f1(2, 16);
	Rational f2(7, 8);

	//测试有理数加法运算
	Rational res = f1 + f2;
	f1.print();
	std::cout << " + ";
	f2.print();
	std::cout << " = ";
	res.print();
	std::cout << std::endl;

	//测试有理数减法运算
	res = f1 - f2;
	f1.print();
	std::cout << " - ";
	f2.print();
	std::cout << " = ";
	res.print();
	std::cout << std::endl;

	//测试有理数乘法运算
	res = f1 * f2;
	f1.print();
	std::cout << " * ";
	f2.print();
	std::cout << " = ";
	res.print();
	std::cout << std::endl;

	//测试有理数除法运算
	res = f1 * f2;
	f1.print();
	std::cout << " / ";
	f2.print();
	std::cout << " = ";
	res.print();
	std::cout << std::endl;

	return 0;
}

刚才的示例程序还有一个小小的问题需要解决，就是ration.cpp和main.cpp文件都包含了rational.h头文件。

这意味着rational.h类被声明了两次，这显然没有必要（如果它是一个结构，声明两次还将导致编译器报错呢）。

解决方案之一是把其中一个文件里的#include删掉即可，但却会给今后留下麻烦。

C++预处理器

利用C++预处理器，我们可以让头文件只在这给类还没有被声明的情况下才生命它。

预处理器的条件指令

指令	说明
#if	如果表达式为真，执行代码
#else	如果前面的#if表达式为假，执行代码
#elif	相当于“elseif”
#endif	用来标志一个条件指令的结束
#ifdef	如果本指令所引用的定义已存在，执行代码
#ifndef	如果本指令所引用的定义不存在，执行代码

以前的课程中，我们曾建议大家在注释很多段代码的话用预处理的方式，比用/* */要效果好。

#if 0
      这里都是代码
      这也是
      全都是
#endif

#if 0,0为假，就永远不会执行。

再来个例子：

#ifndef LOVE_FISHC
#define LOVE_FISHC
#endif

这段代码的含义是：如果LOVE_FISHC还没有定义则定义它。

看下面这个：

#ifndef LOVE_FISHC
#define LOVE_FISHC
class Rational{...};
#endif

如果LOVE_FISHC还没有定义，这里将发生两件事：定义一次LOVE_FISHC，然后对Rational类做出声明等操作。

这样一来，即使包含了这段代码的文件在某个项目里被导入了100次，Rational类也只会被声明一次，因为在第一次之后LOVE_FISHC就有定义。

作为一种固定模式，这里使用的常量名通常与相应的文件名保持一致，把据点替换为下划线。

于是，rational.h文件将对应RATIONAL_H。现在将上面的例子改写成：

头文件

//Rational.h
//Create by 孙浩天

//这个头文件声明了有理数类(Rational class)
//类里对四则运算进行重载，以实现分数运算

#ifndef RATIONAL_H
#define RATIONAL_H

#include <iostream>

class Rational
{
public:
	Rational(int num, int denom);  //num表示分子，denom表示分母

	Rational operator+(Rational rhs); //rhs = right hand side表示重载右边的参数
	Rational operator-(Rational rhs);
	Rational operator*(Rational rhs);
	Rational operator/(Rational rhs);

	void print();

private:
	void normalize(); //负责对分数的简化处理

	int numerator;    //分子
	int denominator;  //分母

	friend std::ostream& operator<<(std::ostream& os, Rational f);
};

#endif

rational.cpp和main.cpp不变