Concurso casero de C

[Instru]

bueno, si, mi solucion fue parecida:

Código:

#define devuelve_estructura(puntero_miembro,nombre_estructura,nombre_miembro) \
	(nombre_estructura *)(puntero_miembro-(long)(&((nombre_estructura *)0)->nombre_miembro));

Solo que yo si tarde mas tiempo...

Saludos

[Nivel7]

en realidad, es la misma, si, es como la pense entregra, solo que lo ideal, es que la aritmetica de punteros se realize entre punteros del mismo tipo.
por eso agrege los casting a char*.


empese con la idea de buscar el offset, del miembro de la estructura en cuestion, primero intente con una estructura, y hacia la resta entre la direccion del primer miembro y del miembro en cuetion.

esto fue dificil meterlo en una macro, a menos que usara un funcion,
despues lo ví, todo como un array de caracteres. fue cuando se me ocurrio,
que para evitar crear un array o una estructura, posicionaría mi codigo en la memoria 0 e interpretaria a esta como un puntero a estructura.
el compilador se encargaria de darme el offset, haciendo referencia al miembro de la estructura.
cuando pides la memoria de este, te entrega la memoria a partir de 0 y listo,
todo era tan facil.


Saludos.

[MaxExtreme]

Iniciado por Nivel7

en realidad, es la misma, si, es como la pense entregra, solo que lo ideal, es que la aritmetica de punteros se realize entre punteros del mismo tipo.
por eso agrege los casting a char*.

En realidad, da =.

La aritmética de punteros se puede hacer tanto con enteros (como Instru hizo), lo cual es el uso normal, o como tú has hecho, sumando punteros (no muy normal).

p+1; // Instru
p+q // Nivel7

[Nivel7]

oy eInstru, sin la intencion de molestar, pero creo que tu algoritmo no funciona con todos los campos, y enesto MaxExtreme tambien anda mal,
ya que el comento:

En realidad, da =.

La aritmética de punteros se puede hacer tanto con enteros (como Instru hizo), lo cual es el uso normal, o como tú has hecho, sumando punteros (no muy normal).

p+1; // Instru
p+q // Nivel7

y esto no es del todo cierto.

tu algortimo funciona siempre y cuando el campo en cuestion sea un char, esto es por que la aritmetica de punteros sabe de tipos.

es decir, si tu puntero es de tipo char, al restarle o sumarle se incrementara en un byte a la ves, es decir una posicion en memoria.
pero si tu puntero es te tipo int, al restarle o sumarle se incrementara o decrementara en 4 bytes.
por tanto si en el problema, si el campo en cuestion es un int com es el caso de Edad, y tu le restas 1, no obtendras la direccion de la estructura sino una direccion menor que la que realmente quieres. ya que el offset de es 4, que es el tamaño de un puntero(char*), por tanto al restarle 4 a &miFicha.Edad, se decrementara en 4 int's, es decir 4*4 = 16 byte's.
entonces estaremos en 12 bytes antes que &miFicha.

[Instru]

aj si. De hecho al principio miltiplicaba el offset por 4 para que la aritmetica fuera "correcta" y al final ya el resultado de toda la operacion lo dividia entre cuatro. Pero como dices, eso no funcionaba con todos los miembro de la estructura.

Mas sinembargo el algoritmo que puse, si funciona con todos, simplemente porque hace la operacion aritmetica dependiendod el tipo de dato.

saludos

[Nivel7]

Bueno, en realidad me refiero a que he probado tu algoritmo, y no me funciona, mas que con los miembros char.

con los miembros int, e incluso char*, no funciona.


(puntero_miembro-(long)(&((nombre_estructura *)0)->nombre_miembro))

esta es la base de tu algoritmo.

como podemos ver, el offset siempre sera un long, entonces:

el offset de Nombre es = 0;
el offset de Edad es = 4;
el offset de Pais es = 8;
el offset de Ciudad es = 12;
el offset de calle es = 16;
el offset de Piso es = 20;
el offset de Letra es = 21;

Direccion de miFicha: (&miFicha) = 2293584; (0x22FF50 en exadecimal).

la direccion del miembro Nombre(&miFicha.Nombre) es = 2293584;
en decimal(0x22FF50 en exadecimal).

la operacion es: 2293584 - 0 = 2293584;
en este caso vemos que funciona, pero no por que la operacion este bien sino que se estan restando 0.

con el miembro Edad la operacion sería:
la operacion es: 2293588 - 4 = (en este caso pensariamos: correcto el resultado el 2293584).
pero no, ya que estamos restado a un puntero a int.(la direccion de int)
es decir la resta en bytes será:
2293588 - 4* (sizeof(tipo)). y en este caso tipo es int.(la operacion real es esta: 2293588 - 16);
el resultado es: 2293572; y la direccion buscada es 2293584;(error).

esto ocurrira con todos los miembros a escepcion de char.
ya que sizeof de char es 1 y no causa problemas en la aritmetica.

en mi algoritmo evito tener este problema, haciendo el casting a char*, esto le permite al compilador ver al miembro de la estructura como un array de caracteres, y la resta se hace byte a byte.

otra opcion sin castings tan orribles es convertir a long la direccion del miembro de la estructura en cuestion:

por tanto el algoritmo correcto sería:

((long)puntero_miembro-(long)(&((nombre_estructura *)0)->nombre_miembro))



Saludos.

[MaxExtreme]

Nivel7, te repondo primero a la desacreditación que me has lanzado:

Creo tener los punteros bastante claros, y no, no "ando mal" como dices. Que tengo ya tiempo con C... ¿Crees que habría logrado hacer lo del SO que te mostré si no supiera como funciona la aritmética de punteros? Andaaa... casi cuela ;)

Estamos hablando de que a un (char *) le da exactamente igual que tipo le sumes.

La aritmética de punteros puede hacerse de las dos maneras, y da exactamente igual como yo dije.

Si tú a un char * le sumas (char)K, incrementarás K bytes.
Si tú a un char * le sumas (short)K, incrementarás K bytes.
Si tú a un char * le sumas (int)K, incrementarás K bytes.
... y lo mismo siempre.

Igualmente, como un puntero no es más que un entero,

Si tú a un char * le sumas (T *)K, incrementarás K bytes.

Resumen: Da igual hacer "p+1" que "p+q".

Ahora te respondo más a fondo acerca de tu afirmación inicial, para que entiendas que el equivocado eras tú:

Dices 3 cosas mal en una sola frase.



1ª "lo ideal, es que la aritmetica de punteros se realize entre punteros"

La suma de dos punteros no tiene nada que ver con aritmética de punteros.

La aritmétca de punteros se da cuando sumas a un puntero un entero, no cuando sumas dos punteros.



2ª "lo ideal, es que la aritmetica de punteros se realize entre punteros"

De hecho, precisamente porque la aritmética de punteros NO se da entre punteros, NO tiene sentido sumar entre punteros.

Lo normal es es sumar a un puntero una dirección, para moverte en la memoria con seguridad usando la aritmética de punteros sin preocuparte de tipos y tamaños.



3ª "lo ideal, es que la aritmetica de punteros se realize entre punteros del mismo tipo"

Un puntero no es más que un entero que representa una dirección de memoria (en x86, unsigned int), y como tal:

Da exactamente igual del tipo que sean. Numéricamente:

void * = char * = int * = T *

¿Por qué te crees que sino existe el tipo void *?...

Como ves, podía haberte respondido todo esto último la primera vez, pero NO LO HAGO, porque no me gusta desacreditar de tal manera a la gente, y que se den cuenta de sus errores ellos solos.

Pero tú veo que vas a matar a la primera ;) Como ves, yo también puedo contestar con parrafadas :D

[mike.p]

Hola hola, no habra alguna otra solucion para este problema, menos eficiente claro, algo como un metodo para determinar la direccion de todas las estructuras en memoria y luego comparar las mismas con la del miembro que se pasa y de ahi tomar la menor mas cercana al mismo

[MaxExtreme]

Iniciado por mike.p

Hola hola, no habra alguna otra solucion para este problema, menos eficiente claro, algo como un metodo para determinar la direccion de todas las estructuras en memoria y luego comparar las mismas con la del miembro que se pasa y de ahi tomar la menor mas cercana al mismo

¿Y para qué la necesitas?

[mike.p]

para saber si es posible una solucion alterna al uso de macros

[Nivel7]

OK, no es mi intencion desacreditarte, solo quiero, aclarar que algoritmo de instru es incorrecto, me gustaría que alguien mas lo pruebe, con diferentes campos de la estructura, para ver si estoy o no equivocado.

me gustaria que TolaWare(o cualquiera que este dispuesto)lo comprueve para salir de este dilema. claro si es que quiere hacerlo:

el programa con el algoritmo de Instru es este:
(quien quiera probarlo y poner sus obserbaciones:)

Código:

#include <stdio.h>

struct Ficha {
	char * Nombre;
	unsigned int Edad;
	char * Pais;
	char * Ciudad;
	char * Calle;
	unsigned char Piso;
	unsigned char Letra;
};


#define devuelve_estructura(puntero_miembro,nombre_estructura,nombre_miembro) \
	(nombre_estructura *)(puntero_miembro-(long)(&((nombre_estructura *)0)->nombre_miembro));


int main()
{
	struct Ficha miFicha;
	struct Ficha * nuevaFicha;

	nuevaFicha = devuelve_estructura(&miFicha.Edad, struct Ficha, Edad);
	// nuevaficha = devuelve_estructura(&miFicha.Piso,struct Ficha, Piso);
	// nuevaficha = devuelve_estructura(&miFicha.Calle,struct Ficha, Calle);
	// ...
	printf("Ficha original = 0x%X\nFicha devuelta = 0x%X\n",&miFicha, nuevaFicha);

	if(&miFicha==nuevaFicha) printf("Correcto, son iguales.\n");
	else printf("Incorrecto, son diferentes.\n");

	return 0;
}

Podria ser la diferencia de compilador pero, lo dudo, segun mis obserbaciones este algoritmo funciona solo con el 1ero, y los 2 ultimos campos de la estructura Ficha, con los campos como Edad, no funciona.

Saludos.

[Developer9]

El código que puso Nivel7 compilada en Visual Studio 2003 da como resultado lo siguiente:

[Nivel7]

vamos MaxExtreme, no es para molestarse, tan solo es un tema que me gustará que quedara claro.
si mecione tu comentario no es para ofender, o desacrditar sino, para salvar mi comentario anterior.
si te ofendí por eso, me disculpo, pero esto no evita en insitir en que no estoy equivocado.

Código:

#include <stdio.h>

int main()
{
	char cad[] = "La aritmetica es correcta";
	
	char *result1 = (char*)((char*     )&cad[25] - 8);
	char *result2 = (char*)((short*    )&cad[25] - 4);
	char *result3 = (char*)((int*      )&cad[25] - 2);
	char *result4 = (char*)((long long*)&cad[25] - 1);
	
	puts(result1);
	puts(result2);
	puts(result3);
	puts(result4);
	
	puts("\nLa aritmetica de punteros sabe de tipos");
	getchar();
}

Código:

/*
El resultado es:

correcta
correcta
correcta
correcta

La aritmetica de punteros sabe de tipos
*/

"No soy perfecto en C pero intento serlo, por eso siempre acepto cualquier correcion sobre mis errores."

Donde escuche esto???

Saludos.

Una cita de un fragmento del Manual de C++, de Zator:

4.2.2 Aritmética de punteros
§1 Sinopsis

La aritmética de punteros se limita a suma, resta, comparación y asignación. Las operaciones aritméticas en los punteros de tipoX (punteros-a-tipoX) tienen automáticamente en cuenta el tamaño real de tipoX. Es decir, el número de bytes necesario para almacenar un objeto tipoX.
Por ejemplo, suponiendo una matriz de double con 100 elementos, si ptr es un puntero a dicha matriz, la sentencia ptr++; supone incrementar el Rvalue de ptr en 6.400 bits, porque el tamaño de la matriz es precisamente 100x64 bits.

Nota: no confundir el puntero-a-matriz con un puntero a su primer elemento (que aquí sería puntero-a-double).

La aritmética realizada internamente en los punteros depende del modelo de memoria en uso y de la presencia de cualquier modificador superpuesto.

Las operaciones que implican dos punteros exigen que sean del mismo tipo o se realice previamente un modelado apropiado

[MaxExtreme]

Iniciado por mike.p

para saber si es posible una solucion alterna al uso de macros

Claro pero a ver, una solución sin macros, es posible alcanzarla, pero como lo propones lo único que haces es perder simplicidad, velocidad, memoria, y de todo.

Si no te gustan las "macros" porque leíste que son "malas", no hagas mucho caso a eso ;)

Hay cosas, como esta, en las que son necesarias.

[MaxExtreme]

(Arg edité el mensaje que no era...)

Antes ponía que el fallo de Instru era no convertirlo a char* antes de la resta.

Con sustituir puntero_miembro con ((char*)puntero_miembro) está solucionado.

Código:

#define devuelve_estructura(puntero_miembro,nombre_estructura,nombre_miembro) (nombre_estructura *)(((char*)puntero_miembro)-(long)(&((nombre_estructura *)0)->nombre_miembro));

[MaxExtreme]

Iniciado por Nivel7

no evita en insitir en que no estoy equivocado.

Y yo sigo insistiendo en que no me has entendido. Vuelve a leer mis comentarios, aquí te les explico por 3ª vez:

El primer comentario que hice, simplemente te corregía una afirmación que habías hecho:

Iniciado por MaxExtreme

En realidad, da =.

La aritmética de punteros se puede hacer tanto con enteros (como Instru hizo), lo cual es el uso normal, o como tú has hecho, sumando punteros (no muy normal).

p+1; // Instru
p+q // Nivel7

En ese comentario yo no veo nada incorrecto, ni veo que lo que haya dicho sea erróneo, como luego tú indicas en tu primera réplica:

Iniciado por Nivel7

y esto no es del todo cierto.

¿Me puedes apuntar dónde no es del todo cierto?

Después, en mi segundo comentario te desmenuzo aún más tu mensaje, y te pongo ejemplos para demostrarte que da igual sumar enteros que punteros a un char*, así:

Iniciado por MaxExtreme

Si tú a un char * le sumas (char)K, incrementarás K bytes.
Si tú a un char * le sumas (short)K, incrementarás K bytes.
Si tú a un char * le sumas (int)K, incrementarás K bytes.
... y lo mismo siempre.

Mientras que en tu réplica vuelves a malinterpretar tu mensaje, y me respondes con algo similar a lo que te escribí pero ya en C:

Iniciado por Nivel7

char *result1 = (char*)((char* )&cad[25] - 8);
char *result2 = (char*)((short* )&cad[25] - 4);
char *result3 = (char*)((int* )&cad[25] - 2);
char *result4 = (char*)((long long*)&cad[25] - 1);

Que si te fijas, es diferente a lo que yo estaba hablando.


Fíjate la diferencia entre lo que hablaba yo y en lo que lo has transformado tú:
- MaxExtreme: Sumar ENTEROS (char, short, int) a CHAR*
- Nivel7: Sumar INTs a PUNTEROS (char *, short *, int *).


No hace falta que cites libros...

[fightmx]

Claro pero a ver, una solución sin macros, es posible alcanzarla, pero como lo propones lo único que haces es perder simplicidad, velocidad, memoria, y de todo.

Si no te gustan las "macros" porque leíste que son "malas", no hagas mucho caso a eso ;)

Hay cosas, como esta, en las que son necesarias.

Estoy de acuerdo con eso.


Ahora en lo que refiere Nivel7 yeap, si solo queda:

Código:

(nombre_estructura *)(puntero_miembro-(long)(&((nombre_estructura *)0)->nombre_miembro));

de esta forma esta bien a medias, solo funciona cuando el tipo del puntero_miembro es char.
(Ya se ha explicado del porque)

Lo comento porque yo en mi tercer intento de solución(jejeje) me di cuenta de eso, y la solución que mandé fue:

Código:

(nombre_estructura *)((char*)puntero_miembro-(int)(&((nombre_estructura *)0)->nombre_miembro));

solo vease que si

void * p = 0;

entonces

(char*)p + 1 seria igual a 1
(short*)p + 1 seria igual a 2
(int*)p + 1 seria igual a 4

no es lo mismo sumarle 1 a un puntero de tipo char a que a uno de tipo short o que a uno de tipo int, lo mismo si le sumamos un entero n(avanzariamos el puntero n elementos del tipo del puntero mas allá del actualmente apuntado), y lo mismo si fuera el caso de la resta.

viendolo asip podemos decir que no es lo mismo

(char*)puntero_miembro - offset
que...
(short*)puntero_miembro - offset
que...
(int*)puntero_miembro - offset
...por ejemplo.

Por otro lado tiene sentido la resta entre 2 punteros del mismo tipo mas no la suma, por ejemplo

int *a = (int*)0x04;
int *b = (int*)0x10;

de donde b - a = -(a - b) = 3; (para este caso)

Que seria como preguntarse cuantos elementos del mismo tipo se pueden almacenar entre una dirección y otra.
Pero la suma??...creo que ni siquiera se permite.

Saludos.

[MaxExtreme]

Iniciado por fightmx

...

Sí, así es la aritmética de punteros (3ª explicación en lo que va de tema).

Pues aquí hay una 4ª, más sencilla que todo eso y resumida, a la manera matemática:

Iniciado por Aritmética de punteros

(T*)p + n = p + n*sizeof(T)

No hace tanto rollo para explicarla ;)

Y para Nivel7, si T = char, tenemos que:

Iniciado por Aritmética con char

(char*)p + n = p + n*sizeof(char)

y por tanto

(char*)p + n = p + n

es decir, repito, por enésima vez, de lo que yo hablaba: A un char* le da igual lo que le sumes, tanto punteros como enteros, es lo mismo.

[Nivel7]

MaxExtreme
como tu digas, ya no quiero discutir mas sobre esto, creo que exagere un pequeño error en un algoritmo.

no tengo que poner a prueba mis conocimientos de C/C++.

ahi la dejamos.


fightmx

Creo si lo has comprendido muy bien, lo unico es que mencionas que la suma no tiene sentido,
y en realidad sí, de hecho son varios los operadores que son aplicacbles a la aritmetica de punteros:

ptr++; desplazamineto acendente, la cantidad de bytes segun su tipo.
ptr--; decremento decendente '' '' ''.
ptr + n; desplazamiento acendente n elementos(analogo a un arraya[n]).
ptr - n; desplazamineto decendente '' '' ''.
ptr1 - ptr2; distancia entre punteros.
ptr == NULL; comporbar la igualdad o desigualdad con NULL.
ptr != NULL; lo contrario a la anterior.
ptr1 <, > ptr2; relacion mayor o menor.
ptr1 = ptr2; asignacion.
ptr1 = void; asignacion.

todas estas operaciones son aplicables a los punteros y es a esto a lo que se le llama aritmetica de punteros.
y sí, todas tienen su utilidad en algun momento.

[mike.p]

Ahora un nuevo problemilla :D

[fightmx]

Creo si lo has comprendido muy bien, lo unico es que mencionas que la suma no tiene sentido,
y en realidad sí, de hecho son varios los operadores que son aplicacbles a la aritmetica de punteros:

ptr++; desplazamineto acendente, la cantidad de bytes segun su tipo.
ptr--; decremento decendente '' '' ''.
ptr + n; desplazamiento acendente n elementos(analogo a un arraya[n]).
ptr - n; desplazamineto decendente '' '' ''.
ptr1 - ptr2; distancia entre punteros.
ptr == NULL; comporbar la igualdad o desigualdad con NULL.
ptr != NULL; lo contrario a la anterior.
ptr1 <, > ptr2; relacion mayor o menor.
ptr1 = ptr2; asignacion.
ptr1 = void; asignacion.

todas estas operaciones son aplicables a los punteros y es a esto a lo que se le llama aritmetica de punteros.
y sí, todas tienen su utilidad en algun momento.

Sip no hay bronca con la aritmetica de punteros NIvel7, yo mas bien me referia solo a la operación:

p + q con p y q punteros.

[Developer9]

Iniciado por fightmx

Sip no hay bronca con la aritmetica de punteros NIvel7, yo mas bien me referia solo a la operación:

p + q con p y q punteros.

Y eso no lo metes en la calculadora y sale la respuesta

[Nivel7]

ja ja, si tienes razon, mike.p, ya estubo bueno, de discucion, esperemos que MaxExtreme tenga otra bomba por ahi(Un algoritmo que cause tanta controvercia), o alguien mas. pueda ponerlo.

fightmx
todo depende como lo aprecie cada uno, yo preferí verlo como memoria plana, (char*).
tu prefieres verlo como un entro independiente de la memoria.
otro punto, es que la aritmetica de punteros no se aplica a punteros genericos(void*).

jajaja, te psas, Develper9, estamos hablando de punteros, enserio.

Saludos.

[Instru]

Bueno, que curioso, despues de leer todo el rollo, pues si me entro la duida de porque no llegue a ver el supuesto error.
Probe el programa y si funciona, de hecho a la hora de programarlo, lo intente con estructuras personalizadas a mi modo para ver lo de tamaño de bytes y todo eso.

Aun asi si se me hizo extraño que en tu caso Nivel7 , si saliera incorrecto. Checare mas calma mi algoritmo y con diferentes compiladores para saber si en realidad mi algoritmo esta mal, o hay alguna diferencia en cuanto a la compilacion.

"No soy perfecto en C pero intento serlo, por eso siempre acepto cualquier correcion sobre mis errores."

Donde escuche esto???

Gracias... por recordarlo.


Saludos

[Nivel7]

oye Instru, en verdad disculpa por hacer todo este rollo por la falta de un casting, te dire que cuando probe tu codigo, yo tambien me confie, y asta me asombre de ver que era mas simple que el mio.
pero en una de las ultimas pruebas, fue cuando me entere de el error.

en fin todos nos equivocamos en algo que creemos que ya esta claro.

Saludos.

[MaxExtreme]

Iniciado por Nivel7

ptr++; desplazamineto acendente, la cantidad de bytes segun su tipo.
ptr--; decremento decendente '' '' ''.
ptr + n; desplazamiento acendente n elementos(analogo a un arraya[n]).
ptr - n; desplazamineto decendente '' '' ''.
ptr1 - ptr2; distancia entre punteros.
ptr == NULL; comporbar la igualdad o desigualdad con NULL.
ptr != NULL; lo contrario a la anterior.
ptr1 <, > ptr2; relacion mayor o menor.
ptr1 = ptr2; asignacion.
ptr1 = void; asignacion.

todas estas operaciones son aplicables a los punteros y es a esto a lo que se le llama aritmetica de punteros.
y sí, todas tienen su utilidad en algun momento.

De hecho, NO.

La aritmética de punteros se da en operadores como la suma o la resta, incremento y decremento...

Las comparaciones, tanto de igualdad, mayor, menor, etc. son completamente normales; es decir no tienen nada de aritmética de punteros.

Las asignaciones, también son normales; es decir, no tienen nada de aritmética de punteros.

Y "ptr1 = void"... ¿?

Nivel7, creo que eres de los programadores que tienen futuro y quiero que te quede claro el tema este, para que no metas la pata y nadie te diga nada nunca: Para aclararte qué es y qué no es la aritmética de punteros: Eso de "aritmética de punteros" se refiere a una propiedad especial de los operadores relacionados con la suma de enteros a punteros:

Iniciado por Aritmética de punteros

(T*)p + (N)n = p + (N)n*sizeof(T) siendo T un tipo cualquiera y N un tipo entero.

De igual manera, la resta, incremento y decremento son sumas, así que también la cumplen.

Nada más.

[MaxExtreme]

Iniciado por Nivel7

ja ja, si tienes razon, mike.p, ya estubo bueno, de discucion, esperemos que MaxExtreme tenga otra bomba por ahi(Un algoritmo que cause tanta controvercia), o alguien mas. pueda ponerlo.

Claro, de eso se trataba ;)

A que soy una mina de discusiones :D

Estoy mirando a ver algún otro sencillo pero interesante, como este último, y que no requiera de mucho código.

[Instru]

A que soy una mina de discusiones :D

JUA JUA JUA JUA
Y LO REITERO. JAJAJAJAJAJAJAJAJAJA

saludos

[GM_Juanjo]

Iniciado por MaxExtreme

Y "ptr1 = void"... ¿?

Supongo que quisiera decir ptr1 = NULL

Si no es un error que me lo explique por que yo nunca vi eso...

[Nivel7]

OK, MaxExtreme, dejemoslo en que hay ciertos operadores aplicacbles unicamente a punteros y otros en los que puede intervenir un puntero.
y olvidemos el consepto de aritmetica de punteros.

Saludos.