wie kann ich abwechselnd ma plus, mal minus rechnen?

a-b

im nächsten durchgang soll

a+b

kommen...
geht das orgendwie mit einer random funktion?

MfG SideWinder

add = false;
add ^= true ? a += b : a -= b;

Hast du dir mal die Operator-Rangfolge angesehen? Damit dieses Gebilde funktioniert, benötigst du noch zusätzliche Klammern.

@Travis: Und dein Fragment rechnet immer a+b aus

a=2;
b=5;
a-=(b*-1); // 5*(-1)=-5; 2-(-5) = 2+5=7
b=-5; //-5*(-1)=5; 2-5=-3

und es passt nicht?

for (int i = 0; i < n; i++)
   c= a+(b*pow(-1,i));

und nicht vergessen:

#include <cmath>

oder auch:

int multiplikator = 1;
for (int i = 0; i < n; i++)
{
   muliplikator *= -1;
   c = a+(b*mulitplikator);
}

Ja, wenn du b auf -5 setzt, wird es negativ Aber bei deinem obigen Code hast du b nirgends verändert.

achso, jetzt weiss ich was du meinst ^^
dann setzt einfach ein

b=b*-1;

vor die berechnung ^^

int a,b;
while(essollrechnen)
{
    a-(b*-1);
}

Nehmen S'e diesen:

int a,b;
while(essollrechnen)
{
  result = a-=(b*=-1);

  /* irgendwas mit a und/oder result machen */
}

Wenn schon kurz, dann wenigstens richtig und so, dass man damit überhaupt was anfangen kann

Ich würde die teure? Multiplikation da doch rausetzen...

int a,b;
char Vorzeichen = 1;
while(essollrechnen)
{
  if( Vorzeichen ) result = a-=b;
  else             result = a+=b;

  Vorzeichen^=1;

  /* irgendwas mit a, b und/oder result machen */
}

Keine Multiplikation, dafür ein Vergleich gegen 0 und ein Jump mehr.
Ob das auf aktuellen CPUs noch jemanden interessiert, kann ich nicht sagen, aber der Vergleich gegen 0 ist nicht teuer.

Müsste man mal gegeneinander laufen lassen, um zu erfahren, wie es aktuell aussieht. Bei Gleichstand würde ich die längere Variante bevorzugen, da ich sie für verständlicher halte. Aber das ist sowieso subjektiv. Wichtiger die Frage, ob man b kopieren muss, weil es noch gebraucht wird?!

struct Operator
{
	Operator()
		: op( sub )
	{
	}

	int operator () ( int lhs, int rhs )
	{
		( op == sub ) ? ( op = add ) : ( op = sub );
		return op( lhs, rhs );
	}

private:

	static int add( int lhs, int rhs )
	{
		return lhs + rhs;
	}

	static int sub( int lhs, int rhs )
	{
		return lhs - rhs;
	}

	(int)(*op)(int,int);
};

int DoOp( int lhs, int rhs )
{
	static Operator op;
	return op( lhs, rhs );
}

int main()
{
	int a = 3;
	int b = 6;
	int i = 10;
	while( i-- )
		cout << DoOp( a, b ) << "\t";
}

Man kann es ja echt übertreiben, aber wenn ihr es unbedingt übertrieben haben wollt:

[Lösung per Funktionszeiger]

Das wird langsamer sein, weil Du laufend Daten auf den Stack kopieren musst.
Das ist teurer als die Vergleich oder die Multiplikation, insbesondere, wenn Du noch DoOp dazwischen stehen hast.

EDIT: Abgesehen davon solltest Du die Zuweisung von op in die jeweilige Funktion packen, damit Du Deinen Vergleich wenigstens noch sparst. ^^

Ich würde die teure? Multiplikation da doch rausetzen...
...
Keine Multiplikation, dafür ein Vergleich gegen 0 und ein Jump mehr.
Ob das auf aktuellen CPUs noch jemanden interessiert, kann ich nicht sagen, aber der Vergleich gegen 0 ist nicht teuer.

ok. wüßte zu gerne, was ein sprung kostet.
mal was ohne sprung und ohne plutimikation:

int a,b;
int Vorzeichen = -1;
while(essollrechnen)
{
  a=a+(b&Vorzeichen);
  Vorzeichen=~Vorzeichen;
  a=a-(b&Vorzeichen);
  //irgendwas mit a machen
}

Müsste man mal gegeneinander laufen lassen, um zu erfahren, wie es aktuell aussieht.

jo.

Nehmen S'e diesen:

int a,b;
while(essollrechnen)
{
  result = a-=(b*=-1);

  /* irgendwas mit a und/oder result machen */
}

Ich würde die teure? Multiplikation da doch rausetzen...

hm...

int a,b;
while(essollrechnen)
{
  a-=b=-b;

  /* irgendwas mit a machen */
}

a-=b=-b

du hast gewonnen.