2 simple fragen

hallo zusammen

2 simple fragen.

1. pointer:
ich habe mir gerade folgenden artikel durchgelesen:
http://www.codeproject.com/KB/cpp/pointers.aspx

wenn ich nun bspw folgende funktion habe:

static void Foo(int &myInt);

Wenn ich innerhalb dieser Funktion

*myInt = 3

mache, ändert sich die Variable ja auch ausserhalb.
bei

myInt = 3

ändert sie sich nicht, ist das so richtig?

wie kann ich einem WORD (unsigned short int) einen Binärwert zuweisen?
in ADA würde dies ja folgendermassen aussehen:

var := 2#0000_0000_1110_1000#;

- oniwa

ipsec

Kurze Antwort:
1. nein, nicht richtig
2. ist nicht direkt in der Syntax vorgesehen

Lange Antwort:

1. Du hast Pointer leider nicht verstanden. int &myInt definiert nicht etwa ein Pointer sondern eine Referenz. Ein Pointer wäre int *myInt . Aber selbst dann ist dir offenbar das Konzept hinter Pointern nicht richtig klar. myInt und *myInt sind völlig andere Sachen, das eine ist der Pointer selbst, das andere das Objekt, auf das er zeigt. Mit nach außen ändern oder nicht hat das nichts zu tun.

2. Am einfachsten kommst du wohl, wenn du die Literale (es geht ja sowieso nur um Literale) einfach umrechnest (so viele werden es ja nicht sein). Ansonsten gibt es z.B. bei boost::utility das Makro BOOST_BINARY .

SeppJ

oniwa schrieb:

hallo zusammen

2 simple fragen.

1. pointer:
ich habe mir gerade folgenden artikel durchgelesen:
http://www.codeproject.com/KB/cpp/pointers.aspx

wenn ich nun bspw folgende funktion habe:
static void Foo(int &myInt);
Wenn ich innerhalb dieser Funktion
*myInt = 3
mache, ändert sich die Variable ja auch ausserhalb.
bei
myInt = 3
ändert sie sich nicht, ist das so richtig?

Beides falsch. Bei *myInt=3 würdest du den Wert von myInt nicht ändern, sondern den Wert auf den myInt zeigt. Da myInt aber hier kein Zeiger ist, wird dies gar nicht erst compilieren. Bei myInt=3 würdest du die Variable auch außerhalb ändern, denn myInt ist eine Referenz. Kann es sein, dass du hier Referenzen und Zeiger durcheinanderwirfst? Denn wenn der funktionskopf so aussähe: static void Foo(int *myInt); , dann würden deine Aussagen stimmen. *myInt=3 würde dann den Wert der Variable ändern, auf die myInt zeigt. Und myInt=3 würde bloß den Wert des Zeigers auf 3 setzen, was die Variable auf die er vorher gezeigt hat unbeeeinflusst lässt aber insegesamt nicht viel Sinn macht.
Ich empfehle dir, dir aber erst einmal Referenzen anzugucken. Das ist leichter zu verstehen und sie leisten fast genau das gleiche wie Pointer.

wie kann ich einem WORD (unsigned short int) einen Binärwert zuweisen?
in ADA würde dies ja folgendermassen aussehen:

var := 2#0000_0000_1110_1000#;

Als Literal gar nicht. Du könntest dir zwar leicht eine Funktion zum Umrechnen schreiben (mit Templates sogar während der Compilezeit), aber einfacher wäre es wohl, einfach var = 232; zu schreiben.

Salute,

nochmal zur 1. Frage.

Dass ich mit & eine Referenz angebe, ist mir schon klar.
Nur, mit * sollte ich dann doch auf den Speicherbereich zeigen..?

muli

zu 1:

*myint = 3;

Ändert den Integerwert der Variablen auf die myint zeigt. (Dereferenzieren)

myint = 3;

Wird dir wahrscheinlich einen Compilererror einbringen da Du einem Zeiger nicht einen int wert zuweisen kannst.... Zeiger braucht eine Adresse.

zu 2:

Du kannst einen Hexwert zuweisen:

myshort = 0x00e8;

gruß muli

SeppJ

oniwa schrieb:

Salute,

nochmal zur 1. Frage.

Dass ich mit & eine Referenz angebe, ist mir schon klar.
Nur, mit * sollte ich dann doch auf den Speicherbereich zeigen..?

Ich verstehe die Frage nicht. Was soll zeigen? Du? Und auf welchen Speicherbereich?

Ich entnehme der Frage, dass du vermutlich weder Referenzen noch Pointer verstanden hast.

Fellhuhn

unsigned long aDec = std::bitset("0000000011101000").to_ulong();

Ist aber ein Overkill.

wxSkip

oniwa schrieb:

Salute,

nochmal zur 1. Frage.

Dass ich mit & eine Referenz angebe, ist mir schon klar.
Nur, mit * sollte ich dann doch auf den Speicherbereich zeigen..?

Eine Referenz benutzt du genauso wie eine normale Variable. Du KANNST sie nicht dereferenzieren. Beispiel:

#include <iostream>

void change(int &y)
{
    y = 5;
}

int main()
{
    int x = 3;
    change(x);    
    //weil hier eine Referenz genommen wird ist y effektiv die gleiche Variable wie x
    // (bzw. zeigt auf x aber du musst nix machen)
    //und daher wird die 5 auch in x gesetzt
    cout << x << endl;   //und hier wird dann auch 5 ausgegeben.
}

Nehmen wir das gleiche mit Pointern:

#include <iostream>

void change(int *y)  //hier Pointer!!
{
    *y = 5;   //du musst die 5 an die Adresse schreiben, auf die y zeigt
    //y = (int*)5 würde dazu führen, dass y auf das 5. Byte im Speicher zeigt und das is Blödsinn
}

int main()
{
    int x = 3;
    change(&x);    //hier musst du die Adresse angeben, bei der Referenz nicht   
    //so und hier passiert dann das gleiche
    //und daher wird die 5 auch in x gesetzt
    cout << x << endl;   //und hier wird dann auch 5 ausgegeben.
}