otra de punteros

[Tequila94]

utilizando gcc y linux he utilizado el siguiente codigo

/* en punteros.h */

struct algo {
char nombre[60] };

void funcion(struct algo **st_punt);

/* en punteros.c */

# define MAX_REGISTROS 1500500 /*parece ser que estoy cerca del
limite */

int main(...) {
int x = 0;
struct algo *algomas[MAX_REGISTROS];
*algomas = malloc( siseof(struct algo *));
for ( x = 0; x < MAX_REGISTROS; x++) {
algo[x] = malloc (sizeof(struct algo));

}
funcion(algomas);
...

NOTA: el sangrado y la apertura no es como la manejo, lo hice aqui para
ahorra lineas, tamiben esta definida en la cabecera stdio.h stdlib.h.

COMENTARIOS: en mi maquina he llegado a "violacion de segmento" con 2
000 000 de registros.

a pesar de que en varias partes se trata de punteros, malloc y
estructuras no he encontrado algo parecido a este codigo, si he visto
el manejo con int, long y creo que *algomas = malloc ( sizeof (struct
algo *)); no se maneja asi en las ayudas que he leido.

en resumen, gracias por tratar el tema de punteros.

Saludos

Pd creo voy a pasar al siguiente nivel de programacion

[Ezequiel Foncubierta]

Post by Tequila94
utilizando gcc y linux he utilizado el siguiente codigo
/* en punteros.h */
struct algo {
char nombre[60] };
void funcion(struct algo **st_punt);
/* en punteros.c */
# define MAX_REGISTROS 1500500 /*parece ser que estoy cerca del
limite */
int main(...) {
int x = 0;
struct algo *algomas[MAX_REGISTROS];
*algomas = malloc( siseof(struct algo *));
for ( x = 0; x < MAX_REGISTROS; x++) {
algo[x] = malloc (sizeof(struct algo));
}
funcion(algomas);
...

malloc devuelve void. Tienes que hacer un casting para devolver un puntero
a un registro "algo" talque:

*algomas = (struct algo **)malloc(sizeof(struct algo *));

[Horst Kraemer]

Post by Ezequiel Foncubierta
malloc devuelve void. Tienes que hacer un casting para devolver un puntero
*algomas = (struct algo **)malloc(sizeof(struct algo *));

No estamos en C++.

[Oscar Garcia]

Post by Tequila94
utilizando gcc y linux he utilizado el siguiente codigo
/* en punteros.h */
struct algo {
char nombre[60] };
void funcion(struct algo **st_punt);

st_puntero es un puntero que apunta a un array de punteros que apunta
a estructuras "algo" alojadas en memoria.

Post by Tequila94
/* en punteros.c */
# define MAX_REGISTROS 1500500 /*parece ser que estoy cerca del
limite */
int main(...) {
int x = 0;
struct algo *algomas[MAX_REGISTROS];

Alojas en memoria 1500500 punteros a estructuras "algo".

Post by Tequila94
*algomas = malloc( siseof(struct algo *));

En el primer registro (el número 0 - algomas[0]) alojas el puntero a
una zona de memoria alojada para un puntero que apunta a una
estructura "algo".

Post by Tequila94
for ( x = 0; x < MAX_REGISTROS; x++) {
algo[x] = malloc (sizeof(struct algo));

Supongo que eso es "algomas" y no "algo". ¡¡¡¡Estás llenando 1500500
punteros y sólo habías reservado memoria para un único puntero!!!!

Post by Tequila94
a pesar de que en varias partes se trata de punteros, malloc y
estructuras no he encontrado algo parecido a este codigo, si he visto
el manejo con int, long y creo que *algomas = malloc ( sizeof (struct
algo *)); no se maneja asi en las ayudas que he leido.

Creo que tienes un jaleo muy gordo con los punteros. Explicanos un
poco lo que deseas hacer a ver si damos con la tecla.

Un saludo.

[Horst Kraemer]

Post by Tequila94
utilizando gcc y linux he utilizado el siguiente codigo
/* en punteros.h */
struct algo {
char nombre[60] };
void funcion(struct algo **st_punt);
/* en punteros.c */
# define MAX_REGISTROS 1500500 /*parece ser que estoy cerca del
limite */
int main(...) {
int x = 0;
struct algo *algomas[MAX_REGISTROS];
*algomas = malloc( siseof(struct algo *));

Esta línea no tiene sentido. Estás confundiendo dos métodos distintos
de alocación de un array de punteros.

Alocación estatica

struct algo *algomas[MAX_REGISTROS];

for ( x = 0; x < MAX_REGISTROS; x++) {
algomas[x] = malloc (sizeof(struct algo));
...
funcion(algomas);



Alocación dinamica.


struct algo **algomas;

algomas = malloc(MAX_REGISTROS*sizeof(struct algo*));
if (algomas==0) { /* ERROR */ }

for ( x = 0; x < MAX_REGISTROS; x++) {
algomas[x] = malloc (sizeof(struct algo));
if (algomas(x)==0) { /* ERROR */ }
}
...
funcion(algomas);
...
for ( x = MAX_REGISTROS-1; x>=0;x--) {
free(algomas[x]);
free(algomas);

[Tequila94]

gracias por responder, este programa fue tomado de estas news y lamento
no poder citar la fuente, aunque si me obligan a ello efectuare una
busqueda detallada, no es mi proposito infrigir reglas de
comportamiento, AGRADEZCO a las personas que hicieron este programa y a
las personas que lo modificaron.

En el caso que nos ocupa, aunque pueda tener algun problema de
procedimiento o de estructura, funciona en una maquina linux y gcc
3.4.2:

#include <stdio.h>
#include <stdlib.h>
//#include <conio.h> <----- fijate como se programo para DOS o similar
#include <string.h>
#define MAX_REGISTROS 1800500 <----- mas de esta cantidad da
violacion de segmento
#include "punteros.h"

int main () <--- aqui si manejo argc y argv
{
int x = 0;
struct amigos *amigo[MAX_REGISTROS];
*amigo = malloc( sizeof(struct amigos *)); <--- me dices que solo
separa pocos bytes y no hago cast (es c no c++)

for ( x = 0; x < MAX_REGISTROS; x++)
{
amigo[x] = malloc( sizeof( struct amigos)); <--- y aqui separa
todo
}

func(amigo);

printf("RETENDRA su valor?\n");
//for(x=0; x < MAX_REGISTROS; x++)
// {
//printf("%s \n",(*amigo+x)->nombre);
//printf("%s \n",(*amigo+x)->apellido);
//printf("%d \n",(*amigo+x)->edad);
printf("registro inicial : %p \n", amigo[0]->DNI);
printf("registro final : %p \n", (amigo[MAX_REGISTROS - 1])->DNI);
printf("%d \n", x);
// }

for ( x = MAX_REGISTROS - 1; x > 1; x--)
{
free(amigo[x]);
}
return 0;
}

void func(struct amigos **punt1)
{
printf("inicia la funcion func \n");
int x=0;
strcpy((*punt1+x)->nombre, "jose");
strcpy((*punt1+x)->apellido, "perez");
(*punt1+x)->edad =12;
strcpy((*punt1+x)->DNI, "43332334");
x++;
strcpy((*punt1+x)->nombre, "javi");
strcpy((*punt1+x)->apellido, "peraz");
(*punt1+x)->edad = 32;
strcpy((*punt1+x)->DNI, "32442334");
x++;
strcpy((*punt1+x)->nombre, "leche");
strcpy((*punt1+x)->apellido, "agua");
(*punt1+x)->edad = 42;
strcpy((*punt1+x)->DNI, "32554554");
/*aqui queria cambiar un valor determinado del puntero, se me ocurrio
lo
siguiente*/
(*punt1+1)->edad = 78;
//Que valor quieres para x?
/*aqui queria cambiar un valor determinado del puntero, se me ocurrio
lo
siguiente*/
(*punt1+1)->edad = 78;
//Que valor quieres para x?
//gotoxy(15,2);/*Esto no se para que lo haces pero...*/
printf("%p PUNTERO punt1 \n", (*punt1+x));/*compruebo las direcciones
a las
que
apuntan los puntero*/
for(x=0; x<3; x++)
{
printf("%s \n",(*punt1+x)->nombre);
printf("%s \n",(*punt1+x)->apellido);
printf("%d \n",(*punt1+x)->edad);
printf("%s \n\n",(*punt1+x)->DNI);
}
for ( x = 0; x < MAX_REGISTROS; x++)
{
strcpy(punt1[x]->DNI, "hola tu");
}

}


*** puntero.h
struct amigos
{
char nombre[20];
char apellido[20];
int edad;
char DNI[20];
};

void func(struct amigos **punt1);


¿Que quiero hacer?
utilizar memoria dinamica para evitar violacion de segmento.

este programa funciona y utiliza 240MB de memoria, los comentarios
vienen del programa original, (lamento no citar la fuente, tal vez
lepton), pero reitero, no he encontrado referencias de manejo de
memoria dinamica similar a esto, si hay mucha informacion de como
manejar int, long, etc.

[Horst Kraemer]

Post by Tequila94
gracias por responder, este programa fue tomado de estas news y lamento
no poder citar la fuente, aunque si me obligan a ello efectuare una
busqueda detallada, no es mi proposito infrigir reglas de
comportamiento, AGRADEZCO a las personas que hicieron este programa y a
las personas que lo modificaron.
En el caso que nos ocupa, aunque pueda tener algun problema de
procedimiento o de estructura, funciona en una maquina linux y gcc
#include <stdio.h>
#include <stdlib.h>
//#include <conio.h> <----- fijate como se programo para DOS o similar
#include <string.h>
#define MAX_REGISTROS 1800500 <----- mas de esta cantidad da
violacion de segmento
#include "punteros.h"
int main () <--- aqui si manejo argc y argv
{
int x = 0;
struct amigos *amigo[MAX_REGISTROS];
*amigo = malloc( sizeof(struct amigos *)); <--- me dices que solo
separa pocos bytes y no hago cast (es c no c++)

Te digo que tienes que *borrar* esta linea. No tiene sentido.

Post by Tequila94
for ( x = 0; x < MAX_REGISTROS; x++)
{
amigo[x] = malloc( sizeof( struct amigos)); <--- y aqui separa
todo
}
func(amigo);
printf("RETENDRA su valor?\n");
//for(x=0; x < MAX_REGISTROS; x++)
// {
//printf("%s \n",(*amigo+x)->nombre);

//printf("%s \n",(*(amigo+x))->nombre);

o

//printf("%s \n",amigo[x]->nombre);

(*amigo+x) es un error

Post by Tequila94
//printf("%s \n",(*amigo+x)->apellido);
//printf("%d \n",(*amigo+x)->edad);
printf("registro inicial : %p \n", amigo[0]->DNI);
printf("registro final : %p \n", (amigo[MAX_REGISTROS - 1])->DNI);
printf("%d \n", x);
// }
for ( x = MAX_REGISTROS - 1; x > 1; x--)

for ( x = MAX_REGISTROS - 1; x >=0; x--)

Post by Tequila94
{
free(amigo[x]);
}
return 0;
}
void func(struct amigos **punt1)
{
printf("inicia la funcion func \n");
int x=0;
strcpy((*punt1+x)->nombre, "jose");

strcpy(punt1[x]->nombre, "jose");

etc...

reemplazar todos los

(*punt1+x)->

por

punt1[x]->

Post by Tequila94
este programa funciona y utiliza 240MB de memoria,

Si funciona, funciona por casualidad ;-)

[r***@gekapi.com]

Post by Horst Kraemer
Te digo que tienes que *borrar* esta linea. No tiene sentido.
//printf("%s \n",(*(amigo+x))->nombre);
o
//printf("%s \n",amigo[x]->nombre);
(*amigo+x) es un error
for ( x = MAX_REGISTROS - 1; x >=0; x--)
strcpy(punt1[x]->nombre, "jose");
etc...
reemplazar todos los
(*punt1+x)->
por
punt1[x]->
Si funciona, funciona por casualidad ;-)
--
Horst

Thank you

***@gekapi.com

[Piccolo]

Hola, si lo que quieres es evitar la violación de segmento y tratas con
punteros genera listas dinámicas. Tu tienes una estructura estática de
MAX_REGISTROS que son todos punteros a struct algo. Seguramente desperdicies
mucha memoria. Si intentaras hacer el array dinámico lo que te podría pasar
es que ocupes casi todo el espacio de HEAP o memoria dinámica que crece en
oposicion a la zona de pila que la usa el propio programa cuando llama a
funciones para habilitar registros de activación y demás. Puede ocurrir que
tengas tanto HEAP que no dejes espacio de pila para la propia gestión de tu
programa.

Por otro lado, también puede ocurrir que el malloc no te esté
devolviendo nada (NULL) porque se haya quedado sin espacio. Yo comprobaria
con un if si me ha devuelto algo el malloc.

Un saludo.