Kann mir jemand folgendes Verhalten bei Zeigern erklären (brauche wohl Nachhilfe)

Niko1111

Hi,

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

Braunstein

Ist Value vom Typ DataPacket? Wie sieht diese Klasse denn aus?
Bei einem

vector< double* > dataVector

würde man so multiplizieren

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

Niko1111

Nein, das hast du wohl falsch verstanden!

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

Braunstein

Dann zeig doch einfach mal die Deklaration von DataPacket, sonst kann man nur raten. Mich haben hier nur diese float-casts irritiert.

Niko1111

Okay:

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

Braunstein

Was ist denn Value (oder genauer FloatValue) für eine Klasse?

Niko1111

Ahh

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

Braunstein

Bitte lass mal diese Casts weg oder verwende wenigstens richtige C++Casts.
Ich nehme mal an, dass Values die Basisklasse zu FloatValues ist. Ist da getFloat() auch schon drin? Dann kann man die Casts weglassen. Ansonsten besser static_cast<FloatValue*>.
Was Values für eine Klasse ist, hatte ich eigentlich schon im ersten Post gefragt.

Niko1111

Hi,

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

static_cast<Datentyp>
const_cast<Datentyp>
dynamic_cast<Datentyp>
reinterpret_cast<Datentyp>

Braunstein

Hier noch was aus der FAQ
http://www.c-plusplus.net/forum/viewtopic-var-t-is-39493.html
http://www.c-plusplus.net/forum/viewtopic-var-t-is-39463.html
und einem Tutorial
http://tutorial.schornboeck.net/reinterpret_cast.htm
http://tutorial.schornboeck.net/dynamic_cast.htm
http://tutorial.schornboeck.net/casts.htm

Simon2

Niko1111 schrieb:

...
(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.

Niko1111

Hi,

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

Simon2

Niko1111 schrieb:

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.