¿Qué pasa con la matriz

Tengo un gran bloque de código que está diseñado para tomar una matriz y trabajar a través de ella. En el proyecto actual solo habrá un elemento, por lo que, en lugar de cambiar la variable a un carácter, lo declaré como matriz de caracteres [1]. De esta manera no necesito modificar mi código y arriesgarme a agregar errores y puedo boostlos fácilmente si los requisitos aumentan.

Parece que se comstack, pero tengo curiosidad por lo que está pasando debajo del capó, ¿estoy perdiendo la memoria? ¿Esto agrega tiempo extra de procesamiento? ¿El comstackdor lo optimizará todo, por lo que no sería diferente si lo escribiera?

Alguien puede explicar cualquier posible inconveniente de usar arreglos de esta manera.

Yo uso c y c ++, ¿sería diferente entre ellos?

Primero, su código es válido, pero si le importan los inconvenientes, puedo ver los problemas que se enumeran a continuación:

Al usar la matriz, aumenta la posibilidad de acceder a ella con acceso fuera de los límites cuando recorre la matriz sin tener cuidado.

Otro inconveniente es que la matriz no interactúa con el polymorphism. A veces intenta almacenar el objeto derivado en una matriz de tipo base, el objeto se dividirá y es posible que no lo note.

Así que no escribiría el código de matriz [1]. Espero que esto responda algunas de tus preguntas.

Suena como una buena estrategia, y no hay inconvenientes. Definitivamente no está desperdiciando memoria en C o C ++. La memoria tomada por una matriz de tamaño uno es la misma que la memoria tomada por una variable del mismo tipo.

Es posible que el comstackdor genere un código microscópicamente menos eficiente, pero realmente no vale la pena preocuparse.

El estándar dice que se le permite tomar la dirección de un objeto que no es una matriz y tratarla como una matriz de tamaño 1 (para que pueda llevar un puntero hasta el final).

Consulte la sección §5.7.4 del estándar C ++ 11:

A los efectos de estos operadores, un puntero a un objeto que no es una matriz se comporta igual que un puntero al primer elemento de una matriz de longitud uno con el tipo del objeto como su tipo de elemento.

Aquí nos enfrentamos a 2 bloques de código.

  • Un gran bloque de código que está diseñado para tomar una matriz y trabajar a través de ella.
  • Un fragmento de código que utiliza un bloque de código anterior con algunos datos.

Estructure su código.

El gran bloque de código debe ser una función posiblemente dividida en varias subfunciones. La otra pieza de código llamará a esta función.

Parámetros de la función. Array o solo char.

  (a) void work( char c ); (b) void work( char& c ); (c) void work( const char v[], size_t size); (d) void work( char v[], size_t size); 

Las opciones (a) y (b) deben usarse si el tipo de trabajo no tiene sentido para una matriz. Que no es el caso.
Las opciones (c) y (d) deben usarse si el trabajo tiene sentido para una matriz.

Así que usa una matriz.

Variable que contiene los datos. Array o solo char.

Si solo necesita mantener un solo carácter, utilice un único carácter sin matriz. Todavía puede llamar a la función de matriz.

 char c; c = 'b'; work( &c, 1 ); ////// char a[1]; a[0] = 'b'; work( a, 1 ); 

La función de trabajo ve la variable única y la matriz como una matriz de tamaño 1. El código funcionará bien en ambos casos y sin problemas de eficiencia.

Pruebas

Vamos a ver si el código real contiene mis declaraciones anteriores.

 #include  #include  #include  #include  #include  using namespace std; unsigned long miliTime() { return std::chrono::system_clock::now().time_since_epoch() / std::chrono::milliseconds(1); } // An hypotetical work function with arrays void workArray( char v[], size_t size ) { for ( size_t n=0; n 

Cuando se comstack en gcc-4.7 con esta línea de comando y se ejecuta en mi computadora:

 g++ -O2 -Wall -std=c++11 x.cpp -o x.out && ./x.out 

Obtengo esta salida:
Resultado = z
Var no de matriz pasada al código de matriz = 5520 ms
Resultado = z
Array var pasado al código de matriz = 5515ms
Resultado = z
Var no de matriz pasada a código no de matriz = 5203 ms
Resultado = z
Array var pasado a un código no-array = 5203 ms

Como era de esperar el resultado es siempre el mismo. No hay una diferencia significativa en pasar una matriz o una variable no de matriz a la función de trabajo para ambas implementaciones.

workSingle es un 6% más rápido que workArray.
La ejecución del bucle externo (que no existe en workSingle) es poco probable que sea la causa, ya que el bucle interno se ejecuta 1000 veces. La causa se debe probablemente a que el acceso a v [n] es más lento que el acceso a c debido a la indirección.
¡Aunque si cambia el 1000 en el bucle interno para una variable global leída desde std :: cin, entonces WorkSingle en realidad da tiempos más lentos que workArray!

Algún tipo de optimizaciones, errores de caché u otras cosas de bajo nivel pueden ser la causa. No sacrificaría la reutilización de workArray por la eficacia incierta de workSingle a menos que el tiempo sea tan crítico que esté dispuesto a ir al nivel de ensamblaje.

Conclusión.

Declare su variable como no-matriz ya que solo tiene que contener un solo carácter.
Implemente su gran sección de código como una función que toma un parámetro de matriz. Posiblemente dividido en varias subsecciones si es tan grande.