小甲鱼-C++快速入门笔记(41)之命名空间和模块化编程2

使用头文件

在创建了头文件之后，只要把它的文件名用双引号括起来写在如下所示的指令里就可以导入它：

#include “fishc.h”

注意：自定义的头文件用双引号括起来，系统定义的头文件用<>。

如果没有给出路径名，编译器将到当前子目录以及当前开发环境中的其他逻辑子目录里去寻找头文件。为了消除这种猜测，在导入自己的头文件时可以使用相对路径。如果头文件与主程序文件在同一个子目录里，则可以这么写：

#include “./fishc.h”

// fishc.h
// Create by 小甲鱼
// 2012-09-05

// 演示用途

void call_love_fishc();

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

using namespace std;

int main()
{
	call_love_fishc();

	return 0;
}

void call_love_fishc()
{
	int i, j;
	int n = 10;

	for(i=1-(n>>1); i<=n; i++)
	{
		cout << "I love FISHC.com";

		if(i >= 0)
		{
			for(j=0; j<i; j++)
				cout << " ";
			for(j=1; j<=2*(n-i)+1; j++)
				cout << " *";
			cout << endl;
		}
		else
		{
			for(j=i; j<0; j++)
				cout << " ";
			for(j=1; j<=n+2+i+1; j++)
				cout << " *";
			for(j=1; j<=-1-2*i; j++)
				cout << " ";
			for(j=1; j<=n+2+i+1; j++)
				cout << " *";
			cout << endl;
		}
	}
}

创建实现文件

以重载有理数运算例子:

头文件:

#include <iostream>
#include <string>
#include <cmath>

using namespace std;

#ifndef _ONCE_
#define _ONCE_

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; //分母
};
#endif

 函数定义cpp

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

using namespace std;

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 = a*c;
	int f = b*d;

	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)
		cout << numerator / denominator;
	else
		cout << numerator << "/" << denominator;
	
}

主函数:

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

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

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

	// 测试有理数的减法运算
	Rational sub = f1 - f2;
	f1.print();
	cout << " - ";
	f2.print();
	cout << " = ";
	sub.print();
	cout << endl;

	// 测试有理数的乘法运算
	Rational mul = f1 * f2;
	f1.print();
	cout << " * ";
	f2.print();
	cout << " = ";
	mul.print();
	cout << endl;

	// 测试有理数的加法运算
	Rational div = f1 / f2;
	f1.print();
	cout << " / ";
	f2.print();
	cout << " = ";
	div.print();
	cout << endl;

	return 0;
}

注意一个问题:

类定义时防止 'class' type redefinition

在类定义时，加入这三句，防止防止头文件被重复包含造成类被重复定义 
class定义前加
#ifndef _ONCE_  
#define _ONCE_ 
class定义的分号后加
#endif 

引用别人的话：
防止重复包含

防止头文件被重复包含造成类被重复定义 
---------------------------------------------------------------

#ifndef 后面的内容可以任意，但最好唯一，并且易读。

---------------------------------------------------------- 
#ifndef __SOMETHING_H__ 
#define __SOMETHING_H__

// 头文件中的声明

#endif 
----------------------------------------------------------

任何头文件都应该包含上面的内容，把真正的声明放在其中。 
这组宏叫做“守卫宏”，为的就是防止头文件被重复包含所导致的类型被重复定义。

C预处理器

利用c++预处理器,我们可以让头文件只在这个类还没被声明过的情况下才声明它。

预处理器的条件指令：

如上述的代码：

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

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

于是rational.h文件将对应RATIONAL_H

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