MULTIMEDIA, Video digital, Grabación, Diseño gráfico, Diseño web, Programación > Webmasters - Diseño Web - Programación - Diseño gráfico
¿Qué características son recomendable para programar en C?
ALP:
jirho...hola
creo que anoche se me fue un poco la olla (...demasiados gin-tonics...) :lol:
de todos modos... no te entiendo del todo.. podrías poner un ejemplo?
(creo que deberías abrir un nuevo hilo, ya que nos estamos desviando del tema un pelín)
jirho:
...claro amigo...supon una estructura de X campos...
int main()
{
struct X *x;
while (Res!=s)
{
x=(X *)realloc((X *)x,(N+1)*sizeof(X));
}
}
...poco despues de esto, asi se libere la memoria dentro del ciclo...se nukea...
ALP:
a ver... prueba esto
--- Código: ---
#include <stdlib.h>
#include <stdio.h>
struct X {
int uno;
float dos;
char tres[10];
};
int main()
{
struct X *x = NULL;
int n = 0;
for (n = 0; n < 100000; n++) {
x = (X*)realloc(x, (n+1)*sizeof(X));
if (n%1000 == 0)
printf("%5i\t", n);
if (x == NULL) {
printf("\nError: n = %li\n", n);
perror("Error asignando memoria");
exit(1);
}
}
if (x)
free(x);
return (0);
}
--- Fin del código ---
en borland 5.02 funciona correctamente.
¿Es posible que no inicialices el puntero a NULL antes de la primera llamada a realloc()? La documentación dice que el puntero que le pasas debe ser un puntero válido proveniente de malloc() o con valor NULL, y así realloc() se comporta como malloc().
Otra cosa: la sentencia...
--- Código: ---x = (X*)realloc(x, (n+1)*sizeof(X));
--- Fin del código ---
...no es segura, puesto que si realloc() devuelve NULL, por que no haya memoria disponible, el puntero que le pasas sigue siendo válido (no se libera ni se mueve)
Una forma más segura de hacer esto sería:
--- Código: ---
x2 = (X*)realloc(x, (n+1)*sizeof(X));
if (x2 != NULL)
x = x2;
--- Fin del código ---
Por otro lado puede surgir un error si x se libera con free() y no se le asigna el valor NULL, con lo que apuntaría a una zona de memoria libre, y por lo tanto no accesible, con lo que la siguiente llamada a realloc() fallaría.
Si incrementas el tamaño de la estructura, se vuelve más lento, pero sigue funcionando. Prueba a cambiar char tres[10]; por char tres[100]; o por char tres[1000];
Espero que esto te ayude.
jirho:
#include <iostream.h>
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
struct Persona{
char Nombre[10];
int Edad;
};
int main()
{
Persona *Pers=NULL;
char Res='s'
;
int Tam=0;
int i=0;
while(Res=='s')
{
Pers=(Persona *)realloc((Persona *)Pers,(Tam+1)*sizeof(Persona));
if(Pers==NULL)
{
cout<<"ERROR...";
return 0;
}
cout<<"INGRESE NOMBRE: ";
cin>>Pers.Nombre;
cout<<"INGRESE EDAD: ";
cin>>Pers.Edad;
i++;
cout<<"DESE SEGUIR INGRESANDO REGISTROS?...";
Res=getche();
}
getch();
}
/************************************************************/
:oops: solo era inicializar en NULL :oops: ...confiezo publicamente que me deshice del realloc en un progrma solo por eso...bien gracias amigo...la verdad es que si un punto muy importante al igual que las variables locales, es INICIALIZAR...bien, tal parece que tengo que volver un poco mas al C, es que desde que estoy con C++, siempre lo manejo y me vuelvo al C solo para el tuto...gracias amigo...aveces hay cosas tan pequeñas que te joden y no te das cuenta que la solucion esta ahi...
...ALP..espero que te pases mucho por aqui...veo que sabes bien sobre C...
ALP:
Una última cosilla....
No olvides nunca LIBERAR la memoria reservada dinámicamente. Aunque en teoría el sistema libera la memoria que has reservado cuando el programa termina, es una buena costumbre liberar siempre la memoria reservada cuando ya no te sirva (aunque sea un programa de prueba).
Imagina que el ejemplo que has puesto es una función que pide los datos, y al terminar los guarda en un fichero. Si no liberas la memoria cuando ya no la necesitas, tu función se convertirá en un "gusano" que irá comiendo memoria sin parar. Al final, el programa podría fallar en otro lado por falta de memoria. Estas fugas de memoria son muy difíciles de encontrar, y son más habituales de lo que puedas creer.
De hecho, en linux hay multitud de herramientas para detectar estas fugas de memoria, como dmalloc, electric-fence, memprof, memwatch, etc.
Esto no quiere decir que no la utilices, si no que mantengas cierta disciplina cuando trabajes con punteros dinámicos.
Yo la utilizo para casi todo, de forma que no tienes que implantar límites artificiales, ni desperdiciarás memoria que no utilices (por ejemplo declarando arrays muy grandes).
Si tomas las debidas precauciones cuando trabajes con la memoria dinámica, no tendrás que pasar horas depurando un programa que aparentemente es correcto. Te lo digo por experiencia...
Navegación
[#] Página Siguiente
[*] Página Anterior
Ir a la versión completa