Get the size of a generic type

Hi all! Im working on a library which manages raw memory (void *). Tipically the data are structures that may contain pointers, thus their size can change during the execution. I need to know at run time the size oh these structures starting from a generic void*, how can i get it?.. I tried to use sizeof but without success!..Any help please?

Cheers.

How sizeof is causing problem?

>> I tried to use sizeof but without success

sizeof isn't going to tell you anything about the data referenced by a pointer. If you want to do something like this, it's going to require quite a bit of work on your part. Is there some compelling reason why you need to do this?

Well is not causing problem, but it gives me wrong answers!

Code:

void *p=malloc(10); //allocates 10 bytes
sizeof(p); //this is 4 bytes as any pointer
sizeof(*p); //this is 1 byte

isn't that normal?

Hi sebastiani, basically the library manages mathematical sets, and every set must be able to contain any kind of data (even different types in the same set) at any given time. I thought to do this using void, in a way that the library can work with the data without knowing what the element is. Thus i need to know, when i add an element to a set (and also for other operations), how much memory is needed in order to contain this element.

>> sizeof(*p); //this is 1 byte

You can't dereference a void pointer, so sizeof(*p) is meaningless. The point is, though, you can't retrieve the size of the data referenced by the pointer, even if it were a concrete type, since you don't know if it's a single object or an array.

Keep in mind that sizeof is an operator whose result is determined at compile time. Consequently, you cannot possibly use it to determine the size of something when what exactly that something is is only known at run time (except in the case where all the possible options for what that something can be have the same size).

>> basically the library manages mathematical sets, and every set must be able to contain any kind of data (even different types in the same set) at any given time. I thought to do this using void, in a way that the library can work with the data without knowing what the element is. Thus i need to know, when i add an element to a set (and also for other operations), how much memory is needed in order to contain this element.

I still don't see why you would need the size. Can you give a compilable (stripped-down) example of what you're trying to do?

Code:

/**	Il tipo che definisce un elemento */
typedef struct elem_t {
	/** tipo dell'elemento	*/
	int type;
	/** il puntatore alla zona di memoria doce
	    l'elemento è allocato */
	void *elm;
	/** dimensione (in byte) dell'elemento */
	unsigned int size;
}
elem_t;

elem_t* new_elem(int type, unsigned int size, void *e) {
	elem_t *tmp;
	ec_null( (tmp=(elem_t*)malloc(sizeof(elem_t))), NO_SET )
	ec_null( (tmp->elm=malloc(size+1)), NO_SET )
	ec_null( (tmp->elm=memcpy(tmp->elm, e, size+1)), NO_SET )
	tmp->type=type;
	tmp->size=size;
	return tmp;
}

I would like to avoid the argument "size" int the function. thus to know the size of the memory referenced by "e".
Any suggestion??

>> I would like to avoid the argument "size" int the function. thus to know the size of the memory referenced by "e".

Well, regardless, the size has to be stored somewhere. Theoretically, you could "piggyback" the size information on the allocated buffer (before or after the data), but that might be more of a hassle than its worth...

It is a hassle!.. what i do infact is to carry the size into the elem_t structure, and pass it into the functions that requires that! Unfortunately this library is an assignment and there is some function with a prefixed signature that i cannot change!...am i scruid?..this is a pain!! HEEEELP!!

The only way to know the size of a generic pointer is to remember that size somewhere. There is NO, and I repeat, NO other way to get the size of a generic pointer.
C does not offer any way of solving this problem without remembering the size, either. You are going to have make to home-baked solution or remember the size.
An alternative is C++, which due to its generic code support can do what you want better, but I suppose this is out of the question.

Originally Posted by Elysia

An alternative is C++, which due to its generic code support can do what you want better, but I suppose this is out of the question.

Well, yeah, if you redesign. However, starting with a void pointer, C++ has no generic way to obtain the size of whatever is pointed at, unless you explicitly store the size somewhere, either. In that respect, C++ is no different from C.

Yes, but replace void* with a template and you can query your size. It isn't much of a change and is the only way I can think of the be able to always query the size of a generic object.
But I would think that you wouldn't even need the size if designed properly in C++.
Well, I digress. It's always one option.

Thanks Elysia.. I suspected that there was noway to do that and you confirmed it! what i do is to store in a structure the pointer and the size of the memory it references, this structure is meant as an element of a set, so once an application creates a set and fills it, the type is known (from the application) thus the size can be passed as parameter to a function "add_toSet()". what happen is that the library offers the possibility of apply a function to a set of elements(using pointers to functions), this takes an element as parameter and gives back another element of the same type that might have a different size. the problem is that only the application that uses the library knows about types and so sizes, but the library only works with void* and if it needs to create an element it can't know the size!..moreover, the application talks only with a public interface of the library, because of this it doesn't have any idea of what an element (the structure described above) is, but it just knows the type set that contains void *. how would you solve this? :-)