malloc返回指向已分配内存的指针

Question

It's a long time since I've written C. My understanding is that malloc returns a pointer to a newly allocated memory region which does not overlap with previously malloc ed reactions. However, my program (below) seems to show malloc returning a pointer to the middle of an already allocated region!

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

typedef struct {
  int* bla;
  int baz;
  int qux;
  int bar;
} foo;

int main() {
  foo* foo = malloc(sizeof(foo));
  int* arr = malloc(sizeof(int) * 10);
  // my understanding of malloc is that `foo` and `bar` now point to
  // non-overlapping allocated memory regions

  printf("arr          %p\n", arr);            // but these print
  printf("&(foo->bar)  %p\n", &(foo->bar));    // the same address

  foo->bar = 42;
  printf("arr[0] = %d\n", arr[0]);   // prints 42

  return 0;
}

I am compiling and running this with:

$ cc --version
Apple LLVM version 7.3.0 (clang-703.0.29)
Target: x86_64-apple-darwin15.3.0
Thread model: posix
InstalledDir: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin
$ cc     main.c   -o main
$ ./main
arr          0x7fa68bc03210
&(foo->bar)  0x7fa68bc03210
arr[0] = 42

What am I doing wrong?

Answer 1

What is that?!

foo* foo = malloc(sizeof(foo));

Please use different identifiers!

foo* variable = malloc(sizeof(foo));

Just to get sure I tested this main() :

int main() {
    printf("sizeof(foo)=%zu\n", sizeof(foo));
    foo* foo = malloc(sizeof(foo));
    printf("sizeof(foo)=%zu\n", sizeof(foo));
}

output (64bits with LLP64 ):

sizeof(foo)=24
sizeof(foo)=8

Don't use twice the same identifier, you get bad surprises.

Answer 2

There is no collision between the typdef alias and declaration of an instance as the same name. You can, but not recommended, do what you had originally, but take the size from the variable instead of attempting to get it from the type. Specifically:

    foo *foo = malloc (sizeof *foo);

You can confirm in the full example:

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

typedef struct {
    int *bla;
    int baz;
    int qux;
    int bar;
} foo;

int main (void) {

    foo *foo = malloc (sizeof *foo);
    int *arr = malloc (sizeof *arr * 10);

    printf ("arr          %p\n", arr);
    printf ("&(foo->bar)  %p\n", &(foo->bar));

    foo->bar = 42;
    printf ("foo->bar = %d\n", foo->bar);

    return 0;
}

Example Output

$ ./bin/foofoo
arr          0x17f3030
&(foo->bar)  0x17f3020
foo->bar = 42

Answer 3

using the following code

Notice the unique name for the instance of foo

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

typedef struct
{
  int* bla;
  int baz;
  int qux;
  int bar;
} foo;

int main()
{
  foo* myfoo = malloc(sizeof(foo));
  int* arr = malloc(sizeof(int) * 10);

  // my understanding of malloc is that `foo` and `bar` now point to
  // non-overlapping allocated memory regions

  printf("arr          %p\n", arr);            // but these print
  printf("&(foo->bar)  %p\n", &(myfoo->bar));    // the same address

  myfoo->bar = 42;
  printf("arr[0] = %d\n", arr[0]);   // prints 42

  return 0;
}

the output is:

arr          0x1578030
&(foo->bar)  0x1578020
arr[0] = 0

which is exactly what I would expect.

I compiled this under ubuntu linux 14.04 with gcc 4.8.4

using:

gcc -ggdb -c -Wall -Wextra -pedantic -Wconversion -std=gnu99 myfile.c -o mybile.o

then

gcc -ggdb -std=gnu99 myfile.o -o myfile

then ran it with

./myfile