Zeiger und immernochnicht verstanden!

HAllo leute,

ich habe eine aufgabe, die hatte ich glaub ich schonmal gepostet, asber ich verstehs einfach nich:

Aufgabe:

[b]Die Übung:[/b]
Definieren Sie einen char-Zeiger und eine long-Variable. Die long-Variable ist mit dem Hex-Wert 0x12345678L zu initialisieren.

Stellen Sie dann die Ausgabe auf Hex um. Zusätzlich soll bei allen nachfolgenden Ausgaben die eingestellte Zahlenbasis mit ausgegeben werden (cout-Flags!).

Geben Sie zunächst den Inhalt der long Variablen aus. Anschließend ist der Inhalt der long Variable in Byte-Darstellung auszugeben, so wie unten angegeben.

 Hinweis: Verwenden Sie dazu den char-Zeiger. Die unten stehende Ausgabe gilt nur bei Prozessoren, bei denen das Low-Byte auch auf der niederen Adresse liegt. Bei anderen Prozessoren erhalten Sie eine umgekehrte Ausgabe. 

Zum Schluss ist der char-Zeiger auf die Adresse des String-Literal "ABCD" zu setzen. Der String ist dann mithilfe des char-Zeigers in einzelne Buchstaben zu zerlegen und auszugeben (siehe Programmausgabe unten).

[b]Die Programmausgabe:[/b]
0x12345678 liegt wie folgt im Speicher:
0x78,0x56,0x34,0x12
String ist: ABCD
In Buchstaben: A,B,C,D

wie komm ich denn auf die programmausgabe?
Wie komm ich auf die 4 adressen?

Ich verstehs einfach nich!

was verstehst du da nicht?

hier ist nix mit hausaufgaben erledigen!

poste mal bissle code

tipp

char *c; // dein char zeiger
long l; // keine long variable
// 0x12345678L ==  305419896 in dezimal also
l = 305419896;  // entweder selber kurz ausrechnen oder casten oder oder
// oder
l = 0x12345678; // ;)

// ausgaben mit cout

cout << l << endl; // hier normal ausgeben
cout << // hier die flag nutzen, man kann jede zahl einfach auch hex anzeigen lassen

// ein buch oder google würde helfen

string str = "ABCD"

// tipp str[i]  also das *c auf str[i] zeigen lassen und dann 

// wie wird man das wohl machen? hmm ;) dann einfach den zeigen c einfach ++ machen ;)

so die tipps muessten reichen also

1. versuch anfang
2. suche hier im forum nach volkrads kurs dort die zeiger anschauen oder googlen

//lol ich meine

// *c auf  str zeigen lassen also zeigs dann auf str[0]
str = "ABCD"; // str[0] = A --> str[3] = D
// sorry

nützliche ergänzung

flags

z.b.

right
hex <--- gut
dec
uppercase
ect.
ect.

bsp

cout.unsetf(ios::uppercase);  //lösche uppercase
cout.setf(ios::right); // was wird das wohl sein

Sind keine hausaufgaben, is ausm tutorial!

Also ich versuche mal zusammenzutragen:

das das hier rauskommen muss:

0x78,0x56,0x34,0x12

liegt daran, das es ein long ist, und der 4 bytes belegt!oder?

String ist: ABCD
In Buchstaben: A,B,C,D

hier dachte ich, das sich das zu der longvariablen bezieht?!
Weil ich erst von den 4 adressen verwirrt war...da dachte ich das die loingvariable als char ABCD ergibt....ist wohl falsch oder?

@newkid: das versteh ich hier nich(schaue meine kommentare

long l; // keine long variable <---------??? wieso keine??
// 0x12345678L ==  305419896 in dezimal also
l = 305419896;  // entweder selber kurz ausrechnen oder casten oder oder
// oder
l = 0x12345678; //und wieso das nochmal normal ausgeben?? da sollen doch die speicheradressen hin, oder???

geil ne?
ich hab mich vertippt

natürlich ist

keine

falsch und es muss

EINE heissen

aber immer wieder nett, wie man leute damit verwirren kann

Weil ich erst von den 4 adressen verwirrt war...da dachte ich das die loingvariable als char ABCD ergibt....ist wohl falsch oder?

musst schon die aufgabenstellung lesen

Adresse des String-Literal "ABCD" zu setzen. Der String ist dann mithilfe

weiss ja nicht warum ein string ein long sein soll, bei dir

Wenn du den zeiger auf str zeigst. also auf den string, dann zeigt der auf die "erste" adresse von string str. also auf das A

ein A ist laut acsii

http://www.torsten-horn.de/techdocs/ascii.htm

endweder 41 hex oder 65 dezimal ein "A"

0x78 wäre ja "x"

bissle googeln hilft

versuch mal die aufgabe mit dem string zuerst ist einfacher und mit wenigen zeilen erledigt. dann hast ein kleines verständnis schon mal. im internet gibts zig bsp dazu. check dann die flags ab. und dann mit der long variable versuchen

wie gesagt lies echt mal genau durch

und wieso das nochmal normal ausgeben??

darum

Geben Sie zunächst den Inhalt der long Variablen aus. Anschließend...

ausgeben kansnte mit

cout << hex << .....  // das hex halt ne zahl hex ausgeben.

so ähnlich wie die sting funktioniert die long auch.

also fang mal mit dem tutorial an und zeig bissle deine versuche, dann werde ich dir helfen

hey ich meine

wenn ich es dir hinposte haste nichts davon. dann vergisst es wieder und ausserdem hast du dieses tolle

"ich habs GESCHAFFT" erlebnis dann nicht. und ey. das will ich dir nicht wegnehmen

l = 0x12345678; //und wieso das nochmal normal ausgeben?? da sollen doch die speicheradressen hin, oder???

ähm du verwechselst da was

da gebst du nichts aus. damit kannst du der long l variable die zahl hex gleich übergeben

entweder halt dezimal übergeben ( zuweisen als fachwort ) oder halt hex

du kannst auch z.b. sowas machen.

int i;

i = 20;  // i ist 20 dez und 20 halt
i = 0x14;  // i = 14 hex oder halt 20 dezimal  du brauchst "l = 0x12345678;"
i = 024; // i = 24 oktal oder halt den dezimalwert von 20

also kannst du die zahl gleich hex zuweisen.

exkurs

ja ein long sind entweder 32 ( meistens ) oder 64 bit

bei 8 bit = 1 byte ergibt sich dann

32/8 = 4
ein char hat 8 bit = 1 byte ( in deinem fall )

also den rest kannst dir ja denken, ist wie beim string

also das mit dem string hab ich mal versucht, scheint auch zu funktionieren:

int main(int argc, char* argv[])
{
string str = "ABCD";
unsigned char* ptr;
for (int i = 0;i<str.length();i++)
 {
 *ptr=str[i];
 cout<<*ptr<<endl;
 }
getch();
        return 0;
}

nun werd ich nochmal das mit dem long probieren!

Bei dem long brauch ich aber auch einen zeiger oder?
Auch den char zeiger? (Weil in aufgabenstellung ja nur von charzeiger die rede ist)!

Ja nen char-Zeiger, sonst gibts die HEX-Zahlen die im Speicher stehen..;)

so also das long geht nich so richtig!

int main(int argc, char* argv[])
{
long var = 0x12345678;
char *ptr = reinterpret_cast<char*>(&var);
for(int i = 0;i<4;i++)
{
cout<<ptr[i]<<endl;
}
getch();
        return 0;
}

aber er gibt mir den speicherinhalt aus, aber nich als 78 etc...eben nur als x!

PunI*0R

Machs so:
char *ptr;
ptr = (char &var;
Damit sagst du ihm das er egal was da steht, es auf jeden Fall Buchstaben sind.

ich will ja aber eben KEINE buchstaben ausgeben, sondern das:

0x78,0x56,0x34,0x12

PunI*0R

Wirklich? Dafuer muesstust du die flags im ofstream aendern..
Was willst du damit ueberhaupt bezwecken?

bei der string aufgabe kannst du auch

den zeiger auf string zeigen lassen dann

for schleife von int i = 0 bis size

den zeiger++ machen und

cout zeiger // ausgeben

ist geschmackssache

zu der long aufgabe

du musst wie gesagt die aufgabenstellung lesen

da steht extra dran das du die FLAG nehmen sollst und ich sagte es auch mehrmals

in deinem long bsp hast du NULL etwas mit FLAGS gemacht. Tja so kannst dann auch nichts werden. schau dir FLAG bsp an und da findest schon was du brauchst, etwas rumprobieren und voila es geht

viel spass

PunI*0R

Die cout-Flags sind nich soo einfach oder??

Uup, sry hab nur nicht das richtige auf anhieb gefunden..

hm...hab ios::hex, ios::dec, ios::alles probiert, es kommt immer nur x bla bla bla!

iomanip inkludiert!
cout.setf() und cout<<hex etc... genommen!

hm...

PS:
@Newkid: aber meine stringmethode is nicht schlechter oder??

Windoof

Hmm... wir haben gelernt, dass char (Zeichen) nur 8 Bit (1 Byte) ist. Dieses kann man als Zahl anzeigen lassen. Um eine Zahl als hex anzuzeigen muss man den hex-flag setzen. Dass man casten kannst, hast du ja selbst schon herausgefunden, also ergibt sich was aus deinem Code? - Richtig, das hier:

int main(int argc, char* argv[])
{
long var = 0x12345678;
char *ptr = reinterpret_cast<char*>(&var);
for(int i = 0;i<4;i++)
{
cout<<hex<<(int)ptr[i];//und ohne endl, weil du willst die zeichen ja hintereinander, nicht untereinander.
if(i<3) cout<<", "; // Damit es auch schön mit Komma getrennt ist...
}
cout<<endl; // Aber zum Schluss natürlich endl ;)
getch();
        return 0;
}

hm....ich bin auf das hier gekommen:

int main(int argc, char* argv[])
{
long var = 0x12345678;
char *ptr = reinterpret_cast<char*>(&var);
cout.flags(ios::hex|ios::showbase);
for(int i = 0;i<4;i++,ptr++)
{
cout<<static_cast<int>(*ptr)<<endl;

}
getch();
        return 0;
}

is das falsch?