Jo, ich habe mal ein kleines billiges Programm programmiert. Es liest 2 Zahlen ein und multipliziert sie und gibt das Ergebnis aus. Doch dieses ist immer 0!
Hier ein Bild:

Und hier der Quelltext:
Quellcode:
#include <iostream>
#include <iomanip>
#include <string>
using namespace std;

#define BUFFER ( cin >> buffer )

char buffer;
int x_achse;
int y_achse;
int ergebnis = ( x_achse * y_achse );

void main()
{
    cout << "Wert fuer X-Achse eingeben: ";
    cin >> x_achse;

    cout << "Wert fuer Y-Achse eingeben: ";
    cin >> y_achse;

    cout << endl;
    cout << "X-Achse = " << x_achse << endl;
    cout << "Y-Achse = " << y_achse << endl;
    cout << "Ergebnis = X-Achse * Y-Achse" << endl << endl;

    cout << x_achse << " * " << y_achse << " = " << ergebnis << endl;

    cout << "Das Feld betraegt " << ergebnis << " Units" << endl;
    BUFFER;
}


Mir ist das schon öfters passiert und ich habe es irgendwie auch wieder hinbekommen, aber ich vergesse immer wie :|

Logisch.
1. Wieso deklarierst du alle Variblen global?
2. Du definierst ja ergebnis bevor du weißt was x- und y-achse íst!

Du könntest entweder eine Funktion schreiben, oder einfach so:
Quellcode:
cout << x_achse << " * " << y_achse << " = " << x_achse * y_achse << endl;


BattleTech-MOD:
http://bthl.unitedgaming.net/

also mich wundert das nich ;) Bei folgender zeile wird x_achse * y_achse gerechnet, aber beide Variablen sind noch gleich 0:

Quellcode:
int ergebnis = (x_achse * y_achse);


Deklariere ergebnis als int und berechne vor der Ausgabe des Ergebnisses folgendes:

Quellcode:
ergebnis = x_achse * y_achse


Zitat:

int ergebnis = ( x_achse * y_achse );

das ist eine zuweisung und keine gleichung im mathematischen sinne!

btw: DAS: #define BUFFER ( cin >> buffer ) ist uberevil

'KEINE PANIK' - aus der Triologie in fuenf Baenden von Douglas Adams

'FÜR DEINN FERD' - aus 'Gevatter Tod' von Terry Pratchett

soll mir doch egal sein was es is auf jedenfall liegts draan

Ok, danke erstmal für die Hilfe und das BUFFER (*g*) habe ich nur gemacht, um mir alles anzusehen.

Zitat:

[...]aber beide Variablen sind noch gleich 0

Man kann nur bei als static deklarierten Variablen davon ausgehen, dass sie
"automatisch" mit 0 intialisiert werden. Sonst ist der Wert undefiniert.

Ok , ist falsch, was ich gesagt habe. Da die beiden Variablen global sind, sind sie automatisch static. Sorry !

globale variablen sind nicht automatisch static, sie sind nur automatisch auto

'KEINE PANIK' - aus der Triologie in fuenf Baenden von Douglas Adams

'FÜR DEINN FERD' - aus 'Gevatter Tod' von Terry Pratchett

Mal ne frage (nicht lachen =) kann gerade net testen weil ich heute formatiert hab)
Wenn ich ne globale Variable deklariere und die in ner Funktion nutzen will, brauch ich noch den Scope Operator oder gehts auch ohne?

Den Scope-Operator brauchst du erst, wenn du in einer Funktion eine lokale Variable hast, die genauso heißt wie eine globale Variable:
Quellcode:int i = 10; // Globales i

void Foo(void)
{
    int i = 5; // Lokales i
    cout << "Global = " << ::i << "\nLokal = " << i << endl;
}

K:R-I)Z++
"CSS ist cascading style sheets. Und nicht so'n Ranzspiel." - dp
In memory of Voice († 2005/03/30)

machs doch einfach so:
#include <iostream.h>
#include <iomanip.h>
#include <string.h>
#define BUFFER ( cin >> buffer )

char buffer;

void main( void )
{
int x_achse;
int y_achse;
int ergebnis;

cout << "Wert fuer X-Achse eingeben: ";
cin >> x_achse;
cout << "Wert fuer Y-Achse eingeben: ";
cin >> y_achse;
cout << "X-Achse = " << x_achse << '\n';
cout << "Y-Achse = " << y_achse << '\n';
cout << "Ergebnis = X-Achse * Y-Achse" << '\n';
ergebnis = x_achse * y_achse;
cout << x_achse << " * " << y_achse << " = " << ergebnis << '\n';
cout << "Das Feld betraegt " << ergebnis << " Units";
BUFFER;
}

das ist dann wohl das einfachste für dein problem :]

Leveldesigner bei Dark-Zone

Zitat:

also mich wundert das nich ;) Bei folgender zeile wird x_achse * y_achse gerechnet, aber beide Variablen sind noch gleich 0:

Code:
int ergebnis = (x_achse * y_achse);

@wurm: was du in 011 gepostet hast ist noch nichtmal die einfachste lösung, die ist nämlich folgende:
Quellcode:
#include <iostream.h>
void main( void )

{
int x_achse;
int y_achse;

cout << "Wert fuer X-Achse eingeben: ";
cin >> x_achse;
cout << "Wert fuer Y-Achse eingeben: ";
cin >> y_achse;
cout << "X-Achse = " << x_achse << '\n';
cout << "Y-Achse = " << y_achse << '\n';
cout << "Ergebnis = X-Achse * Y-Achse" << '\n';
cout << x_achse << " * " << y_achse << " = " << x_achse*y_achse << '\n';
cout << "Das Feld betraegt " << x_achse*y_achse << " Units";
}

noch ein paar fragen: was ist der scope-operator? der doppelte doppelpunkt? (::)
und was sollte das mit dem buffer? tastendruck zum beenden? das macht man aber besser mit getch();

Entities: HL | HL²
Kompilierfehler
r_speeds | mehr über r_speeds

Der Scope-Operator (Auch glaub ich Zugriffsoperator gennant) legt den Scope (Sichtbarkeitsbereich) einer Variablen (z.B. ein Attribut einer Klasse) oder einer Funktion fest.
D.h. wenn du auf die Variable einer bestimmten Klasse zugreifen willst musst du sagen CDeineKlasse::DeineVariable
Oder wie Kriz mal auf Frage geantwortet hat: Wenn du ne globale Variable deklarierst und in einer bestimmten Funktion hast die genauso heißt dann musst du ja unterscheiden können welche der beiden Variablen du benutzen willst. Und das kann man eben damit.