Objekt auf dem Heap oder Stack?

Fellhuhn

Versuch doch mal folgende Methode:

bool isOnStack(void *x){
    int a;
    return (void*)&a < x;
}

Unter der Annahme das der Anfang des Heaps immer hinter dem maximalen Bereich des Stacks liegt (und du keine Threads verwendest), dürfte das funktionieren.

EDIT:
Aber wenn du den Nutzern solche Einschränkungen aufbrummst, ist das nicht gerade "nett". Vor allem wenn er von diesen nichts weiß.

Dravere

@Badestrand,
Das war das erste, was ich gemacht habe. Bin mir aber noch nicht sicher, welches besser ist, muss das noch genau durchdenken.

Das schöne an meinem oben geschriebenen Code ist, das eigentlich das gleiche, was du mit vielen Funktionen machst, bei mir auch mit weniger geht.

// get_metadataxyz() liefert einen den Zeiger zurück
// und abc ist ein Objekt von CMetaDataABC

if(abc.get_metadataxyz())
{
}

// genau das gleiche, wie bei deiner Funktion
if(abc.has_metadataxyz())
{
}

// Aber bei mir kann man auch das machen:
const CMetaDataXYZ* pMDxyz = abc.get_metadataxyz();

if(!pMDxyz)
{ pMDxyz = new CMetaDataXYZ(); }

// Mit pMDxyz arbeiten.

// Das dürfte bei deine Lösung etwas schwerer werden

Naja, mal schauen

Danke für die Hilfe!

@Fellhuhn,
Lies den Thread durch

Grüssli

Fellhuhn

Bei vier Seiten? Da poste ich doch lieber arrogant einfach rein.

Simon2

Hi Dravere,

das ist die eine Möglichkeit (Lib hält Kopie).
Vorteil: Die Objekte sind entkoppelt (so kann z.B. der Anwender die Lib nicht durch ein vorzeitiges delete zu Fall bringen).
Nachteil: Die Objekte sind entkoppelt (Lib bekommt Änderungen am Anwenderobjekt nicht mit).

Eine andere wäre tatsächlich der "Verantwortungsübergang":

class CMetaDataABC
{
    // Attributes 
private:
   // ...
   bool m_myObj;
public:
    CMetaDataABC(unsigned char uc1, unsigned short us1)
        : // ...
        , m_pMetaDataXYZ(new CMetaDataXYZ)
        , m_myObj(true)   
    { }
    ~CMetaDataABC() { if(myObj) delete m_pMetaDataXYZ; };

    // Methods //
public:
    const CMetaDataXYZ* get_metadataxyz() const { return m_pMetaDataXYZ; };
    void set_metadataxyz(const CMetaDataXYZ* pMetaDataXYZ) { if(myObj) delete m_pMetaDataXYZ; m_pMetaDataXYZ = pMetaDataXYZ; myObj = false;}

    // Weitere getter und setter
};

Ist aber eine Designalternative, die nicht unbedingt besser/schlechter ist als die obige.... nur eben anders.

Gruß,

Simon2.

Phoemuex

Fellhuhn schrieb:

Versuch doch mal folgende Methode:
bool isOnStack(void *x){
    int a;
    return (void*)&a < x;
}
Unter der Annahme das der Anfang des Heaps immer hinter dem maximalen Bereich des Stacks liegt (und du keine Threads verwendest), dürfte das funktionieren.

EDIT:
Aber wenn du den Nutzern solche Einschränkungen aufbrummst, ist das nicht gerade "nett". Vor allem wenn er von diesen nichts weiß.

In der Praxis wird das zwar (mit deinen Einschränkungen) funktionieren, aber der Standard sagt ganz klar:

If two pointers p and q of the same type point to different objects that are not members of the same object or elements of the same array or to different functions, or if only one of them is null, the results of p<q, p>q, p<=q, and p>=q are unspecified.

Felix

Außerdem wurde ja schon auf den anderen Seiten festgestellt, dass das Herausfinden, ob ein Objekt auf dem Stack, oder dem Heap liegt einfach schlechtes Design ist...