template klasse verschachteln...

wenn ich den erwähnten code in der main habe bekomm ich sowas:

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

und wegen den privaten methoden... gar keinen, deshalb hab ich sie privat gemacht! sind nur für die ausgabefkt. dispArray() da.

fällt dir eine andere methode ein auf private variablen, zuzugreifen ohne memberfunktionen zu benutzen?

leo_

Der Fehler liegt in dispArray(). Du versuchst, operator<<(const ostream& os, const dynArray<dynArray<int> >) aufzurufen, aber das existiert eben nicht.

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

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

ich habe jetzt meine klasse umgebaut und diese funktion global gemacht:

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?

Thread kann gelöscht werden.

Caipi

@dgrat: Du hast nicht wirklich was verändert. Das Problem ist jetzt die folgende Funktion:

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

es ist mir etwas peinlich, aber ich habe noch nie einen operator überladen!
http://www.willemer.de/informatik/cpp/cppovrld.htm
ABER ein bissel ge google t

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

Caipi

Hallo,
Bezogen auf dein Beispiel:

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

danke so ähnlich sah mein versuch aus aus, buis auf das const
aber ich bekomme immer noch diesen fehler!

#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

Caipi

Hallo,
in dem geposteten Code kann ich keinen Fehler entdecken. Poste doch mal ein minimales zu compilierendes Beispiel, in dem der Fehler auftritt.

Gruß Caipi

sehr merkwürdig! bitte guck mal nach ob das auch wirklich dem original entsprechen würde! denn hier kann ich ohne probleme kompillieren auch ohne operator-überladung...
d.h.:der fehler liegt wo anders

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

icch poste mal alles zum selber probieren:

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

Caipi

dgrat schrieb:

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

danke caipi!

das mit dem index war doof... das war compilefehler
das mit den listen wusste ich gar nicht
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.

Caipi

dgrat schrieb:

danke caipi!

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

zum index: funktion hab ich noch nicht gepostet
[cpp]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 < 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?

ich sehe echt keinen grund dafür dass ich einen speicherzugriffsfehler bekomme weil ich auf private normale variablen zugreife. und zwar über normale funktionen...
hier ein beispiel:

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