Ich bekomme immer nur b ausgeben.

#include <iostream>
using namespace std;

int start (int a, int b );

int main()
{
int a,b;
int erg;

erg = start(a,b);

cout<<erg<<endl;

system("PAUSE");
}
//---------------------------------------------------------------------------

int start (int a, int b )
{
a = 2;
b = 3;

return a,b;

}

P.S.: Was hast du denn erwartet, was bei deiner Zuweisung (erg) passiert? Bekommt erg dann den Wert von a oder von b? Oder von beiden? Werden die dann addiert oder wie?

Aus der MSDN:
Commas can be used as separators in some contexts, such as function argument lists. Do not confuse the use of the comma as a separator with its use as an operator; the two uses are completely different.

Consider the expression

e1 , e2

The type and value of the expression are the type and value of e2; the result of evaluating e1 is discarded. The result is an l-value if the right operand [...}.

Eine Möglichkeit: Mach die Argumente deiner Funktion zu Pointern (so dass die Originale und keine Kopien in der Funktion verändert werden), und gib dann nach Aufruf der Funktion a und b einfach aus.

Besser: Mit Referenzen. Leichter zu lesen, und die Argumente können nicht NULL sein...

void a_b_setzen(int & a, int & b)
{
    a = 2;
    b = 3;
}

void a_b_setzen(int * a, int * b)
{
    if(a)
      *a = 2;
    if(b)
      *b = 3;
}

Also da sind Referenzen mir doch deutlich lieber...

P.S: Ändert nichts daran das dies aber die Ursprünglichen Werte ändert, und kein Ergebniswert...

Mit den einen, feinen Unterschied, dass man eine Übergabe per (C++-)Referenz an der aufrufenden Stelle nicht optisch von normalem by-value unterscheiden kann.

So? Also zumindestens meine IDE zeigt die Typen der Parameter an...
Ja, im Code kann man es an der Aufrufstelle nicht erkennen (Daher habe ich die Funktion auch "a_b_setzen" genannt; zumindestens aussagekräftiger als "start"...).

_matze schrieb:

Aber das NULL-Argument ist natürlich vollkommen richtig. Vielleicht sollte ich langsam mal anfangen, mich umzugewöhnen...

Mich stören eher die Sprachen bei denen man dies Typabhängig betrachten muss (Sprich sowas wie Implizite Wertübergabe bei integralen werden und PODs und Referenzübergabe bei Klassen und Co...). In C++ sieht man es wenigstens dem Funktionsrumpf an, und kann auch angeben ob änderbar oder nicht (const bei Parametern vermisse ich auch in vielen Sprachen, gerade bei impliziter Referenzübergabe).

cu André

So? Also zumindestens meine IDE zeigt die Typen der Parameter an...

Sicher, wenn du die Maus in die Hand nimmst und dir den Tooltip holst. Ich bin (zumindest beim Programmieren) eigentlich eher der Tastatur-Freak, der eine Maus nur in höchster Not anpackt. Im Ernst, ich finde es einfach schöner, wenn man sowas auf einen Blick sieht, und das bietet keine IDE. Warum konnte man nicht einfach festlegen, dass z.B. bei der Übergabe auch ein "&" hinter dem Bezeichner stehen muss/kann? Hätte mir besser gefallen. Aber das sind letztlich nur Kleinigkeiten. Und ich gab dir ja Recht, dass Referenzen Vorteile haben, die nicht von der Hand zu weisen sind, Man sollte seine optischen Ansprüche vielleicht nicht über die Sicherheit des Codes stellen (solange die negativen Auswirkungen sich im Rahmen halten und ihrerseits nicht wieder die Sicherheit gefährden ).

asc schrieb:

So? Also zumindestens meine IDE zeigt die Typen der Parameter an...

Sicher, wenn du die Maus in die Hand nimmst und dir den Tooltip holst.

Der kommt beim Tippen nach kurzen Warten auch ohne Maus...

_matze schrieb:

Ich bin (zumindest beim Programmieren) eigentlich eher der Tastatur-Freak, der eine Maus nur in höchster Not anpackt.

Während des Programmierens ist dies bei mir auch so (Obwohl ich zu denen gehöre die mit der Maus aufgewachsen sind. Am Atari ST war die Maus gang und gäbe, der Umstieg auf DOS und Windows 3.1 war im ersten Moment für mich ein Rückschritt).

_matze schrieb:

Warum konnte man nicht einfach festlegen, dass z.B. bei der Übergabe auch ein "&" hinter dem Bezeichner stehen muss/kann? Hätte mir besser gefallen.

Ich hätte auch nichts gegen Markierungen wie in/out/ref bei Übergaben, so in der Form: "a_b_austauschen(ref a, ref b);". Aber dazu ist die Syntax von C++ schon viel zu alt.