mehrdimensinale Arrays mit verschiedenen Datentypen je dim

JohnC.

Hi Leute,

ich möchte gerne ein Array haben, welches in der 1. und 2. dimension int Typen speichern kann, und in der dritten zB. bool Typen

Habt ihr da eine Idee?

greetz johnc.

MFK

Ich glaube, du hast nicht ganz verstanden, was mehrdimensionale Arrays sind. Kann es sein, dass du einfach nur ein eindimensionales Array einer Struktur mit zwei ints und einem bool brauchst?

BorisDieKlinge

struct DATASET{

 int A;
 float B;
 boolean C;

} sArray[100];

sArray[4].A= 5;
sArray[4].B= 0.3434;
sArray[4].C= true;

JohnC.

Ich verstehe was du meinst. Ich benutze so einen auch schon.

Gerade hab ich so 'nen kleinen AHA - Effekt was mein Problem angeht.
den muss ich nutzen

danke für die schnelle Antwort

greetz johnc.

BorisDieKlinge

oder ohne struktur:

unsinged char sArray[100][12];

((int*)&sArray[4])[0]= 4;
((float*)&sArray[4])[1]= 0.3434;
((BOOL*)&sArray[4])[2]= true;

müsste evtl. ghen.. habs nich getestest

MFK

BorisDieKlinge schrieb:

müsste evtl. ghen.. habs nich getestest

Undefiniertes Verhalten.

Wo hast du eigentlich so einen Stuss her?

BorisDieKlinge

wieso? theoretisch müsste das doch klappen oder net? int, float ,bOOL alles 32 Bit typen.. vll. irre ich mich auch

unsigned char sArray[100][12]; 

	((int*)&sArray[4])[0]= 4; 
	((float*)&sArray[4])[1]= 0.3434; 
	((BOOL*)&sArray[4])[2]= true;

	printf("A: %i B: %f C: % i\n", ((int*)&sArray[4])[0],((float*)&sArray[4])[1],((BOOL*)&sArray[4])[2]);

Ausagebe = "A: 4 B: 0.343400 C: 1"

VS 2003

CStoll

BorisDieKlinge schrieb:

vll. irre ich mich auch

Ja, du irrst dich - C++ legt Mindestgrößen für die Typen fest, aber keine exakten Größen (und BOOL ist nichtmal im Standard enthalten).

Fellhuhn

Wenn für jede Dimension ein anderer Datentyp gebraucht wird, kann man natürlich auch union nehmen. Mir fällt zwar keine sinnvolle Verwendung gerade ein aber dann braucht man immerhin weniger Platz als mit einem struct und hat auch noch eine mögliche Fehlerquelle mehr.

JohnC.

Hab' das Problem nun doch mit Struct, bzw habe ich eine Klasse defieniert, gelöst.

Manchmal sieht man die Lösung vor der Nase nicht

Vielen Dank für eure Antworten!

greetz johnc

BorisDieKlinge

Nochmal:

unsigned char sArray[100][12];

    ((int*)&sArray[4])[0]= 4;
    ((float*)&sArray[4])[1]= 0.3434;
    ((BOOL*)&sArray[4])[2]= true;

hier gibt es ein undefinierts verhalten...

woran leigt das genau?

Wie sieht es wenn ich sowas in ANSI C machen?

Braunstein

Hat CStoll doch schon gesagt. Der Standard legt keine exakten Größen für die Typen fest (nur Mindestgrößen). Also kann float durchaus größer als unsigned char sein.
BOOL ist, wie gesagt, gar nicht Teil des Standards. Da steht die Größe also auch nicht fest.

asc

BorisDieKlinge schrieb:

Nochmal:...

Die Lösung wurde schon angegeben, nur noch zum BOOL und deiner Lösung an sich noch etwas.

"BOOL" wird z.B. in der WinAPI definiert, und dieses Define stammt aus einer Zeit bevor es "bool" in den Standard geschafft hat. Grundsätzlich kannst du davon ausgehen das alle großgeschriebenen Bezeicher nicht im Standard enthalten sind. Und der Typ "bool" ist auf einen normalen System IMHO kleiner als 32 bit.
C-Sytle Casts sollten in C++ nicht verwendet werden.
Warum musst du eigentlich unsaubere Lösungen posten wenn saubere bereits genannt wurden? (Nichts für ungut, aber wenn ich einen Post mit deinen Namen sehe graust es mich zumeist schon vor dem Lesen, da du sehr häufig unsaubere Programmierung weitergibst).

cu André

BorisDieKlinge

ich hab hier die saubere und unsaubere version gepostet:)

Ja hackt auf mir rum, nur weil ich helfen will.... tzzz

asc

BorisDieKlinge schrieb:

ich hab hier die saubere und unsaubere version gepostet:)

Okay, übersehen.
ABER: Warum zur Hölle noch die Unsaubere nachschieben? Muss das wirklich sein?

cu André

BorisDieKlinge

ne musste nich sein...ich bin grad bischen am C coden, und da extrahiere ich werte mit best. typen aus rohdaten bytes... da kamm mir das in sinn..

deswegen auch meine darauf folgende Frage ob die länge von datentypen in ANSI C fest sind?? Ob es da zu keinem undefinierten verhalten kommt?

asc

BorisDieKlinge schrieb:

deswegen auch meine darauf folgende Frage ob die länge von datentypen in ANSI C fest sind??

Nein, die Länge von Datentypen in ANSI C und ANSI C++ ist nicht festgelegt. Das einzige was zu den Längen festgeschrieben ist, wie die Größe der unterschiedlichen Datentypes zueinander ist.

Meist ist das in einer Form wie dieser angegeben: char <= int <= long

Wie du daraus schon Ablesen kannst ist auch diese Größenuntergliederung nicht unbedingt wirklich aussagekräftig. In der Regel kann man davon ausgehen das int unter 32 Bit Umgebungen auch 32 Bit groß ist, und unter 64 Bit Umgebungen eben 64 Bit. Aber soviel ich weiß ist selbst das nicht zwingend festgeschrieben.

cu André

BorisDieKlinge

hmm ok..

würde ich jetzt :

#pragma pack(1)

struct test{

int A;
float B;
char C;

} test;

#pragma pop()

machen.

würde nund bei sizeof(test); bei winXP, win 3.11 und Vista unterschiedliche länge nraus kommen?

LordJaxom

BorisDieKlinge schrieb:

würde nund bei sizeof(test); bei winXP, win 3.11 und Vista unterschiedliche länge nraus kommen?

Es könnten auch unterschiedliche Längen bei MSVC, gcc und Borland rauskommen...

BorisDieKlinge

hmm , und wie geht ich mit folgender problematik um?

Ich lese Roh daten von einer SPS... die SPS hat ja feste Datentyp längen

REAL 32bit
char 8bit
WORD 16bit
DWORD 32Bit

etc.

nun spiegel ich einen best speicehr bereich der SPS als Byte sequenz..

welche ich ja jetzt in ein struct spiegeln kann. Da aber nie sicher gegeben ist das die längen eindeutig lang sind, könnte das ja auf unterschiedlichen OS probleme geben odeR?

CStoll

Ja, könnte es. Aber die systemspezifischen Typen wie WORD oder REAL werden idR so definiert, daß die Größe exakt stimmt (zumindest bei den Compilern, die sie anbieten). D.h. wenn der Compiler WORD versteht, steckt dahinter ein 2 Byte großer Ganzzahltyp.

PS: "char" ist der einzige Datentyp, bei dem der Standard die Größe auf 1 Byte festlegt - ABER er erlaubt den Compilern immer noch, Bytes mit mehr als 8 Bit zu definieren.