Ich habe da eine Frage, und zwar:

Ich habe zwei integer-Variablen x und y, welche die Koordinaten eines Onjektes sind. Damit ich die Koordinaten verarbeiten kann, brauch ich sie in einem Char-Array: char koordinaten[2]. koordinaten[0] soll hierbei den Wert von x und koordinaten[1] den Wert von y enthalten. Später muss ich das dann wieder zurückkonvertieren, also aus koordinaten[0] muss x werden und aus koordinaten[1] muss y werden. Meine Versuche sind bis jetzt alle gescheitert, weiß jemand zuverlässig, wie ich das bewerkstelligen kann?

char koordinaten[2];

int x = 870;
int y = 220;

koordinaten[0] = char(x);
koordinaten[1] = char(y);

...

int x = int(koordinaten[0]);
int y = int(korrdinaten[1]);

So hatte das leider nicht funktioniert gehabt. Weiß jemand wie ich das besser machen kann?

Grüssli

#include <iostream>

int main( )
{
	unsigned int x, y;
	x = 870;
	y = 220;

	unsigned char buffer[2];

	///// char to int /////
	buffer[0] = x;
	buffer[1] = y;

	///// int to char /////
	::memcpy( &x, &buffer[0], sizeof( unsigned char ) );
	::memcpy( &y, &buffer[1], sizeof( unsigned char ) );

	std::cin.get( );
}

EDIT:
Siehe Vorredner.

Davon abgesehen löst es das Problem des Informationsverlusts in keinster Weise.

Was soll das memcpy() bringen? Inwiefern ist es besser als eine Zuweisung?

Davon abgesehen löst es das Problem des Informationsverlusts in keinster Weise.

Aber es ging ihm doch um die Konvertierung?

Aber es ging ihm doch um die Konvertierung?

Und dafür braucht man ja unbedingt memcpy() , weil man jedes Mal einige Bits des int erhalten möchte, oder?

Hat jemad vllt. eine gute Idee, wie ich die Koordinaten einfach verpackt in ein char-Array bekomme, sodass es mir später nicht all zu schwer fallen wird, das ganze wieder in zwei integer aufzusplitten?

Zum Beispiel:

int FirstInt;
int SecondInt;

char TwoInts[2*sizeof(int)];

reinterpret_cast<int&>(TwoInts[0]) = FirstInt;
reinterpret_cast<int&>(TwoInts[sizeof(int)]) = SecondInt;

Okok, die Idee von mir war dumm. Hintergrund ist, dass ich die Koordinaten über die WinSockets verschicken will und da fand ich die Idee von mir durchaus komfortabel, da man nur char-Arrays senden kann. Hat jemad vllt. eine gute Idee, wie ich die Koordinaten einfach verpackt in ein char-Array bekomme, sodass es mir später nicht all zu schwer fallen wird, das ganze wieder in zwei integer aufzusplitten?

Du kannst über Sockets alle Daten schicken, die du magst. Das ist nicht auf char-Arrays beschränkt.

int koordinaten[2];
// ...
send(sockHandle, reinterpret_cast<char *>(koordinaten), 2 * sizeof(int), flags);
// ...

Stefan.

Kóyaánasqatsi schrieb:

Aber es ging ihm doch um die Konvertierung?

Und dafür braucht man ja unbedingt memcpy() , weil man jedes Mal einige Bits des int erhalten möchte, oder?

Nein, natürlich nicht. War doch nur eine Idee.

Du kannst über Sockets alle Daten schicken, die du magst. Das ist nicht auf char-Arrays beschränkt.

int koordinaten[2];
// ...
send(sockHandle, reinterpret_cast<char *>(koordinaten), 2 * sizeof(int), flags);
// ...

Stefan.

Kann ich die daten dann auch genauso empfangen?
[/cpp]
int buf[2];
rv = recv( connectedSocket, reinterpret_cast<char >( buf ), 2sizeof( int ), 0 );
buf[rv] = 0;
int X = buf[0];
int Y = buf[1];
[cpp]

Kann ich die daten dann auch genauso empfangen?

Sofern du garantieren kannst, dass auf dem System, auf welchem du empfängst, die Bytereihenfolge gleich ist, ja.

Du musst übrigens nicht mal über ein Array gehen sowas geht auch:

int x, y;
recv(connectedSocket, reinterpret_cast<char*>(&x), sizeof(int), 0);
recv(connectedSocket, reinterpret_cast<char*>(&y), sizeof(int), 0);

Gleiches gilt natürlich auch für das Senden.

Grüssli

Nein, natürlich nicht. War doch nur eine Idee.

Ja, aber eine unnötig komplizierte. Noch dazu kann es wie gesagt passieren, dass irgendein Müll als int rauskommt, weil nicht alle Bits überschrieben werden. Konvertieren kann man mittels Cast-Operatoren.

intTochar schrieb:

Kann ich die daten dann auch genauso empfangen?

Sollte so gehen, allerdings müsstest du dann wieder zu int reinterpret_casten.

Das, was zunächst mal geklärt werden sollte, ist die Kodierung ("Encoding").

Gruß,
SP