Deberías dar un poco de formato a tu código: cada sentencia en una línea, controlar las sangrías, dejar las llaves de cierre solas en su propia línea. Consideraciones estéticas. El código se ve mucho mejor y a simple vista se puede seguir de forma más intuitiva.

A lo que voy. Te dejo la función inacabada rellena con el código comentado más una recomendación: cuanto menos código escribas mejor (sin llegar a hacer críptica la solución, hay que sacrificar muchas veces la simplicidad por la claridad). La lógica muchas veces se puede simplificar, y no digo solo operaciones lógicas sino las líneas de código. Muchas veces el código se repite y no nos damos cuenta. Vale la pena perder un poco de tiempo en revisarlo y dejar todo lo que se repita fuera de las estructuras condicionales y reorganizar éstas para que solo toquen los pequeños cambios que se suceden.

Tu solución, supongo que esto te lo ha dado el profesor

void AddToCollection(Collection &col, int element) {
    // la primera parte de la funcion
    if (col.elno==0) {
        col.elements = new int[1];
        col.elements[0] = element;
    }
    //lo que no esta terminado
    else {
        int *temporal;
        int i;
 
        temporal = new int[col.elno + 1]; // Hago que temporal sea un elemento más grande que el actual número de elementos.
        for(i = 0; i < col.elno; ++i)
            temporal[i] = col.elements[i]; // Copio todos los elementos del array antiguo al nuevo.
        temporal[i] = element; // i está actualizada al nuevo último elemento por la forma en que trabaja for,
                               // así que guardo el elemento pasado a la función.
        delete[] col.elements; // Ahora puedo borrar el arrar antiguo
        col.elements = temporal; // y hacer que el puntero elements apunte al nuevo array.
    }
    col.elno++; // Actualizo elno para indicar que hay un elemento más.
}

Ahora la mía:
Se basa en que todo el trabajo es el mismo, menos en una cosa, tanto si no había elementos guardados o si los había.
Obviamente faltan las comprobaciones de seguridad, por si acaso hubiera algún fallo pero no están incluidas por simplicidad y claridad.

void AddToCollection(Collection &col, int element) {
    int *temporal;
    int i;
 
    temporal = new int[col.elno + 1];
    for(i = 0; i < col.elno; ++i)
        temporal[i] = col.elements[i];
    temporal[i] = element;
    if(col.elno) // Esta es la excepeción que he nombrado. Que es lo mismo a: if(col.elno > 0)
        delete[] col.elements;
    col.elements = temporal;
    col.elno++;
}

Tiene que ser carácter a carácter. Si quieres hacerlo de una vez genera una función que tome dicha cadena y pase toupper carácter a carácter. Al regresar tendrás tu cadena en mayúsculas.

Por cierto, para guardar "hola" necesitas un array de 5 caracteres. Acuérdate que toda cadena tiene un carácter NUL ('\0') al final para marcar el fin de ésta.

Antes de ayudarte con tu el algoritmo:
El ejercicio pide números introducidos a mano en el código, eso es, el array debes inscribirlo de la forma:
Los valores óbviamente debes ponerlos tú.

Ahora:
Sabes que sí o sí es un array. Prepara dos variables, una que guarde el mayor y otra que guarde el menor.
Al principio del código haz que valgan lo mismo que el primer elemento del array.
Después, por cada elemento del array, menos el primero por la razón que ya hemos dicho, si menor es mayor que el elemento del array copiar dicho elemento a menor y de igual forma si mayor es menor que el elemento del array copiar dicho elemento a mayor.
Una vez terminado el bucle el número que buscas será la diferencia entre mayor y menor. No te preocupes por si menor o mayor y menor son negativos pues matemáticamente la respuesta será igual de buena.

No entiendo qué pretendes con esa condición del if.

Mete el código entre estas dos etiquetas:
[code=c] copia aquí todo tu código [/code]
Si no lo hace así ves que no se va a entender.

No sé como vas de punteros pero te cuento:
Como sabes los parámetros se pasan a las funciones por valor, eso quiere decir que a la vuelta el parámetro no se habrá modificado.
Cuando pasas un puntero como parámetro de una función, dentro de ella podrás modificar el contenido de esa memoria, no el puntero en sí, que una vez que regreses, y recuerda que lo has pasado por valor (es decir, una copia) éste no se habrá modificado.
Es muy importante que memorices estos conceptos.

Ahora. La función fopen devuelve un puntero, es decir, genera una estructura en algún sitio de forma dinámica y nos devuelve el puntero al principio. Pretendes que ese puntero se quede guardado en el argumento que le pasas a la función, pero lo por explicado más arriba esa información no puede salir de la función, en main sigue el puntero original y por tanto se pierde.

¿Cómo podrías solucionar esto?
Haciendo que la función devuelva un puntero a FILE, es decir:

FILE* abrir(char nom[], char b[]) {
    FILE *fich;
    char nombre[40], dni[40], apellido[100];
 
    fich = fopen(nom, b);
 
    // aquí el resto de la función
 
    return fich;
}
 
int main() {
 
    // aquí el código de main hasta llegar a abrir, y entonces
 
    fichlec = abrir(nombre, b);
 
    // ...
}

O si te interesa pasar el parámetro sí o sí como argumento tendría que ser como puntero a puntero. La idea es: sabiendo que se puede cambiar el contenido de un puntero, pero no el puntero en sí, debes dar ese puntero (FILE *) como dato (de un puntero anterior que será el que se copiará) para que así se pueda modificar.

Por cierto, printf tiene un carácter de control para ver la dirección de los punteros: %p

void abrir(char nom[],FILE **fich, char b[]) {
    // ...
    *fich = fopen(nom,b); // para acceder al contenido, que es FILE *
 
    // Ahora, si quieres ver la dirección debes hacer
    printf(" valor del identificador:  %p         ------------\n", *fich); // recuerda, el contenido de fich es lo que se devolverá a main
}
 
int main() {
    // ...
    abrir(nombre, &filelec, b)
 
    // para ver la dirección de filelec es de la forma habitual:
    printf(" valor del identificador:  %p         ------------\n", fichlec);
}

Y recuerda que al terminar debes cerrar los archivos con fclose.

Así es. El problema es que actualizas contaproceso y cintacanti fuera de eso, por tanto también suman las comas y los otros caracteres no deseados.

Por otra parte, y como consejo, todos esos if-else que se basan en un número entero los puedes sustituir por otra construcción que existe en C para ese propósito: switch-case. El código quedará más claro.
Aunque aún puedes ir un paso más allá con otra instrucción que te hará toda la captura de forma automática aprovechando que el formato del archivo siempre es el mismo y se considera, de por sí, bien formateado: la función fscanf. El grupo de de funciones scanf son muy potentes para estos trabajos pero para eso uno debe saber usar la cadena de control, aunque no es nada difícil.

Todo lo que tienes hecho debe estar dentro del if(carácter !='\n'...
Cómo lo haces fuera, tu contador también cuenta esos caracteres y como lo usas para presentarlos en pantalla te devuelve lo que hay más allá de tus datos.

Para compilar para diferentes S.O. pásate por aquí:
https://stackoverflow.com/questions/6649936/c-compiling-on-windows-and-linux-ifdef-switch

Para controlar el terminal en Linux por aquí:
https://www.google.es/search?q=termios&oq=termios&aqs=chrome..69i57.953j0j7&sourceid=chrome&ie=UTF-8
Y un ejemplo del uso de termios para realizar getche y getch de conio: https://github.com/billroy/bitlash/blob/master/src/conio.h

Vas muy rápido. Ya haces uso de programación visual y aún no dominas el lenguaje. Por ahora, y de verdad te será mucho más fácil, sí solo trabajas en modo texto. Aprende bien los fundamentos, después ya podrás combinarlo con el s.o. de tu elección y con el entorno gráfico que más te guste.

En este punto, para aprender esto, deberías estar con algo tan sencillo como:

#include <stdio.h>
 
Int devuelve_5() {
    return 5;
}
 
int main() {
    int num = devuelve_5();
    printf("num = %d", num);
 
    return 0;
}