duda sobre error en C

[emmarz]

Buenos dias chicos,

dentro del main.c tengo esta asignacion:
char *p;

if ((p=crearSegmento(pInicioMemoria, tamanioNuevoSegmento, CANT_MEM, pSegmentos))==NULL) {expresion}
else{expresion}

Despues tengo implementada la funcion crearSegmento:

int crearSegmento(char* pInicioMemoria, int tamanioNuevoSegmento, int CANT_MEM, t_list* pSegmentos){

int cantidad, mayorTamanio, i, tamanioNodo, posicion =0;
char *dirFisicaNodo;
char *dirPosicion;
tipoSegmento *nodo;
while ((posicion!=CANT_MEM)&&(pSegmentos!=NULL)){
i++;
nodo= list_get(pSegmentos, i);
dirFisicaNodo= nodo -> dirFisica;
tamanioNodo= nodo -> tamanio;

while (pInicioMemoria!=dirFisicaNodo){
posicion++;
cantidad++;
pInicioMemoria++;
}

if(cantidad> mayorTamanio){
mayorTamanio=cantidad;
dirPosicion=pInicioMemoria;
} else{

}
pInicioMemoria= pInicioMemoria + tamanioNodo;
posicion= posicion + tamanioNodo;
}
if (cantidad>= mayorTamanio){
return posicion;
}else{
return NULL;
}
}

El problema aparece en la asignacion p=crearSegmento(), con el siguiente mensaje "aviso: la asignacion crea un puntero desde un puntero sin una conversion [activado por defecto]

Y un error mas en el return NULL, con el siguiente mensaje "aviso: la devolucion crea un puntero desde un puntero sin una conversion"
Alguien podria darme una mano en que me estoy equivocando?
gracias
_________________
Emmanuel Ruiz

[untio]

Hola,

Reconozco que todavía estoy aprendiendo.

Es curioso como mezclas enteros y punteros. Eso en un sistema de 64 bits puede ser motivo de un bug.

Tu función retorna un entero y lo asigna a un puntero a carácter.

Si lo que quieres es retornar un puntero a carácter, declara tu función así:

char * mifuncion(misparametros);

Además, dentro de tu función haces que lo que almacena el puntero esté declarado como entero.

Si lo que quieres es convertir sin que se queje (lo que en 64 bits generará un error) lo puedes hacer así:

varint = (int) charpuntero; // para pasar de puntero a int
o
charpuntero = (char *) varint; // para pasar de int a puntero a carácter.

Perdonad mis posibles errores. Con toda seguridad, los que saben más que yo podrán explicarlo mejor.

Saludos.
_________________
Hago algo muy raro: primero leo las instrucciones.

[emmarz]

hola untio,

Perdon por no poner lo que queria obtener. Estoy con un trabajo practico en la facultad y lo que necesito es obtener la direccion fisica (por medio de una condicion). Para eso hice mi funcion, la cual me devuele la direccion fisica o en su caso de no cumplir con la condicion devolver NULL. Trabajo todo en sistema de 32 bits, asi que no habra problema con la arquitectura. Lo que quiero hacer dentro de la funcion es, en un bloque de memoria "malloc", podes ir moviendome direccion por direccion. Mi gran duda es...
Puedo sumar o restar direcciones fisica de memoria con enteros?

Sobre:
varint = (int) charpuntero; // para pasar de puntero a int
o
charpuntero = (char *) varint; // para pasar de int a puntero a carácter.

La primera, estaria guardando en varint, la direccion a la cual esta aputando el charpuntero?
Y la segunda es lo contrario, correcto?

Muchas gracias por responder
_________________
Emmanuel Ruiz

[untio]

Hola de nuevo,

Imagina que tengo 2 punteros:

pc de tipo puntero a char apunta a la dirección 1000 y tiene reservados 100 chars.

pi de tipo puntero a int apunta a la dirección 2000 y tiene reservados 100 ints.

Si tu haces:

pv = pc + pi;

Obtienes que pv apunta a la dirección 3000, en la cual tú no tienes derecho ni a leer ni a escribir. Eso produce un error y el sistema te cierra tu programa.

Lo que creo que necesitas es algo que se llama aritmética de punteros.

pc tiene reservados 100 chars, que en bytes es 100 * sizeof(char) = 100 bytes.

pi tiene reservados 100 ints, que en un sistema de 32 bits es 100 * sizeof(int) = 400 bytes.

Pero a la hora de sumar o restar al puntero no te tienes que fijar en los bytes sino en el tipo de puntero.

pv = pc + 99; //hace que pv apunte al último char reservado, que está en la posición 1099 de la memoria.

pv = pi + 99; //hace que pi apunte al último int reservado, que está en la posición 2396 (aquí tal vez me halla equivocado) de la memoria.

Si pc es 1000 y haces:

pc++;//pc apunta ahora a 1001. Que es el segundo char

Si pi es 1000 y haces:

pi++;//pi apunta ahora a 1004. Que es el segundo entero.

El compilador incrementa el puntero o suma al puntero dependiendo del tipo al que apunte.

Pero te vuelvo a decir:

1. Puedes sumar un entero a un puntero. Incrementarás el puntero un número de elementos igual al entero.

2. No puedes sumar dos punteros. ¿Qué sentido tendría eso?.

3. Puedes sumar, restar, incrementar y decrementar un puntero a una variable o una constante. Eso se conoce como aritmética de punteros. Eso en C/C++ es perfectamente viable. Pero ten cuidado con no salirte de la zona que tienes reservada ni por delante ni por detrás y ni para leer ni para escribir.

Otra cosa:

int * pi2;
pi2 = pi + 5;

Ahora pi2 apunta a la sexta posición reservada para pi y pi sigue apuntado a la posición original.

Bueno, reconozco que puedes hacer:

int numints = pi2 - pi;

numints será igual a 5, que son los elementos que los separan (no los bytes), pero esto no sé si lo necesitarás en algún momento.

Mi explicación tal vez no sea muy correcta. Puedes visitar:

http://www.uco.es/grupos/eatco/informatica/metodologia/mtptema13.pdf

Para una explicación más correcta que la mía.

Perdonadme los errores.
_________________
Hago algo muy raro: primero leo las instrucciones.

[rir3760]