C 在结构中分配内存时类型不兼容

我正在制作一个程序，但不知道为什么

code:：Blocks

显示一些错误：

error: conflicting types for 'loadSavedGame'
note: previous declaration of 'loadSavedGame' was here(In headers of file)
In function 'loadSavedGame':error: incompatible types when assigning to type 'struct saveGame' from type 'struct saveGame *'

我不明白，因为显示一个错误，如果我用同样的方式声明了其他函数，请看：

        struct configParam{
           char *clave;
           char *valor;
        };

        struct saveGame{
           char *id;
           char *score;
           char *position;
           char *maze_level;
           char *achievements;
           char *time_playing;
           char *virtual_players;
        };

        void loadSettings(char fileName[],struct configParam *paramsReaded[], int *length, int *statusCode);
        void saveSettings(char fileName[],struct configParam paramsToWrite[], int length, int *statusCode);

        void loadSavedGame(char fileName[],struct saveGame *savedGamesReaded[], int *length, int *statusCode);
        void saveGame(char fileName[],struct saveGame savedGamesToWrite[], int length, int *statusCode);

    void loadSettings(char fileName[],struct configParam *paramsReaded[], int *length, int *statusCode){


        *paramsReaded = (struct configParam*)malloc((*length)*sizeof(struct configParam)); //THIS WORK
        int j;
        for(j=0; j<*length; j++){
            (*paramsReaded)[j].clave = (char *)malloc(MAX_STRING*sizeof(char)); //reserva de memoria para los miembros "clave" y "valor" de la estructura
            (*paramsReaded)[j].valor = (char *)malloc(MAX_STRING*sizeof(char));
        }

    }

void loadSavedGame(char fileName[], struct saveGame *savedGamesReaded, int *length, int *statusCode){

    *savedGamesReaded = (struct saveGame*)malloc((*length)*sizeof(struct saveGame)); // HERE SHOW AN ERROR :(
    int j;
    for(j=0; j<*length; j++){
        (*savedGamesReaded)[j].id = (char *)malloc(MAX_STRING*sizeof(char)); 
        (*savedGamesReaded)[j].score = (char *)malloc(MAX_STRING*sizeof(char));
        (*savedGamesReaded)[j].position = (char *)malloc(MAX_STRING*sizeof(char));
        (*savedGamesReaded)[j].maze_level = (char *)malloc(MAX_STRING*sizeof(char));
        (*savedGamesReaded)[j].achievements = (char *)malloc(MAX_STRING*sizeof(char));
        (*savedGamesReaded)[j].time_playing = (char *)malloc(MAX_STRING*sizeof(char));
        (*savedGamesReaded)[j].virtual_players = (char *)malloc(MAX_STRING*sizeof(char));
    }






}

struct configParam{
字符*clave；
勇气；
};
结构保存游戏{
字符*id；
字符*分数；
字符*位置；
字符*u级；
char*成就；
char*time\u播放；
虚拟玩家；
};
无效加载设置（char fileName[]，struct configParam*paramsreded[]，int*长度，int*状态码）；
无效保存设置（字符文件名[]，结构配置参数paramsToWrite[]，整数长度，整数*状态码）；
void loadSavedGame（char fileName[]，struct saveGame*savedgamesraded[]，int*长度，int*状态码）；
void saveGame（char fileName[]，struct saveGame savedGamesToWrite[]，int-length，int*statusCode）；
无效加载设置（char fileName[]，struct configParam*paramsreded[]，int*长度，int*状态码）{
*paramsreded=（struct configParam*）malloc（（*length）*sizeof（struct configParam））；//这项工作
int j；
对于（j=0；j让我们进一步将其简化为

区别是什么？让我们进一步研究，剥离参数标识符和主体，形成这两个函数的原型：

void loadSettings(struct configParam *[]);
void loadSavedGame(struct saveGame *);

你现在看到区别了吗？第一个使用两个级别的间接寻址（
*
和
[]
），而第二个只使用一个级别的间接寻址

第一种方法使用了正确的惯用法，如果您打算分配给
loadSettings
返回后存在的对象，它看起来是正常的

第二个尝试使用相同的模式，但它缺少
[]
…Hmmmm

另外，为了将来的参考，请学习如何制作S，这样你就可以自己更容易地发现这些简单的印刷问题

p.p.S.在您尝试将某些内容存储到它所指向的对象中之前，不要忘记检查
malloc
（对于
NULL
值）的返回值。
您会遇到错误

错误：“LoadSavedName”的类型冲突

注意：“loadSavedGame”的上一个声明在这里（文件头中）

因为这是函数的原型
loadSavedGame
-

void loadSavedGame(char fileName[],struct saveGame *savedGamesReaded[], int *length, int *statusCode);

在定义你写的-

void loadSavedGame(char fileName[], struct saveGame *savedGamesReaded, int *length, int *statusCode){

请参见两个文件中参数2的类型

1.在第一个
struct saveGame*savedgamesreded[]
（指向struct的指针数组）

2.在定义函数时以秒为单位
struct saveGame*savedgamesraded
（指向struct的指针）

因此，类型冲突和错误。在定义函数时，您错过了那里的
[]

下一个错误就是由于这个-

 *savedGamesReaded = (struct saveGame*)malloc((*length)*sizeof(struct saveGame)); // HERE SHOW AN ERROR :(

这也是由于上述问题。如果保留指针数组，即
struct saveGame*savedgamedreadded[]
，这将是一条有效语句，不会产生错误。因为
*
和
[]
将提供两个级别的间接寻址

但如果不这样做，那么使用
*
将产生问题。然后您将不得不删除它。
以下代码可能是您希望实现的更多内容

代码需要为每个malloc添加错误检查

所有的“混乱”都从代码中删除。
所有未使用的函数参数都将从代码中删除
代码编译时没有错误/警告

#include <stdlib.h>


#define MAX_STRING (100)

struct configParam
{
   char *clave;
   char *valor;
};

struct saveGame
{
   char *id;
   char *score;
   char *position;
   char *maze_level;
   char *achievements;
   char *time_playing;
   char *virtual_players;
};

//prototypes
void loadSavedGame(struct saveGame **savedGamesReaded, int *length );
void loadSettings( struct configParam **paramsReaded, int *length );

void loadSettings( struct configParam **paramsReaded, int *length )
{
    *paramsReaded = malloc((*length)*sizeof(struct configParam)); //THIS WORK
    int j;
    for(j=0; j<*length; j++)
    {
        (*paramsReaded)[j].clave = malloc(MAX_STRING); //reserva de memoria para los miembros "clave" y "valor" de la estructura
        (*paramsReaded)[j].valor = malloc(MAX_STRING);
    }

}

void loadSavedGame(struct saveGame **savedGamesReaded, int *length )
{
    *savedGamesReaded = malloc((*length)*sizeof(struct saveGame));
    int j;
    for(j=0; j<*length; j++)
    {
        (*savedGamesReaded)[j].id              = malloc(MAX_STRING);
        (*savedGamesReaded)[j].score           = malloc(MAX_STRING);
        (*savedGamesReaded)[j].position        = malloc(MAX_STRING);
        (*savedGamesReaded)[j].maze_level      = malloc(MAX_STRING);
        (*savedGamesReaded)[j].achievements    = malloc(MAX_STRING);
        (*savedGamesReaded)[j].time_playing    = malloc(MAX_STRING);
        (*savedGamesReaded)[j].virtual_players = malloc(MAX_STRING);
    }
} // end function: loadSavedGame

#包括
#定义最大字符串（100）
结构配置参数
{
字符*clave；
勇气；
};
结构保存游戏
{
字符*id；
字符*分数；
字符*位置；
字符*u级；
char*成就；
char*time\u播放；
虚拟玩家；
};
//原型
void loadSavedGame（结构saveGame**savedgamesreded，int*length）；
无效加载设置（struct configParam**paramsreded，int*length）；
无效加载设置（结构配置参数**paramsreded，int*length）
{
*paramsreded=malloc（（*length）*sizeof（struct configParam））；//这项工作
int j；
对于（j=0；jI忘记了“[]”，现在它的工作是，感谢您解释编译发布的代码，并且启用了所有警告（对于gcc，至少使用：
-Wall-Wextra-pedantic
）会导致编译器引发的不是2个错误和警告，而是19个错误和警告。在C中，不要强制转换malloc（）返回的值和函数族。由于返回值的类型是
void*
，因此可以将其分配给任何指针，并且在执行代码维护时添加这样的强制转换将产生问题。表达式
sizeof（char）
在标准中定义为1乘以1绝对不会影响传递给malloc（）的值，只会导致代码混乱。请一致缩进代码。此行：
*savedgamesraded=malloc（（*length）*sizeof（struct saveGame））；
仅更新调用堆栈上的指针，因为传递的参数定义不正确。若要更新原始指针，传入的参数必须是
**
。savegame（）函数的名称与结构定义的标记名相同。这可能/将产生问题。建议使用唯一的名称
#include <stdlib.h>


#define MAX_STRING (100)

struct configParam
{
   char *clave;
   char *valor;
};

struct saveGame
{
   char *id;
   char *score;
   char *position;
   char *maze_level;
   char *achievements;
   char *time_playing;
   char *virtual_players;
};

//prototypes
void loadSavedGame(struct saveGame **savedGamesReaded, int *length );
void loadSettings( struct configParam **paramsReaded, int *length );

void loadSettings( struct configParam **paramsReaded, int *length )
{
    *paramsReaded = malloc((*length)*sizeof(struct configParam)); //THIS WORK
    int j;
    for(j=0; j<*length; j++)
    {
        (*paramsReaded)[j].clave = malloc(MAX_STRING); //reserva de memoria para los miembros "clave" y "valor" de la estructura
        (*paramsReaded)[j].valor = malloc(MAX_STRING);
    }

}

void loadSavedGame(struct saveGame **savedGamesReaded, int *length )
{
    *savedGamesReaded = malloc((*length)*sizeof(struct saveGame));
    int j;
    for(j=0; j<*length; j++)
    {
        (*savedGamesReaded)[j].id              = malloc(MAX_STRING);
        (*savedGamesReaded)[j].score           = malloc(MAX_STRING);
        (*savedGamesReaded)[j].position        = malloc(MAX_STRING);
        (*savedGamesReaded)[j].maze_level      = malloc(MAX_STRING);
        (*savedGamesReaded)[j].achievements    = malloc(MAX_STRING);
        (*savedGamesReaded)[j].time_playing    = malloc(MAX_STRING);
        (*savedGamesReaded)[j].virtual_players = malloc(MAX_STRING);
    }
} // end function: loadSavedGame