referenzen->eine kleine frage!

exigoner

ich hab zweimal die selbe funktion mit und ohne referenz, aber es wird immer zum schluss 0,1,2,3,4 ausgegeben.(ich dachte bei der fkt. ohne referenz wär das nicht der fall ): )
nun weiß ich leider nicht mehr wozu referenzen da sind oder wie sie konkret funktionieren. an sich wird doch, durch eine referenz ein kopieren der übergebenen daten verhindert...
könnte mir das einer genauer an einem bsp. erklären?

meine klasse "array" macht genau dass, was meine member ihr sagen

void fill(array<int> &array, int grenze)
{
	for(int i = 0; i < grenze; i++)
		array.push_back(i);
}

int main(int argc, char *argv[])
{	
	array<int> moave;
	moave.set_dim(5);
	fill(moave, 5);
	moave.ausgabe_array();

  return EXIT_SUCCESS;
}

void fill(array<int> array, int grenze)
{
	for(int i = 0; i < grenze; i++)
		array.push_back(i);
}

int main(int argc, char *argv[])
{	
	array<int> moave;
	moave.set_dim(5);
	fill(moave, 5);
	moave.ausgabe_array();

  return EXIT_SUCCESS;
}

frosty

wie ist array denn aufgebaut?

FireFlow

Ich tippe mal drauf dass du den Copy-C'tor nicht richtig überladen hast und dass das neue Array einen internen Zeiger hat der einfach vom alten kopiert ist. Teste doch mal das hier:

array<int> a, b(a);
a.push_back(1);
cout << b.size();

Wird da 1 oder 0 ausgegeben?

exigoner

also ich habe nicht die stl verwendet, ich hab selbst ne kleine klasse gemacht, darum habe ich noch kein "size()" aber meine ausgabefunktion gibt nichts aus, was darauf hindeutet, dass bei deiner variante eine "0" als ergebnis zurückgeliefert werden müsste!

auf die gefahr hin dass, das ich jetzt ein bissel noob wirkt, ich wusste gar nicht das ein b(a) bei einem objekt so einfach funktioniert, ich hab das zwar immer bei inline funktionen (bei meinen klassen) für wertzuweisungen meiner privaten variablen gemacht, ABER hier noch nie. wird das objekt einfach kopiert, oder was wird da im speziellen gemacht???

jetzt aber noch zu der referenz, ich denke das der fakt das mein objekt "b" leer ist darauf hindeutet, mmh, sag du es mir bitte

was müsste denn deiner meinung nach da rauskommen, wenn ich diesen code benutze:

void fill(array<int> array, int grenze)
{
    for(int i = 0; i < grenze; i++)
        array.push_back(i);
}

int main(int argc, char *argv[])
{   
    array<int> moave;
    moave.set_dim(5);
    fill(moave, 5);
    moave.ausgabe_array();

  return EXIT_SUCCESS;
}

ganz einfach OHNE referenz, dürfte da normalerweise was ausgegeben werden oder nicht???

so und jetzt noch als kleine dreingabe meine klasse. eigentlich wollte ich das ding nicht posten

meine klasse "array" macht genau dass, was meine member ihr sagen

aber, dann doch, obwohl sich dass hier eh keiner durchliest, und der versuch sowieso sinnlos ist! aber wenn FROSTY es so will.... :p

#ifndef ARRAY_KLASSE
#define ARRAY_KLASSE

#include <iostream>
#include <cstdlib>

template <class T>
class array
{
    private:
	T *array_eindim;

	unsigned int zeilen_array;
	unsigned int index_z;

    public:
	array();
	array(unsigned int z);
	~array();

	T *get_array();
	T get_element(unsigned int zeile);

	void ausgabe_array();
	void set_dim(unsigned int z);

	void push_back(T data);//zu machen
	void push_back(T *feld, unsigned int zeilen_feld);
	void push_pos(T *feld, unsigned int zeilen_feld, int pos_z);

	T mult(T *feld, unsigned int zeilen_feld);

	void clear_all();
};

//##############################################################################

template <class T>
inline array<T>::array() 
: index_z(0), zeilen_array(0) {}

template <class T>
inline array<T>::array(unsigned int zeilen) 
: index_z(0), zeilen_array(zeilen)
{
	array_eindim = new T[zeilen];
}

template <class T>
array<T>::~array()
{
	delete [] array_eindim;
}

template <class T>
T *array<T>::get_array()
{
	return array_eindim;
}

template <class T>
T array<T>::get_element(unsigned int z)
{
	if(z < zeilen_array)
		return array_eindim[z];
}

template <class T>
void array<T>::set_dim(unsigned int zeilen)
{
	array_eindim = new T[zeilen];
	zeilen_array = zeilen;
	index_z = 0;
}

template <class T>
void array<T>::ausgabe_array()
{
	for(unsigned int i = 0; i < zeilen_array; i++)
		std::cout << "Position " << i << ": " << array_eindim[i] << std::endl;
    if(zeilen_array == 0)
        std::cout << "Array leer!" << std::endl;
}

template <class T>
void array<T>::push_back(T data)
{
	array_eindim[index_z] = data;
	index_z++;
}

template <class T>
void array<T>::push_back(T *feld, unsigned int feld_zeilen)
{
	for(unsigned int i = 0; i < feld_zeilen; ++i && ++index_z)
		array_eindim[index_z] = feld[i];
}

template <class T>
void array<T>::push_pos(T *feld, unsigned int feld_zeilen, int position_zeile)
{
	for(unsigned int i = position_zeile, j = 0; i < (feld_zeilen + position_zeile); i++, j++)
		array_eindim[i] = feld[j];

	if( (feld_zeilen + position_zeile) > index_z)
		index_z = (feld_zeilen + position_zeile);
}

template <class T>
T array<T>::mult(T *feld, unsigned int zeilen_feld)
{
	T temp;
	for(unsigned int i = 0; i < zeilen_array && i < zeilen_feld; i++)
		temp = array_eindim[i] * feld[i];
	return temp;
}

template <class T>
void array<T>::clear_all()
{
	for(unsigned int i = zeilen_array; i < zeilen_array; i++)
		array_eindim[i] = 0;

	index_z = 0;
}
#endif

FireFlow

Das ist sehr leicht zu erklären:

Ich bekomm Unmengen Access Vilations an Kopf wenn ich das teste. Wenn du das Objekt per Value übergibts ruft der Compiler den Copy-C'tor auf. Da du keinen Copy-C'tor hast baut sich der Compiler selber einen in dem er jedes Attribut kopiert. Das führt dazu dass 2 Arrayklassen auf den selben Speicher zugreifen. Du musst das so machen:

template <class T>
array<T>::array(array<T> const& ref)
: index_z(0), zeilen_array(zeilen)
{
    zeilen = ref.zeilen
    index_z = ref.index_z;
    array_eindim = new T[zeilen];
    for(int i=0; i<zeilen; ++i)
        array_eindim[i] = ref.array_eindim[i];
}

Dann hasst du noch in der Methode set_dim() vergessen den alten Speicher freizugeben!

exigoner

ach, danke! hats also, was gebracht das zu posten. ABER was ist nun mit der referenz

FireFlow

Wenn du es mit korrektem Copy-C'tor ausprobierst wirst du bemerken dass nur bei der Übergabe per Referenz nacher im Array Werte sind. Bei der Übergabe per Value wird ein neues lokales Objekt in der Funktion erzeugt das am Ende der Funktion wieder zerstört wird. Das neue Objekt wird erstellt indem der Copy-C'tor aufgerufen wird. Bei einer Referenz wird kein neues Objekt erstellt sondern du greifst auf dsa alte zu.

exigoner

super

jerry

Hi,

ich versuch es mal mit der Referenz.

An eine Funktion wird meist eine Kopie der Werte übergeben:
f1 ( int k) { k = 2*k; }
Aufruf: m = 5; f1 ( m )
In der Funktion wird k zwar verdoppelt, aber nur dort. Das hat keinen Einfluss auf das Original m.
An eine Funktion wird die Adresse übergeben: f2 (int & n) { n = 2*n;}
Aufruf: p = 4; f2(p);
Wegen der Adressübergabe wird p verändert: p == 8!
Referenz ist kein Pointer, der auch Adressen übergibt.

referenzen-&gt;eine kleine frage!

referenzen->eine kleine frage!