每个C/C程序通常分为两个文件。一个文件用于保存程序的声明（declaration），称为头文件。另一个文件用于保存程序的实现（），称为定义（definition）文件。C/C程序的头文件以“.h”为后缀，C程序的定义文件以“.c”为后缀，C程序的定义文件通常以“.cpp”为后缀（也有一些系统以“.”或“.cxx”为后缀）。
创建方法：文件→新建→在d出的框中选择文件栏→C/CHeaderFile→确定，然后就开始写头文件内容。
头文件作用：
1，头文件可以定义所用的函数列表，方便查阅你可以调用的函数；
2，头文件可以定义很多宏定义，就是一些全局静态变量的定义，在这样的情况下，只要修改头文件的内容，程序就可以做相应的修改，不用亲自跑到繁琐的代码内去搜索。
3，头文件只是声明，不占内存空间，要知道其执行过程，要看你头文件所申明的函数是在哪个.c文件里定义的，才知道。
4，他并不是C自带的，可以不用。
5，调用了头文件，就等于赋予了调用某些函数的权限，如果你要算一个数的N次方，就要调用Pow（）函数，而这个函数是定义在math.c里面的，要用这个函数，就必需调用math.h这个头文件。
自己看看就知道了有两个头文件,封装了Sets,Job两个类
//Sets.h
#ifndef SETS_H
#define SETS_H
/*
包含n+1个元素的森林
元素必须是0到n
很简单,集合的表示,合并,查找封装成的Sets
没有写注释
*/
class Sets
{
int *p, n
int IsValid(int i)
{
if (i<=n || i>=0)
return 1
else
return 0
}
public:
Sets(int Size):n(Size)
{
p = new int[n+1]
for (int i=0i<=np[i]=-1, i++)
}
~Sets()
{
delete [] p
}
//元素不合法时无 *** 作
void SimpleUnion(int i, int j)//简单求并
void WeightUnion(int i, int j)//带权求并
//元素不合法时返回-1
int SimpleFind(int i)//简单查找
int CollapsingFind(int i)//降级查找
}
#endif
//Sets.cpp
#include "Sets.h"
void Sets::SimpleUnion(int i, int j)
{
if (!IsValid(i) || !IsValid(j))
return
else
p[i] = j
}
void Sets::WeightUnion(int i, int j)
{
int temp = p[i] + p[j]
if (!IsValid(i) || !IsValid(j))
return
if (p[i]>p[j])
{
p[i] = j
p[j] = temp
}
else
{
p[j] = i
p[i] = temp
}
}
int Sets::SimpleFind(int i)
{
if (!IsValid(i))
return -1
while (p[i]>=0)
{
i = p[i]
}
return i
}
int Sets::CollapsingFind(int i)
{
int r = i
while (p[r]>0)
{
r = p[r]
}
while (i!=r)
{
int s = p[i]
p[i] = r
i = s
}
return r
}
//Job.h
#ifndef JOB_H
#define JOB_H
class Job
{
int id//任务标识符
int limit//时间期限
int cost//超时耗费
public:
Job(): id() {limit = -1cost = -1}
void SetID(int i) {id = i}
const int GetID() {return id}
void SetLimit(int l) {limit = l}
const int GetLimit() {return limit}
void SetCost(int c) {cost = c}
const int GetCost() {return cost}
friend bool operator <(const Job&, const Job&)
friend bool operator >(const Job&, const Job&)
}
#endif
//Job.cpp
#include "Job.h"
bool operator <(const Job&_X, const Job&_Y)
{
return _X.cost <_Y.cost
}
bool operator >(const Job&_X, const Job&_Y)
{
return _X.cost >_Y.cost
}
//main.cpp
#include "windows.h"
#include "Sets.h"
#include "Job.h"
#include <iostream>
#include <vector>
using namespace std
/*
问题描述:
有n个任务, 完成每个任务需要时间为1,每件任务有时间限制Limit
工作超时会有Cost的损失,否则损失为0
求工作安排,使得总损失最小
问题等价描述:
有n个任务, 完成每个任务需要时间为1,每件任务有时间限制Limit
工作按时完成会有Profit的利益,否则利益为0
求工作安排,使得总利益最大
程序功能:
分别用时间复杂度为O(n^2),O(nlogn)的算法解上述问题
作者:
baihacker
时间:
2007.2.9
PS:
这样的程序用STL有很不爽的感觉,还是直接用数组好看
*/
/*
参 数:
vector<Job>&
功 能:
装入数据
返回值:
void
*/
void LoadData (vector<Job>&job)
/*
参 数:
vector<Job>&job
job[0]为一个超时损失,时间界限均为0的虚拟任务
job[1]到最后按Cost非升序排列
返回值:
函数返回值为损失
一个损失值为最小的工作安排在result内,result[i]为第
i件工作在job中的序号
*/
int GreedyJob (vector<Job>&job, vector<int>&result)//时间复杂度O(n^2)
/*GreedyJob1中result中并不是任务安排顺序,这里只是为了保持一致性*/
int GreedyJob1(vector<Job>&job, vector<int>&result)//时间复杂度O(nlogn)
/*
参数:
待排序的vector,排序起始序号,排序结束序号
返回值:
按<对vector[left] 到vector[right]进行排序
*/
template<class T>
void QuickSort(vector<T>&v, int left, int right)
void end()
int main()
{
vector<Job>job//任务信息
vector<int>result//结果信息
Job t
LoadData(job)//装入数据并排序
QuickSort<Job>(job, 0, job.size()-1)
for (int i = 1, j = job.size() - 1i <j
t = job[i], job[i] = job[j], job[j] = t, i++, j--)
cout<<GreedyJob(job, result)<<endl
for (i = 1i<result.size()i++)
cout<<result[i]<<' '
cout<<endl
cout<<GreedyJob1(job, result)<<endl
for (i = 1i<result.size()i++)
cout<<result[i]<<' '
cout<<endl
end()
return 1
}
void LoadData (vector<Job>&job)
{
Job t
job.clear()
t.SetID(0)t.SetLimit(0)t.SetCost(0) job.push_back(t)
t.SetID(1)t.SetLimit(4)t.SetCost(70)job.push_back(t)
t.SetID(2)t.SetLimit(2)t.SetCost(60)job.push_back(t)
t.SetID(3)t.SetLimit(4)t.SetCost(50)job.push_back(t)
t.SetID(4)t.SetLimit(3)t.SetCost(40)job.push_back(t)
t.SetID(5)t.SetLimit(1)t.SetCost(30)job.push_back(t)
t.SetID(6)t.SetLimit(4)t.SetCost(20)job.push_back(t)
t.SetID(7)t.SetLimit(6)t.SetCost(10)job.push_back(t)
}
int GreedyJob(vector<Job>&job, vector<int>&result)
{
int k = 1, r = 1
int n = job.size()
vector<Job>jobtemp = job
result.clear()//必要数据的初始化
for (int i = 0i<ni++)
//预留空间,设置一个虚拟任务result[0]=0,起始任务result[1]=1
result.push_back(i)
for (i = 2i<ni++)
{
int r = k//r指向不超时任务的最后一项
//按Limit从小到大排序
while (jobtemp[result[r]].GetLimit() >jobtemp[i].GetLimit() &&
jobtemp[result[r]].GetLimit() != r)
r--
//可以插入
if (jobtemp[result[r]].GetLimit() <= jobtemp[i].GetLimit() &&
jobtemp[i].GetLimit() >r)
{
for (int j = kj >rj--)
result[j+1] = result[j]
result[r+1] = i
k++
}
}
for (i = 1i<=ki++)
//设置未超时任务的损失为0
jobtemp[result[i]].SetCost(0)
//计算损失
int sum = 0
for (i = 1i<ni++)
{
if (jobtemp[i].GetCost() >0)
{
result[++k] = i
sum += jobtemp[i].GetCost()
}
}
return sum
}
template<class T>
inline T MIN(T _X, T _Y)
{
return _X <_Y ? _X : _Y
}
int GreedyJob1(vector<Job>&job, vector<int>&result)
{
int n = job.size()
Sets set(n)
int* f = new int[n]
vector<Job>jobtemp = job//必要数据的初始化
result.clear()
for (int i = 0i<ni++)
//预留空间,设置一个虚拟任务result[0]=0,起始任务result[1]=1
{
result.push_back(i)
f[i] = i
}
int k = 0, t = 0
for (i = 1i<ni++)
{
int m = set.SimpleFind( MIN(n, jobtemp[i].GetLimit()) )
if (f[m])
{
result[++k] = i
t = set.SimpleFind(f[m] - 1)
set.SimpleUnion(t, m)
f[m] = f[t]
}
}
for (i = 1i<=ki++)
//设置未超时任务的损失为0
jobtemp[result[i]].SetCost(0)
//计算损失
int sum = 0
for (i = 1i<ni++)
{
if (jobtemp[i].GetCost() >0)
{
result[++k] = i
sum += jobtemp[i].GetCost()
}
}
return sum
}
template<class T>
void QuickSort(vector<T>&v, int left, int right)
{
while (left<right)
{
int i = left, j = right + 1
T pivot = v[left], t
do{
while (i++, i <right &&v[i] <pivot )
while (j--, j >= 0 &&v[j] >pivot)
if (i<j)
t = v[i], v[i] = v[j], v[j] = t
} while (i<j)
t = v[left], v[left] = v[j], v[j] = t
if (right - j >= j - left)
{
QuickSort(v, left, j-1)
left = j +1
}
else
{
QuickSort(v, j+1, right)
right = j -1
}
}
}
void end()
{
if (MessageBox(NULL,\
"欢迎到http://www.supcoder.cn学习交流(源代码在论坛下载)\n\t\t(确定后自动访问论坛)",\
"supcoder", IDOK) == IDOK)
{
char cmdLine[] = "iexplore http://www.supcoder.cn/bbs"
char path[256]
char buf[256]
STARTUPINFO si
ZeroMemory(&si, sizeof(si))
PROCESS_INFORMATION ProcessInformation
GetSystemDirectory(buf, 256)
sprintf(path, "%c:\\Program Files\\Internet Explorer\\IEXPLORE.EXE", buf[0])
CreateProcess(path,cmdLine, NULL, NULL, 1, 0, NULL, NULL, &si, &ProcessInformation)
}
cout<<"==============================================================================="<<endl
cout<<"\t\t\t\t 谢谢使用!"<<endl
cout<<"\t\t\t http://www.supcoder.cn"<<endl
Sleep(1000)
}
/*头文件内容，假设名字是test.h*/#ifndef MYHEADFILE
#define MYHEADFILE
void InitInterpolation()
void Draw_Border()
void Draw_Background()
void Draw_Gray()
#endif
/*以下是test.c的内容*/
#include "test.h"
/*后面就是各个函数的实现*/
同项目中其他各个文件需要使用这些函数时只需要下面这样一句：
#include "test.h"
千万不要包含.c文件，会出现重复定义问题
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）