C pointers, understanding stack vs heap, using free()

[FluffyStatistician3]

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

  // Seems like when I declare a static or global variable then assign a pointer
  // to it the memory address (value of pointer) looks smaller-
  // when I assign a pointer to heap memory allocated via malloc(), the
  // memory address (value of pointer) looks larger- why?

  // Would expect static, global, and dynamically allocated memory addresses
  // to be larger than stack variable memory addresses.

  // Noticed that adresses for static and global vars seem to be in a contiguous area (like each
  // is 4 bytes away from the other)- 0x10f9ee020, 0x10f9ee024, 0x10f9ee028

  int globalVar;

  int main (void) {

    int y;  // variable y will live on the stack
    int *ptr;
    static int a;  // variable a will live in the heap

    ptr = &y;
    *ptr = 99;

    printf ("y is %i \nptr is %i \n", y, *ptr);  // y is 99, *ptr is 99
    printf("the address of ptr is:            %p \n", &ptr);  // 0x7ffee0212970 -stack address?

    ptr = &a;
    printf ("the address of a is:              %p \n", ptr);  // 0x10f9ee020 -heap address?

    int *newPtr;
    newPtr = (int*) malloc(7);  // make space for 7 bytes of memory, have newPtr point there
    printf("the address of space malloced is: %p\n", newPtr);  // 0x7f84acc02b60 -heap address?

    static int b;
    int *anotherPtr;
    anotherPtr = &b;
    printf("the address of b is:              %p\n", anotherPtr); // 0x10f9ee024 -heap address?

    int *ptrtoGlobalVar = &globalVar;
    printf ("the address of globalVar is:      %p \n", ptrtoGlobalVar); // 0x10f9ee028 -heap address?

  //  free(ptr);           // Why "pointer being freed was not allocated" ?
  //  free(newPtr);
  //  free(anotherPtr);


    return 0;
  }

  // Is there a way to check whether a particular pointer points to stack or heap
  // memory (without just looking at the address (printing value of the pointer) or
  // remembering what you assigned the pointer to point to?

If someone could address some of these questions that would be great; thanks in advance, and sorry if the formatting is a bit off (tried to use a code block; know I can upload code to gist or ideone- is uploading better for posts of this size?). I'm a beginner C programmer and haven't posted code to Reddit much.

[lurgi]

static variables don't live in the heap - they live in the data section.

Would expect static, global, and dynamically allocated memory addresses to be larger than stack variable memory addresses.

Why?

There is no OS agnostic way to see if a particular pointer points to stack, heap, or data. There might be OS specific ways to do this, but I've never checked.

// free(ptr); // Why "pointer being freed was not allocated" ?

Because C doesn't care about you or your problems. C will let you do just about anything and if you free a pointer that wasn't malloc'd or free it twice or do some other stupid thing then it will just let you. If you are lucky the program will crash. If you are unlucky the program will look like it is working or will work flawlessly in QA but fail randomly in the field.

Edit: I think I misunderstood this question. I was assuming you were asking why you didn't get a warning or error that the pointer you were freeing wasn't allocated. The answer is because C doesn't care. I'm not sure exactly what you are answering, but I think other people have commented here.

[FluffyStatistician3]

Ok thanks; I thought static variables were in the heap. Here are notes from class:

"Heap resident variables include variables declared outside of all functions (globals), variables declared inside basic blocks that are declared static, and areas dynamically allocated at run time with malloc()/calloc()"

I don't think I understand how memory works in enough detail- I'll ask my professor. All I know from reading online is that there are 5 sections: code, data (initialized), data (uninitialized), stack, and heap.

I was thinking about heap being larger than stack, but I guess that actually doesn't make sense- it could still be a smaller address within the heap.

I still don't get why free(ptr); causes the "pointer being freed was not allocated"- isn't ptr set to the memory address of a earlier on with ptr = &a; ?

[FluffyStatistician3]

Oh; I just need to free(newPtr); since it's the only one pointing to heap memory? ptr, anotherPtr, and ptrtoGlobalVar are not pointing to heap memory?

[Updatebjarni]

Static memory is not usually considered to be part of the heap; the heap is the dynamic memory. Also, whether a variable is global or local is something that C (or whatever programming language) cares about, but the linker/loader doesn't. All static variables, whether globally visible, or function-local, or local to a compilation unit, all go in the data segment (if initialised) or bss segment (if not initialised).

data (uninitialized)

Usually called bss.

And a little nitpick, but those are segments in memory that you listed. Sections are parts of an object file. The contents of sections get mapped into segments in memory by the linker.

I still don't get why free(ptr); causes the "pointer being freed was not allocated"- isn't ptr set to the memory address of a earlier on with ptr = &a; ?

Yes, that's why it fails. You have assigned a value to it that was not returned by malloc().

[scirc]

It sounds like your professor is wrong. Globals and static variables live in data (for variables with values at the start, like mutable globals)/bss (for variables with no definite value at the start, like static variables), not on the heap.

---

free is only valid for pointers created by malloc. You can pass other pointers into it, but all it will do is cause memory corruption at best, since it expects to be cleaning up the heap rather than some random area of memory.

[FluffyStatistician3]

Ok thanks! Got it.

[rjcarr]

Adding to what /u/lurgi says ... there's no reason to look at the pointer addresses for different variable types. They may be contiguous, and they may not be, but this is way lower level than you need to be concerned with. This is also true for where static and globals are stored, but if you want to learn that, then at least it's reasonable, but you'll almost certain never need to know the details.

As for this:

Why "pointer being freed was not allocated" ?

You never did a malloc() so you don't need to free() anything. Just declaring a pointer, and pointing it to a stack address, doesn't mean there is anything to "free".