ENUM: sirve para crear constantes bajo un nombre que las agrupe. Por defecto el primer elemento de la enumeración vale 0. Las siguientes irán sumándose una unidad.

#include <stdio.h>
 
enum dia {
    LUNES,
    MARTES,
    MIERCOLES,
    JUEVES,
    VIERNES,
    SABADO,
    DOMINGO
};
 
int main() {
    enum dia entrada = LUNES;
 
    printf("%d", entrada);
}
 

Prueba este código cambiando LUNES, dentro de main, por otro de los días.
Se puede cambiar el valor de la constante indicándole el nuevo que puede tener, por ejemplo MIERCOLES = 20 dentro de la enumeración. En ese momento MARTES valdrá 1, MIERCOES 20, JUEVES 21, pues sigue la regla de que el siguiente identificador vale uno más que el anterior.

Hay que diferenciar que una enumeración en C es una simple constante mientras que en C++ es un tipo de dato, con las restricciones que esto supone.



UNION:
Las uniones sirven para dar a una misma posición de memoria diferentes nombres y comportamientos. Es decir en la misma posición de memoria puede empezar un int, un char, un double, un array de 8 floats, una estructura, etc. El tamaño intrínseco de la unión es el mismo que la del dato que ocupa más tamaño, por ejemplo si una unión está constituida como te he explicado antes y el array de 8 floats es quien ocupa más, el tamaño de toda la unión ocupará lo mismo que el array de 8 floats.
Ahora la unión no tiene mucha utilidad, pero antes cuándo los ordenadores no tenían mucha memoria esta era una buena forma de reutilzar la memoria teniendo diferentes identificadores que se usaban en diferentes momentos pero sin ocupar más.

Un ejemplo de su uso:

#include <stdio.h>
 
union var {
    int entero;
    double real;
    char caracter;
};
 
int main() {
    union var mi_dato;
 
    puts("Caracteristicas de mi_dato:");
    printf("Direccion de inicio: %p\n", &mi_dato);
    printf("Tamanyo: %I64d\n\n", sizeof(mi_dato));
 
    // USOS
    mi_dato.entero = 5;
    printf("%d\n", mi_dato.entero);
 
    // ...
 
    mi_dato.real = 14.54;
    printf("%f\n", mi_dato.real);
 
    // ...
 
    mi_dato.caracter = 'c';
    printf("%c\n", mi_dato.caracter);
}

Una forma de usar una unión en estos días podría ser la siguiente:

#include <stdio.h>
 
union por_partes {
    int entero;
    unsigned char trozo[sizeof(int)];
};
 
int main() {
    union por_partes mi_numero;
 
    mi_numero.entero = 4789432;
 
    // Simula enviar por bytes un dato
    puts("Dato a enviar: ");
    printf("%X\n\n", mi_numero.entero);
 
    puts("Enviando byte a byte:");
    for(int i = 0; i < sizeof(mi_numero); ++i) {
        printf("%X\n", mi_numero.trozo[i]);
    }
}

Este programa es dependiente al endiandness de la máquina, pero eso ya es harina de otro costanl

Ya que en la pregunta está especificado que se trata de C++, conviene decir que hay diferencias importantes entre C y C++.

Una union en C++ siempre tiene un miembro activo, que es el último que se ha escrito, y tratar de leer un miembro que no sea el activo está calificado como "UB" (undefined behavior). Puede ser que algún compilador en particular lo implemente como una extensión al lenguaje, pero eso ya es otro cuento.

En el ejemplo:


Otra diferencia importante es que el C++ permite funciones miembro de una union, incluidos constructores y un destructor.

También, una union puede tener miembros que sean clases, con o sin constructores o destructores definidos por el usuario, en ese caso habrá que instanciar al miembro activo usando placement new e invocar a su destructor antes de cambiar de miembro activo.

Otra diferencia importante es la forma de inicialización. En C se puede hacer
pero hay que esperar al C++20 para hacer lo mismo en C++.

Hola MAFUS;

Una de la diferencias que señalo en mi respuesta anterior se refiere al comportamiento frente a la
lectura de un miembro de la union que no haya sido el más recientemente escrito.

Mientras que para el C es de comportamiento definido por la implementación ("implementation defined"), para el C++ es de comportamiento indefinido ("undefined behavior").

Esto es, para el caso del C, es una cuestión práctica; para el caso del C++ es una cuestión moral:

• En C puedes hacerlo, el lenguaje no lo prohíbe, sólo que el resultado dependerá del compilador (simplemente no es portable).
• En C++ no debes hacerlo, el lenguaje lo prohíbe, el resultado es indefinido, puede suceder cualquier cosa, casi siempre mala.