关于全局变量

 一个源程序有几个模块组成：

模块一：log.h, log.c    模块二：aaa.h, aaa,c    模块三：bbb.h, bbb.c

模块二和模块三都要用到模块一。但是模块一中又使用了一些全局变量，这些全局变量都定义在log.c中。显然，模块二和模块三会共享模块一中的全局变量。

可以写个小程序测试一下：

模块一：

log.h

#ifndef LOG_H
#define LOG_H

#include <stdio.h>

void fun();

#endif

log.c

#include "log.h"

int test = 0;

void fun()
{
	test++;
	printf("test--%d\n", test);	
}

 

模块二：

aaa.h

#ifndef AAA_H
#define AAA_H

#include "log.h"
void a_fun();

#endif

aaa.c

#include "aaa.h"

void a_fun()
{
	printf("aaa moudle:\n");
	fun();	
}

 

模块三：

bbb.h

#ifndef BBB_H
#define BBB_H

#include "log.h"
void b_fun();

#endif

bbb.c

#include "bbb.h"

void b_fun()
{
	printf("bbb moudle:\n");
	fun();	
}

源程序如下：

#include "aaa.h"
#include "bbb.h"

int main()
{
	a_fun();
	b_fun();
	a_fun();
	b_fun();
	
	return 0;	
}

执行结果：

[lgh@localhost gv]$ ./main
aaa moudle:
test--1
bbb moudle:
test--2
aaa moudle:
test--3
bbb moudle:
test--4
==============================

从结果可以看出，模块二和模块三是共享模块一中的全局变量，其实它也就是整个源程序的全局变量。

我要解决的问题是：怎样让模块二和模块三独占模块一中的全局变量，也就是，模块二和模块三在使用模块一中的全局变量时互不影响？

如果在头文件log.h中定义全局变量，编译不会出现问题，但是连接的时候会出现变量重定义的错误。在网上看到利用宏定义变相在头文件定义全局变量，但效果还是和前面描述的一样，不能解决我的问题。这种变相定义全局变量，方法如下：只是改下了log.h和log.c

log.h

#ifndef LOG_H
#define LOG_H

#include <stdio.h>

#ifdef   XX_GLOBALS
#define  XX_EXTERN
#else
#define  XX_EXTERN  extern
#endif

XX_EXTERN int test;

void fun();

#endif

log.c

#define XX_GLOBALS
//上面这个define要写在下面的#include "log.h"前面
#include "log.h"

void fun()
{
	test++;
	printf("test--%d\n", test);	
}

执行结果和上面的一样。

待解决的问题：怎样让模块二和模块三独占模块一中的全局变量，也就是，模块二和模块三在使用模块一中的全局变量时互不影响？

也就是说，在这个例子中，我想让它的执行结果为：

[lgh@localhost gv]$ ./main
aaa moudle:
test--1
bbb moudle:
test--1
aaa moudle:
test--2
bbb moudle:
test--2

===============================等待大侠来解救。。

目前只想到一个简单的实现方法，将模块一中的全局变量在其它模块中私有。将模块一中的全局变量用结构体封装，在其它模块只要定义这个结构体的变量就好了，不过这样会使得模块一中要调用“全局变量”的函数会增加一个此结构体的指针变量形参。

下面贴出简陋的实现代码：

/* log.h */
#ifndef LOG_H
#define LOG_H

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct log_globle_variable{
	int test;
}lgv_t;

lgv_t *init_gv();
void release_gv(lgv_t *gvp);
void fun(lgv_t *gvp);   //globle variable point

#endif

 

/* log.c */
#include "log.h"

lgv_t *init_gv()
{
	lgv_t *gvp;
	if (gvp = (lgv_t *)malloc(sizeof(lgv_t)))
		memset(gvp, 0, sizeof(lgv_t));
	return gvp;
}

void release_gv(lgv_t *gvp)
{
	if (gvp)
		free(gvp);
}

void fun(lgv_t *gvp)
{
	gvp->test++;
	printf("test--%d\n", gvp->test);	
}

 

/* aaa.h */
#ifndef AAA_H
#define AAA_H

#include "log.h"
void a_fun();

#endif

/* aaa.c */
#include "aaa.h"

lgv_t *a_gv;

void a_fun()
{
	printf("aaa moudle:\n");
	fun(a_gv);	
}

 

/* bbb.h */
#ifndef BBB_H
#define BBB_H

#include "log.h"
void b_fun();

#endif

/* bbb.c */
#include "bbb.h"

lgv_t *b_gv;

void b_fun()
{
	printf("bbb moudle:\n");
	fun(b_gv);	
}

 

/* main.c */
#include "aaa.h"
#include "bbb.h"

extern lgv_t *a_gv;
extern lgv_t *b_gv;

int main()
{
	a_gv = init_gv();
	b_gv = init_gv();
	a_fun();
	b_fun();
	a_fun();
	b_fun();
	release_gv(a_gv);
	release_gv(b_gv);
	
	return 0;	
}

执行结果：

[lgh@localhost gv]$ ./main
aaa moudle:
test--1
bbb moudle:
test--1
aaa moudle:
test--2
bbb moudle:
test--2
===========================================