unions

I am using bitfields to get easy access on a float library I am trying to make for a microcontroller with no FPU. The problem is that I can't seem to make it work with bitfields. Take a look: typedef struct { union{ unsigned long mantissa: 23; unsigned long exponent: 8; unsigned long sign: 1; float all; }; }_float __attribute__((__packed__)); The problem is that when I try to access or change anything it considers the bitfields as 1,8,23 bits from the end respectively. While it should be 23 bits from the end, then 8 bits and then the last bit. Unless I have totally misunderstood the use of

I'm attempting to globally initialise a union as in the following example: #include <cstdio> typedef union { char t[4]; int i; } a; enum { w = 5000, x, y, z }; a temp = {w}; int main() { printf("%d %d %d %d %d\n", temp.t[0],temp.t[1],temp.t[2],temp.t[3],temp.i); return 0; } However, if you run the code, you'll note that neither of temp.i or temp.t[...] actually give the correct item i initialised the union with. I'd imagine this would be avoided if I could manually initialise the integer member, but unfortunately I can't. I also can't change the ordering of elements within the struct (swapping

I have defined to following structures to emulate a C++ union (which will eventually be used for C++ Interop): [StructLayout(LayoutKind.Sequential)] internal struct STRUCT1 { public Guid guid; public String str1; public String str2; } [StructLayout(LayoutKind.Sequential)] internal struct STRUCT2 { public Guid guid; public String str1; public String str2; public Int32 i1; } [StructLayout(LayoutKind.Explicit)] internal struct MASTER_STRUCT_UNION { [FieldOffset(0)] public STRUCT1 Struct1; [FieldOffset(0)] public STRUCT2 Struct2; } [StructLayout(LayoutKind.Sequential)] internal struct MASTER

Look at this code: struct A { short s; int i; }; struct B { short s; int i; }; union U { A a; B b; }; int fn() { U u; u.a.i = 1; return u.b.i; } Is it guaranteed that fn() returns 1 ? Note: this is a follow-up question to this . NathanOliver- Reinstate Monica Yes, this is defined behavior. First lets see what the standard has to say about A and B . [class.prop]/3 has A class S is a standard-layout class if it: has no non-static data members of type non-standard-layout class (or array of such types) or reference, has no virtual functions and no virtual base classes, has the same access control

Consider the following code snippet: union { int a; float b; }; a = /* ... */; b = a; // is this UB? b = b + something; Is the assignment of one union member to another valid? Shafik Yaghmour Unfortunately I believe the answer to this question is that this operation on unions is under specified in C++, although self assignment is perfectly ok. Self assignment is well defined behavior, if we look at the draft C++ standard section 1.9 Program execution paragraph 15 has the following examples: void f(int, int); void g(int i, int* v) { i = v[i++]; // the behavior is undefined i = 7, i++, i++; // i

Ever since TypeScript introduced unions types, I wonder if there is any reason to declare an enum type. Consider the following enum type declaration: enum X { A, B, C } var x:X = X.A; and a similar union type declaration: type X: "A" | "B" | "C" var x:X = "A"; If they basically serve the same purpose, and unions are more powerful and expressive, then why are enums necessary? Amid As far as I see they are not redundant, due to the very simple reason that union types are purely a compile time concept whereas enums are actually transpiled and end up in the resulting javascript ( sample ). This