¿Qué computadora nueva aprendí cuando decidí escribir Chrome Dino en C?

Un poco sobre el proyecto

Para familiarizarme con el lenguaje, decidí escribir una pequeña aplicación Chrome Dino, que es un clon fallido del familiar dinosaurio Chrome. Debido a la falta de clases en C, decidí reinventar mi rueda: coloqué los campos y métodos de la clase en una estructura, el constructor era una función que devuelve esta estructura. Los campos y métodos internos se ocultan precediéndolos con static. (Hay varios artículos sobre esto)

...

typedef struct Barrier {
    int width, height;
    int *picture;
    int x0, y0;
} Barrier;

Barrier* new_Barrier() {
  Barrier* barrier = NULL;
  barrier = malloc(sizeof(Barrier));

  return barrier;
}

[0, 1, 2, 3],

.

0 — ,

1 — ,

2 — ,

3 — .

, —

, , . .

, , .. .

Para iterar sobre una serie de datos (matriz unidimensional), se toma la dirección del primer elemento y luego en un bucle (con un paso = tamaño del tipo de datos), se mueve la siguiente dirección.

int n = 10;
int step = sizeof(Barrier);
Barrier* barrier = malloc(step * n);

for (int i = 0; i < n; i += step) {
  *(barrier + i) = data;
}

Se vuelve más difícil implementar la búsqueda de un elemento en una matriz bidimensional, porque toda la matriz se escribe en celdas secuenciales y la búsqueda debe realizarse por una fila, no por una matriz. Para buscar un elemento de matriz en una fila, puede usar la fórmula:

$$

$$A[ i ][ j ] = i * w + j$$

donde A es una matriz bidimensional,

      i es el índice de fila,

      j es el índice de columna,

      w es la longitud de la matriz anidada A (ancho de matriz)

Es aún más difícil encontrar un elemento de una matriz tridimensional; para encontrarlo, debe usar la fórmula:

$$

$$B[ i ][ j ][ k ] = i * w * h + j * w + k$$

donde B es una matriz tridimensional,

      k es el índice de una serie de matrices bidimensionales,

      h es la longitud de la matriz anidada B (la altura de la matriz).

Está claro que para implementar el trabajo con más anidamiento de matrices, se requiere un algoritmo de búsqueda unificado para su elemento:

$$

$$C[a_1][a_2]...[a_n] = \sum_{i = 1}^n a_i * L_{i - 1} * ... * L_1$$

donde C es una matriz n-dimensional,

      n es anidado,

      $$$a_i$ - índice de la i-ésima matriz,

      $$$L_i$ - la longitud de la matriz i.

Si tomamos el número de operaciones de la computadora como el eje de ordenadas y el anidamiento como el eje de abscisas, entonces podemos ver cómo el número de operaciones para calcular un elemento de matriz crece al aumentar el anidamiento. (La suma y la multiplicación se toman en una sola operación).

Recuerda el recuerdo

. : , . .

c Barrier. , . , ( ). push ( ) ( ) , . .

int n = 10;
int step = sizeof(Barrier);
Barrier* barrier = malloc(step * n);

for (int i = 0; i < n; i += step) {
    *(barrier + i) = data;
}

n = 11;
free(barrier);
barrier = malloc(step * n);

for (int i = 0; i < n; i += step) {
    *(barrier + i) = data;
}

: , . (, ArrayList java), .

No es un primitivo primitivo

En los lenguajes de alto nivel, hay tipos de datos que se pasan por referencia y datos que se pasan por valor. Pero para pasar datos por valor, debe tener una referencia a la variable, es decir ¿El tipo primitivo no es tan primitivo? En ensamblador, cualquier variable almacena tanto una referencia a una ubicación de memoria como el valor que se almacena en ella. Cada variable almacena su dirección y valor de celda (el valor también puede ser la dirección de otra celda). Pero, ¿dónde se almacenan las referencias a las direcciones de las celdas de memoria? Resulta que cuando el compilador genera código de máquina, automáticamente reemplaza todos los nombres de variables con sus compensaciones. Esto significa que cada variable se puede pasar por referencia, pero en lenguajes de alto nivel esta característica está oculta para el desarrollador.

Puedes ver el proyecto aquí .