====== Arreglos de C plano ======

FIXME: Escribir bien un artículo que además de explicar la sintaxis básica, mencione las siguientes cosas de los arreglos de C plano.


  * Tamaño fijo una vez creado (nada de push_back ni similares)
  * Multidimensionales: Todas las dimensiones tienen que ser una constante fija, salvo la primera que puede ser dinámica.
  * Equivale a tener un vector unidimensional, y acceder en $iM + j$, o en general para el arreglo ''int a[N1][N2][N3][N4]'' digamos, acceder a $a[i][j][k][l]$ es igual que acceder directamente a la posición $iN_2N_3N_4 + jN_3N_4 + kN_4+l$, y el compilador lo hace automático (esta es la razón por la cual te deja que sea dinámico el tamaño de la primera dimensión, pero no las demás).
  * Si son locales, usan memoria de stack, en resumen, tener un arreglo local (sin static) y gigante puede traer problemas, a diferencia de vector.
  * No se pueden asignar con =, a diferencia de lo que ocurre con vector. Sin embargo si son parte de un struct, el struct se asigna bien, así que envolver un arreglo en un struct lo hace asignable. Nunca tiene "operator <" ni "operator ==" sin embargo((O mejor dicho, "tiene pero son los de punteros", asi que usarlo es casi con certeza un bug)), a diferencia de vector que ya lo tiene.
  * No se pueden pasar nunca por valor (por copia), cuando escribimos la sintaxis de "pasar un arreglo por valor", C++ lo transforma por abajo silenciosamente a pasar un puntero en su lugar. El "efecto práctico para el programador" simplificado es como si siempre se pasaran por referencia.
  * Son más eficientes que los vector (y la diferencia aumenta más cuantas más dimensiones tenga el arreglo, comparado contra el vector de vector de vector correspondiente). Por esto y porque la sintaxis queda más compacta, suelen ser una elección mucho más práctica que vector para tablas multidimensionales.
  * Idea de explicación: Enseñar la idea de hacer el mapeo de índices con un #define (cosa que sirve por sí misma igualmente para hacer cosas como tener un arreglo que va de -10 a 10), para asi tener #define tabla(i,j) arreglo[(i)*M+(j)] , y luego explicar que eso "ya viene hecho" en C++ en forma de arreglos de C plano.
  * Desventaja de los arreglos de C plano: No hacen chequeos de rangos en runtime con la opción -D_GLIBCXX_DEBUG, a diferencia de todas las cosas de la STL que sí lo hacen.
  * Otra desventaja es no tener .size(), y así tener que conocer y pasar el N a mano de ser necesario.
  * Uso con sort: sort(v, v+N) , o su equivalente sort(&v[0], &v[N]) , ya que son punteros y no hay .begin() ni .end() que sepan el tamaño N real del arreglo.