Eso está claro, el problema es que si intentas guardar la cadena que el usuario introduce en <cadenados> cuando no se ha reservado memoria para ello, se genera un error en tiempo de ejecución por lo que no se producen las salidas que deberían.
En mi caso al menos me genera una segmentation fault aunque me suena que en ocasiones en C se permitía escribir en espacios de memoria que no habían sido reservados si estos espacios no superaban los límites de memoria del programa. De todas formas sigue sin ser correcto...

No sé cómo te funcionaría pero a mí no me funciona. Sale un error por no tener memoria para <cadenados>.
Siempre que estés escribiendo en <cadenados> tiene que darte ese error (violación de segmento / segmentation fault). Otra cosa es si quitas también la parte en la que pides introducir "hola" en <cadenados>.

PD: No uses la librería <conio.h>, no es una librería estándar.

Buenas, lo primero de todo si puedes poner el código anterior entre etiquetas de código GeSHi (encima del cuadro de texto hay un desplegable que pone "Código GeSHi" donde puede seleccionar el lenguaje de programación correspondiente).

Tu problema no está en la línea que has comentado, esa sentencia es correcta. El problema lo tiene <cadenados>, te comento.
Imaginemos la memoria como cajitas, en cada una cabe un valor. Por ejemplo:

char x = 'a'; // seria una cajita que guarda el contenido de <x> o sea, la 'a'. 

Un array/arreglo son un conjunto de cajitas; en las que en cada una de ellas, se guarda un valor, por ejemplo:

char arregloDeChar[SIZE]; //serian un numero de cajitas igual al valor SIZE y en cada una cabe un <char> 

Muchas veces se confunde un array con un puntero, pero un puntero únicamente es una cajita que en vez de guardar un dato directamente, guarda la dirección de memoria de otro dato, por ejemplo:

char x = 'a'; // supongamos que la direccion de x es 0x1 entonces en la posicion de memoria 0x1 se almacena 'a' (dicho de forma simple)
char *px = &x; // aqui creamos otra cajita para px que almacena la direccion de x. Imaginemos que px se encuentra en 0x2, entonces en 0x2 se guarda 0x1. 

La confusión entre punteros y arrays se debe a lo siguiente:

char array[10] = {'a', 'b', 'c'};
// array[0] es un dato de tipo char, array[0] = 'a'
// array[1] es un dato de tipo char, array[1] = 'b'
// array[2] es un dato de tipo char, array[2] = 'c'
// array es un puntero a array[0] 

Entonces cuando se trabaja con memoria dinámica (cosa que si estás empezando dudo que conozcas) lo que se hace es declarar un puntero y luego a ese puntero se le reserva memoria para que pase de tener 1 cajita de memoria a tener más. Si trabajas con memoria dinámica lo que debes usar son arrays estáticos, es decir, con los corchetes como he hecho yo arriba.
Aquí es donde aparece tu problema. Estás guardando una cadena mediante la función <gets()> (la cual te recomiendo que cambies por <fgets()>, no se recomienda usar <gets()> porque es menos segura) al puntero <cadenados>, pero <cadenados> solo tiene 1 cajita para un caracter.

Y puede que te preguntes "por qué con <cadenados> tengo ese problema y con <cadenauno> y <cadenatres> no?"
Verás, al poner por ejemplo:

char *cadenauno = "hola"; 

Lo que sucede es que al cargar el programa en memoria para ser ejecutado hay un "array" (entiéndase así) en el que el programa tiene guardado "hola" para poder asignarlo a <cadenauno>. Como ese "hola" ya está guardado en una posición de memoria, el programa lo único que hace es guardar en <cadenauno> la dirección de memoria en la que está guardado "hola" (la dirección en la que comienza "hola").
Es por esto que <cadenauno> y <cadenatres> no dan problemas. Porque la cadena de caracteres "hola" ya existe en memoria. Sin embargo, <cadenados> como la introduce el usuario por teclado, no existe en memoria antes del tiempo de ejecución.

Solución: Declarar un array. Y si luego quieres usar otro puntero pues lo creas y haces que apunte al comienzo del array.

#define SIZE 100 // longitud suficiente para que quepa lo que queremos guardar
char cadena2Array[SIZE];
printf("Introduce el valor de cadena2: ");
fgets(cadena2Array, SIZE, stdin); //  mas seguro que gets() porque se asegura de no pasarse del limite SIZE
printf("El valor de cadena2Array es: %s", cadena2Array);
 
// si quieres otro puntero
char *cadena2Puntero = cadena2Array;
printf("El valor de cadena2Puntero es: %s", cadena2Puntero); // Misma salida ya que apunta al mismo sitio 

Te dejo AQUÍ un enlace a otro tema reciente en el que se tratan también estos temas y tienen algunas explicaciones más completas.
Espero que te sirva.
Suerte

No entiendo lo que pides. Que te digamos un problema con esas características para tú resolverlo (lo cual puedes encontrar infinidad de ellos en cualquier sitio o puedes inventar uno propio) o que te demos un problema con esas características resuelto (lo cual está en contra de las normas del foro de hacer tareas).
Tanto en un caso como en otro, eres tú quien debe poner de su parte.

Diría que sí, tienes que ir pasando por todas las palabras mediante una variable "vertedero" (al final se le va a quedar ese nombre )
Porque para trabajar con ficheros de acceso aleatorio tienes que saber moverte en un fichero binario calculando los Bytes por los que quieres pasar.Te recomiendo usar acceso secuencial mejor.

Ese código se puede optimizar un poco. Te dejo aquí un código que guarda cada dígito en una posición del array.
Como estamos usando números enteros, no hace falta restarle la última cifra al número ya que el operador de división / realiza una división entre enteros por lo que obvia los decimales.
Además es recomendable que uses nombres de variables que expliquen mejor su uso.

int main(){
    int digitos[MAX_CIFRAS] = {0};
    long long numero;
    for(size_t i = MAX_CIFRAS-1; i >= 0; --i){
        digitos[i] = numero%10;
        numero /= 10;
    }
} 

Hay muchas formas de resolver esto, yo te voy a comentar una posible solución.
Te recomiendo leer el número en una variable de tipo <long long> porque en un <int> no cabe un número de 16 dígitos y después ir guardando cada dígito en un array ya que tal como lo haces en esa cadena podrías escribir cualquier cosa y tener problemas en la ejecución.
Además separar un número en dígitos es un problema muy común cuando empiezas en programación y que viene bien que lo practiques ya que es muy útil.
Una vez guardado el número, si creas un array de memoria estática de tamaño 16 siempre (quiero decir, que no usas memoria dinámica) empieza a guardar los dígitos por el final y así podrás localizar siempre la penúltima posición ya que los 0 estarán al principio, no al final.

Suerte

Si especificas un poco más tu problema, será más fácil ayudarte...
Creo que nadie se va a leer todo ese mensaje para explicártelo entero.

Dejo por aquí otra función que permite validar una fecha

bool validarFecha(int day, int month, int year){
    int dias_mes[12] = {31,28,31,30,31,30,31,31,30,31,30,31};
    if(month < 1 or month > 12)
        return false;
    if(month == 2 and esBisiesto(year))
        dias_mes[1] = 29;
    return day <= dias_mes[month-1];
}
 
bool esBisiesto(int year){
    return (year % 4 == 0 && (!(year % 100 == 0) || (year % 400 == 0)))
} 

Otra opción sería esta:

char *pm = claveHabitacion[9];