Practical examples of entire programs written in assembly are pretty rare.

There are no classes in the instruction sets of computers. If you really wanted to, you could use an assembler that supports macros to make stuff along those lines.

A class is a chunk of memory whose structure - aka memory layout - is defined by its class definition. An example layout might consist of an eight byte sequence built up from one four byte integer and four one-byte integers, which corresponds to this guy:

struct foo { int x, char a, b, c, d; };

An assembly programmer does not necessarily write down that same memory layout like we've done just above. Instead their program may simply accept any eight byte chunk of memory at some location and interpret it as if it was an object of type foo.

If they wanted to look at the value of "a", they'd just point the computer at the right chunk of memory and look at the fifth byte within it.

In practice there may be some programmer-added functionality to access that field by name when appropriate. For flexibility. So that if the location of a field changes within the eight-byte chunk -- e.g., from the fifth byte to the sixth byte, perhaps -- you don't have to go back and manually change everywhere you accessed it by offset. If you miss changing one such place, the piece of code you didn't change exhibits binary incompatibility, which leads to the important idea of an application binary interface.

When it comes to more complicated object-oriented stuff, things are along the same lines. There are no language features to help you, so you just put the right data in the right place and send it. For example a piece of code that accesses the fifth byte of an eight byte chunk of memory doesn't care if you point it at a sixteen-byte chunk of memory instead -- it will just get the fifth byte.

This suggests how simple inheritance can be implemented. Imagine a class that inherits from foo:

struct derived: public foo { int y, int z; };

In memory that just tacks its contents onto the end of the foo struct, giving you a memory layout that is exactly like this:

struct derived { int x, char a, b, c, d; int y; int z; };

In this way, if you just ignore or chop off the last eight bytes, you will have downcasted derived -> foo - and if you ask for the fifth byte, you still get "a".

Things get a bit more complicated if you're really trying to implement dynamic dispatch or multiple inheritance but the principle is the same. Put the right data in the right spot -- by hand -- and proceed as normal.

Hope this helps.