3. template klasse verschachteln...

template klasse verschachteln...

  • ?

    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

    0
  • C

    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

    0
  • ?

    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;
}
    0
  • ?

    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;
}
    0
  • C

    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

    0
  • ?

    danke 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()??

    0
  • ?

    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.

    0
  • C

    dgrat schrieb:

    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

    0
  • ?

    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?

    0
  • ?

    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;
}
    0
Anmelden zum Antworten