C 如何向函数发送另一个模块中的变量？

如何将另一个模块中的指针发送到新模块

您好，我刚刚开始一个c语言的编程项目。这个游戏包含一个名为game的结构，它还包含不同类型的数据，如玩家ir对象。这些结构由一个长Id标识，例如，对对象进行分类，使其Id介于#0和#100之间

为了更简单，我创建了一个函数“what_id”，它只接收一个id，然后返回一个指向对应结构的指针。我知道如何通过发送包含所有Id和Id的“game”结构返回变量，但有些模块在任何情况下都不使用大的“game”变量，例如player.c

如何在没有“游戏”的情况下将“游戏”发送到此函数

typedef struct _Game{
  Player* player[MAX_PLAYERS + 1];
  Object* object[MAX_OBJECTS + 1];
  Space* spaces[MAX_SPACES + 1];
 T_Command last_cmd;
} Game;
  typedef struct _Object{
  Id id;
  char name[MAX_SPACES];
}

void* what_id(Game* game, Id id){
   if(id == NO_ID) return ERROR;
   if(0 <id<=MAX_SPACES){
      return what_space(game->space, id);
   }else if(MAX_SPACES<id<=(MAX_OBJECTS+MAX_SPACES)){
      return what_object(game->object, id);
   }else if((MAX_OBJECTS+MAX_SPACES<id<(MAX_PLAYERS+MAX_OBJECTS+MAX_SPACES)){
      return what_player(game->player, id);
   }else {
      fprinf(stderr,"Id asigment max stacked.";
      return ERROR;
    }
}
Space* what_space(const Space* space, Id id){
   int i;
   for(i=0;i<MAX_SPACES;i++){
       if(space[i]->id == id)return space[i];
   }
   fprintf(stderr, "Error no space_id %d founded", id);
   return ERROR;
}

typedef结构\u游戏{
玩家*玩家[最多玩家+1]；
Object*Object[MAX_OBJECTS+1]；
空格*空格[MAX_空格+1]；
T_命令last_cmd；
}游戏；
typedef结构对象{
身份证；
字符名[MAX_SPACES]；
}
无效*什么身份证（游戏*游戏，身份证）{
if（id==NO_id）返回错误；
如果（0不清楚你所说的“模块”是什么意思，或者游戏将从何而来。如果你所说的模块是指产生独立目标文件的独立源文件，通常有两种方法

第一个是声明全局变量并将其作为外部变量导入：

文件1.c：

// declare struct
typedef struct {
    int value;
} Foo;

// declare global variable
Foo *globalfoo;

// declare external function from another module
void printfoo();

void main()
{
    Foo foo;
    foo.value = 3;
    globalfoo = &foo;
    printfoo();
}

typedef struct {
    int value;
} Foo;

void printfoo(Foo *foo);

void main()
{
    Foo foo;
    foo.value = 3;
    printfoo(&foo);
}

#include <myproject.h>

void main()
{
    Foo foo;
    foo.value = 3;
    printfoo(&foo);
}

文件2.c：

#include <stdio.h>

// declare struct
typedef struct {
    int value;
} Foo;

// declare variable from another module
extern Foo *globalfoo;

void printfoo()
{
    printf("foo: %d\n", globalfoo->value);
}

#include <stdio.h>

typedef struct {
    int value;
} Foo;

void printfoo(Foo *foo)
{
    printf("foo: %d\n", foo->value);
}

#include <myproject.h>
#include <stdio.h>

void printfoo(Foo *foo)
{
    printf("foo: %d\n", foo->value);
}

文件2.c：

#include <stdio.h>

// declare struct
typedef struct {
    int value;
} Foo;

// declare variable from another module
extern Foo *globalfoo;

void printfoo()
{
    printf("foo: %d\n", globalfoo->value);
}

#include <stdio.h>

typedef struct {
    int value;
} Foo;

void printfoo(Foo *foo)
{
    printf("foo: %d\n", foo->value);
}

#include <myproject.h>
#include <stdio.h>

void printfoo(Foo *foo)
{
    printf("foo: %d\n", foo->value);
}

文件1.c：

// declare struct
typedef struct {
    int value;
} Foo;

// declare global variable
Foo *globalfoo;

// declare external function from another module
void printfoo();

void main()
{
    Foo foo;
    foo.value = 3;
    globalfoo = &foo;
    printfoo();
}

typedef struct {
    int value;
} Foo;

void printfoo(Foo *foo);

void main()
{
    Foo foo;
    foo.value = 3;
    printfoo(&foo);
}

#include <myproject.h>

void main()
{
    Foo foo;
    foo.value = 3;
    printfoo(&foo);
}

#包括
void main（）
{
富富,；
foo.value=3；
printfoo（&foo）；
}

文件2.c：

#include <stdio.h>

// declare struct
typedef struct {
    int value;
} Foo;

// declare variable from another module
extern Foo *globalfoo;

void printfoo()
{
    printf("foo: %d\n", globalfoo->value);
}

#include <stdio.h>

typedef struct {
    int value;
} Foo;

void printfoo(Foo *foo)
{
    printf("foo: %d\n", foo->value);
}

#include <myproject.h>
#include <stdio.h>

void printfoo(Foo *foo)
{
    printf("foo: %d\n", foo->value);
}

#包括
#包括
无效打印Foo（Foo*Foo）
{
printf（“foo:%d\n”，foo->value）；
}
如果您需要在一个只知道空间的模块中获取
空间
实例，为什么不直接调用
what_Space
而不是
what_id
？这比获取
void*
类型安全得多。相反，拥有对象类型枚举和单独的id也更有意义为不同的对象类型设置ID范围的广告。我当然会给这些字段命名为
players
，
objects
，等等（即复数）为了清楚地表明它们包含多个项。而且
MAX_SPACES+1
似乎不正确，为什么
+1
？请检查。根据这些列表中的项数，a可能是更合适的数据结构，为您提供
O（1）
对象查找。