Feststellen der Größe einer Variablen bei Übergabe eines void pointers

[Sam (Gast)]

Hallo,
ist es auf irgendeine Art und Weise möglich innerhalb der Funktion 
test()
festzustellen welche Größe der übergebene Parameter g_val1 hat? Oder wie 
kann man diese Problematik anders lösen?

Gruß
Sam

unsigned long g_val1;

void test(void* par1)
{
//.............

}

main()
{

test((void*)&g_val1)

}

[Peter II (Gast)]

Sam schrieb:
> welche Größe der übergebene Parameter g_val1 hat?

nein

> Oder wie kann man diese Problematik anders lösen?
in den man die größe mitgibt.

[Torsten R. (Firma: Torrox.de) (torstenrobitzki)]

Sam schrieb:
> Hallo,
> ist es auf irgendeine Art und Weise möglich innerhalb der Funktion
> test()
> festzustellen welche Größe der übergebene Parameter g_val1 hat?

nein

>Oder wie
> kann man diese Problematik anders lösen?

auf void pointer verzichten, oder die Größe explizit als zusätzliche 
Parameter übergeben.

Oder wie immer: Was ist das eigentliche Problem, dass Du lösen 
möchtest?

mfg Torsten

[Thorsten (Gast)]

Nein.

[Niklas G. (erlkoenig)]

Direkt geht das nicht, du musst die Größe mit übergeben:

unsigned long g_val1;

void test(void* par1, size_t size)
{
//.............

}

int main() {
  test((void*)&g_val1, sizeof (g_val1));
}

Allerdings ist das lästig und man kann leicht versehentlich etwas 
falsches übergeben. Wenn du mit C++ kompilierst kannst du dir so 
behelfen:

unsigned long g_val1;

void test(void* par1, size_t size)
{
//.............

}

template <typename T>
void test (T& par1) {
  test (static_cast<void*> (&par1), sizeof (T));
}

int main() {
  test(g_val1);
}

Das template bestimmt automatisch die korrekte Größe.

[Sam (Gast)]

Mein problem ist eigentlich folgendes.
die Funktion test() liest unterschiednliche Daten (deslab void*) von 
einem EEPROM aus und schreibt diese auf Variablen/Felder mit 
unterschiedlicher Größe.
Ich möchte in der Funktion test() aber zuvor prüfen, ob der 
Zieldatenspeicher von der größe her ausreicht

int test(void* data_destination, data_size_in_EEPROM)
{
    // Dies funktioniert leider so nicht
    if(sizeof(data_destination) < data_size_in_EEPROM)
    {
        return error;
    }
    ..................
}

[Nico W. (nico_w)]

Wenn du etwas aus dem EEPROM ausließt musst du doch schon vorher wissen 
was du auslesen willst. Von daher stellt sich die Frage ja eigentlich 
gar nicht. Das EEPROM weiß ja gar nicht, was für einen Datentyp es hat. 
Das weißt nur du.

[Sam (Gast)]

richtig, deshalb übergebe ich ja auch die Größe mit data_size_in_EEPROM 
and die Funktion. Aber ich möchte überprüfen, ob der Zielspeicher 
ausreicht.

[Dirk B. (dirkb2)]

Du kannst ja ein Makro schreiben.

Etwa

#define TEST(g_val1)  test((void*)&g_val1, sizeof (g_val1))

[Nico W. (nico_w)]

Dann übergebe doch eine Funktion die dir die größe Ausgibt?

[Der Andere (Gast)]

Sam schrieb:
> Aber ich möchte überprüfen, ob der Zielspeicher
> ausreicht.

Dann übergebe der Funktion auch die Größe des Zielspeichers.
Wo ist jetzt eigentlich das Problem?

[Dirk B. (dirkb2)]

Der Andere schrieb:
> Dann übergebe der Funktion auch die Größe des Zielspeichers.

Das sollte man in C eigentlich immer machen, wenn sich die Größe nicht 
anderweitg herleiten läßt.

[nicht"Gast" (Gast)]

Niklas G. schrieb:
> template <typename T>
> void test (T& par1) {
>   test (static_cast<void*> (&par1), sizeof (T));
> }

Aua

Wenn schon C++ dann bitte auch keinen Cast nach void, sondern das 
Template benutzen. Dann kann man sich auch die separate Übergabe der 
Größe sparen.

template<class T>
void test(T par1){
   //wasauchimmer
}

[Niklas G. (erlkoenig)]

nicht"Gast" schrieb:
> Wenn schon C++ dann bitte auch keinen Cast nach void, sondern das
> Template benutzen.

An sich natürlich richtig, ich wollte dem TO nicht zu viel auf einmal um 
die Ohren hauen... Da er die Daten aber vermutlich mit bytes von einem 
Bus beschreibt, muss wohl onehin gecastet werden, aber eher zu einem 
char Typ.
2 Funktions-Overloads wie gezeigt sind etwas flexibler und u.U. 
Platz-effizienter (Type-Erasure).

[A. S. (Gast)]

Es ist unnötig, in der aufgerufenen Funktion zu testen, ob der Aufrufer 
genug Speicherplatz zur Verfügung stellt, da er explizit angibt, wieviel 
er möchte.

Wenn der Aufrufer das falsch macht, dann ist keine Annahme über seine 
Absicht mehr sinnvoll. Ganz im Gegenteil: Vermutlich übergibt er einen 
Pointer auf einen unsigned char, weil dass sein General purpose Memory 
Konstrukt ist.