malloc, pointer auf pointer

Hallo!
Irgendwie bekomm' ich's nicht hin. Folgendes Problem:
Ich möchte einen Speicherbereich allocieren:

void *pMem;

pMem = malloc( sizeof (irgendwas) + sizeof(void*) );
funktioniert prima.
Nun der Teil, der Schwierigkeiten macht:

*pMem = pMem + sizeof(void*);

Da meckert (auch in anderen Formulierungen mit diversen casts) der Compiler.
Was das ganze soll:
Ich möchte eine Indirektion auf den allocierten (nur bei char*) Speicher erstellen, damit ich später, unabhägig von der tatsächlichen Art des Wertes (malloc von double, short, string, ...) auf die gleiche Art und Weise darauf zugreifen kann. z.B: printf( "%s", *pMem) oder printf( "%ld", *pMem) denn sonst (also ohne Dereferenzierung) würden nur strings korrekt ausgegeben werden, alles andere aber nicht.

char *p = malloc(10); //10 Bytes;

	int i=34;
	memcpy(p,(char*)&i,sizeof(int));
	printf("%i\n",*p);

	double d=3.454;
	memcpy(p,(char*)&d,sizeof(double));
	printf("%f\n",*p);

	char ac[]="Hallo";
	memcpy(p,ac,strlen(ac));
	printf("%s\n",p);

Genau das will ich NICHT!

Ich möchte printf IMMER mit der notation *p aufrufen können, egal welchen Typ der Wert auf den p zeigt tatsächlich hat.

Also printf("%f", *p) für floats ...
UND printf("%s", *p) ALSO STERN P für strings!!!

LordJaxom

char* p = malloc(12);
strcpy(p, "Hallo, Welt");

void *pMem = malloc(sizeof(char*));
*((char**)pMem) = p;

printf("%s\n", *pMem);

warum willst du das so machen? du könntes die adresse des zeiger auf den string speichern... aber wieso so uncool?

Prinzipiell wollte ich eine polymorphen Zeiger auf diverse Datentypen. Leider kann ich diesen nicht in printf u.Ä. nicht verwenden, da, zumindest mein Compiler (LabWindowsCVI) gerne einen konkreten Typ haben möchte, ich also erst wieder den polymorphen Zeiger nach double, float, int usw. casten muß.

Danke an alle, die sich des Problems angenommen haben.

Wer's genau wissen will:
Ich bekomme (per magic) Werte aus einer Datenbank. Da ich zur Laufzeit
nicht weiß welche Typen ich zu erwarten habe, schreibe ich die Werte in einen
zuvor allocierten Bereich auf den ein void pointer hinzeigt.
In etwa so:
p->value = malloc(size_t);
fillValue( p->value );

Später muß ich diese Werte mittels printf ausgeben. Die Formatierung, die zu
diesem Wert gehört habe ich, kann also sowas ähnliches wie
printf( strFormatAnweisung, p->value ) schreiben.

Das geht natürlich nur bei String - Werten, alles andere müsste in etwa so
printf( strFormatAnweisung, *p->value ) ausgegeben werden.

Nun folgen daraus 2 Probleme:
1.: Ich wollte nun auch für Strings eine Indirektion aufbauen, damit ich also
generell *p->value schreiben konnte.
2.: printf braucht den zur Formatanweisung passenden Parametertyp, ergo type cast, was aber die ganze pointer "polymorphie" sinnlos macht.
2.a: Mein Copiler behauptet stur, dass *p->value irgendwas vom typ void sei, und ist nicht davon zu überzeugen, dass es ein Pointer auf irgendwas ist.

BorisDieKlinge

variant typen union ... schau dir bspw. mal COleVariant struktur an von Mfc an