Einmal von char nach int und wieder zurück

Meinst du vielleicht eher "String-Array"? In einen Char passen nur Zahlen von 0-256 bzw -128 bis 127, könnte also knapp werden mit deinen Koordinaten.
Für die Konvertierung siehe in der FAQ den Eintrag "Einmal Zahl und zurück".

freaky

Naja, man kann schon die Grenze überschreiten, sollte man aber nicht machen, da sowieso nur Datenmüll etc. entsteht und wirres Zeug.

Zum beispiel hab ich den x-Wert 870 und den y-Wert 220. Der x Wert soll in das erste Element vom char-Array und der y-Wert in das zweite Element. Später muss ich die Werte wieder zurück in int's konvertieren:

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?

Don06

Es geht nicht. Ein char ist auf gängigen Plattformen kleiner als ein int . Auf deinem System ist char vermutlich 1 Byte und int 4 Byte. Du kannst also die Informationen in dem int nicht in ein char quetschen. So wie du es zeigst macht es auch gar keinen Sinn. Vielleicht willst du die ints in Strings umwandeln. Da musst du aber anders vorgehen.

Dravere

Ein char hat auf einem x86 System genau ein Byte. Die meisten Kompiler verwenden zudem per Standard signed char . Wodurch der maximalste positive Wert 127 ist. Fällt dir was auf?

Grüssli

Kóyaánasqatsi

Das Problem ist die Byteanzahl. Den Inhalt der Variable kannste einfach per ::memcpy( ) rüberkopieren. Vielleicht meinst du ja sogar so:

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

Nexus

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

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

Kóyaánasqatsi

Nexus schrieb:

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?

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?

Nexus

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?

Nexus

intTochar schrieb:

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;

DStefan

intTochar schrieb:

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

Nexus schrieb:

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.

DStefan schrieb:

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]

Dravere

intTochar schrieb:

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

Nexus

Kóyaánasqatsi schrieb:

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.

Sebastian Pizer

Das sieht alles, ehrlich gesagt, ganz schön nach Pfusch. Ich hoffe doch, es ist im Sinne des OPs, dass sich zwei Rechner unterhalten können, auch wenn sie int s anders im Speicher ablegen oder sogar unterschiedliche Wertebereiche abdecken können.

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

Gruß,
SP