Printable View
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.
If i have a char array, each char should be 4 bytes, but always returns 4 bytes as the size
Are you sure you're not checking the size of a pointer?
http://c-faq.com/aryptr/aryparmsize.html
Actually if you have an array of T, each T might not be four bytes according to sizeof.
Proper use of sizeof when arrays enter the picture comes down to knowing when arrays decay into pointers and when they don't - because this dictactes (logically) what sizeof does. If an array is a pointer at the moment, you'll get something different than say sizeof double. I think what you need is simply a detailed explanation.
edit: Dave types faster.
this outputs, Size of key is 1.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.Code:char *key;
int size = 0;
printf("Please fill key: ");
scanf(key);
size = sizeof(key);
printf("\nSize of key is %i.\n",size);
Yup, the size of an unsigned char is 1.Quote:
Originally Posted by Doorsdown
Yup, the size of a pointer to an unsigned char is 4, on your system.Quote:
Originally Posted by Doorsdown
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.
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
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).
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:Quote:
Originally Posted by Doorsdown
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 soCode:#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;
}
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.
outputsCode:09 double *key;
10 int size = 0;
11 key = "149186491491496146\n";
12 size = strlen(key) * sizeof(key[0]);
13 printf("Key is equal to %s and its %i bytes.\n",key,size);
it works, but i need to know how to get ride of those errors before i can go any further. As i if i get a char array it will be fine, but it won't always be a char arrayCode:memory.c: In function 'main':
memory.c:11: warning: assignment from incompatible pointer type
memory.c:12: warning: passing argument 1 of 'strlen' from incompatible pointer type
Key is equal to 149186491491496146
and its 152 bytes.
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:
But that's probably more port-a-bull than it is port-a-ble.Code:size_t _msize( void *memblock )
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...
the 152 bytes is because its of type double, i would expect that.
i looked into that function but it wouldn't work as what ever i use has to be portableQuote:
Originally Posted by @nthony
C is a type strict language. I am not responsible if you try to use a function built for C strings on an array of a different type. Which is the extent of your problem. In C, "4" is not 4. Resist your Pythonic background.Quote:
it works, but i need to know how to get ride of those errors before i can go any further. As i if i get a char array it will be fine, but it won't always be a char array
To calculate the size of a local array of some type sizeof a will work. If you think about it both the size of the pointer and the array's individual elements will be known at compile time. The exception is heap memory, where you will always end up with the size of a pointer (simply because that is how it is accessed). Then you have to do a run time calculation such as
length * sizeof( *p )
like what you did for malloc: p's net load on your RAM.
great, i should be all set from here
thank you
You're very welcome.
Yes I also would expect that 8 * 19 will give a result of 152Quote:
Originally Posted by Doorsdown
but this number has nothing to do with the actually allocated size in the memory, because the 8 has nothing to do with the size of the array member...
i fixed that, it was seeing the 0 and using it as a null terminator, it now showsQuote:
Originally Posted by vart
Code:Key is 23 long and its type is 8 big
Key is 184 bytes.
These warnings are due to type mismatch.Quote:
Originally Posted by Doorsdown
1)What u r doing is, u have taken a double type pointer *key. and assigning a character string into it.
2)Signature of strlen is "size_t strlen(const char *s)". And u r paasing adouble type pointer in it.
Use proper type casting.