struct Ipv4 {
  int protocol;  // always == 4
  uint32_t num;
  uint16_t port;
};

struct Ipv6 {
  int protocol;  // always == 6
  unsigned char octets[16];
  uint16_t port;
};

struct Local {
  int protocol;  // always == 1 
  char path[256];
};

struct AbstractAddress {
  int protocol;
  char padding[60];
};

union AddressStorage {
  AbstractAddress aa;
  Ipv4 a4;
  Ipv6 a6;
  Local local;
};

void connect(const AddressStorage& addr);

void connect(const AddressStorage& addr) {
  switch (addr.aa.protocol) {
    case 1: return connect_local(addr.local);
    case 4: return connect_ipv4(addr.a4);
    case 6: return connect_ipv6(addr.a6);
    default: throw std::domain_error("unknown protocol");
  }
}

union D{
LVV>int a;
LVV>char b[4];     // или std::byte b[4]
LVV>};
LVV>D temp;
LVV>temp.a = 1234;
LVV>char byte = temp.b[0];
LVV>

It is undefined behavior to read from the member of the union that wasn't most recently written. Many compilers implement, as a non-standard language extension, the ability to read inactive members of a union.

union D{
LVV>int a;
LVV>char b[4];     // или std::byte b[4]
LVV>};
LVV>D temp;
LVV>temp.a = 1234;
LVV>char byte = temp.b[0];
LVV>

In a standard-layout union with an active member of struct type T1, it is permitted to read a non-static data member m of another union member of struct type T2 provided m is part of the common initial sequence of T1 and T2; the behavior is as if the corresponding member of T1 were nominated.
[Example 5:

struct T1 { int a, b; };
struct T2 { int c; double d; };
union U { T1 t1; T2 t2; };
int f() {
  U u = { { 1, 2 } };   // active member is t1
  return u.t2.c;        // OK, as if u.t1.a were nominated
}

— end example]

[Note 1: One special guarantee is made in order to simplify the use of unions: If a standard-layout union contains several standard-layout structs that share a common initial sequence ([class.mem]), and if a non-static data member of an object of this standard-layout union type is active and is one of the standard-layout structs, it is permitted to inspect the common initial sequence of any of the standard-layout struct members; see [class.mem].
— end note]

If the member used to read the contents of a union object is not the same as the member last used to store a value in the
object, the appropriate part of the object representation of the value is reinterpreted as an object representation in the new
type as described in 6.2.6 (a process sometimes called “type punning”). This might be a trap representation

6 When a value is stored in an object of structure or union type, including in a member object, the bytes of the object representation that correspond to any padding bytes take unspecified values.51) The value of a structure or union object is never a trap representation, even though the value of a member of the structure or union object may be a trap representation.
7 When a value is stored in a member of an object of union type, the bytes of the object representation that do not correspond to that member but do correspond to other members take unspecified values.

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 members (or if a member is a bitfield, then to the unit in which it resides), and vice versa.

A>void foo(uint32_t x, std::uint8_t out[4])
A>{
A>    out[0] = x & 0x000000FF;
A>    out[1] = (x & 0x0000FF00) >> 8;
A>    out[2] = (x & 0x00FF0000) >> 16;
A>    out[3] = (x & 0xFF000000) >> 24;
A>}
A>

#include <concepts>
#include <cstdint>

void foo(uint32_t x, uint8_t out[4])
{
    static_assert(std::same_as<uint8_t*, decltype(out)>);

    // . . .    
}

int main()
{
    uint8_t out[1]{};

    foo(42, out); // Oops! Заезд по памяти.
}

void foo(uint32_t x, uint8_t (&out)[4]);

void u32to8(uint32_t u32, uint8_t *u8) {
    u8[0] = u32 & 0xff;
    u8[1] = (u32 >> 8) & 0xff;
    u8[2] = (u32 >> 16) & 0xff;
    u8[3] = (u32 >> 24) & 0xff;
}

u32to8(unsigned int, unsigned char*):
        str     r0, [r1]  @ unaligned
        bx      lr
main:

union D{
LVV>int a;
LVV>char b[4];     // или std::byte b[4]
LVV>};
LVV>D temp;
LVV>temp.a = 1234;
LVV>char byte = temp.b[0];
LVV>

void foo(uint32_t x, std::uint8_t out[4])
{
    out[0] = x & 0x000000FF;
    out[1] = (x & 0x0000FF00) >> 8;
    out[2] = (x & 0x00FF0000) >> 16;
    out[3] = (x & 0xFF000000) >> 24;
}

GNU extensions to standard C++ (and to C90) do explicitly allow type-punning with unions.

union D{
int a;
char b[4];     // или std::byte b[4]
};
D temp;
temp.a = 1234;
char byte = temp.b[0];

R>>    foo(42, out); // Oops! Заезд по памяти.
R>>

#include <iostream>
#include <cstdint>

void foo(uint32_t x, uint8_t out[4])
{
    static_assert(std::same_as<uint8_t*, decltype(out)>);

    out[0] = x & 0x000000FF;
    out[1] = (x & 0x0000FF00) >> 8;
    out[2] = (x & 0x00FF0000) >> 16;
    out[3] = (x & 0xFF000000) >> 24;
}

int main()
{
    uint8_t out[1]{};

    foo(42, out); // Oops!

    std::cout << "Hello, World! Everything is OK" << std::endl;
}

If a program attempts to access the stored value of an object through a glvalue whose type is not similar to one of the following types the behavior is undefined:
— the dynamic type of the object,
— a type that is the signed or unsigned type corresponding to the dynamic type of the object, or
— a char, unsigned char, or std​::​byte type.

union D
{
int a;
char b[4]; // или std::byte b[4]
};

[Note 2: A union object and its non-static data members are pointer-interconvertible ([basic.compound], [expr.static.cast]).
As a consequence, all non-static data members of a union object have the same address.
— end note]

int A[3][4]{{1,2,3,4},{2,3,4,5},{3,4,5,6}};
      int n = size(A[0]);
      cout << A[2][1] << ' '
           << A[2*n+1] << endl;       // по-любому выдает адрес

LVV>int A[3][4]{{1,2,3,4},{2,3,4,5},{3,4,5,6}};
LVV>      int n = size(A[0]);
LVV>      cout << A[2][1] << ' '
LVV>           << A[2*n+1] << endl;       // по-любому выдает адрес
LVV>

void test() {
    int a0[4]={11,12,13,14};
    int a1[4]={21,22,23,24};
    int a2[4]={31,32,33,34};
    int* A[3]={a0,a1,a2};
    int B[3][4]={{11,12,13,14},{21,22,23,24},{31,32,33,34}};
    printf("A1=%d\n",(int)((char*)A[1]-(char*)A[0]));
    printf("A2=%d\n",(int)((char*)A[2]-(char*)A[0]));
    printf("B1=%d\n",(int)((char*)B[1]-(char*)B[0]));
    printf("B2=%d\n",(int)((char*)B[2]-(char*)B[0]));
}

A1=16
A2=32
B1=16
B2=32