Thread: size of the memory reserved for a pointer

pointers don't reserve memory, they are just variables that point to memory locations. YOU have to allocate that memory (or point it to memory already allocated). In terms of how dynamically allocated memory keeps track of the size, it's not explicitly defined by the language. It can vary from compiler to compiler. Usually that data is stored in the memory prior to the location that the poiner points to.

The pointer has no size. It is just pointing to some memory location that contains your data. You'd have to keep track of how big you made the array.
If you want to find out how big a data type is, you are looking for sizeof(). That will tell you the size reserved for an int, float, char, etc.

Here's an example...

Code:

#include <stdio.h>

main()
{
    printf("float: %d\n" , sizeof(float));
    printf("int: %d\n" , sizeof(int));
    printf("double: %d\n" , sizeof(double));
    printf("long: %d\n" , sizeof(long));
    printf("long long: %d\n" , sizeof(long long));
    printf("long double: %d\n" , sizeof(long double));
}

A pointer-variable does have a size. This size depends on which system you use. I thought a pointer-variable is usually integer size. You can check it like this:

Code:

char *ptr;
printf ("Size of pointer-variable is %d", sizeof (ptr));

The size of a dynamically allocated datastructure is not stored, you should keep administration of its size if you want to know it.

The pointer itself doesn't contain the size though. A pointer is of a data type, whose size can be told through sizeof(). It's all how you phrase things...I interpretted it alittle differently I guess

At any rate, if you create a dynamic array, you will need to keep track of the size of that array, it's not stored anywhere in the array.

Originally posted by cris_orpi
How would I acces to the size information?

As I said, there is nothing in the standard that says how the data must be stored or how to access it. You simply CAN'T get the size. You have to keep track of it by yourself.

>How would I acces to the size information?

Code:

size_t size = some_num;

p = malloc ( size * sizeof *p );
if ( p != NULL )
  printf ( "%p points to %lu blocks\n", p, (unsigned long)size );

The size information is now in the size variable. This is the only portable and accurate/safe way to remember how much memory is allocated to you.

-Prelude

Originally posted by cris_orpi
Actually, this is the way I allocate the memory assiated to pointer "p".

But, if I pass pointer "p" to a function, were I'm reading or writing information in the memory associated, can have any control of whether or not I'm writing out of the reserved memory?

My doubt is if it is possible to know the size of the allocated memory pointed by a pointer, in case I don't have acces to the variable "size".

Most functions that receive a pointer as an arg use one of two method to determine how much data they can read/write. In the case of strings (char arrays), the nul terminator ('\0') is used to denote the end of the array. The second method is to pass the size of the memory chunk as another parameter.

Code:

void foo(char *p, int len)
{
   printf ("I can read/write %d bytes at location %p\n", len, (void*)p);
}

>Is this right?
Correct, there is no guaranteed way of getting the size of allocated memory. Which is why we told you to place the size in a variable from the start.

-Prelude

Originally posted by Polymorphic OOP
In terms of how dynamically allocated memory keeps track of the size, it's not explicitly defined by the language. It can vary from compiler to compiler. Usually that data is stored in the memory prior to the location that the poiner points to.

In other words, it can vary. That's not something specifically specified by the language, which is why you have to keep track of it by yourself as well.