unions

I have a union in C like this: union AUnion { struct CharBuf { char *buf; size_t len; } charbuf; uint8_t num; double fp_num; }; My question is, can I guarantee that if given the following: union AUnion u; Then the following are true: &u == &u.num &u == &u.fp_num &u == &u.charbuf I.e they all start at the beginning of the memory segment where u is stored. In the case of this C program compiled with gcc version 5.3.0 and -std=c11 the above is true: #include <stdio.h> #include <stdint.h> #include <stdlib.h> union AUnion { struct CharBuf { char *buf; size_t len; } charbuf; uint8_t num; double fp

typedef union epoll_data { void *ptr; int fd; __uint32_t u32; __uint64_t u64; } epoll_data_t; Here int and __uint32_t are 4 bytes,while the others are 8 bytes. When we set fd to an int ,does it lie on the first 4 bytes or the last 4 bytes,or does it depend on endianness? Some reason is appreciated. It lies on the first 4 bytes. From the C99 standard §6.7.2.1/14: The size of a union is sufficient to contain the largest of its members. The value of at most one of the members can be stored in a union object at any time. A pointer to a union object, suitably converted, points to each of its

A junior developer asked me if it was possible to overload assignment operators for a union with POD arguments such that the corresponding data type within the union would get written to when an instance of the union is assigned to variable of that type. I replied that I did not think so, but then played around with the following code. To my surprise this code actually compiled (using g++ version 4.6.3 on Ubuntu 12.04) union unMember { float fData; unsigned int uiData; unMember():uiData(0) {}; unMember(float data):fData(data) {}; unMember(unsigned int data):uiData(data) {}; operator float()

Is there anything wrong with a union having one or more methods? Or anything to watch out for? (I can see constructors/destructors being problematic for schizophrenic reasons) From the C++03 & C++0x (Draft N3092) standards: 9.5 Unions A union can have member functions (including constructors and destructors) , but not virtual (10.3) functions . A union shall not have base classes. A union shall not be used as a base class. Initializing the union using the aggregate initializer syntax ( U u = { 42 }; ) or setting a member afterwards ( U u; u.i = 42; ) is not "problematic". And neither is

Important clarification: some commenters seem to think that I am copying from a union. Look carefully at the memcpy , it copies from the address of a plain old uint32_t , which is not contained within a union. Also, I am copying (via memcpy ) to a specific member of a union ( u.a16 or &u.x_in_a_union , not directly to the entire union itself ( &u ) C++ is quite strict about unions - you should read from a member only if that was the last member that was written to: 9.5 Unions [class.union] [[c++11]] In a union, at most one of the non-static data members can be active at any time, that is, the

I wrote the following code: #include <iostream> #include <string> #include <cstring> struct bar { std::string s3; std::string s4; }Bar; union foo { char * s1; char * s2; bar b1; foo(){}; ~foo(){}; }Foo; int main () { foo f1; bar b2; std::string temp("s3"); b2.s3 = temp; b2.s4 = temp; //f1.b1 = b2; //-- This Fails (Seg faults) /* #0 0x00002b9fede74d25 in std::string::_Rep::_M_dispose(std::allocator<char> const&) [clone .part.12] () from /usr/local/lib64/libstdc++.so.6 #1 0x00002b9fede75f09 in std::string::assign(std::string const&) () from /usr/local/lib64/libstdc++.so.6 #2 0x0000000000400ed1