Si utilizas mal la memoria, como en el caso de tu programa anterior que sobreescribia memoria, no existe garantia que esto siempre se caiga, o que siempre funcione, si tiene algun comportamiento deterministico, es suerte. Desde mi punto de vista, tienes suerte que el programa se caiga y te permita descubrir sus errores. Muchos problemas en el software se presentan despues de mucho tiempo, por ejemplo, grandes fallas de seguridad han pasado an~os sin ser descubiertas.

(Otras observaciones:
 - Interpretaste mal lo que dije. Nunca dije que estabas reservando memoria de mas, al reves, quise decir que estabas pidiendo memoria insuficiente, y copiando de mas en esa memoria insuficiente.
 -  sizeof(char) es siempre 1, no necesitas hacer la multiplicacion por sizeof(char), pues ya sabes que la multiplicacion por 1 es superflua.
)

El ciclo for al interior de la funcion comprobarSiEsRepetida no parece tener oportunidades de repetirse muchas veces dado que el if-else siempre hace break, tanto si la condicion del if es verdadera o es falsa.

Me da la impresion que no quieres tener un else ahi y solo salir del for y de la funcion si una condicion ocurre y seguir en el loop si aun no se presenta.

Tampoco entiendo muy bien el ciclo for de la funcion listaOrdenadaAscendente. AL parecer quieres insertar en this2 si no se ha visto antes y eliminarlo si lo has visto antes. Es raro esto, porque no solo insertas si no lo has visto, y si lo has visto simplemente lo ignoras, en vez de intentar borrarlo?

Te sugiero usar nombres de variables que sirvan para entender mejor el programa, this y this2 no son los mejores nombres, especialmente si este codigo llegase a ser compilador por un compilador de C++.

Mire' solo el final de ese kilometrico programa y al menos tienes un problema en la funcion copiaOperacion pues pides memoria para una cierta cantidad de elementos, digamos n+1, copias n caracteres, un + y un 0.

Si pides n+1 elementos en memoria y copias n+2, estas invitando a que tu programa se porte mal. O copias menos o pides mas, decidete, tal como lo tienes es una receta para el desastre.

Tal vez haya otro problema similar por ahi, te recomiendo recortar tu programa para depurarlo si se sigue portando mal. Tal como esta se hace dificil adivinar donde esta mal algo.

No necesitas guardar todos los datos en un arreglo, ni tampoco necesitas ordenarlos.

Si lees los datos 1 a 1, puedes actualizar 2 variables, la que tenga el maximo y la que tenga una despues del maximo. Si las llamas maximo1 y maximo2, cuando lees un numero, si ese numero es menor que maximo2, no es necesario cambiar ni maximo1 ni maximo2, pues esos valores siguen siendo los mas grandes. Si es mas grande que el maximo2, hay que, al menos, deshacerse del maximo2 y actualizar a los nuevos valores, dependiendo si es o no mayor que el maximo1

maximo1 = leer numero
maximo2 = leer numero
si maxmo2 > maximo1 -> intercambiar maximo1 y maximo2
 
ciclo hasta terminar {
     leer numero
     si numero > maximo2 {
         si numero > maximo1 {
             maximo2 = maximo1
             maximo1 = numero
         } else {
             maximo2 = numero
         }
     }
}
 
imprimir maximo1 y maximo2
 

Basado en el requerimiento original, y pensando de lo que nos dice que el profesor querria restringir el uso de arreglos, tal vez se trate de un curso introductorio y ni siquiera las funciones han sido vistas aun. En ese caso, la solucion propuesta no serviria tampoco.

Como no hay muchas pistas, adivino que solo se puede usar while y los datos se leen uno tras otro, quedando algo asi como:

   leer numero
   maximo = numero
 
   repetir 4 veces {
       leer numero
       si el numero > maximo -> maximo = numero
   }
 
   imprimir maximo
 

No hay uso de arreglos, no hay paso de parametros ni funciones, solo lectura de un entero en 5 ocasiones, actualizando el maximo cuando corresponde.

Hay que considerar que los años pueden ser bisiestos.

Que tal si calcular la distancia hacia una fecha pasada comun de cada fecha y luego la diferencia entre ambas ditancias?

Mirando el codigo que publicaste en github, no pareces estar usando socket() para nada en realidad. Si eliminas la invocacion de socket tu programa se deberia comportar igual.

Aprovechando, elimina variables que definiste y no usas. Hay varias.

Opino que tu programa se va a comportar mal igual despues. Incluso sin la presencia de socket(), pues ademas estas usando variables sin inicializar.

Te falta pedir memoria para el 0 final.
No es suficiente contar los caracteres que quieres copiar desde el string original, porque en verdad requieres 1 mas. Hazme caso y cuando pidas memoria pide 1 mas que los caracteres visibles. La linea 25 de tu programa esta escribiendo en un espacio de memoria que no es tuyo. Hazlo tuyo pidiendo memoria para 1 mas en la linea 17.

Cambiaste el problema por otro.
Pides memoria en la linea 7 y luego la ignoras y sobreescribes en la linea 8.

Hiciste lo mismo que asignar una variable y luego volverla a asignar con otro valor

i = 3;
i = 5;

El 3 que esta en la primera linea se pierde con la asignacion de 5.
Lo mismo con la memoria que pediste, no tiene sentido liberarla despues en la linea 10 porque la variable d ya no tiene la memoria pedida.

Te sugiero copiar el string, no asignarlo para resolver el problema DE ESTE PROGRAMA y se sugiero pedir memoria suficiente EN EL PROGRAMA ANTERIOR.

Reemplaza la asignacion por

strcpy( d, "Prueba" );

// #include <string.h>  es necesario

Cambia algo el comportamiento si pides un espacio de memoria para el '\0' fiinal?

char *d = new char[contadorStrings(texto)];

modificalo por

char *d = new char[contadorStrings(texto)+1];

Si es este el caso, o no, podrias publicar el codigo, encerrando tu codigo usando el "Codigo Geshi" que aparece entre los botones arriba, para que uno pueda indicar en que linea se ve un problema, y el codigo aparezca con colores de acuerdo a la sintaxis del lenguaje que elijas?