Feststellen, ob ein Zeiger auf gültigen( reservierten ) Speicherbereich zeigt.

Ahoj !

Ich habe eine Funktion, die mir Strukturen vom Typ Foo generiert:

Foo* create_foo()
{
    Foo* p_foo = malloc( sizeof( Foo ) );
    if ( p ) return p; 
    else return NULL;
}

Und diverse andere Funktionen, die einen Zeiger auf Foo als Parameter entgegennehmen:

int do_something( Foo* p_foo )
{
//...
    if ( p_foo == NULL ) return 1;
//...
    p_foo->a_member_of_foo = xyz;
//...
    return 0;
}

Jetzt umgeht aber jemand die create_foo Funktion und macht das hier:

int main()
{
    Foo* p_trash;
    do_something( p_trash ); // CRASH !!!
    return 0;
}

Welche Möglichkeiten habe ich, einen Absturz zu vermeiden ?
Gruß E.K.

Shade Of Mine

keinen.

die meisten compiler bieten zwar etwas an: zB VC++ bietet IsBadXxxPtr() (zB IsBadWritePtr) aber das Problem ist: nur weil man dorthin schreiben kann, muss der speicher noch lange nicht gut sein. ein wilder zeiger kann halt überall hin zeigen auch in beschreibbaren speicher und dennoch nicht dorthin wo man eigentlich hinschreiben will.

erstens warum überprüfst du malloc, wenn du eh NULL zurückgibst wenn malloc NULL zurückgibt bzw. den pointer wenn malloc einen gültigen pointer zurückgibt. die funktion ist nichts als eine cast, der in C noch nichteinmal notwendig ist. solange du nur den rückgabewert verwendest bist du auf der sicheren seite!

Egal Karl schrieb:

Jetzt umgeht aber jemand die create_foo Funktion und macht das hier:

kann mir nicht vorstellen dass jemand so gemein sein kann

Undertaker

Shade Of Mine schrieb:

die meisten compiler bieten zwar etwas an: zB VC++ bietet IsBadXxxPtr() (zB IsBadWritePtr)...

nicht die compiler und auch nicht vc++. die von dir genannten funktionen stecken in der winapi.

... schrieb:

erstens warum überprüfst du malloc, wenn du eh NULL zurückgibst wenn malloc NULL zurückgibt bzw. den pointer wenn malloc einen gültigen pointer zurückgibt. die funktion ist nichts als eine cast, der in C noch nichteinmal notwendig ist. solange du nur den rückgabewert verwendest bist du auf der sicheren seite!

Du hast völlig Recht, eigentlich füttere ich sonst in der if ( p ) Abfrage einen
Status-Puffer:

if ( p == NULL )
{
     sprintf( status_buf, "failed on malloc" );
     return NULL;
}
return p;

Den der Anwender dann bei Bedarf abfragen kann.
War ich wohl irgendwie in Gedanken.

kann mir nicht vorstellen dass jemand so gemein sein kann :open_mouth:

Naja, ich möchte das möglichst DAU - sicher machen

LordJaxom

Egal Karl schrieb:

Naja, ich möchte das möglichst DAU - sicher machen

Dann bist Du bei der falschen Sprache. Dumme User und gescheite C-Programme schließen sich irgendwíe aus

Don06

Naja, mir fällt da ne ziemlich umständliche Lösung ein:
Du schreibst deine eigenen malloc() bzw. free() Funktionen.
(Bsp: egalKarl_malloc, egalKarl_free())
Du speicherst die Adressen die du alloziert hast und löscht die, die wieder freigegeben worden.
Dann kannst du überprüfen, ob an der Stelle, auf den der Zeiger zeigt bereits ein allokiertes Objekt ist.
Problem: wilde Zeiger können durch Zufall auch einen für dich korrekten Wert haben. In Wirklichkeit zeigen sie aber auf ein anderes bereits alloziertes Objekt.
Ausserdem müsste sich der User an deine komischen Funktionen gewöhnen.

Alles in allem eine nicht gerade prickelnde Lösung.
Das Problem in C ist ja das man einen zufälligen Wert nicht von einem gewollten Wert unterscheiden kann. Deshalb ist es ja so wichtig seine Variablen zu initialisieren.

Du solltest einfach in deiner Doku vermerken, dass man deine create_foo()-Funktion verwenden muss. Wers dann nicht tut ist halt selber schuld.

Gruß
Don06