+ | - abwechselnd

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

MamboKurt

also mein vorschlag wäre:

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);
}

Ich würde ein enum mit 2 States vorschlagen. (anstatt der bool-Variable)

CStoll (off) schrieb:

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 ^^

Xin

TravisG schrieb:

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?!

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

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";
}

Xin

Übertrieben schrieb:

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. ^^

volkard

Xin schrieb:

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.

camper

Xin schrieb:

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 */
}

volkard

camper schrieb:

a-=b=-b

du hast gewonnen.