Variablentyp selber definieren

[Empire]

Tach alle zusammen,
Ich bin gerade dabei ein eigenes Chat Programm zu schreiben. Aber da man nie weis was einem am anderen erwartet dachte ich
es wäre das einfachste für das Programm 2 eigene Variablentyp zu definieren. Eine für Strings und eine für ganz Zahlen.
ABER geht das überhaupt und wenn ja wie?

mfg
Empire

[Bebu]

Ich verstehe dein Problem nicht so ganz. Als erstes C oder C++? Ein bisschen Quellcode hilft manchmal das Problem zu verstehen und Tipps zu geben.

[Empire]

C/C++.
gibt kein passenden Quellecode.
Also auf manchen Systemen hat int 4 auf manchen 8 Bit (muss jetzt nicht so stimmen aber nach dem prinzip halt).
Wenn man jetzt eine int Variable von System A (4Bit) nach System B (8Bit) schickt kann das ja nicht gut gehen.
Wenn ich jetzt selber eine Variable definiere hab ich das Problem nicht.

mfg
Empire

[Bebu]

Also ich denke die größe der Variablen int wird vom System definiert, darauf kannst du wohl keinen Einfluss nehmen. Du kannst aber selber Speicher reservieren. Also müsstest du die Größe des Ankommenden Pakets überprüfen und dann entsprechend Speicher reservieren.

[Empire]

Ich will nicht int verändern, sondern selber eine Variable definieren und zwar vom Typ bsp oä.

[cloidnerux]

Ich will nicht int verändern, sondern selber eine Variable definieren und zwar vom Typ bsp oä.

Erstens ist in der Regel nur der Typ "int" Systemabhänig, entweder 2, 4 oder 8 Byte.
Das bedeutet, das die Typen "short (int)"(2 Byte), "long (int)"(4 Byte) und "long long (int)"(8 Byte), die auch alle Ganzahlige Werttypen darstellen bei fast allen System gleich sind, es gibt aber einige Minimale unterschiede. Zudem wirst du nur sehr selten Zahlen größer 2^31(signed long int) oder 2^32 (unsigned long int) versenden.
Und weil der User an sich keine Zahlen versenden kann, sondern nur Texte und du weist, welche Zahlen dein Chatprogramm versendet, kann es dir egal sein, ob 4Byte oder 8Byte ints, weil du bei Zahlen <= 2^32 keine Casting-Verluste hast, solange du das Untere Nibble der breiteren Variable verwendest.

[Empire]

Thx
Trotzdem würde es mich noch Interesieren ob es jetzt geht oder nicht.

mfg
Empire

[Dirty Oerti]

Das bedeutet, das die Typen "short (int)"(2 Byte), "long (int)"(4 Byte) und "long long (int)"(8 Byte), die auch alle Ganzahlige Werttypen darstellen bei fast allen System gleich sind, es gibt aber einige Minimale unterschiede

Nope.
Ich würde den Unterschied zwischen 4 und 8 Byte nicht unbedingt als "minimalen" Unterschied beschreiben:

Code: Alles auswählen

#include <stdio.h>

int main(int argc, char** argv)
{
	printf("\nSize of INT:             %lu", sizeof(int));

	printf("\nSize of SHORT INT:       %lu", sizeof(short int));
	printf("\nSize of LONG INT:        %lu", sizeof(long int));
	printf("\nSize of LONG LONG INT:   %lu", sizeof(long long int));

	printf("\nSize of SHORT:           %lu", sizeof(short));
	printf("\nSize of LONG:            %lu", sizeof(long));
	printf("\nSize of LONG LONG:       %lu", sizeof(long long));

	printf("\nSize of FLOAT:           %lu", sizeof(float));
	printf("\nSize of DOUBLE:          %lu", sizeof(double));
	printf("\n");
	return 0;
}

daniel@GosigMus:~/Desktop$ gcc test.c
daniel@GosigMus:~/Desktop$ ./a.out

Size of INT: 4
Size of SHORT INT: 2
Size of LONG INT: 8
Size of LONG LONG INT: 8
Size of SHORT: 2
Size of LONG: 8
Size of LONG LONG: 8
Size of FLOAT: 4
Size of DOUBLE: 8

Zudem wirst du nur sehr selten Zahlen größer 2^31(signed long int) oder 2^32 (unsigned long int) versenden.

Das ist - meiner Ansicht nach - keine Begründung dafür, dass man es lassen sollte.
Ich bin mir SEHR sicher, dass es (auch bei einem simplen Chatprogramm) nicht unüblich sein kann, so "große" Datenpakete zu versenden.

Erstens ist in der Regel nur der Typ "int" Systemabhänig, entweder 2, 4 oder 8 Byte.

float, double oder sowas ist auch noch abhängig vom System.
Außerdem gibt es auf unterschiedlichen Systemen noch unterschiedliche Byte-Orders:

Das heißt, wenn du ein 2 Byte Integer mit folgendem Inhalt hast (dargestellt, wie der Integer linear im Speicher liegt):

01000000 | 00000010

Dann wird das auf manchen Systemen (automatisch, ohne, dass du darauf Einfluss nehmen kannst) folgendermaßen zu einer Zahl zusammengesetzt:

0100000000000010 (binär) = 16386 (dezimal)

Auf anderen Systemen (mit einer anderen Byte-Order) kommt allerdings das dabei heraus:

0000001001000000 (binär) = 576 (dezimal)

Das Problem ist, denke ich, ersichtlich.
Um dies zu umgehen verwendet man in der Regel eine vordefinierte Byte-Order für Übertragungen über Netzwerke.

Dazu benötigt man Funktionen, die - abhängig vom verwendeten Hostsystem - Zahlen vor dem versenden über das Netzwerk in die Network Byte Order umwandeln und Zahlen direkt nach dem Empfangen über das Netzwerk in die Host Byte Order konvertieren.

Schön (viel) dazu steht hier:
http://de.wikipedia.org/wiki/Byte-Reihe ... von_Zahlen
Und hier:
http://www.gnu.org/s/libc/manual/html_n ... Order.html

Im letzten Link siehst du auch schon etwas, dass dir hilft, dein ursprüngliches Problem zu lösen:

uint32_t

Dabei handelt es sich um einen Integerdatentyp, der unsigned (also ohne Vorzeichen) und genau 32 Bit lang ist, und das auf allen Systemen, die diesen Typ unterstützen.
Davon gibt es natürlich noch mehr, alle definiert durch die liebe Standardbibliothek.

http://en.wikipedia.org/wiki/Stdint.h

Code: Alles auswählen

#include <netinet/in.h>

void sende(uint32_t data)
{
   uin32_t data_networkorder = htonl(data);
   //senden
}
uint32_t empfange()
{
   uint32_t data_networkorder = EMPFANGSFUNKTION();
   return  ntohl(data_networkorder);
}

--------------------------------------

Code: Alles auswählen

#include <stdio.h>
#include <stdint.h>


int main(int argc, char** argv)
{
	printf("\nSize of INT64:           %lu", sizeof(int64_t));
	printf("\nSize of INT32:           %lu", sizeof(int32_t));
	printf("\nSize of INT16:           %lu", sizeof(int16_t));
	printf("\nSize of INT8:            %lu", sizeof(int8_t));
	printf("\n");
	return 0;
}

Sollte auf jedem System das ergeben:

Code: Alles auswählen

Size of INT64:           8
Size of INT32:           4
Size of INT16:           2
Size of INT8:            1

[Empire]

So was nen ich Antwort.
Darf ich unser neues Lexikon presentieren:
Dirty Oerti! *applaudieren*
thx

mfg
Empire

[Xin]

Tach alle zusammen,
Ich bin gerade dabei ein eigenes Chat Programm zu schreiben. Aber da man nie weis was einem am anderen erwartet dachte ich
es wäre das einfachste für das Programm 2 eigene Variablentyp zu definieren. Eine für Strings und eine für ganz Zahlen.
ABER geht das überhaupt und wenn ja wie?

Das wird sogar - insbesondere für Zahlen - notwendig, da es Systeme gibt, die Zahlen in Big-Endian speichern und andere in Little Endian.

Little Endian bedeutet, dass die niedrigeren Werte am Ende stehen: 1234 ist tausendzweihundertvierunddreißig.
Bei BigEndian stehen die höheren Werte aber hinten, der Computer speichert also die Zahl in anderer Reihenfolge: 4321 ist tausendzweihundertvierundzwanzig.

Wenn Du nun die Zahl 1234 übermittelst, musst Du die Zahl in einem klar definiertem Format speichern. Dafür schreibst Du Dir in C++ am besten eine Klasse, die eine Zahl speichert und sie in beiden Formaten ausgeben kann.