Deine Data Klasse ist nicht sehr schön aufgebaut.
Ist es wirklich notwendig, dass ...
1 | T *field;
|
2 | field = (T*) mem_malloc( data.getElements()*sizeof(T) );
|
3 |
|
4 | ...
|
5 |
|
6 | dat.setData( field );
|
7 | dat.setElements( data.getElements() );
|
... sich der Verwender der Klasse um die Speicherallokierung kümmert?
Das sollte nicht sein und läuft eigentlich ein bischen dem
objektorientierten Gedankengang zuwider:
Objekte kümmern sich selbst um ihre internen Belange.
1 | template <class F, class T>
|
2 | DataClass<T> operator+( const F offset, const DataClass<T>& data )
|
3 | {
|
4 | DataClass<T> result( data.getCount() );
|
5 |
|
6 | for( size_t i = 0; i < data.getCount(); ++i )
|
7 | result[i] = data[i] + offset;
|
8 |
|
9 | return result;
|
10 | }
|
So würde ich das machen.
Beachte auch das const in der Argumentliste und die Namen der
Funktionen, die m.E. den Zweck der Funktion besser wiederspiegeln. Mit
einer Funktion getElements verbinden wohl die meisten eine Funktion, die
einem Zugriff auf die tatsächlichen Elemente gibt und nicht eine
Funktion die die Anzahl der Elemente liefert. So etwas hat normalerweise
ein 'Count' im Funktionsnamen oder ein 'Size', wenn die Funktion nicht
slebst der Einfachheit halber 'count()' oder 'size()' heißt.
Wenn es einen guten Grund gibt, warum es keinen Konstruktor geben soll,
der die Anzahl der zu allokierenden Elemente übernimmt, dann verpass ich
der DataCalss noch eine allocate() Funktion. Aber den Speicher soll sich
die DataClass Klasse selber allokieren und nicht jemand ausserhalb. Wie
willst du sicherstellen, dass derjenige das in einer Form tut, so dass
du im Destruktor weißt, wie du den Speicher freizugeben hast, bzw. im
Copy Construktor eine Kopie zu erstellen hast?
Trag keine Implementierungsdetails aus einer Klasse heraus, wenn du
nicht musst! Wie Speicher allokiert wird, ist ein
Implementierungsdetail. Und ich hoffe, du hast einen extrem guten Grund,
warum du mem_malloc benutzt und nicht new.
Apropos Copy Constructor.
Da dat sowieso konstruiert werden muss, kann es sich auch gleich als
Kopie von data erzeugen
1 | template <class F, class T>
|
2 | DataClass<T> operator+( const F offset, const DataClass<T>& data )
|
3 | {
|
4 | DataClass<T> result( data );
|
5 |
|
6 | for( size_t i = 0; i < result.getCount(); ++i )
|
7 | result[i] += offset;
|
8 |
|
9 | return result;
|
10 | }
|
Da deine Klasse sowieso offenbar einen Copy Constructor braucht, wäre
das noch naheliegender und kann dann auch gleich noch Gebrauch von einem
+= Operator machen.
