Mensajes

Tal como dice ivancea96.
Pero puedes replicar: bueno, hay muchas librerías de terceros que también se usan y no son parte del estándar.
La respuesta a eso es: conio.h viene integrada en el compilador de Borland y es el que se usa en centros educativos o en los libros de texto. La gente, al salir de ellos, usan compiladores diferentes al de Borland, o tienen que  trabajar en Linux y después se quejan que esas funciones no existen. O piden ayuda y vienen con esas funciones que los demás no tenemos y si queremos probar su código tenemos que hacer unos cuantos cambios.

Yo digo: usa todo lo que te permita el compilador pero si al cambiarlo encuentras que lo que sabes no te sirve, no te tires de los pelos y adecúate a la nueva situación. Si vas a pedir ayuda conviételo antes al estándar.

Si el vector es un array, pus con memcpy.
Si el vector es el objeto de C++ pues con asignación =.

Este tema se trató hace muy poco. Mira aquí:
https://foro.elhacker.net/programacion_cc/ejercicio_calcular_la_diferencia-t478628.0.html

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

Código (cpp) [Seleccionar] Expandir

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.

Código (cpp) [Seleccionar] Expandir

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.

[menor]

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:

Código [Seleccionar] Expandir

int array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
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:

Código (c) [Seleccionar] Expandir

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

Código (c) [Seleccionar] Expandir

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.