基本问题：C函数返回指向malloc的结构的指针

Question

About C structs and pointers...

Yesterday I wrote sort of the following code (try to memorize parts of it out of my memory):

    typedef struct {
    unsigned short int iFrames;
    unsigned short int* iTime; // array with elements [0..x] holding the timing for each frame
    } Tile;

    Tile* loadTile(char* sFile)
    {
    // expecting to declare enough space for one complete Tile structure, of which the base memory address is stored in the tmpResult pointer
    Tile* tmpResult = malloc(sizeof(Tile));

    // do things that set values to the Tile entity
    // ...

    // return the pointer for further use
    return tmpResult;
    }

    void main()
    {
    // define a tile pointer and set its value to the returned pointer (this should also be allowed in one row)
// Expected to receive the VALUE of the pointer - i.e. the base memory address at where malloc made space available
    Tile* tmpTile;
    tmpTile = loadTile("tile1.dat");

    // get/set elements of the tile
    // ...

    // free the tile
    free(tmpTile);
    }

What I see: I cán use the malloced Tile structure inside the function, but once I try to access it in Main, I get an error from Visual Studio about the heap (which tells me that something is freed after the call is returned).

If I change it so that I malloc space in Main, and pass the pointer to this space to the loadTile function as an argument (so that the function does no longer return anything) then it does work but I am confident that I should also be able do let the loadTile function malloc the space and return a pointer to that space right?!

Thanks!!

Answer 1

There's nothing wrong with what you're trying to do, or at least not from the code here. However, I'm concerned about this line:

unsigned short int* iTime; // array with elements [0..x] holding the timing for each frame

That isn't true unless you're also mallocing iTime somewhere:

Tile* tmpResult = malloc(sizeof(Tile));
tmpResult->iTime = malloc(sizeof(short) * n);

You will need to free it when you clean up:

free(tmpTile->iTime);
free(tmpTile);

Answer 2

You are probably writing over memory you don't own. I guess that in this section:

// do things that set values to the Tile entity

you're doing this:

tmpResult->iFrames = n;

for (i = 0 ; i < n ; ++n)
{
  tmpResult->iTime [i] = <some value>;
}

which is wrong, you need to allocate separate memory for the array:

tmpResult->iTime = malloc (sizeof (short int) * n);

before writing to it. This make freeing the object more complex:

free (tile->iTime);
free (tile);

Alternatively, do this:

typedef struct {
  unsigned short int iFrames;
  unsigned short int iTime [1]; // array with elements [0..x] holding the timing for each frame
} Tile;

and malloc like this:

 tile = malloc (sizeof (Tile) + sizeof (short int) * (n - 1)); // -1 since Tile already has one int defined.

and the for loop remains the same:

for (i = 0 ; i < n ; ++n)
{
  tmpResult->iTime [i] = <some value>;
}

but freeing the tile is then just:

free (tile);

as you've only allocated one chunk of memory, not two. This works because C (and C++) does not do range checking on arrays.

Answer 3

您显示的代码看起来不错，该错误必须在省略的代码中。

Answer 4

Whatever problem you are having, it is not in the code shown in this question. Make sure you are not clobbering the pointer before returning it.

Answer 5

这应该可以正常工作...可能只是来自VisualStudio的警告，您正在释放一个指针，该指针与分配了它的函数不同。

Answer 6

Technically, your code will work on a C compiler. However, allocating dynamically inside functions and returning pointers to the allocated data is an excellent way of creating memory leaks - therefore it is very bad programming practice. A better way is to allocate the memory in the caller (main in this case). The code unit allocating the memory should be the same one that frees it.

Btw if this is a Windows program, main() must be declared to return int, or the code will not compile on a C compiler.

Answer 7

You code, with as little changes as I could live with, works for me:

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

typedef struct {
  unsigned short int iFrames;
  unsigned short int* iTime;
} Tile;

Tile *loadTile(char* sFile) {
  Tile *tmpResult = malloc(sizeof *tmpResult);
  if (!tmpResult) return NULL;

  /* do things that set values to the Tile entity */
  /* note that iTime is uninitialized */
  tmpResult->iFrames = 42;

  (void)sFile; /* used parameter */
  return tmpResult;
}

int main(void) {
  Tile* tmpTile;
  tmpTile = loadTile("tile1.dat");
  if (!tmpTile) return 1;

  printf("value: %d\n", tmpTile->iFrames);

  free(tmpTile);
  return 0;
}