Foro de elhacker.net

Holas a todos, no se si este bien de la cabeza pero estoy tratando de ingresar n datos en un arreglo; pero sin conocer el limite de comparacion, dejo mi idea que trato de correrlo. aclaro: aun no funciona pero se entendera mi idea.

#include<math.h>
 
double leer(double x[]);
 
int main(){
    double x[]={0};
 
    leer(x);
 
}
 
double leer(double data[]){
    int i=0;
    char opc;
 
    do{
        printf("\nAdd: ");
        scanf("%lf", &data[i]);
        i++;
        printf("\nGoing add data (s/n): ");
        scanf("%c", &opc);
    }while(opc != 's' || opc!='S');
 
    return data[i];
}

Saludos

Eso que haces no es correcto, ya que estás introduciendo datos en zonas de memoria que no habías reservado. A mi se me ocurren dos alternativas:

1. Hacer uso de alguna estructura enlazada, como por ejemplo, una lista enlazada. Creas dos punteros uno que apunte al inicio de la estructura y otro que apunte al último elemento de la estructura. Cada vez que quieras añadir un nuevo elemento reservas espacio con malloc, enlazas el último elemento con este y pasas el puntero último al nuevo elemento.

2. Hacerlo con un array y cada vez que se quiera insertar un nuevo elemento crear un array auxiliar, reservar memoria para el tamaño del array anterior más 1, copiar todos los elementos del array anterior a este, y guardar el nuevo elemento en este, eliminas el espacio del anterior array y vuelves a iterar. Este método lo veo mucho más costoso computacionalmente.

Me imagino que habrán alternativas, pero ahora mismo son las dos que se me ocurren.

Espero que te sirva.

Saludos.

Hola

leer() no es el nombre adecuado para las operaciones que realiza.

Ahora bien, cuando haces leer(x) estas pasando la direccion de memoria de la variable x, por lo tanto no hay manera de saber el limite del arreglo que creaste.

Podrias colocar un printf("Cuantos valores quiere ingresar?: ") y un scanf() para almacenar la respuesta y pasarla como argumento a la funcion leer() y asi podras controlar el limite. Obviamente la cantidad no debe ser mayor a la cantidad maxima de bloques que tiene tu arreglo.

Podrias colocar la longitud de la cantidad maxima de bloques que tienes tu arreglo en leer() para controlar el limite.

Si quieres manejar arreglos con bloques arbitrarios debes aprender a manejar punteros y la funcion malloc().

Lo que intentas se puede solucionar con realloc:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
void leer(double **);
 
int main()
{
    double *p = NULL;
    leer(&p);
    free(p);
 
    return 0;
}
 
void leer(double **pdata)
{
    int i = 1;
    char opc;
 
    do {
        printf("dato: ");
        *pdata = realloc(*pdata, sizeof(double) * i);
        scanf("%lf", *pdata+(i-1));
        i++;
        getchar();
        printf("mas datos (s/n)? ");
        scanf("%c", &opc); 
    } while (opc == 's' || opc == 'S'); 
}