kYp escribió:Voy a ser un poco "pedante".
Como parametro tiene que ir lo que tiene que ir, no es que con una forma vaya con & y dinamica sin &, el caso es que malloc ya te da un puntero a la memoria reservada no hace falta obtenerla con &.
En ese caso es lo mismo por que en vectores es lo mismo "&Vector[0]" que "Vector".
Bueno ya respondimos los dos a que no era causa del & como decias
![[+risas]](/images/smilies/nuevos/risa_ani3.gif "más risas")
nazareth escribió:Joder, cuanto me queda por aprender, PAlib y un poco de c, ahi voy xD
Esto es interesante, asique dos preguntas:
1º- que significa, por ejemplo, int valor[4][5];
2º- pregunta realmente tonta, alguna forma de hacer una GUI para c? como netbeans y javascript.
)kbks escribió:1ª: int valor[4][5] es una declaración de un array bidimensional de 5x5 casillas
kYp escribió:...
Lo único que me sorprendió fue lo del array (de todos modos no uso demasiado C últimamente).kYp escribió:V+1*sizeof(int) = &V[1]
kYp escribió:(Aunque el compilador tira igual con V+1 en vez de multiplicar por el tamaño del tipo de dato por que ya lo comprueba el yo creo que para algo que nunca se hace, es mejor usaar sizeof por que queda mas claro xD)
#include <stdio.h>
int main(void)
{
int *x = NULL;
printf("%p %p\n", x, x + 1);
return 0;
}
kbks escribió:Que no te siente mal lo que te voy a decir, porque no es mi intención, pero antes de pensar en GUIs ni nada por el estilo aprende a programar en C, porque no es lógico pensar en esas cosas y no saber lo que es "int valor[4][5]". Es un consejo para que no te pierdas en llamas a APIs y al final en vez de programar solo sepas "leer tutos", cosa muy usual en casos parecidos.
kbks escribió:Respecto a tus preguntas:
1ª: int valor[4][5] es una declaración de un array bidimensional de 5x5 casillas (conceptualmente se puede pensar en el como en una tabla o un "array de arrays"). Es decir, para acceder a un valor del array se hace como en un array normal pero con dos índices. Por ejemplo "valor[0][3]" hace referencia a la posición [0][3] de la tabla (no pienses cual es la columna y cual la fila porque da igual, como a ti te guste mas).
De la misma manera se pueden declarar arrays de 3, 4, 5 o 20 dimensiones: "int valor[5][6][67][23][3]" sería un array de 5 dimensiones y se accedería igual (y no, no intentes imaginartelo porque imaginarse una estructura de datos de 5 dimensiones es imposible
2º: Depende de la plataforma existirán unas librerías u otras, eso si, no esperes tener un editor gráfico de interfaces drag&drop para C porque eso, que yo sepa, no lo implementa ningún entorno. Aquí tienes que hacer el código a pelo (que es lo mismo que hace netbeans, solo que netbeans en java te autogenera el código de las interfaces que tu diseñes). Para windows yo he realizado alguna cosa con la WinAPI, pero simplemente tener una ventana con 2 botones ya es bastante locura. Si te da igual usar C++ tienes mas opciones. Si lo que estas pensando es tener una librería así en NDS yo diría que no existe ni para uno ni para otro.
kbks escribió:En realidad da bastante igual, ya que puedes pensar que las filas es el primer índice y que las columnas es el segundo o al revés, que va a funcionar igual y conceptual mente va a estar bien. No es mas que un acceso a un valor mediante dos índices.
![[sonrisa]](/images/smilies/nuevos/risa_ani1.gif "sonrisa")
? (Y no, no vale un array unidimensional de 29184 posiciones y un entero para dividirlo ) GameZelda escribió:kYp escribió:Voy a ser un poco "pedante".
Como parametro tiene que ir lo que tiene que ir, no es que con una forma vaya con & y dinamica sin &, el caso es que malloc ya te da un puntero a la memoria reservada no hace falta obtenerla con &.
En ese caso es lo mismo por que en vectores es lo mismo "&Vector[0]" que "Vector".
Bueno ya respondimos los dos a que no era causa del & como decias
Mi error viene de que no conocía que "&x" diese el mismo resultado que "x" para un array (nunca me había encontrado con un ningún caso de este tipo, y (creo que) no tiene ningún uso práctico).
El caso es raro, porque mientras &a, en el caso de un puntero (T *) devuelve un puntero a un puntero (T **), en el caso de un array (T[n]) devuelve un puntero (T *), pero el mismo array ya se puede utilizar como si fuera un puntero directamente. No se si me explico mucho
GameZelda escribió:El caso es raro, porque mientras &a, en el caso de un puntero (T *) devuelve un puntero a un puntero (T **), en el caso de un array (T[n]) devuelve un puntero (T *), pero el mismo array ya se puede utilizar como si fuera un puntero directamente. No se si me explico mucho
int b= 20;
int *a = &b;
zheo escribió:GameZelda escribió:kYp escribió:Voy a ser un poco "pedante".
Como parametro tiene que ir lo que tiene que ir, no es que con una forma vaya con & y dinamica sin &, el caso es que malloc ya te da un puntero a la memoria reservada no hace falta obtenerla con &.
En ese caso es lo mismo por que en vectores es lo mismo "&Vector[0]" que "Vector".
Bueno ya respondimos los dos a que no era causa del & como decias
Mi error viene de que no conocía que "&x" diese el mismo resultado que "x" para un array (nunca me había encontrado con un ningún caso de este tipo, y (creo que) no tiene ningún uso práctico).
El caso es raro, porque mientras &a, en el caso de un puntero (T *) devuelve un puntero a un puntero (T **), en el caso de un array (T[n]) devuelve un puntero (T *), pero el mismo array ya se puede utilizar como si fuera un puntero directamente. No se si me explico mucho
El nombre de un vector NO es un puntero. Es una conversión:
http://stackoverflow.com/users/10136?ta ... y#sort-top
La prueba la tienes en que si lo pasas como parámetro a una función que modifica el puntero fallará.
zheo escribió:Y por otro lado, no me parece que tengas entendido del todo lo que es un puntero cuando dices esto:GameZelda escribió:El caso es raro, porque mientras &a, en el caso de un puntero (T *) devuelve un puntero a un puntero (T **), en el caso de un array (T[n]) devuelve un puntero (T *), pero el mismo array ya se puede utilizar como si fuera un puntero directamente. No se si me explico mucho
De hecho el operador de "desreferencia" no lo pillas muy bien me temo.
El operador &, devuelve la posición de memoria donde está alojada una variable.
Un puntero es una dirección de memoria. Pero si almacenas un puntero en una variable entonces también tiene que guardarse en alguna parte: en otra posición en memoria.
Por tanto si tienesy haces &a, esto te devuelve la dirección de memoria donde está alojada la variable que contiene el puntero a. Y como una dirección de memoria es un puntero, lo que &a devuelve es un puntero, que apunta a otro puntero que apunta a la dirección de memoria donde está b.int b= 20;
int *a = &b;
int a = 123; // Tipo T
int *b = &a; // Tipo T *
int **c = &b; // Tipo T **
int d[123]; // Tipo T
int *e = d; // Tipo T *
int *f = &d; // Tipo T *, tambien
GameZelda escribió:Mi error viene de que no conocía que "&x" diese el mismo resultado que "x" para un array (nunca me había encontrado con un ningún caso de este tipo, y (creo que) no tiene ningún uso práctico).
El caso es raro, porque mientras &a, en el caso de un puntero (T *) devuelve un puntero a un puntero (T **), en el caso de un array (T[n]) devuelve un puntero (T *), pero el mismo array ya se puede utilizar como si fuera un puntero directamente. No se si me explico mucho
GameZelda escribió:No se si has entendido bien a lo que me referia con mi post. Algo como así:int a = 123; // Tipo T
int *b = &a; // Tipo T *
int **c = &b; // Tipo T **
int d[123]; // Tipo T
int *e = d; // Tipo T *
int *f = &d; // Tipo T *, tambien
Simplemente esto me sorprendió, que tanto "d" como "&d" se pudieran convertir a una variable de tipo "T *", si "d" es un vector de tipo T.
zheo escribió:No pretendo entrar en discusiones semánticas, pero a mi es lo que me dio a entender frases como estas:GameZelda escribió:Mi error viene de que no conocía que "&x" diese el mismo resultado que "x" para un array (nunca me había encontrado con un ningún caso de este tipo, y (creo que) no tiene ningún uso práctico).
El caso es raro, porque mientras &a, en el caso de un puntero (T *) devuelve un puntero a un puntero (T **), en el caso de un array (T[n]) devuelve un puntero (T *), pero el mismo array ya se puede utilizar como si fuera un puntero directamente. No se si me explico mucho
Sólo pretendía dejarlo claro, porque como pongo en el link, hay diferencias importantes (como hacer un sizeof)GameZelda escribió:No se si has entendido bien a lo que me referia con mi post. Algo como así:int a = 123; // Tipo T
int *b = &a; // Tipo T *
int **c = &b; // Tipo T **
int d[123]; // Tipo T
int *e = d; // Tipo T *
int *f = &d; // Tipo T *, tambien
Simplemente esto me sorprendió, que tanto "d" como "&d" se pudieran convertir a una variable de tipo "T *", si "d" es un vector de tipo T.
El error que tienes ahí es que en realidad d es un tipo T[]:
int d[123]; // Tipo T[]
Cuando haces
int *e = d
se hace una conversión automática a T* con la dirección de memoria del primer elemento del array...
Cuando usas el operador de referencia & (me equivoqué en mi post anterior, ya está corregido) pides la dirección de memoria del array, es decir, la dirección del primer elemento.
La utilidad es que así puedes usar aritmética de punteros en arrays estáticos.
int d[123]; // Tipo Tmientras &a, [...] en el caso de un array (T[n]) devuelve un puntero (T *)
int a[100]; // Tipo T[n]
int *b = &b; // Tipo T *
"&x" diese el mismo resultado que "x" para un array
#include <stdio.h>
#include <assert.h>
int main()
{
int a[10];
printf("%p\n", a); // Imprimir el puntero al primer elemento de un array (printf es una funcion "variadic", con lo que queda probado que siempre que se pasa un array a una función, se pasa como un puntero).
assert(a == &a); // Comparación de array con puntero
a == 123; // (Con GCC, ni idea con el de Microsoft): "warning: comparison between pointer and integer"
return 0;
}
![[ok]](/images/smilies/nuevos2/okis.gif "ok")
zheo escribió:NeoSX escribió:También te recomiendo que mires variables globales que uses en todas las funciones. A mi me ayudo en su día.
Y yo te recomiendo que huyas de variables globales como de la peste.