Warum meckert der Compiler in der Zeile 13 rum?

int main()
{
	int *xPtr;
	int test, neu;

	test = 4;

	xPtr = &test;

	xPtr = xPtr + 64000;

	xPtr = 0x0000AAAA;

	*xPtr = 16;

	cout << *xPtr;

return 0;
}

Warum steht in meinen Folien ein ähnliches Beispiel, aber so aufbereitet, als ob das funktionieren sollte! (Das sind Folien unseres Dozenten.)

void main()
{
int x;
int * xPtr;

xPtr = &x;
*xPtr = 0x00FF00FF;
xPtr = 0x0000FFFF;

return 0;
}

Warum meckert der Compiler in der Zeile 13 rum?

Liest du die Fehlermeldungen auch ab und zu? Darin steht meist der Grund.

vip@r schrieb:

Warum steht in meinen Folien ein ähnliches Beispiel, aber so aufbereitet, als ob das funktionieren sollte! (Das sind Folien unseres Dozenten.)

Frag das den Dozenten. Jedenfalls ist es nicht erlaubt, einen int implizit (ohne Cast) zu einem int* zu konvertieren.

Übrigens heisst es int main() .

Der Code deines Dozenten wird übrigens aus dem gleichen Grunde nicht compiliert werden. Und wenn ich void main sehe, scheint es bei ihm sowieso nicht weit her zu sein mit korrektem Code.

Hier noch eine Frage:

int main()
{
	int * iPtr;
	double * dPtr;
	int test, neu;

	(int*)dPtr;

	(double*)iPtr;

	*iPtr = 5.5;
	*dPtr = 5;

	cout << *iPtr << endl << *dPtr;

return 0;
}

Hier kommt kein Compiler-Error. Hier sagt mir eine Fehlermeldung des Programms, dass die Variable iPtr ohne initialisierung benutzt wird. Versteh aber nicht warum. Sind hier die Casts falsch?

Hier kommt kein Compiler-Error. Hier sagt mir eine Fehlermeldung des Programms, dass die Variable iPtr ohne initialisierung benutzt wird. Versteh aber nicht warum. Sind hier die Casts falsch?

Na, was wird die Warnung wohl bedeuten? Zeig doch mal auf die Stelle, an der iPtr ein Wert zugewiesen wird. Denk dran, iPtr und *iPtr sind ganz verschiedene Objekte.

Was die Casts angeht:
1. Ich kann dir sagen, die machen überhaupt nichts.
2. Ich habe aber keine Ahnung, was sie überhaupt machen sollen. Erleuchte mich. Willst du dass dPtr seine Identität ändert und ein *int wird?

Auf solche Antworten kann ich VERZICHTEN!

Bitte nicht nach Entschuldigungen betteln. An dem Zeitunterschied eurer Posts kannst du erkennen wer gemeint war.;)

Nochmal ein neuer Versuch. Ich hab grad in der Fehlermeldung gelesen, dass das irgendwie mit einem Links-Wert was zu tun haben muss. Leider funktionierts aber auch nicht...

@hmpf: Ok. Dann hab ich das so nicht gemeint. Sorry, 314159265358979!

Hoppla, jetzt muss ich mich entschuldigen. Habe dich mit Skym0sh0 verwechselt. Daher nur munter drauf auf diesen Pi.

Kannst du verbal ausdrücken, was du mit dieser Zeile erreichen willst:

iPtr = (double*)iPtr;

Hoppla, jetzt muss ich mich entschuldigen. Habe dich mit Skym0sh0 verwechselt. Daher nur munter drauf auf diesen Pi.

Mir ist das jetzt egal. Ich bin nicht sehr nachtragend.

Hab jetzt noch was gefunden. So geht's jetzt anscheinend. Der Sinn eines solchen "Konstrukts" bleibt mir allerdings verborgen, da das ja nix mit einer Typumwandlung zu tun hat, "wie man sie gewöhnt" ist.

int main()
{
	int test_int = 5;

	int *iPtr = &test_int;

	double *dPtr = (double*)iPtr;

	cout << *iPtr << endl << *dPtr;

return 0;
}

Es wandlet ja hier eigentlich nix um, in dem Sinn, dass man die gleiche Variable nur mit einem anderen Typ verwendete sondern viel mehr muss anscheinend nichts desto trotz eine neue Variable eingeführt werden... Irgendwie versteh ich das nicht...

Hier gibts einen guten Artikel zu Zeigern, lies ihn.

Ich wollte damit erreichen, dass die vormals int-Zeiger-Variable eine double-Zeiger-Variable wird. So wie man das mit "normalen" Variablen auch machen kann... In der Form wie:

int a;
	double b;

	(int) b;

2. ist richtig, @SeppJ.

Oje, da kann ich mich fast nur 314159265358979 anschließen. Jedenfalls fehlt dir mehr Verständnis über Casts, als ich mir zutraue, dir beizubringen. Falls jetzt nicht ein sehr motivierter Forenteilnehmer einen Artikel über Casts schreiben möchte, kann ich dich eigentlich nur an ein Lehrbuch verweisen. Dir fehlen jedenfalls absolute Grundlagen.

Um zu deinem Problem zu kommen: Das geht so nicht. Du kannst nicht den Typen eines Bezeichners ändern. Du kannst nur ändern, als welcher Typ sich der Bezeichner in einer bestimmten Ausdruck verhält. Das nennt man dann Casten. Und das ist eigentlich etwas, was man nur äußerst selten braucht. Vielleicht mal ein Beispiel:

Wie du sicherlich nicht weißt, haben die meisten Computersprachen eine spezielle Division für Ganzzahlen:

int a = 10;
 int b = 3;
 cout << a / b;   // Ergibt genau 3!

Was ist aber, wenn du lieber ein Fließkommaergebnis hättest? Dann musst du dem Compiler irgendwie klarmachen, dass a und/oder b sich in dem Ausdruck wie eine Fließkommazahl (z.B. double) verhalten sollen. Dazu kann man einen Cast benutzen:

cout << static_cast<double>(a) / b;   // Ergibt 3.3333333333

Das static_cast<double>(a) macht, dass sich das a an der Stelle wie ein double verhält. Der Compiler sieht dann eine Division von double durch einen int (das b) und macht eine Fließkommadivision. Das static_cast bedeutet, dass dies eine "unproblematische" Umwandlung ist. Es ist absolut klar, dass der int mit dem Wert 10 einem double mit Wert 10. entspricht (achte auf den Punkt nach der 10). Es gibt auch noch andere Casts für andere Fälle, die erkläre ich aber hier nicht. In vielen Fällen deuten diese anderen Casts auch stark auf Designprobleme hin. Deine Pointerkonversionen die du im ersten Beitrag machen wolltest, gehen mit einem static_cast beispielsweise nicht, da braucht man den stärksten, den reinterpret_cast für, der dem Compiler sagt "ich weiß das sieht für dich nach Müll aus, aber ich weiß genau was ich da tue". Entsprechend hätte dein Programm im ersten Beitrag dann Laufzeitfehler verursacht, denn wu wusstest nicht, was du da tust.

(Und noch ein Nachwort: Normalerweise würde man in dem Beispiel eher nicht casten, um eine Fließkommadivision zu erzwingen, sondern die Regeln zu Typenkonvertierungen in Rechnungen benutzen. Dazu würde man dann 1. * a / b schreiben.)

edit: Da habe ich viel zu lange für den Beitrag gebraucht. In der Zwischenzeit hat sich im Thread einiges getan...

Ich wollte damit erreichen, dass die vormals int-Zeiger-Variable eine double-Zeiger-Variable wird. So wie man das mit "normalen" Variablen auch machen kann... In der Form wie:

int a;
double b;

(int) b;

Genau das meine ich, dir fehlen essentielle Grundlagen über das C++-Typsystem. Solange du Typen und Variablen nicht verstehst, kannst du Zeiger gleich vergessen. Gesteh dir ein, dass du hier noch etwas Nachholbedarf hast, und nimm dir die Zeit, um die entsprechende Theorie nochmals gründlich anzuschauen.