dynArray<dynArray<int> > foo;

KLASSE:

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

template<class T>
class dynArray
{
private:
	T *mainArray;

	int zeilen;
	int index;
	int dimArray;

	T getElement(int pos)
	{
		return mainArray[pos];
	}
	int getIndex()
	{
		return index;
	}
	int getSize()
	{
		return zeilen;
	}

public:
	dynArray();
	dynArray(int size);
	dynArray(dynArray<T> const &ref);

	~dynArray();

	void setSize(int range);
	void clearArray();
	void dispArray();

	void fillArray(T data);
};

template<class T>
dynArray<T>::dynArray() : index(0), zeilen(1)
{
	mainArray = new T[1];
}

template<class T>
dynArray<T>::dynArray(int size) : index(0), zeilen(size)
{
	mainArray = new T[size];
}

template<class T>
dynArray<T>::dynArray(dynArray<T> const &ref) : zeilen(ref.zeilen), index(ref.index)
{
	for(int i = 0; i < index; i++)
		mainArray[i] = ref.mainArray[i];
}

template<class T>
dynArray<T>::~dynArray()
{
	std::cout<<"Speicher vom Array wird jetzt wieder freigegeben"<<std::endl;
	delete [] mainArray;
}

template<class T>
void dynArray<T>::setSize(int range)
{
	zeilen(range);
}

template<class T>
void dynArray<T>::dispArray()
{
std::cout<<"SIZE: "<<getSize()<<std::endl;
std::cout<<"INDEX: "<<getIndex()<<std::endl;

	for(int i = 0; i < index; i++)
		std::cout<<i<<".) "<<mainArray[i]<<std::endl;
}

template<class T>
void dynArray<T>::fillArray(T data)
{
	mainArray[index] = data;
	index++;

	T tempArray[index];
	for(int i = 0; i < zeilen; i++)
		tempArray[i] = mainArray[i];

	if(zeilen <= index)
	{
		zeilen++;
		mainArray = new int[zeilen];

		for(int i = 0; i < zeilen; i++)
			mainArray[i] = tempArray[i];
	}
}

Btw. was haben denn die Privaten Methoden für einen Sinn?

Die Implementation deiner Methoden muss bei Templateklassen inline geschehen, also in der selben Datei.
Da ist auch gerade ein anderer Thread zu aktiv, such einfach mal.

Falls du mich meinst: Das ist mir klar, ich meinte eigentlich die privaten
Methoden getElement, getIndex und getSize die ja eigentlich ziemlich unnötig sind.

/home/dgdaniel/develop/cpp/dynarray/src/main.cpp:38: instantiated from here
/home/dgdaniel/develop/cpp/dynarray/src/dynarray.hpp:102: error: no match for ‘operator<<’ in ‘std::operator<< [with _Traits = std::char_traits<char>](((std::basic_ostream<char, std::char_traits<char> >&)(+ std::cout. std::basic_ostream<_CharT, _Traits>::operator<< [with _CharT = char, _Traits = std::char_traits<char>](i))), ((const char*)".) ")) << *(((dynArray<dynArray<int> >*)this)->dynArray<dynArray<int> >::mainArray + (+(((unsigned int)i) * 16u)))’
/usr/include/c++/4.0.2/bits/ostream.tcc:67: note: candidates are: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(std::basic_ostream<_CharT, _Traits>& (*)(std::basic_ostream<_CharT, _Traits>&)) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.0.2/bits/ostream.tcc:78: note: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(std::basic_ios<_CharT, _Traits>& (*)(std::basic_ios<_CharT, _Traits>&)) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.0.2/bits/ostream.tcc:90: note: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(std::ios_base& (*)(std::ios_base&)) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.0.2/bits/ostream.tcc:125: note: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(long int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.0.2/bits/ostream.tcc:159: note: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(long unsigned int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.0.2/bits/ostream.tcc:102: note: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(bool) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.0.2/ostream:177: note: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(short int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.0.2/ostream:188: note: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(short unsigned int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.0.2/ostream:192: note: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.0.2/ostream:203: note: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(unsigned int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.0.2/bits/ostream.tcc:183: note: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(long long int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.0.2/bits/ostream.tcc:218: note: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(long long unsigned int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.0.2/bits/ostream.tcc:242: note: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(double) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.0.2/ostream:218: note: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(float) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.0.2/bits/ostream.tcc:265: note: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(long double) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.0.2/bits/ostream.tcc:288: note: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(const void*) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.0.2/bits/ostream.tcc:311: note: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(std::basic_streambuf<_CharT, _Traits>*) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.0.2/ostream:448: note: std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, char) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.0.2/bits/ostream.tcc:509: note: std::basic_ostream<char, _Traits>& std::operator<<(std::basic_ostream<char, _Traits>&, char) [with _Traits = std::char_traits<char>]
/usr/include/c++/4.0.2/ostream:459: note: std::basic_ostream<char, _Traits>& std::operator<<(std::basic_ostream<char, _Traits>&, signed char) [with _Traits = std::char_traits<char>]
/usr/include/c++/4.0.2/ostream:464: note: std::basic_ostream<char, _Traits>& std::operator<<(std::basic_ostream<char, _Traits>&, unsigned char) [with _Traits = std::char_traits<char>]
/usr/include/c++/4.0.2/bits/ostream.tcc:571: note: std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&, const char*) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.0.2/bits/ostream.tcc:616: note: std::basic_ostream<char, _Traits>& std::operator<<(std::basic_ostream<char, _Traits>&, const char*) [with _Traits = std::char_traits<char>]
/usr/include/c++/4.0.2/ostream:498: note: std::basic_ostream<char, _Traits>& std::operator<<(std::basic_ostream<char, _Traits>&, const signed char*) [with _Traits = std::char_traits<char>]
/usr/include/c++/4.0.2/ostream:503: note: std::basic_ostream<char, _Traits>& std::operator<<(std::basic_ostream<char, _Traits>&, const unsigned char*) [with _Traits = std::char_traits<char>]
gmake[2]: *** [main.o] Fehler 1
gmake[2]: Das Target »all« wurde wegen Fehlern nicht aktualisiert.
gmake[1]: *** [all-recursive] Fehler 1
gmake[2]: Für das Ziel »all-am« ist nichts zu tun.
gmake: *** [all] Fehler 2
*** Beendet mit Status: 2 ***

Das ist das gleiche, wie wenn du das hier machen würdest:

dynArray<int> array;
std::cout << array;

template<class T>
void dispArray(dynArray<T> array)
{
	std::cout<<"SIZE: "<<array.getSize()<<std::endl;
	std::cout<<"INDEX: "<<array.getIndex()<<std::endl;

	for(int i = 0; i < index; i++)
		std::cout<<i<<".) "<< array.getMainArray(i) <<std::endl;
}

klasse:

template<class T>
class dynArray
{
private:
	T *mainArray;

	int zeilen;
	int index;
	int dimArray;

public:
	dynArray();
	dynArray(int size);
	dynArray(dynArray<T> const &ref);

	~dynArray();

	void setSize(int range);
	void clearArray();
	void dispArray();

	void fillArray(T data);

	T getElement(int pos)
	{
		return mainArray[pos];
	}
	int getIndex()
	{
		return index;
	}
	int getSize()
	{
		return zeilen;
	}
	T getMainArray(int pos)
	{
		return mainArray[pos];
	}
};

nur bekomme ich jetzt

error: ISO C++ forbids comparison between pointer and integer

warum?

T getMainArray(int pos)
    {
        return mainArray[pos];
    }

Solange T = builtin ist das kein Problem, da Arrays aus Builtins den operator[] zur Verfügung stellen. Wenn T dagegen für dynArray<builtin> steht (also T = dynArray<builtin>), gibt es keinen operator[] über welchen du auf die Elemente des Arrays vom Typ dynArray<builtin> zugreifen kannst.

Lösung: Du überlädst den operator[] in der Klasse für den Typ T.

Btw: Elemente werden in der Reihenfolge ihrer Deklaration initialisiert! => Schau dir deine Initialisierungslisten mal näher an, diese sind nämlich 'fehlerhaft'.

Gruß Caipi

wie müsste iene überladene operator-fkt aussehen?

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

template<class T>
class dynArray
{
private:
	T *mainArray;

	int zeilen;
	int index;
	int dimArray;

public:
	dynArray();
	dynArray(int size);
	dynArray(dynArray<T> const &ref);

	~dynArray();

	void setSize(int range);
	void clearArray();
	void fillArray(T data);

	void dispArray();

	T getElement(int pos)
	{
		return mainArray[pos];
	}
	int getIndex()
	{
		return index;
	}
	int getSize()
	{
		return zeilen;
	}
};

template<class T>
dynArray<T>::dynArray() : index(0), zeilen(1)
{
	mainArray = new T[1];
}

template<class T>
dynArray<T>::dynArray(int size) : index(0), zeilen(size)
{
	mainArray = new T[size];
}

template<class T>
dynArray<T>::dynArray(dynArray<T> const &ref) : zeilen(ref.zeilen), index(ref.index)
{
	for(int i = 0; i < index; i++)
		mainArray[i] = ref.mainArray[i];
}

template<class T>
dynArray<T>::~dynArray()
{
	std::cout<<"Speicher vom Array wird jetzt wieder freigegeben"<<std::endl;
	delete [] mainArray;
}

template<class T>
void dynArray<T>::setSize(int range)
{
	T tempArray[index];
	bool transmit = false;

	if(index > 0)
	{
		transmit = true;
		for(int i = 0; i < zeilen; i++)
			tempArray[i] = mainArray[i];
	}

	if(transmit == true)
	{
		zeilen++;
		mainArray = new int[zeilen];

		for(int i = 0; i < zeilen; i++)
			mainArray[i] = tempArray[i];

		std::cout<<"Daten ueberschrieben"<<std::endl;
	}

	zeilen = range;
	delete [] mainArray;
	mainArray = new T[zeilen];
	std::cout<<"neuer Speicher wurde allokiert"<<std::endl;
}

template<class T>
void dynArray<T>::fillArray(T data)
{
	T tempArray[index];

	if(index > 0)
	{
		for(int i = 0; i < zeilen; i++)
			tempArray[i] = mainArray[i];
	}

	if(zeilen <= index)
	{
		zeilen++;
		mainArray = new T[zeilen];

		for(int i = 0; i < zeilen; i++)
			mainArray[i] = tempArray[i];

		std::cout<<"Daten ueberschrieben"<<std::endl;
	}

	mainArray[index] = data;
	index++;
}

// Für konstante Objekte. D.h. wenn du ein dynArray<T>-Objekt als const deklarierst, wird diese Methode aufgerufen.
template <class T>
T& dynArray<T>::operator[](size_t indx) { return mainArray[indx]; }

// Für nichtkonstante Objekte. Wird immer aufgerufen, wenn das aufrufende Objekt _nicht_ const ist.
template <class T>
const T& dynArray<T>::operator[](size_t indx) const { return mainArray[indx]; }

Bzg. Mehr Infos zur Operatorenüberladung sei auf dein Lielings-Tutorial/Buch verwiesen.

Gruß Caipi

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

template<class T>
class dynArray
{
private:
	T *mainArray;

	int zeilen;
	int index;
	int dimArray;

public:
	dynArray();
	dynArray(int size);
	dynArray(dynArray<T> const &ref);

	~dynArray();

	void setSize(int range);
	void clearArray();
	void fillArray(T data);

	void dispArray();

	T getElement(int pos)
	{
		return mainArray[pos];
	}
	int getIndex()
	{
		return index;
	}
	int getSize()
	{
		return zeilen;
	}

	const T& operator[](size_t indx) const;
	T& operator[](size_t indx);
};

template <class T>
const T& dynArray<T>::operator[](size_t indx) const { return mainArray[indx]; }

template <class T>
T& dynArray<T>::operator[](size_t indx) { return mainArray[indx]; }

ich habe übrigens versucht:

T &dynArray<T>::operator[] (int pos) //Referenz
{
	return *(mainArray+pos);
}

scheiß invaid comparison

Gruß Caipi

#include <iostream>
#include <cstdlib>

using namespace std;

template<class T>
class dynArray
{
private:
	T *Array;

public:
	dynArray() {Array = new T[25];}

	T getElement(int pos) {return Array[pos];}
};

template<class T>
void dArray(dynArray<T> array) {std::cout<< array.getElement(0) <<std::endl;}

int main(int argc, char *argv[])
{
  dynArray<int> foo;
  dArray(foo);

  return EXIT_SUCCESS;
}

/***************************************************************************
 *   Copyright (C) 2005 by Daniel Frenzel   *
 *   dgdaniel@linux   *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

template<class T>
class dynArray
{
private:
	T *mainArray;

	int zeilen;
	int index;
	int dimArray;

public:
	dynArray();
	dynArray(int size);
	dynArray(dynArray<T> const &ref);

	~dynArray();

	void setSize(int range);
	void clearArray();
	void fillArray(T data);

	void dispArray();

	T getElement(int pos)
	{
		return mainArray[pos];
	}
	int getIndex()
	{
		return index;
	}
	int getSize()
	{
		return zeilen;
	}
/*
	const T& operator[](size_t indx) const;
	T& operator[](size_t indx);
*/
};
/*
template <class T>
const T& dynArray<T>::operator[](size_t indx) const { return mainArray[indx]; }
template <class T>
T& dynArray<T>::operator[](size_t indx) { return mainArray[indx]; }
*/
template<class T>
dynArray<T>::dynArray() : index(0), zeilen(1)
{
	mainArray = new T[1];
}

template<class T>
dynArray<T>::dynArray(int size) : index(0), zeilen(size)
{
	mainArray = new T[size];
}

template<class T>
dynArray<T>::dynArray(dynArray<T> const &ref) : zeilen(ref.zeilen), index(ref.index)
{
	for(int i = 0; i < index; i++)
		mainArray[i] = ref.mainArray[i];
}

template<class T>
dynArray<T>::~dynArray()
{
	std::cout<<"Speicher vom Array wird jetzt wieder freigegeben"<<std::endl;
	delete [] mainArray;
}

template<class T>
void dynArray<T>::setSize(int range)
{
	T tempArray[index];
	bool transmit = false;

	if(index > 0)
	{
		transmit = true;
		for(int i = 0; i < zeilen; i++)
			tempArray[i] = mainArray[i];
	}

	if(transmit == true)
	{
		zeilen++;
		mainArray = new int[zeilen];

		for(int i = 0; i < zeilen; i++)
			mainArray[i] = tempArray[i];

		std::cout<<"Daten ueberschrieben"<<std::endl;
	}

	zeilen = range;
	delete [] mainArray;
	mainArray = new T[zeilen];
	std::cout<<"neuer Speicher wurde allokiert"<<std::endl;
}

template<class T>
void dynArray<T>::fillArray(T data)
{
	T tempArray[index];

	if(index > 0)
	{
		for(int i = 0; i < zeilen; i++)
			tempArray[i] = mainArray[i];
	}

	if(zeilen <= index)
	{
		zeilen++;
		mainArray = new T[zeilen];

		for(int i = 0; i < zeilen; i++)
			mainArray[i] = tempArray[i];

		std::cout<<"Daten ueberschrieben"<<std::endl;
	}

	mainArray[index] = data;
	index++;
}
/*
template<class T>
void dynArray<T>::dispArray()
{
	std::cout<<"SIZE: "<<getSize()<<std::endl;
	std::cout<<"INDEX: "<<getIndex()<<std::endl;

	for(int i = 0; i < index; i++)
		std::cout<<i<<".) "<< getMainArray(i) <<std::endl;
}
*/

/***************************************************************************
 *   Copyright (C) 2005 by Daniel Frenzel   *
 *   dgdaniel@linux   *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <iostream>
#include <cstdlib>

#include "dynarray.hpp"

using namespace std;

template<class T>
void dArray(dynArray<T> array)
{
	std::cout<<"SIZE: "<<array.getSize()<<std::endl;
	std::cout<<"INDEX: "<<array.getIndex()<<std::endl;

	for(int i = 0; i < index; i++)
		std::cout<<i<<".) "<< array.getElement(i) <<std::endl;
}

int main(int argc, char *argv[])
{
  dynArray<int> b;
  dynArray<int> c;

  b.fillArray(1);
  c.fillArray(4);

  dArray(b);

  return EXIT_SUCCESS;
}

denn hier kann ich ohne probleme kompillieren auch ohne operator-überladung...

Hier verwendest du ja auch nicht das Konstrukt dynArray<dynArray<...> >, sondern hier steht T für einen builtin-datentyp. => Für Arrays aus Builtins ist der op[] defniert, desshalb kannst du auf ein Indiz über die Methode getElement() zugreifen..

Zu den Fehlern:

1. In der Funktion dArray() ist die Member-Variable index unbekannt. Du musst diese schon über die Methode getIndex() des entsprechenden Objekts ansprechen.
2. In den Methoden setSize() und fillArray() versuchst du ein Array mit einer nicht-konstanten Größe zu definieren. Das geht nicht, da die größe eines Arrays dieser Art zur compile-Zeit bekannt sein muss. => Hantiere hier z.B. ebenfalls mit new[] und delete[].
3. Deine Initialisierungsliste ist immer noch fehlerhaft.

beheb' diese Fehler mal, danach sollte das Programm laufen...

Gruß Caipi

1. das mit dem index war doof... das war compilefehler
2. das mit den listen wusste ich gar nicht
3. an sich funktioniert doch die speicherverwaltung meines arrays, ich kann daten reinpacken, vergrößern etc.... ohne probleme
   merkwürdig ist aber das mir bei der member ausgabefunktion alles gut und schön angezeigt wird und bei der normalen funktion dArray bekomm ich nur einen speicherzugriffsfehler?

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

template<class T>
class dynArray
{
private:
	T *mainArray;

	int zeilen;
	int index;
	int dimArray;

public:
	dynArray();
	dynArray(int size);
	dynArray(dynArray<T> const &ref);

	~dynArray();

	void setSize(int range);
	void clearArray();
	void fillArray(T data);

	void dispArray();

	T getElement(int pos)
	{
		return mainArray[pos];
	}
	int getIndex()
	{
		return index;
	}
	int getSize()
	{
		return zeilen;
	}
/*
	const T& operator[](size_t indx) const;
	T& operator[](size_t indx);
*/
};
/*
template <class T>
const T& dynArray<T>::operator[](size_t indx) const { return mainArray[indx]; }
template <class T>
T& dynArray<T>::operator[](size_t indx) { return mainArray[indx]; }
*/
template<class T>
dynArray<T>::dynArray() : zeilen(0), index(1)
{
	mainArray = new T[1];
}

template<class T>
dynArray<T>::dynArray(int size) : zeilen(0), index(1)
{
	mainArray = new T[size];
}

template<class T>
dynArray<T>::dynArray(dynArray<T> const &ref) : zeilen(ref.zeilen), index(ref.index)
{
	for(int i = 0; i < index; i++)
		mainArray[i] = ref.mainArray[i];
}

template<class T>
dynArray<T>::~dynArray()
{
	std::cout<<"Speicher vom Array wird jetzt wieder freigegeben"<<std::endl;
	delete [] mainArray;
}

template<class T>
void dynArray<T>::setSize(int range)
{
	T tempArray[index];
	bool transmit = false;

	if(index > 0)
	{
		transmit = true;
		for(int i = 0; i < zeilen; i++)
			tempArray[i] = mainArray[i];
	}

	if(transmit == true)
	{
		zeilen++;
		mainArray = new int[zeilen];

		for(int i = 0; i < zeilen; i++)
			mainArray[i] = tempArray[i];

		std::cout<<"Daten ueberschrieben"<<std::endl;
	}

	zeilen = range;
	delete [] mainArray;
	mainArray = new T[zeilen];
	std::cout<<"neuer Speicher wurde allokiert"<<std::endl;
}

template<class T>
void dynArray<T>::fillArray(T data)
{
	T tempArray[index]; //lege buffer-array an

	if(index > 0) //falls unser array leer ist wird es kopiert
	{
		for(int i = 0; i < zeilen; i++)
			tempArray[i] = mainArray[i];
	}

	if(zeilen <= index) //falls unser array zu klein ist
	{ //wird es vergroeßert und damit inhalt geloescht
		zeilen++;
		mainArray = new T[zeilen];

		for(int i = 0; i < zeilen; i++)
			mainArray[i] = tempArray[i];

		std::cout<<"Daten ueberschrieben"<<std::endl;
	}

	mainArray[index] = data; //daten werden in das array geschrieben
	index++;
}

template<class T>
void dynArray<T>::dispArray()
{
	std::cout<<"SIZE: "<<getSize()<<std::endl;
	std::cout<<"INDEX: "<<getIndex()<<std::endl;

	for(int i = 0; i < index; i++)
		std::cout<<i<<".) "<< getElement(i) <<std::endl;
}

im speziellen diese funktion:

template<class T>
void dynArray<T>::fillArray(T data)
{
	T tempArray[index]; //lege buffer-array an

	if(index > 0) //falls unser array leer ist wird es kopiert
	{
		for(int i = 0; i < zeilen; i++)
			tempArray[i] = mainArray[i];
	}

	if(zeilen <= index) //falls unser array zu klein ist
	{ //wird es vergroeßert und damit inhalt geloescht
		zeilen++;
		mainArray = new T[zeilen];

		for(int i = 0; i < zeilen; i++)
			mainArray[i] = tempArray[i];

		std::cout<<"Daten ueberschrieben"<<std::endl;
	}

	mainArray[index] = data; //daten werden in das array geschrieben
	index++;
}

wo steht denn da nicht fest wie viel speicher benötigt wird? und warum funktioniert die member funktion im gegensatz zur diesr problemfunktion dArray()??

wo steht denn da nicht fest wie viel speicher benötigt wird? und warum funktioniert die member funktion im gegensatz zur diesr problemfunktion dArray()??

sorry ich meinte, warum funktioniert die ausgabefunktion dispArray im gegensatz zur dArray funktion nicht? sind ja praktisch baugleich.
und sicher spielst du deshalb auf das speicherzeugs an. aber der müsste theoretisch wirklich in ordnung sein, sonst würde dispArray nicht wunderbar funktioieren, bzw solche guten ergebnisse liefern.

danke caipi!

1. das mit dem index war doof... das war compilefehler

Ich sehe trotzdem nicht, dass du ihn behoben hast.

dgrat schrieb:

wo steht denn da nicht fest wie viel speicher benötigt wird? und warum funktioniert die member funktion im gegensatz zur diesr problemfunktion dArray()??

sorry ich meinte, warum funktioniert die ausgabefunktion dispArray im gegensatz zur dArray funktion nicht? sind ja praktisch baugleich.

Nicht ganz. dArray ist nämlich _keine_ Memberfunktion von dynVec, weshalb sie _nicht_ auf private Datenelemente von dynVec zugreifen kann.

Schau dir am besten nochmal die Grundlagen, insbesondere Arrays, Das Prinzip der Kapselung, etc. an.

Gruß Caipi

for(int i = 0; i < array.getIndex(); i++)
std::cout<<i<<".) "<< array.getElement(i) <<std::endl;
}[/cpp]

dgrat schrieb:
Zitat:
wo steht denn da nicht fest wie viel speicher benötigt wird? und warum funktioniert die member funktion im gegensatz zur diesr problemfunktion dArray()??

sorry ich meinte, warum funktioniert die ausgabefunktion dispArray im gegensatz zur dArray funktion nicht? sind ja praktisch baugleich.

Nicht ganz. dArray ist nämlich _keine_ Memberfunktion von dynVec, weshalb sie _nicht_ auf private Datenelemente von dynVec zugreifen kann.

Schau dir am besten nochmal die Grundlagen, insbesondere Arrays, Das Prinzip der Kapselung, etc. an.

Gruß Caipi

aber sie benutzt doch öffentliche funktionen der klasse?

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <iostream>
#include <cstdlib>

using namespace std;

template<class T>
class a
{
private: 
	int b;
public:
	a(int c)
	{
		b = c;
	}

	int getB()
	{
		return b;
	}
};
template<class T>
void getnB(a<T> foo)
{
cout<<foo.getB();
}

int main(int argc, char *argv[])
{
  a<int> foo(6);
  getnB(foo);

  return EXIT_SUCCESS;
}

vergleicht man das mit meins, stellt man fest das es keinen unterschied gibt...:

template<class T>
class dynArray
{
private:
	T *mainArray;

	int zeilen;
	int index;
	int dimArray;
public:
...
	int getIndex()
	{
		return index;
	}
	int getZeilen()
	{
		return zeilen;
	}
};
template<class T>
void dArray(dynArray<T> array)
{
	std::cout<<"SIZE: "<<array.getZeilen()<<std::endl;
	std::cout<<"INDEX: "<<array.getIndex()<<std::endl;
}