Wie kann ich einen Wert an einer bestimmten Stelle im Speicher ablegen?

Vielleicht ist dies eine einfache Frage, aber ich würde es wirklich gerne wissen.

Wenn ich einen Wert, sagen wir ein int, an einer bestimmten Adresse im Speicher (auf dem Heap) speichern möchte, wie mache ich das?

Sagen wir, ich möchte den int-Wert 10 bei 0x16 speichern. Ich vermute, dass Sie dies tun, indem Sie new oder malloc aufrufen: int *p=new int(10); und dann möchte ich die Adresse des gespeicherten Wertes auf 0x16 setzen. Zuerst dachte ich nur so etwas wie &p=0x16, aber das funktioniert nicht. Ich muss dies tun, um einige zusätzliche Informationen vor einem bestimmten Wert im Speicher zu speichern (der zuvor von malloc oder new Speicherplatz zugewiesen wurde).

Ich verwende Linux und C++ (aber C würde auch funktionieren).

Was ich erreichen möchte ist: Ein Prozess ruft malloc mit Größe x auf und ich möchte einen bestimmten Wert (die Größe) vor dem zugewiesenen Speicher speichern, damit ich später auf die Größe zugreifen kann (wenn free aufgerufen wird). Da malloc aufgerufen wurde, kenne ich den Zeiger, wo das Betriebssystem Platz für den Wert zugewiesen hat und möchte nur die Größe des zugewiesenen Speichers in den 4 Bytes vor dem zugewiesenen Speicher speichern. Was ich tue (in dem von mir geschriebenen malloc-Hook), ist, mehr Speicher zuzuweisen (durch einen internen malloc-Aufruf), aber ich muss auch in der Lage sein, diesen Größenwert an einem bestimmten Ort zu speichern.

Ich bin für jede Hilfe dankbar.

Du kannst es so machen:

*(int *)0x16 = 10;  // store int value 10 at address 0x16

Beachten Sie, dass dies davon ausgeht, dass die Adresse 0x16 beschreibbar ist – in den meisten Fällen wird dies zu einer Ausnahme führen.

Normalerweise werden Sie dies nur für eingebetteten Code usw. tun, wo kein Betriebssystem vorhanden ist und Sie in bestimmte Speicherorte wie Register, I/O-Ports oder spezielle Speichertypen (zB NVRAM) schreiben müssen.

Sie können diese speziellen Adressen etwa so definieren:

volatile uint8_t * const REG_1 = (uint8_t *) 0x1000;
volatile uint8_t * const REG_2 = (uint8_t *) 0x1001;
volatile uint8_t * const REG_3 = (uint8_t *) 0x1002;
volatile uint8_t * const REG_4 = (uint8_t *) 0x1003;

Dann können Sie in Ihrem Code Schreibregister wie folgt lesen:

uint8_t reg1_val = *REG_1; // read value from register 1
*REG_2 = 0xff;             // write 0xff to register 2

Ich glaube, dass der beste Weg, um Ihr Ziel zu erreichen, darin besteht, Ihren eigenen Malloc zu implementieren, der 4 Byte mehr zuweist und die Größe des Speicherblocks wie folgt speichert:

void* mymalloc(int size)    
{
    char* ptr = malloc(size+sizeof(int));
    memcpy(ptr, &size, sizeof(int));
    return ptr+sizeof(int); 
}

Was ich erreichen möchte ist: Ein Prozess ruft malloc mit Größe x auf und ich möchte einen bestimmten Wert (die Größe) vor dem zugewiesenen Speicher speichern, damit ich später auf die Größe zugreifen kann (wenn free aufgerufen wird). Da malloc aufgerufen wurde, kenne ich den Zeiger, wo das Betriebssystem Platz für den Wert zugewiesen hat und möchte nur die Größe des zugewiesenen Speichers in den 4 Bytes vor dem zugewiesenen Speicher speichern.

Das ist Also nicht arbeiten gehen. Sie dürfen nur auf Speicheradressen schreiben, die Ihnen von Ihren Bibliotheken zugewiesen wurden. In C bedeutet das malloc und seine Freunde. In C++ bedeutet das auch malloc (obwohl Sie das in C++ vermeiden sollten) und new.

Beliebig Der Versuch, in irgendeinen Speicher außerhalb des expliziten Speicherplatzes zu schreiben, der von diesen Zuweisungsschemata zugewiesen wird, führt zu undefiniertem Verhalten. Was im Allgemeinen bedeutet, dass “schlechte Dinge passieren können”.

Zum Beispiel die 4 Byte vor einer Adresse, die von . zurückgegeben wird malloc kann ein Teil des Haufens sein. Das heißt, die Datenstrukturen, die malloc und free verwenden, um ihre Arbeit zu erledigen. Indem Sie an sie schreiben, haben Sie den Heap jetzt beschädigt; jede Speicherzuweisung oder -aufhebung ist jetzt mit Gefahren behaftet und kann spektakulär fehlschlagen.

Oder vielleicht liegen die 4 Bytes vor der Adresse außerhalb Ihres virtuellen Adressraums. In diesem Fall wird das Betriebssystem Ihr Programm umgehend beenden. Das passiert bei einer „allgemeinen Schutzstörung“ oder einer „Segmentierungsstörung“. Die gute Nachricht ist, dass dies normalerweise sofort geschieht, sodass Sie in einem Debugger sehen können, wo es passiert ist. Im Gegensatz zu Heap-Korruption, bei der Sie nicht sagen können, was schief läuft, es sei denn, Sie wissen, wie Ihr Heap funktioniert (oder ohne Heap-Debugging-Tools).

Sie können einen Typ an einem bestimmten Speicherort auf Freestore (auch bekannt als Heap) platzieren, indem Sie verwenden Platzierung Neu.