Thread: Size of objects in Memory

I have tried searching both google and these forums to no avail. I am looking to obtain the size of an object(s) in memory. I have researched sizeof() and found it to only show how many byte a given type takes up. But I need to know the size of any object in memory. I'm not exactly sure where to start or how to go about it. So any help would be great.

Thank you

The sizeof() function gives you the number of bytes in memory an object will occupy. I don't see how that's different from what you're asking, or maybe I'm misunderstanding your question.

Are you sure you're not checking the size of a pointer?
http://c-faq.com/aryptr/aryparmsize.html

Originally Posted by Doorsdown

Code:

char *key;
int size = 0;
printf("Please fill key: ");
scanf(key);
size = sizeof(*key);
printf("\nSize of key is %i.\n",size);

this outputs, Size of key is 1.

Yup, the size of an unsigned char is 1.

Originally Posted by Doorsdown

Code:

char *key;
int size = 0;
printf("Please fill key: ");
scanf(key);
size = sizeof(key);
printf("\nSize of key is %i.\n",size);

this outputs, Size of key is 4.

Yup, the size of a pointer to an unsigned char is 4, on your system.

Are you looking for strlen? [edit=3]http://www.open-std.org/jtc1/sc22/wg...trlen_function[/edit]

Wait, first allocate some memory into which to write the input. Oh, and see the FAQ about getting user input as text. And ditch scanf until you know more than you want to.

Strings can be an annoying case.

Otherwise, if you've made the things you're passing, you should be able to calculate the size.

With structures and built in primitives, the sizeof is fine.

For arrays of anything OTHER than character arrays, sizeof(whatever) * num where num is the number of entries in the array is fine (number actually stored, not the allocated size from malloc).

As declared, unless your compiler has specific rules to the contrary, a char array is in bytes, not words or dwords. This, however, is the annoying part. Sometimes one sees a char * or unsigned char * used to point to an otherwise undefined buffer of structures, unicode characters or MCBS characters. For this, you have to do more work.

If you know you created a character array, and the string processing functions you've used are ASCII versions, then strlen will be correct as the number of bytes.

Otherwise, you need to know what characters or other structures have been appended to the buffer, and that can get nasty (especially if the char * is otherwise used as a void * for things like bitmaps headers).

If your compiler has defined the char as an unsigned short or signed short, the sizeof(char) would be 16 bits, but if you use ASCII string functions on that array, you'll probably have bytes. Control over the compiler's options is critical to pin down what you want.

Keep it simple for yourself. If you're using unicode, get the size of a unicode character (which is constant over the character set) and use that to compute the size in bytes.

If you're using MCBS, you'll have functions that give you the size in bytes (it's a variable sized character set).

Originally Posted by Doorsdown

that was just a example, i am writing a task for python and it will pass in a pyobject and i need to find a way to figure out its size in memory. So strlen will not cut it

Why not? Consider that C strings are a relatively simple type: The only thing strlen really does is count bytes (except you constantly have to +1 to account for the terminating zero). The difference here is that sizeof counts the bytes at compile time, and strlen does so at run time. just to prove it:

Code:

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

int main( void ) {
  const char stat[] = "deadbeef";
  char *heap = malloc( sizeof stat );

  if( stat )
  {
    strcpy( heap, stat );
    if( strlen( heap ) + 1 == sizeof stat )
    {
      printf( "%s is the same size regardless of storage.\n", stat );
      free( heap );
      heap = NULL;
    }
  }
  else
    perror( "\"deadbeef\" array" );

  return 0;
}

To be more serious, your options are thin. Memory allocated at run time will always use some sort of runtime devised method to find the relative size of things. And by "relative size of things" I mean that the bytesize of an object can often be less important than how many objects there are. If you used a Unicode string, for instance, the byte size would be up to four bytes per character, so you might feel better calculating the bytesize like so

strlen( key ) * sizeof key[0]

key[0]'s size is known at compile time, so sizeof works, but the string length could be (and if you're using heap memory, often should be) a question answered at run time.


This advice also applies to any other object in the history, present, and future of the C world.

I think what the OP is getting at is what I posed here. Basically, if you have a (void) pointer to some object in memory, why isn't there a standard way of finding out that object's size? It stands to reason that since free() is passed a void pointer and still manages to find out the size of that object (it has to in order to be able to deallocate), then why isn't there a function that will explicitly do this for you?
The closest that was found was:

Code:

size_t _msize( void *memblock )

But that's probably more port-a-bull than it is port-a-ble.

It works? And the size part also? Do you see there 152 bytes of data?
While it is char array - make it char array... When it want - change it to the appropriate type...