Template Klasse mit Überladung von Operatoren

pulse00

Hallo,

habe hier ein kleines Verständnisproblem, ich poste mal die
fragliche Klasse:

#ifndef BUFFER_H_
#define BUFFER_H_

#include <iostream>
template <class T> class Buffer
{
public:

	T *data;
	int size;

	Buffer(int size);
	~Buffer();

	Buffer& operator+=(Buffer const& other);
	Buffer& operator=(T* _data);
	void setData(T *data);
	T& operator[](int index);

};

template <class T>  Buffer<T>::Buffer(int size)
{
	this->size = size;
	data = new T[size];
}

template <class T> void Buffer<T>::setData(T* data) {

}

template <class T> Buffer<T>::~Buffer()
{

	delete[] data;
}

template <class T> Buffer<T>& Buffer<T>::operator+=(Buffer<T> const& other) {

	for (int i = 0; i < size; i++) {

		data[i] += other.data[i];
	}

	return *this;

}

template <class T> Buffer<T>& Buffer<T>::operator=(T* _data) {

	if (data)
		delete[] data;

	data = _data;

	return *this;

}

template <class T> T& Buffer<T>::operator[](int index) {

	return data[index];
}

#endif /*BUFFER_H_*/

Die Verwendung der Klasse funktioniert auch einwandfrei, solange ich
das Objekt nicht dynamisch erzeuge:

Buffer<double> foo(2);
foo[0] = 10; // funkioniert

Buffer<double>* bar = new Buffer<double>(2);

bar[0] = 10;  // Hier stürzt das Programm ab,
(*bar)[0] = 10;   // Das funktioniert aber

delete bar;

Sehe ich es richtig dass mit bar[0] das ganze als array von Buffer objekten interpretiert wird und versucht wird auf das erste element, nämlich einen Buffer zuzugreifen, und ich deshalb erst dereferenzieren muss ?

Falls ja, weswegen funktioniert das dereferenzieren hier nur geklammert ?
*bar[0] gibt mir den gleichen fehler wie bar[0], (*bar)[0] hingegen passt.

Vielen Dank!

-pulse00

camper

pulse00 schrieb:

Falls ja, weswegen funktioniert das dereferenzieren hier nur geklammert ?

Weil [] Vorrang vor * hat. Du könntest auch

bar[0][x] = 10;

schreiben, das dürfte aber nicht leichter zu verstehen sein.