Preguntilla de programación de Arcades

[na_th_an]

(duplicado)

[na_th_an]

A eso me refería: si conoces cómo funciona un ordenador, el lenguaje C es la mínima abstracción posible. En control que tienes sobre lo que va a pasar es casi total, casi como si pprgramases directamente en ensamblador, pero con facilidades. Y, sinceramente, para alguien que comprenda que las variables se almacenan en memoria, en concepto de puntero debe ser algo inmediato de comprender. Sobre todo si se ha hecho algo en ensamblador. Es como cuando guardas una dirección de memoria en HL, una dirección que puedes incrementar, decrementar, sumarle diecisiete o sustituir por otro valor... Eso es un puntero, ni más ni menos. No hay que complicarse más: es así de sencillo.

[mentalthink]

Como digo Nathan despues de mirar algunos números del ASM de Amstrad Semanal, lo de punteros como tu dices con (HL) y demás queda mucho más claro, como digo a mi me está ayudando a cuando programo decir, meto aqui un int o un float, y hablo de GLbasic, que se podría pasar por alto por lo que tiran las máquinas, supongo que eso es la diferencia entre el programador que le gusta programar, y el que programa por hacer algo...

Por cierto igual que estaba Amstrad Semanal y Microhobby , despues en PC hubo alguna revista que enseñara C, de la misma guisa que estás, lo digo porque recuerdo bajar una revista al "boleo" y poder ver pequeños código que ejercían de modo didáctico...

[na_th_an]

Bueno, esa es precisamente la diferencia entre bajo y alto nivel. A bajo nivel controlas muy cerca de la máquina, a alto nivel se te ocultan muchas cosas para que se las guise y se las coma el intérprete o el compilador, con la consiguiente pérdida de control y de velocidad. Por eso, si querías hacer tu scroller de plataformas en QB probablemente necesitarías un Pentium 300 para un juego que, de estar hecho en C, hubiese corrido en un 486 a 66. Cuando hablamos de máquinas limitadas, como bien puede ser una placa System16 o una CPS1, por poner dos "petonas", no te puedes permitir que un compilador decida dónde van tus variables, añada código y comprobaciones para avisarte si te sales del array donde estás escribiendo, o se ponga a hacer copias completas de cadenas largúisimas pasadas como parámetros a funciones, como suele hacer casi cualquier BASIC. No es cuestión de masoquismo (yo soy el primero que no disfruta por el mero hecho de programar, sino que lo hace obteniendo un resultado), sino más bien de necesidad. Tampoco es cabezonismo: si, por ejemplo, quisiera programar el sistema de una aventura conversacional para Spectrum, probablemente tiraría de ZX Basic para no tener que fabricarme todas las operaciones con cadenas, que ya vienen en el runtime.

[Mode2]

Interesante hilo.

Pienso que lo suyo antes de aprender C o un lenguaje similar es conocer algo de conceptos básicos (lo que comenta Mcleod) y algo de ensamblador aunque no sea muy profundo. Creo que adquieres una base que después te viene muy bien para comprender muchas cosas.

[na_th_an]

Exacto. C es un lenguaje estructurado, lo que lo hace amable para programar, pero además es un lenguaje de bajo nivel, que requiere que entiendas cómo funcionan las cosas y te permite sacar mucho partido al hardware. Todo ese tratamiento laxo de tipos, falta de control sobre la memoria y no comprobación de rangos que muchos tanto critican permiten hacer cosas geniales como, por ejemplo, tener una estructura en un binario comprimido con cosas muy diferentes: gráficos, mapas, músicas, estructuras con valores sobre objetos y enemigos... y descomprimirlo a pelo, como si fuera un amasijo de bytes, sobre la zona de la memoria donde tienes creados los arrays y estructuras que maneja tu programa... Y como todo tiene la misma forma... ¡BAZINGA! Nadie se queja y ahí tienes un nivel nuevo

Claro, que luego estás programando y no te fijas que un índice se sale de la tabla y empiezan a salir cosas de colores por la pantalla... Bueno, cuesta a veces arreglarlo, pero creo que es un precio que se paga muy alegremente cuando lo comparas con las ventajas.

[Mode2]

Por cierto señor na_th_an, aunque ahora ando muy liado, creo que usted y yo teniamos algo pendiente en lo concerniente a código.

[na_th_an]

Oh, sí, pero yo ando igual de liado

Hice el intento de empezar, pero ahí se quedó -> http://tcyr.wordpress.com/2014/05/23/po ... m-a-cpc-1/

Voy a hacer un poder para intentar ir escribiéndolo poco a poco... Puede ser algo muy útil

[explorer]

Por otra parte, ¿cómo es eso de que en dos dimensiones, el array fila guarda los punteros de los comienzos de cada array columna? Cuando defines una matriz, por ejemplo: char m[10][10] lo que se genera es un array lineal de 100 chars, no un array de 10 punteros a char apuntando cada elemento a otro array de 10 chars. Probablemente haya una opción en algún compilador para que las matrices las genere así, pero nunca me he topado con ello, y no creo siquiera que sea parte del comportamiento estándar.

A ver... en las matrices normales, sí que es así, pero... no todas las matrices son cuadradas...

Del libro «El lenguaje de programación C», de Kernighan y Ritchie (tanto de la primera como de la segunda edición incluyendo el ANSI C):

---

5.8 Inicialización de punteros a vectores

Considere el problema de escribir una función mes_nombre(n), que devuelve un puntero a una cadena de caracteres conteniendo el nombre del n-ésimo mes. Esta es una aplicación ideal para un vector interno de tipo static. mes_nombre contiene un vector privado de cadenas de caracteres y devuelve un puntero a la apropiada cuando se le llama. Esta sección muestra cómo se inicializa el vector de nombres. La sintaxis es similar a las inicializaciones anteriores:

Código: Seleccionar todo

/* mes_nombre:   devuelve el nombre del enésimo mes */
char *mes_nombre(int n) {
    static char *nombre[] = {
        "mes ilegal",
        "enero",      "febrero",      "marzo",
        "abril",      "mayo",         "junio",
        "julio",      "agosto",       "septiembre",
        "octubre",    "noviembre",    "diciembre"
    };

    return (n < 1 || n> 12) ? nombre[0] : nombre[n];
}

La declaración de nombre, que es un vector de punteros a caracteres, es la misma que lineaptr en el ejemplo de ordenación. El inicializador es una lista de cadenas de caracteres; cada una es asignada a su correspondiente posición dentro del vector. Los caracteres de la i-ésima cadena se colocan en algún sitio, y se almacena un puntero a ellos en nombre. Dado que no se ha especificado el tamaño del vector nombre, el compilador cuenta los inicializadores y lo rellena con el número correcto.

5.9 Punteros frente a vectores multidimensionales

Los recién llegados a C se sienten en algunas ocasiones confundidos sobre la diferencia entre un vector bidimensional y un vector de punteros, como en el caso de nombre del ejemplo anterior. Dada las definiciones

int a[10][20];
int *b[10];

entonces a[3][4] y b[3][4] son sintácticamente referencias legales al mismo int. Pero a es un verdadero vector bidimensional: se han reservado 200 posiciones, cada una de tamaño de un int, y se usa el cálculo habitual de subíndices rectangulares 20xfila+columna para encontrar el elemento a[fila][columna]. Para b, sin embargo, la definición sólo reserva 10 punteros y no los inicializa; la inicialización se debe realizar de forma explícita, tanto estáticamente o por código. Asumiendo que cada elemento de b apunte a un vector de 20 enteros, entonces se reservará espacio para 200 enteros, más diez posiciones para los punteros. La ventaja más importante de un vector de punteros es que las filas del vector pueden ser de longitudes diferentes. Es decir, cada elemento de b no necesita apuntar a un vector de veinte elementos; algunos pueden apuntar a dos elementos, otros a quince, otros incluso a ninguno.

Aunque en esta discusión hemos hablado en términos de enteros, el uso más frecuente, de lejos, de vectores de punteros es el de almacenar cadenas de caracteres con longitudes diferentes, como en la función mes_nombre. Compare la declaración y esquema de un vector de punteros:

pantalla14.png (27.81 KiB) Visto 8812 veces

con los de un vector bidimensional:

pantalla15.png (27.17 KiB) Visto 8812 veces

---

A modo de ejemplo, aquí hay un pequeño programa que muestra diferentes notaciones entre punteros y vectores bidimensionales.

Código: Seleccionar todo

/*
  Pruebas
 
*/
#include <stdio.h>

char *mensajes[] = {
  "FASE BONUS",
  "GAME OVER",
  "PRIMER JUGADOR",
  "SEGUNDO JUGADOR",
  "+---------------v---+",
  "|...................|",
  "|..X................>",
  "|...................|",
  "|.........D.........<",
  ">...................|",
  "|...................|",
  "+---^---------------+",
};

void main(void) {

  int i; 
  for (i = 0; i < 12; i++) {
   
    printf("%2d. %p %p %s\n", i, &mensajes[i], mensajes[i], mensajes[i]);
  }

  printf("Acceso a una fila (1)     : %s\n", mensajes[1]);   // GAME OVER
  printf("Acceso a un carácter (0,5): %c\n", mensajes[0][5]);   // B

  char *p = &mensajes[1][0];
  printf("Acceso a un carácter (1,0): %c\n", *p);      // G
  printf("Dirección de ese carácter : %p\n", p);

  char **ptr = mensajes;
  printf("Acceso por puntero:         %p %c %c %c\n",
    ptr,
    ptr[6][3],         // diversas formas de acceder a (6,3)
    (*(ptr+6))[3],
    *((*(ptr+6))+3)
  );              // todas devuelven X

}

La salida, en mi ordenador, es:

Código: Seleccionar todo

 0. 0x601060 0x400718 FASE BONUS
 1. 0x601068 0x400723 GAME OVER
 2. 0x601070 0x40072d PRIMER JUGADOR
 3. 0x601078 0x40073c SEGUNDO JUGADOR
 4. 0x601080 0x40074c +---------------v---+
 5. 0x601088 0x400762 |...................|
 6. 0x601090 0x400778 |..X................>
 7. 0x601098 0x400762 |...................|
 8. 0x6010a0 0x40078e |.........D.........<
 9. 0x6010a8 0x4007a4 >...................|
10. 0x6010b0 0x400762 |...................|
11. 0x6010b8 0x4007ba +---^---------------+
Acceso a una fila (1)     : GAME OVER
Acceso a un carácter (0,5): B
Acceso a un carácter (1,0): G
Dirección de ese carácter : 0x400723
Acceso por puntero:         0x601060 X X X

[mcleod_ideafix]

A ver... en las matrices normales, sí que es así, pero... no todas las matrices son cuadradas...

Es así en cualquier matriz que se declare como matriz, sea cuadrada o no.
char m[10][10] genera realmente un array lineal de 100 chars.
char m[5][3] genera realmente un array lineal de 15 chars.

Lo que muestras con ese ejemplo es simplemente que un array de punteros a arrays se puede usar como si fuera una matriz, en el sentido de que se usan dos subíndices, pero no puedes decir en clase que al definir una matriz como cualquiera de los ejemplos anteriores, se va a generar en memoria un array de punteros apuntando cada uno a un array. Para tener eso tienes que crearlo exprofeso, declarando un vector de punteros, y luego inicializando cada elemento de ese array a un puntero que habrás obtenido de alguna forma, tal como malloc.

El punto 5.9 que mencionas dice precisamente eso. Y es lo que me extrañaba cuando decías:

salvo cuando comienzas a decir que, por ejemplo para dos dimensiones, en la primera dimensión, el primer arreglo guarda punteros a los comienzos de los arreglos de la segunda dimensión. Les ves las caras, y aunque dibujes flechitas, se quedan pensando que qué es eso. Al final lo aceptan (porque lo asimilan a los iconos con flechas del escritorio de Windows ), pero lo que no puedo es explicárselo a muy bajo nivel porque no es el objetivo de la asignatura.

Salvo que no estuvieras explicando matrices, sino arrays de punteros, que son dos cosas muy distintas en C, aunque puedan usarse con la misma notación.