✔ Speicher frage

[2fast4you87]

Hallo Leute,

Habe mal eine Generelle Grage zu Speicher addressierung.

char * pC = (char *)malloc(5);
pC = "hallo";
cout << &pC;

Der Code gibt mir ja die Start Adresse von pC aus.
Kann ich jetzt aber sowas machen :

pseudo :

cout << &pC; /* 0012FF7C */
char * pC2 = 0012FF7C;

/* sprich die Pointer Adresse kopieren ohne zu sagen: */

pC2 = pC1; /* flache kopie der start Adresse von pC1 */

Habt ihr da eine Idee?

Gruß 2fast...

 

[Matthias Reitinger]

char * pC = (char *)malloc(5);
pC = "hallo";
cout << &pC;

Besser wäre malloc(6), da du auch Platz für das zeichenkettenbegrenzende Nullbyte reservieren musst.

Kann ich jetzt aber sowas machen :

pseudo :

cout << &pC; /* 0012FF7C */
char * pC2 = 0012FF7C;

/* sprich die Pointer Adresse kopieren ohne zu sagen: */

pC2 = pC1; /* flache kopie der start Adresse von pC1 */

Natürlich kannst du einem Zeiger einen beliebigen Wert (=beliebige Speicheradresse) zuweisen. Ob das immer sinnvoll ist, ist natürlich eine andere Frage.

 

[jsendrow]

Hallo Leute,

Habe mal eine Generelle Grage zu Speicher addressierung.

char * pC = (char *)malloc(5);
pC = "hallo";
cout << &pC;

pC = "hallo" kopiert nicht den Inhalt der Zeichenkette in den vorher reservierten Speicher sondern setzt lediglich den Zeiger auf die Speicheradresse dieser Zeichenkette. Um eine Zeichenkette zu kopieren müßte man hier so etwas wie: strcpy(pC, "Hallo") benutzen.

Der Code gibt mir ja die Start Adresse von pC aus.
Kann ich jetzt aber sowas machen :

pseudo :

cout << &pC; /* 0012FF7C */
char * pC2 = 0012FF7C;

/* sprich die Pointer Adresse kopieren ohne zu sagen: */

pC2 = pC1; /* flache kopie der start Adresse von pC1 */

Habt ihr da eine Idee?

Gruß 2fast...

0012FF7C ist offensichtlich ein Hexadezimaler wert und muß daher im Sourcecode auch entsprechend gekennzeichnet werden, also 0x0012FF7C. Mit Ausnahme von festen Speicheradressen, wie z.B. Hardwareadressen macht es aber keinen Sinn sowas fest zu programmieren.

 

[2fast4you87]

#include <iostream>
	using namespace std;

int main(int argc,char *argv[]){
	
	char * pc1 = (char *) malloc(6);
	pc1 = "hallo";

	/*
		0012FF7C << pc1
		0012FF78 << pc2 
	*/

	char * pc2 = (char *) 0x0012FF7A;

	cout << &pc1 << endl << &pc2;
	return 0;
}

Ich gebe dich jetzt der variable einen festen Speicher wert! Trotzdem gibt der mir einen anderen nur warum ?

 

[Matthias Reitinger]

	char * pc1 = (char *) malloc(6);
	pc1 = "hallo";

Der Aufruf von malloc ist hier unnötig, wie jsendrow schon erläutert hat.

	char * pc2 = (char *) 0x0012FF7A;

	cout << &pc1 << endl << &pc2;

Was willst du damit bezwecken? Was wird denn ausgegeben? Was sollte deiner Meinung nach ausgegeben werden?

 

[2fast4you87]

Hi,

Das ist nur zu reinem Interesse, ich kann wohl kaum einen festen Adressen wert in einer variable speichern, das würde früher oder länger schief gehn!
Trotzdem möchte ich mir die Adresse ausgeben lassen und die expliziet einen neuen Pointer damit belegen.

Ich weiß wie Pointer funktionieren, arbeite da oft mit (listen, singleton ...).
Nur das möchte ich einfach mal ausprobieren, bzw erst einmal hinbekommen.

edit: aber ohne eine flache oder hohe kopie ...

Oh sry habe nicht alle fragen beantwortet : "
Ausgabe :
0012FF7C << pc1
0012FF78 << pc2

ich dachte wenn ich sage pc2 = 0x0012FF7C; das dass auch beid er Ausgabe raus kommt!

 

[jsendrow]

Wenn wir folgendes definierren:

char* pc1 = "Hallo";

dann können wir darüber diese Informationen abfragen:

*pc1 = der Inhalt des Speicehrbereiches, worauf der Zeiger Zeigt, im Beispiel also "H";

pc1 = die Adresse des Speichers, auf den der Zeiger zeigt, also die Adresse des Strings in dem Fall.

&pc1 = die adresse der Zeigervariablen, nicht zu verwechslen mit der Adresse des Speichers, worauf der Zeiger zeigt.

Wenn Du also z.B.

char * pC2 = 0x0012FF7C;

schreibst, dann kannst du mit

cout << pc2; eben diese adresse wieder ausgeben.

Ich weiß wie Pointer funktionieren, arbeite da oft mit (listen, singleton ...).

Offensichtlich weisst Du es noch nicht

 

[deepthroat]

Hi.

char * pC2 = 0x0012FF7C;

schreibst, dann kannst du mit

cout << pc2; eben diese adresse wieder ausgeben.

@2fast4you87: Natürlich mußt du dann noch in void* casten sonst gibt er den C-String aus - aber das hast du dir sicherlich schon gedacht.

cout << static_cast<void*>(pc2);

Gruß

 

[RedWing]

Hallo,

	char * pc1 = (char *) malloc(6);
	pc1 = "hallo";

Der Aufruf von malloc ist hier unnötig, wie jsendrow schon erläutert hat.

Der Aufruf von malloc ist da nicht nur unnötig sondern auch falsch,
das resultiert in einem Speicherleak.

Wenn Du also z.B.

char * pC2 = 0x0012FF7C;

schreibst, dann kannst du mit

cout << pc2; eben diese adresse wieder ausgeben.

Das gibt wie deepthroat schon richtig sagte den String aus, nur mit dem Zusatz
das es höchst wahrsch in einem Speicherzugriffsfehler resultiert, da auf irgendwelchen
Speicher zugegriffen wird, der möglicherweise nicht mit '\0' abgeschlossen ist...

Gruß

RedWIng

 

[2fast4you87]

So habe heute mit dem Debugger haltepunkte eingesetzt und mir den Speicher angeguckt!

char * pc; << 0012FF7C adresse 
pc = "hallo"; << addr -> 0012FF7C bekommt als Inhalt die Adresse wo hallo steht

Ist das richtig?

Wenn ja wie kann man den expliziet sagen der pointer char pc hat die Adresse 0012FF7C?


Und warum ist malloc(6) falsch?
malloc sagt doch nur reseviere 6 adresspeicher und gebe sie als void * zurück. wenn ich also :

char * pc = (char *) malloc(6);

mache dann bekommt pc ne adresse mit inhalt eine addresse zu 6 speicher addressen.

Laut msdn muss man malloc() oder new machen.

Oder habe ich da was falsch verstanden!?


gruß 2fast ...