Mejorar traducción de la respuesta de ¿Cómo puedo utilizar las matrices en C++? - Iteramos.com

426 votos

¿Cómo puedo utilizar las matrices en C++?

Preguntado el 26 de Enero, 2011
54116 visitas
5 Respuestas
Solucionado

C++ heredado matrices de C, donde se utilizan prácticamente en todas partes. C++ proporciona abstracciones que son más fáciles de usar y menos propenso a errores (std::vector<T> debido a que C++y 98 std::array<T, n> desde C++11), por lo que la necesidad de matrices no surge tan a menudo como se hace en C. sin Embargo, cuando se lee el código heredado o interactuar con una biblioteca escrita en C, usted debe tener una firme comprensión sobre cómo funcionan los arreglos.

Este FAQ está dividida en cinco partes:

Si usted siente que algo importante faltaba en esta sección de preguntas frecuentes, escribir una respuesta y el enlace aquí como una parte adicional.

En el texto siguiente, "matriz" significa "matriz C", no de la plantilla de clase std::array. Conocimientos básicos de la C declarador de sintaxis que se asume. Tenga en cuenta que el uso del manual de new y delete como se muestra a continuación es extremadamente peligroso en la cara de excepciones, pero eso es tema de otra de las preguntas frecuentes.

_{(Nota: Este está destinado a ser una entrada de Stack Overflow en C++ de preguntas frecuentes. Si usted quiere a la crítica de la idea de ofrecer un documento de preguntas frecuentes en este formulario, a continuación de la publicación en el meta, la que comenzó todo este sería el lugar para hacerlo. Las respuestas a esa pregunta son monitoreados en el C++ sala de chat, donde las preguntas frecuentes idea comenzó en el primer lugar, entonces, la respuesta es muy probable que se lea por los que vinieron con la idea).}

Preguntado el 26 de Enero, 2011 q2astack::content.general.By FredOverflow

Tu respuesta

5. Errores comunes al utilizar matrices.5.1 Escollo: Confiar tipo inseguro de vinculación.
--------------------------------------------------

================================================================================================================================================

OK, que te han dicho, o ha encontrado a sí mismo, que globals (espacio de nombres alcance de las variables que puede obtenerse fuera de la unidad de traducción) Evil™. Pero, ¿sabemos verdaderamente qué Mal™ son? Considere la posibilidad de la siguiente programa, que consta de dos archivos [main.cpp] y [numbers.cpp]:

// [main.cpp]
    #include <iostream>
    
    extern int* numbers;
    
    int main()
    {
        using namespace std;
        for( int i = 0;  i < 42;  ++i )
        {
            cout << (i > 0? ", " : "") << numbers[i];
        }
        cout << endl;
    }

// [numbers.cpp]
    int numbers[42] = {1, 2, 3, 4, 5, 6, 7, 8, 9};

En Windows 7 esto compila y enlaces bien tanto con MinGW g++ 4.4.1 y Visual C++ 10.0.

Dado que los tipos no coinciden, el programa se bloquea cuando se ejecuta.

![The Windows 7 crash dialog](http://i.stack.imgur.com/v7KJF.png)

En-el-explicación formal: el programa tiene un Comportamiento Indefinido (UB), y en lugar de de estrellarse por lo tanto, puede simplemente pasar el rato, o tal vez no hacer nada, o puede enviar amenazando e-mails a los presidentes de los estados UNIDOS, Rusia, la India, China y Suiza, y hacer Nasal Demonios de la mosca de la nariz.

En la práctica explicación: en `main.cpp` la matriz es tratado como un puntero, colocado en la misma dirección de la matriz. Para ejecutable de 32 bits, esto significa que la primera `int` valor de la matriz, es tratada como un puntero. Es decir, en `main.cpp`la `numbers` variable contiene, o parece contener, `(int*)1`. Esto hace que el programa de acceso de la memoria en la parte inferior del espacio de direcciones, que es convencionalmente reservados trampa y que causan. Resultado: obtendrá un bloqueo.

Los compiladores están totalmente en su derecho de no diagnosticar este error, debido a que C++11 §3.5/10 dice, sobre el requisito de tipos compatibles para las declaraciones,

> **[N3290 §3.5/10]**  
>  Una violación de esta regla en el tipo de identidad que no requiere de un diagnóstico.

El mismo párrafo detalles de la variación que se permite:

> ... declaraciones de un objeto array, puede especificar los tipos de matrices que se diferencian por la presencia o ausencia de una serie importante obligado (8.3.4).

Esto permitió que la variación no incluyen declarar un nombre de un array en una la unidad de traducción, y como un puntero en otra unidad de traducción.

5.2 Trampa: Hacer prematuro de optimización (`memset` & friends).
-----------------------------------------------------------------

*Aún no se ha escrito*

5.3 Escollo: Utilizando el lenguaje C para obtener el número de elementos.
--------------------------------------------------------------------------

Con profunda de la C a la experiencia es natural escribir ...

#define COUNT_OF( array )   (sizeof( array )/sizeof( array[0] ))

Desde un `array` de desintegración puntero al primer elemento cuando sea necesario, la la expresión `sizeof(a)/sizeof(a[0])` también puede ser escrito como `sizeof(a)/sizeof(*a)`. Significa lo mismo, y no importa cómo se escrito es el **lenguaje C** para encontrar el número de elementos de la matriz.

Principal escollo: el lenguaje C no es typesafe. Por ejemplo, el código de ...

#include <stdio.h>
    
    #define COUNT_OF( array ) (sizeof( array )/sizeof( *array ))
    
    void display( int const a[7] )
    {
        int const   n = COUNT_OF( a );          // Oops.
        printf( "%d elements.\n", n );
    }
    
    int main()
    {
        int const   moohaha[]   = {1, 2, 3, 4, 5, 6, 7};
    
        printf( "%d elements, calling display...\n", COUNT_OF( moohaha ) );
        display( moohaha );
    }

pasa un puntero a `COUNT_OF`, y por lo tanto más probable es que produce un mal resultado. Compilado como un ejecutable de 32 bits en Windows 7 se produce ...

> 7 elementos, visualización de llamada...  
>  1 elementos.

1. El compilador reescribe `int const a[7]` a solo `int const a[]`.
2. El compilador reescribe `int const a[]` a `int const* a`.
3. `COUNT_OF` es, por tanto, se invoca con un puntero.
4. Para un ejecutable de 32 bits `sizeof(array)` (el tamaño de un puntero) es de 4.
5. `sizeof(*array)` es equivalente a `sizeof(int)`, que para un ejecutable de 32 bits también es 4.

Con el fin de detectar este error en tiempo de ejecución se puede hacer ...

#include <assert.h>
    #include <typeinfo>
    
    #define COUNT_OF( array )       (                               \
        assert((                                                    \
            "COUNT_OF requires an actual array as argument",        \
            typeid( array ) != typeid( &*array )                    \
            )),                                                     \
        sizeof( array )/sizeof( *array )                            \
        )

> 7 elementos, visualización de llamada...  
>  Error de aserción: ( "COUNT_OF requiere de un real de la matriz como argumento", typeid( a ) != typeid (&*)), archivo runtime_detect ion.cpp, línea 16
> 
> Esta aplicación ha solicitado que el tiempo de ejecución para terminar de una manera inusual.  
>  Por favor, póngase en contacto con el equipo de soporte técnico para obtener más información.

El tiempo de ejecución de detección de errores es mejor que la falta de detección, pero pierde un poco de el tiempo de procesador, y quizás mucho más programador de tiempo. Mejor con la detección de tiempo de compilación! Y si usted es feliz no se admiten matrices de tipos locales con C++98, a continuación, puede hacerlo:

#include <stddef.h>
    
    typedef ptrdiff_t   Size;
    
    template< class Type, Size n >
    Size countOf( Type (&)[n] ) { return n; }
    
    #define COUNT_OF( array )       countOf( array )

La compilación de esta definición sustituido en el primer programa completo, con g++, Tengo ...

> M:\count> g++ compile_time_detection.cpp  
>  compile_time_detection.cpp: En la función 'void mostrar(int const*)':  
>  compile_time_detection.cpp:14: error: no hay coincidencia de la función de llamada a 'countOf(const int*y)'
> 
> M:\count> _

Cómo funciona: la matriz se pasa *por referencia* a `countOf`, y así es no se deteriorará puntero al primer elemento, y la función puede devolver simplemente la el número de los elementos especificados por el tipo.

Con C++11 se puede utilizar también para las matrices de tipo local, y es el tipo de seguro **C++ lenguaje** para hallar el número de elementos de una matriz.

Hay un extra de refinamiento para el caso donde se desea un tiempo de compilación constante, pero ya que es así que se utilizan rara vez (si!) mostrando que sería un desperdicio de espacio.

Iteramos es una comunidad de desarrolladores que busca expandir el conocimiento de la programación mas allá del inglés.
Tenemos una gran cantidad de contenido, y también puedes hacer tus propias preguntas o resolver las de los demás.

X