Problem mit Call by Reference

[leo aka qsch]

wenn du es so anschreibst wie du, kannst du nur die werte aendern da die zeiger temporaer sind

zb:

/* diese funktion tauscht die Zahlenwerte aus */
void Austausch_Werte(int *x, int *y)
{
     int hilf = *x;
     *x = *y;
     *y = hilf;
}

[life]

du änderst die zeiger und nicht die variablen auf die sie zeigen. Richtig wärs also:

void Austausch (int *x, int *y)
 {
        int hilf = *x;
          *x = *y;
          *y = hilf;
}

[Murphy]

uhhhhhhaaaaa.........was ist das? Kannst du mir das auch erklären ???

wo liegt der unterschied zwischen beiden !

[life]

Murphy schrieb:

uhhhhhhaaaaa.........was ist das? Kannst du mir das auch erklären ???

wo liegt der unterschied zwischen beiden !

wen meinste jetzt?

[camper]

#include <cstdlib>								// C++ header
#include <iostream>

void Austausch(int* x, int* y)
{
	int hilf = *x;                              // wir wollen die inhalte
	*x = *y;                                    // von *x und *y vertauschen
	*y = hilf;                                  // und nicht die zeiger, die
}                                               // sowiso nur lokal existieren

int main()                                      // jeder process gibt einen exitcode zurück,
{                                               // daher ist int main vorgeschrieben
	int a = 1, b = 2;
	Austausch( &a, &b );
	std::cout << a << '\t' << b << std::endl;   // printf ist erheblich
												// komplizierter und
												// fehleranfälliger als std::cout
    return EXIT_SUCCESS;
}

[Murphy]

ok .... hat sich schon erledigt!
Habs verstanden! Dann steht es in meinen Unterlagen falsch!

Danke schön !

[ssm]

Murphy schrieb:

uhhhhhhaaaaa.........was ist das? Kannst du mir das auch erklären ???

wo liegt der unterschied zwischen beiden !

es gibt keinen

[camper]

das ganze per reference:

#include <cstdlib>
#include <iostream>

void Austausch(int& x, int& y)
{
	int hilf = x;
	x = y;
	y = hilf;
}

int main()
{
	int a = 1, b = 2;
	Austausch( a, b );
	std::cout << a << '\t' << b << std::endl;
    return EXIT_SUCCESS;
}

insbesondere die andere aufrufsyntax macht viel besser klar, was vertauscht wird.

[camper]

noch ein kleiner zusatz, so geht es auch:

void Austausch(int& x, int& y)
{
	y ^= x;
	x ^= y;
	y ^= x;
}

[ssm]

#include <utility>
#include <iostream>

int main()
{
  int a = 1, b = 2;
  std::swap( a, b );
  std::cout << a << '\t' << b << std::endl;
  return EXIT_SUCCESS;
}

[camper]

ssm schrieb:

#include <utility>
#include <iostream>

int main()
{
  int a = 1, b = 2;
  std::swap( a, b );
  std::cout << a << '\t' << b << std::endl;
  return EXIT_SUCCESS;
}

tja, aber was lernt man dabei?

[ssm]

camper schrieb:

tja, aber was lernt man dabei?

STL :p

[Artchi]

camper schrieb:

tja, aber was lernt man dabei?

Nicht das Rad jedes mal neu zu erfinden. Und den Code versteht garantiert JEDER, der std::swap() kennt.

[SideWinder]

camper schrieb:

noch ein kleiner zusatz, so geht es auch:

void Austausch(int& x, int& y)
{
	y ^= x;
	x ^= y;
	y ^= x;
}

Ist das eigentlich performanter?

@ssm: Sollte das nicht so aussehen:

std::swap<int>(a,b);

oder gibts für int ne Spezialisierung?

MfG SideWinder[pclex]

[SideWinder]

BTW: Steckt swap nicht in der algorithm?

*komplett verwirrt bin jetzt*

MfG SideWinder

[leo aka qsch]

beides, is im std namespace aber auch bei den algos dabei

[SideWinder]

leo aka qsch schrieb:

beides, is im std namespace aber auch bei den algos dabei

"beides, ist im Haus aber auch im Wohnzimmer" passt nicht zu "Ists im Wohnzimmer oder im Esszimmer"

MfG SideWinder

[ssm]

SideWinder schrieb:

oder gibts für int ne Spezialisierung?

wozu braucht man eine Spezialisierung für sowas???

template<typename T>
void swap(T &t1, T &t2)
{
   T tmp = t1;
   t1 = t2;
   t2 = tmp;   
}

Compiler soll in der Lage sein, solche Dinge selbst zu machen. Wenn dein Compiler sowas nich kann, schmeiß ihn in Mühl !!!

[ssm]

SideWinder schrieb:

BTW: Steckt swap nicht in der algorithm?

bei mir in der utility

[Shade Of Mine]

SideWinder schrieb:

Ist das eigentlich performanter?

idR nicht.
mag ausnahmen geben, aber auf gängigen pcs mit gängigen compiler ist das idR langsamer.

optimal geht es per xchg - aber das sind so minimale sachen, wobei man ja auch bedenken muss, wo die variablen gerade sind, so dass ein mov reicht oder so...

man sollte nicht versuchen cleverer als der compiler zu sein.

oder gibts für int ne Spezialisierung?

Ne, aber ne überladung vielleicht.
Ansonsten muss man aber trotzdem nicht den template param angeben, weil es gott sei dank eine type deduction gibt, die feststellt, dass bei
swap(int, int)
wohl nur
swap<int>() gemeint sein kann

wobei swap<int>(a,b) uU eine andere funktion als swap(a,b) (für typeof(a)==typeof(b)==int) ist.