also das Problem ist an sich schon gelöst. Nur verstehe ich absolut nicht, warum das funktioniert und damit bringt mir das Kennen der Lösung absolut gar nichts!

Folgendes:
Ich habe einen Vector mit Value-Zeigern definiert in der Klasse "DataPacket" definiert

vector< Value* > dataVector;

Jetzt wird der Vector mit float werten befüllt, dann per TCP verschickt und später wieder aufgenommen (alles noch in der Klasse DataPacket).

Jetzt will ich das erste Element zweier verschiedener Vectoren multiplizieren.
Ich dachte mir, dass das ungefähr so gehen sollte:

((float) *(float*)(p_old->dataVector[0])) * ((float) *(float*)(p->dataVector[0]));

Der Kompilier lässt mir das auch durchgehen, nur kommt bei Gott nicht das Ergebnis raus, was ich erwartet hätte. Anscheinend multipliziere ich hier Adressen (oder was auch immer). Auf jeden Fall kommt immer das selbe Ergebnis raus, egal was in den Vectoren steht (naja... ich denke mal dass es dann die Adresse sein muss, weil die bleiben ja konstant, nur die Werte ändern sich eben..)

Nachdem ich mich heute ein wenig herumgespielt habe, kann ich die Werte, welche ich Multiplizieren will, so ausgeben:

ostringstream outs;
	outs << p_old->dataVector[0] << " " << p->dataVector[0];
	cout << outs.str().c_str();

Wenn ich aber so direkt multiplizieren will, dann mekert der Kompiler, dass ich keine float* multiplizieren kann/soll (hat er ja auch recht).

Was genau geht da vor sich?
Kann mir das bitte mal jemand erklären?

Danke im voraus,
Niko

vector< double* > dataVector

würde man so multiplizieren

double res = *dataVector[i] * *dataVector[i+1];

In der Klasse DataPacket befindet sich der vector. Die Inhalte des Vektors (die Value*) sind vom Typ FloatValue.
Dabei fällt mir auf, dass hier das Problem liegen könnte... wie kann ich FloatValue in float verwandeln?

Naja, aber das was du geschrieben mit "da würde man so multiplizieren"... das habe ich ja eben versucht!

Der Vektor wurde wie folgt befüllt:

packet->dataVector.push_back( new FloatValue( atof(token) ) );

Niko

EDIT: Befüllen des Vektors hinzugefügt

#include "TBObject.h"
#include "Value.h"
#include "OutOfMemoryException.h"

#include <vector>
#include <sys/time.h>

/// [core] Data packet.
/**
 * DataPacket is a container for Values belonging to a certain timestamp.
 * It contains a packet number and a timestamp. Both variables are set in
 * the constructor. The dataVector (containig the Values) can be accessed
 * directly (public).
 */
class DataPacket: public TBObject
{
	public:
		DataPacket();
		DataPacket( DataPacket &p );
		DataPacket( DataPacket &p, vector<unsigned> channels );
		virtual ~DataPacket();

		struct timeval timestamp;
		unsigned short seqNr;
		vector< Value* > dataVector;

		virtual void toString( ostream &o );		///< Print object to stream o.
//		virtual void toString( std::string *str );	///< Prints the data to a string.

		/// Get a copy of the object.
		virtual DataPacket *clone();
		/// Get a copy of the object (selected channels only).
		virtual DataPacket *clone( vector<unsigned> channels );
		/// Append (move) Values from packet \a p.
		virtual void appendContentOf( DataPacket *p );
		/// Only keep selected channels (Values), delete others.
		virtual void narrowData( vector<unsigned> channels );
		/// delete all channels.
		virtual void empty();
		/// invalidate all values.
		virtual void invalidateValues();

	private:
		DataPacket( const DataPacket& p ) {};	///< No default copy constructor.
		static int counter;
		int number;
};

Das war die richtige Frage. Im ersten Moment habe ich gedacht, dass das eine Standart-C++ Klasse ist, die ich einfach so umwandeln kann. Dabei ist das eine Klasse von dem Framework in dem ich grade arbeite.

In FloatValue selbst gibt es eine Funktion getFloat(), die ich benutzen kann.
Die Lösung war also:

((FloatValue*) (p_old->dataVector[0]))->getFloat() * ((FloatValue*) (p->dataVector[0]))->getFloat();

Vielen Dank,
Niko

okay... ohne Casts sieht das Ganze besser aus.
Hatte vorher nicht daran Gedacht, dass Value auch ein getFloat beinhaltet (Value ist Oberklasse von FloatValue)

Was aber genau meintest du mit "richtig C++ Casts". Ich kenne nur diese eine Art... (bin alter Java Programmierer)

MfG,
Niko

...
(bin alter Java Programmierer)

MfG,
Niko

Weswegen Du wohl auch
- mit typisierten Containern etwas ungeübt bist und
- offensichtlich gerne mit Wrapperklassen für eingebaute Typen arbeitest ...

Nicht böse sein, will Dich nicht ärgern, sondern nur darauf hinweisen, dass die C++-Denke hier durchaus eine andere ist. Müssen wirklich in demselben vector-Objekt (zu Laufzeit) unterschiedliche Typen gehalten werden ? Gilt unter C++ als unfein/-sicher/-üblich/-nötig/- .... und ist es auch (unter Java) !

Gruß,

Simon2.

naja, die Tatsache, dass verschiedene Typen zur Laufzeit in einem Vektor gehalten werden ist nicht von mir...
... das war schon so in dem Framework, welches ich benutze (das ist nicht von mir programmiert).

Im Prinzip werden da aber auch nicht verschiedene Typen drin gehalten, sondern das sind eigentlich alles FloatValues. Das die Dekleration mit Value erfolgt ist... naja.. darüber kann man dann sicher treiten

MfG,
Niko

Hi,
...
Im Prinzip werden da aber auch nicht verschiedene Typen drin gehalten, sondern das sind eigentlich alles FloatValues. Das die Dekleration mit Value erfolgt ist... naja.. darüber kann man dann sicher streiten...

nö, braucht man gar nicht drüber zu streiten !
Wenn es unnötig ist, sollte man es lassen ...

Gruß,

Simon2.