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

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

Wird da 1 oder 0 ausgegeben?

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

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!

ich versuch es mal mit der Referenz.

1. 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.
2. 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.