I discovered union when I tried to name a function union

unions are also very useful for dealing with communication packets, where you have a byte array that represents your entire packet, along with each item present within it. This way you can access the entire package (to send to other parts of your program), as well as each separate item

They say big corporations employ people to go into their repos and replace all C unions in commits with other corporate-approved solutions. They're known as "union busters".

The last thing is actually a very old concept called discriminated unions. Primarily used in functional languages, it was buried for years during OOP languages golden age, where it is effectively was substituted by inheritance. More modern languages are bringing it back though, in light of recent tendencies where inheritance is considered a bad thing. Like Rust has native support for discriminated unions via its enums, TypeScript has them too etc.

I used it while making my gameboy emulator, it helped a lot for mapping the CPU registers easily and in a lean way. The data inside some of those registers can be 8 bits (high or low part of a 16bit data, the A, B, C, D, E, H, L registers) or 16 bits (when combining two 8bit registers, the AF, BC, DE, HL), it's a neat feature.

I have been programming for over 20 years and yet while I knew about unions I never used them. Just goes to show that an old dog can learn new tricks. I love how you really explain the low level side of things. Keep up the great work!

I use unions in embedded programming as you described. An other trick for mapping a register to a variable is bit fields where you can make members of the union take a defined number of bits.

Converting between types (such as the IP example) is called 'type punning'. Historically it has been poorly defined in the C standards, but does work in gcc C and C++ via a documented extension. The draft C18 standard does clarify the situation, and explicitly allows it. Note: You need to be careful with endianness - the uint32 representation of the IP address would be different based on endianness, so there are portability considerations.

Every book on C programming I've ever used had had a section teaching about "structures and unions." Now, I've rarely ever used unions, but I appreciate how it can give your program an alternate view of your data. I can think of several interesting ways to use this feature, but very few practical ones.

I use unions all the time. They are really useful. I use it when writing a Lexer/Parser. (Though I use it other times too, it's just where I use it the most) e.g. typedef struct { uint32_t line; uint32_t col; enum {IDENT, NUMBER, STRING} kind; union { struct { char* data; uint32_t len; } string; uint64_t number; } } Token;

I use unions to pack 8 byte CAN messages all the time. Its also very useful when using bitfields as well, instead of checking eight or sixteen individual bit flags, you just check to see if the entire thing is or is not zero.

Unions are great! It's extremely useful to be able to interpret a single piece of data as different types, structures or even arrays. Say you have a 32 bit pixel representing RGBA channels, sometimes you may want to access individual channels with their own unique names as you would in a struct, sometimes as raw byte arrays and maybe sometimes you want to simply assign a 32 bit value to the whole pixel.

Learned about unions when I was teaching myself C back in the early 80s... have used them a lot over the years... very common in systems and embedded programming, data conversion, and the like.

I learned unions quite early in my C language learning process, I find them extremely useful for all the cases you stated here and more. For making VM's for in development hardware and domain specific languages they are a godsend, also comes in handy in game engine programming, hell my yet to be uploaded codebase for a dead simple and easy to use and maintain forth with readable code and a focus on being embeddable in applications as a lua replacement uses that. Speaking of which, I got a video suggestion: Forth! It has seen its fair share of use in embedded systems.

For type punning be sure to use pragma push and pragma pack. Then also add a #if defined processor name to make sure that if the code is compiled for a different processor the endiness can be checked. For C++ the language labels it "undefined behavior", but most compilers have a defined way it is handled. C++ lacks reflection so serialization any other way takes a lot of code. With a untion only arrays and strings have to be handled separately. Also note that the structures in the Union can't be a class, but can be an aggregate.

I do embedded programming and use unions quite a bit. I think they are very useful, but they have their problems. For instance, if your code is targeting two different platforms with different endianness, then multi-byte unions will give you a very bad day!

Short and sweet, really captured the essence of unions, I have never understood it better until now. Thanks!

The data conversion examples are cool, but it's important to note that they depend on the byte order ("endianness") and memory size of int, which can both change depending on what platform you're on.

I've used unions for some embedded stuff but most of the time I just end up using a bunch of bitwise operations instead. Never thought about using them for polymorphism though, that is actually pretty cool!

I discovered unions through cppreference And when I was writing my own json parser as an exercise, unions were the core of library's design They are not used really often, but sometimes they are irreplaceable :) Edit: and they are what makes C more functional of a language than python and many other popular ones. Because unions and structs are basically algebraic data types

thanks for the tips ! I also use struct of function to make some kind near C++ with C

I love it because it can make complicated things more easier. I used it as a messaging protocol, where the shared object is a header, with a type, then the buffer after that depends on the header along with crc

Really well presented video. I really like unions, have used them in some shape or form for most of my embedded programming, although I have a lot of stuff that can’t use them as cleanly as I would like because I have to worry endianness, but that’s just how it goes

Interesting, thank you for your introductions to Unions. I will experiment with it and understand it 100%

Found out about unions when I was making my final project for CS50x a few days ago. Used one in one of my structs for my fighting sim program.

One of the better KZfaq-teachers. In this case it is quite simple but explaining it at a fast speed without neglecting details is an art.

But my sociology professor said unions help undermine class structure 😵‍💫

I've often used unions like in your last example. Usually I'd ensure correctness by using functions or macros to set both the discriminant and the value, just like your printJSON function ensures that you're correctly interpreting the data. I'd never seen unions used to provide multiple ways to read/write the same underlying data though, like with your IP address and hardware register examples, that's really neat! It makes unions an effective way to avoid the "primitive obsession" antipattern, beyond a simple "typedef int ipv4_addr".

I was doing this union/structure stuff 20 years ago....so powerful...especiall as an embedded C programmer....picking out specific bits of a byte...setting/ clearing etc.

I'll be sure to check out the course on the website.

Hey LLL, can you do a video on how SIMD works under the hood? Because it's relatively new, not many assembly textbooks cover it and how to write programs to take advantage of it.

I had come across unions during my first year engineering class, but there wasn't much focus on it, instead all attention was on structures (due to its use in Data Structures). I always wondered why do we need them, and even most websites' explainations of it being useful for type conversion felt silly as I can do it normally using format specifiers. But this is the first time I found the actual practical usage of them. Especially the polymorphism part, which can be used during some DS experiments involving conversion between postfix, prefix, infix operations.

The X intrinsics toolkit (the one Motif is built on) used this trick but with the type identifier being the first member of each struct in the union.

It is interesting that c can already do so many thing just using struct, while union are pretty restricted to the use case that really make sense. So even if I knew it when I was newbie doing tutorial, I don't ready knew where and how to use it. It is when I once faced a problem that really need union to solve, I really know how to use it.

Thanks for your insightful information about C. Because of my bad hearing I struggle, because of the background music...

Always wondered what these were...definitely see how these could save some instructions here and there. Thank you.

Thank you for your videos. I'm not particularly interested in C language. But I write programs in Nim, and it compiles to C. Your insights are very helpful to understand Nim's internals.

I've used something similar to the polymorphism example when sending messages between two processes while working with QNX for an RTOS course

The first time I saw unions being used realistically was in some code for an LED light controller. The union had a struct with one byte per color, a 4-byte RGBI value, and a 4-byte array where each position was one part of RGBI.

Being an embedded developer, unions are a daily thing for me. However, there is one little thing I'd like to add - when you discuss the size of your json_t and say that the enum takes up only one byte... while that can be accurate, it isn't necessarily so. It depends on the compiler and its settings - I have worked with compilers where an enum always takes up 32 bits, as this is the native word size of the target architecture. In other cases, the minimum number of bytes needed to represent all values in the enum is used.

Prior to database management systems, data was written in records composed of fixed-length fields. Unions were used to reinterpret the layout of those records, where the type was indicated at the start of the record to simulate a tagged union similar to your last example, and to provide ways to access elements within a field, e.g. 8 chars for the whole date unioned with 2/2/4 chars for month/day/year. Storing data like this is why the strn* functions exist in the standard library; they weren't intended to be "safe" versions of the non 'n' variants as people started suggesting in the 90s. I don't know if it is useful to learn how computing was done prior to the 80s as a lot of it isn't relevant today unless you find yourself interacting with COBOL but it is helpful if you want to know where some of this stuff comes from.

I have used unions to serialize floating point number as their byte representation. Just write the float to the float part of the union and then read its byte array part when I need to serialize it. Just need to keep in mind the endianess (but that's mostly non-issue for me since the communicating system is always the same MCU)

The only time that I have used unions was to overlay registers. So, I could access EAX or AX depending on whether I needed the 16 bit or 32 bit register, but that was a long time ago and it was only for a hobby project.

I didn't know that unions operated like this! I've only read about them since I was curious about C's 32 keywords and had never seen this one used. I thought it only contained one type at a time so it's useful to know how they actually work! Thanks for this!

Awesome vid! I remember when my prof was talking about unions I never really got it. I can’t believe it took me this long to actually learn it for real lol

Man, Your work is nice. It should enter into Library of Congress.

You should do a video on bitfield structs, with variable width fields. Section 6.9, page 149 in K&R.

Awesome thanks 👍 I believe these will be useful

At one time i decided to design an esolang with the idea of it centering around a datatype whos inner type was dynamic. I was originally using a void pointer and doing the casting as required, but unions seem a lot better for that, nice to know

Unions taught me about endianness, as I was doing something similar to the ipv4addr example and got very confused about the byte order

I consider union an early precursor to polymorphism with capability of adding simple RTTI concept by wrapping union and enum together into a struct, many people use unions this way. It's also the easiest and fastest way to understand polymorphism and it's benefits.

Where do you get your t-shirts? I love them

Keep making videos for C they are the best!!!

i use unions to break down types like floats and doubles for complex conversion, as well as dynamically access arrays and heaped memory. i think its great practice for any budding programmer to learn to use them, so its sad to hear theyre relatively obscure. theyre super useful even in C++ (even though much of their implementation is UB), much faster than a lot of other included functions and features.

Please make one about type punning and Undefined behavior (in C and C++) :))

I'm always using them programming for MCUs. Sometimes I need some tricky data rearranges and unions helps me.

I think unions are cool for those conversion things where you don’t really convert but just want to have a different view of the data. They are also useful sometimes when you have memory that you can only write in blocks of a fixed size. For example I have NVRAM that can only by written in 32 Bit blocks. I define a Union that consists of a uint32 and a struct that is smaller than that and can save and load my struct onto NVRAM easily. However they can throw people off easily. So I rather use then sparsely. An example of their usage is the network address structs in the conversion between these structs in the C library

No experience in c, but I've used a similar feature of Pascal called variant records (if I remember correctly) to access individual words or bytes of an integer.

Other computing languages have used union-type structures and syntax for decades. For example, COBOL has the REDEFINES clause which does exactly the same thing. It is possible that this feature was added to C in part to enable a C program to interact with software and data from other computer languages. 30 years ago, I was involved in an EDI project (Electronic Data Interchange) involving the receipt of purchase orders and the sending of invoices via X.500. One computer was an IBM mainframe, the other was a Unix minicomputer. X.500 was an expensive protocol, so EDI was designed to send the required data in the smallest packets possible, and made heavy use of REDEFINES and unions to accomplish this.

nice examples on unions, thanks for video . informative . from India

Flexibility of unions in C++ however is severely reduced because of stricter safety checks so you have to usually work with some ugly reinterpret cast syntax to make it work

Hi, I want to learn assembly so where shall i start.. some are suggesting go with the x86 and some are saying go with ARM. which one will be best. thx in advance.

This was great timing after just learning about Unions in Zig while doing Ziglings last night

I used unions a lot in my previous job. The system's learning data would be flashed into ram all at once, and then we'd break it down into smaller and smaller structs depending on the "module" within the system. Because of legacy code, some of the structs could have slightly different type definitions across the code base. Using unions is a slightly more structured way of accessing that memory, as opposed to casting void pointers into the type that you're expecting.

Randomly learned about unions through Unreal Engine years back. Vectors are defined structs with a union over the member types.

One way I used unions a while ago was to interpret 32-bit color both as an uint8 array and 4 named 8-bit uints using: union RGBA32 { uint8 RGBA[4]; struct { uint8 R, G, B, A; }; };

I remember using this in Arduino. I wanted to give individual names to my digital output pins, but also iterate through all the pins in a single loop.

I use them to create a bunch of aliases for the members of vector and matrix types. union{struct{float x,y,z;}; float v[3];} Vector3; union{float m[9]; Vector3 row[3];} Matrix33; union{float m[12]; Vector3 row[4]; struct{Matrix33 mtx33; Vector3 translation;};} Matrix43; Very nice when you need to pass a portion of a composed struct as an argument to a function, or access elements with a loop iterator instead of by individual names. The only drawback is that it clutters the debug watch window.

Dude, I'm taking a MicroP class right now and Unions are EVERYWHERE. Pretty much all configuration registers for devices are stored in some sort of union.

I find unions very handy for all of the use cases you mentioned and more. As far as goto I generally abhor them, but in certain instances they are just the cockford Ollie and the code is just more logical than writing spaghetti to get around using one. At the end of the day your code should be as simple as possible and no simpler!

I've used unions to make my C++ code more readable. I had a Vector3 class that I would use to represent rgb color values, and xyz coordinates. Instead of having two Vector3 types, or storing values twice, I used unions for each of the floats.

@ 2:00 - this isn't valid in C++, and is in fact undefined behavior due to the object lifetime rules: Only one member of a union may be active at any time. What you're demonstrating here is type punning, and is considered a 'wrong" use of unions. Instead, use memcpy() (which the compiler will helpfully reduce to an implicit union).

I always thought who would use a union, but this video opened my eyes wide open with their power.

0:41, should be putting floating point numbers 1st in unions, had a compiler complain at me before when I didn't

Very useful! How about a video about C bitfields next?

Unions are one of those really cool features that once you learn how to use, it's hard to not spot places where they could be really useful.

Yeah you can use a union to do some pretty cool stuff. One is quickly read out the binary data of floats union u{ float f; unsigned int ui; }; union u val; val.f=1.0f; printf("%x",val.ui); output: 3f800000

I remember in CS:GO's code that I've seen unions be used for example when representing the coordinates of a Voxel in spatial partitioning as well as its ID (hash?) which was for example used to get all entities inside a specific area on the map or something union Voxel_t { struct { unsigned int x:11; unsigned int y:11; unsigned int z:10; } bitsVoxel; unsigned int uiVoxel; };

I worked on a machine code excutor for a school project. Union saved my butt for "converting" an unsigned short into a array of unisgned char

A very good explaination of unions with nice examples. I do wish to point out that, unless you pack a structure, the size will surprise a few people. Structures, arrays, and types are usualy aligned to word (register size) boundries, which are implementation dependent. I once found a bug that wasn't, because the array, containing a string, was automatically aligned. The character array was declared to be 10 and contained 10 characters. The issues was that it reprented a string, which is suppose to be null terminated. The complier actually aligned the array to 12 bytes, not 10, so it worked because the last 2 bytes were 0. Modifying it to be UNICODE compatible made it blow up, because 10 UNICODE characters were aligned and there was no extra bytes to hide the mistake.

i'm interested in Cyber Security. Know little of C and started to learn Assembly. I like your low level explanation of things. interested to learn more.. Sorry can't afford your course. But your effort deserve something

there are 2 use cases where i wish i had unions in C#. 1 with vectors and colors xyzw = rgba 2 with character hitboxes where the position of the hitbox is shared with the characters position. so character.pos = character.hitbox.pos

I knew about unions but try to avoid them due to the fact that they require extra care in thinking how you are phisically organizing memory in your code (think of an array of unions, for example). In my opinion, another hidden gem in C is the "reserve" keyword. Thanks a lot for the video, high quality as usual !

Unions are used in quite a few places. One place it is very useful is in messaging. There is a common messaging API which is used by all cores and task. The messaging size is fixed and is a messaging payload. Each of the task will have a different representation of that data payload. So the overall structure/union is what is accepted by the messaging API, but up to the task what that data represents

In the example at 3:46, one can define as many fields as the register contains by using bit fields in the structure. While more readable than bit-wise operations, you need to measure to see which is more performant.

The problem with unions is that the C compiler doesn't guarantee most of the use cases you've described If fields are reordered or endianess differs, data conversion will break. It's dangerous to assume otherwise unless you are locked in to a specific system and compiler version. If you write to a union using one type of data and read using another that's "undefined behaviour "

That last case is just like enums and pattern matching in Rust

Something I love to do with unions is treating a multidimensional array as a single linear array for quick one off tasks that would only require a simple for loop instead of a set of nested for loops. Makes rereading my code easier and thinking a lot easier too

just noticed that 42 is * in ASCII. 42 truly never stops to amaze.

It helps to deal with type diversity as well

This reminds me of TypedArray in javascript. You are essentially interpreting a buffer in different ways.

I use discriminated unions somewhat frequently - although I use Zig, which has nice syntax to make sure that you don't get the field of the wrong type. (similar to Rust enums) Using a regular union to change types is generally a bad idea if you are trying to support multiple platforms, because the way that they organize memory might be slightly different leading to different behavior.

They're incredibly useful in game programming since they're the basis of variant data types. Love me a delicious union

I used unions to make a program for a microcontroller to communicate by I2C with a Raspberry Pi. In the Pi side, i made a custom program to access the content sent by the micro. Unfortunately, i didn't made the program in the uC side compatible with Linux kernel way of communicating through I2C, so i could't make it standard. I would be fine if you have the opportunity to talk us about how to program for Linux kernel.

I'll watch this to hear you out, but I learned about unions the same day I learned about structures, in 1996.

Damn, that's cool, thanks ❤

Used it in C and Modula-2 which I also used in production on one project.

Your "practical application" of unions might be legal in C (I have no idea because C is obsolete to me) but in C++ this is undefined behavior i.e. an illegal move. You can't use unions for the purpose of type punning. Unions are for implementing variants and other low level optimizations.

Hey bro what code editor do you use ???

I have absolutely heard of and implemented unions in C before, the fact that this video will not stop showing up on my youtube really annoys me. I came to comment for 2 reasons: 1. This is the only video that bothers me, I love your other content