[SOLUCIONADO] Duda: Contar elementos vector dentro de función.

[Casert]

Hola buenas, el objetivo de la función operar con un vector(tamaño l) y un entero(k), que son los datos recibidos, y devolver un vector (tamaño l*k-k).
El caso es que para crear el nuevo vector y asignarle memoria necesito saber el tamaño del vector inicial y no se como poder recorrerlo para ir contándolo dentro de la función.
Por otra parte, al usar dentro de la función malloc(), ¿La memoria asignada hay que liberarla con free() en algún momento?.
Se supone que el programa pedirá introducir un vector sin especificar tamaño por lo que no se conocerá el tamaño.
Introduciendo un valor en longv1 parece que el programa funciona.

Código C:

#include <stdio.h>
#include <stdlib.h>
 
double *operaVector(int k, double *vector1);
 
int main(){
    int i, k, longv2;
    double vector1[]={3,2,5,4}, *vector2;
    printf("Introduce el valor de k: ");
    scanf("%d",&k);
    longv2=longv1*k-k;
    vector2=operaVector(k,vector1);
    for(i=0;i<longv2;i++)
    printf("El elemento numero %d del nuevo vector es: %lf\n",i+1,*(vector2+i));
    return 0;
}
 
double *operaVector(int k, double *vector1){
    int i, longv2;
    longv2=longv1*k-k;
    double *vector2=malloc(longv2*sizeof(double));
    if (vector2==NULL){
        puts("Error reservando memoria");
        exit(EXIT_FAILURE);
    }
    for(i=0;i<longv2;i++)
        *(vector2+i)=*(vector1+i)*0.5+i;
    return vector2;
}
 

Espero que alguien me pueda ayudar, soy nuevo en el lenguaje C.

[eferion]

La única forma es que la función acepte un nuevo parámetro que indique el tamaño del vector actual.

Por supuesto, sería recomendable conocer también el tamaño del nuevo vector por si tienes que ampliar su capacidad más adelante. En tal caso puede ser recomendable que este parámetro que estamos comentando se pase por referencia, de tal forma que en dicha variable se almacene el tamaño del nuevo array:

Entonces la primera llamada quedaría tal que:

Código C:

double *operaVector(int k, double *vector1, size_t* vectorSize);
 
int main(){
    double vector1[]={3,2,5,4}, *vector2;
    size_t vectorSize = sizeof(vector1)/sizeof(double); // 4 en la práctica
 
    vector2 = operaVector(k,vector1,&vectorSize);
}
 
double *operaVector(int k, double *vector1,size_t* vectorSize){
    int i, longv2;
    // ...
    *vectorSize = longv2;
    return vector2;
}
 

Una vez dicho esto te comento que si usas memoria dinámica lo suyo es liberarla después. Haces uso de malloc pero no veo ningún free. Quizás la función operaVector debería liberar la memoria asociada a vector1. Esta opción es una de las más limpias pero entonces no le puedes pasar un arreglo que no haya sido creado con malloc.

En cualquier caso, lo dicho, libera la memoria que reservas una vez ya no vaya a ser necesaria.

PD.: también existe realloc, que realiza todo el proceso por tí: reserva un área de memoria del tamaño indicado, copia los datos de la memoria antigua a la actual y finalmente libera la memoria antigua.

Un saludo

[Casert]

Muchas gracias por la respuesta.

Respecto al uso del free, no veo muy bien donde situarlo, porque la memoria que se reserva es para el vector2 y lo que devuelve la función es el vector2. Por tanto, ¿Se debe liberar después de usarla en el programa usando free(vector2)?

Por último, ¿En lugar de size_t vectorSize se podría usar de igual manera int vectorSize?

[eferion]

Iniciado por Casert

Respecto al uso del free, no veo muy bien donde situarlo, porque la memoria que se reserva es para el vector2 y lo que devuelve la función es el vector2. Por tanto, ¿Se debe liberar después de usarla en el programa usando free(vector2)?

Imagina que vas a una bollería y te compras un bollo y te lo dan con una servilleta para que no te manches. Te vas de la bollería y te comes el bollo en el parque.... ¿En qué momento de esta historia tiras el papel a la basura?

Vale, ahora imagina que la bollería es la función operaVector, el papel es la memoria dinámica y el bollo los datos almacenados en dicha memoria.

Espero que la respuesta a la pregunta del papel sea que lo tiras una vez que te has comido el bollo, es decir, una vez que ya no necesitas los datos que están almacenados en la memoria te la cargas porque ya no la necesitas.

Se que es un ejemplo tonto pero creo que cambiando la perspectiva se consigue que problemas complicados parezcan bastante sencillos y lógicos.

Y bueno, por si no ha quedado del todo claro, la memoria la puedes borrar en cualquier momento, no tiene que ser necesariamente en la misma función que reservó dicha memoria. Más que nada piensa que a la memoria dinámica se accede desde punteros. free te pide un puntero y libera la memoria apuntada por el mismo... le da igual en qué momento fué creada y, entre otras cosas, solo con un puntero es imposible obtener esa información.

Iniciado por Casert

Por último, ¿En lugar de size_t vectorSize se podría usar de igual manera int vectorSize?

Te pego un párrafo de la documentación de la MSDN (por eso de que está en español)

El operando es un identificador que es un elemento unary-expression o una expresión de conversión de tipo (es decir, un especificador de tipo incluido entre paréntesis).El elemento unary-expression no puede representar un objeto de campo de bits, un tipo incompleto ni un designador de función.El resultado es una constante entera sin signo.El encabezado estándar STDDEF.H define este tipo como size_t.

Es decir, esa función te va a devolver siempre un valor con el tipo size_t. ¿Y qué narices es size_t? Pues es un alias. Uno de tantos que pululan por la librería de C.

¿Y por qué usar un alias? Como bien sabes (o deberías saber), los tipos numéricos en C no tienen un tamaño fijo sino que dependen de la arquitectura. Esto hace que escribir programas multiplataforma sea un auténtico dolor de cabeza ya que los rangos de valores cambiarán de una plataforma a otra.

Usar alias permite que el programador se pueda olvidar por unos momentos de ese problema. Ya que el alias no es un tipo fijo se puede cambiar fácilmente entre plataformas con algo tan tonto como esto:

Código C:

// Prueba a comentar estos defines de forma alternativa
// compila y compara la salida del programa
#define SISTEMA1
//#define SISTEMA2
//#define SISTEMA3
 
#ifdef SISTEMA1
typedef int miTipo;
#elif SISTEMA2
typedef double miTipo;
#else
typedef char miTipo;
#endif
 
int main()
{
  printf("%d",sizeof(miTipo));
}
 

Por cierto, los propios compiladores suelen traer un juego de constantes ya definidas que indican ciertas características.

Dicho todo esto y para responder a tu pregunta:

Sí podrías, pero tu programa podría dar problemas en entornos multiplataforma. Otro problema que podrías tener (aunque sería raro de narices) es que el tamaño del objeto no entrase en un int pero sí en un "unsigned int", en ese caso obtendrías un resultado negativo y el programa se volvería errático.

Pero vamos que sin llegar a ser paranóicos te diría que sí, puedes usarlo... pero recuerda que puede dar problemas y, por tanto, no es una buena práctica a adquirir.

Un saludo.

[Casert]

No tenía muy claro si el uso de free se podía hacer fuera de la función con malloc y me ha quedado claro. Buen ejemplo aclarativo

Muchas gracias. He podido solucionar y comprender los errores.