8.5: Punteros y matrices

Última actualización
Guardar como PDF

Page ID: 82071

\( \newcommand{\vecs}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \) \( \newcommand{\vecd}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash {#1}}} \)\(\newcommand{\id}{\mathrm{id}}\) \( \newcommand{\Span}{\mathrm{span}}\) \( \newcommand{\kernel}{\mathrm{null}\,}\) \( \newcommand{\range}{\mathrm{range}\,}\) \( \newcommand{\RealPart}{\mathrm{Re}}\) \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\) \( \newcommand{\Argument}{\mathrm{Arg}}\) \( \newcommand{\norm}[1]{\| #1 \|}\) \( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\) \( \newcommand{\Span}{\mathrm{span}}\) \(\newcommand{\id}{\mathrm{id}}\) \( \newcommand{\Span}{\mathrm{span}}\) \( \newcommand{\kernel}{\mathrm{null}\,}\) \( \newcommand{\range}{\mathrm{range}\,}\) \( \newcommand{\RealPart}{\mathrm{Re}}\) \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\) \( \newcommand{\Argument}{\mathrm{Arg}}\) \( \newcommand{\norm}[1]{\| #1 \|}\) \( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\) \( \newcommand{\Span}{\mathrm{span}}\)\(\newcommand{\AA}{\unicode[.8,0]{x212B}}\)

Muy a menudo usamos punteros con matrices. Un ejemplo es el uso de cuerdas. Esto lo notamos en trabajos anteriores. Recordemos que la “dirección de” y el índice de matriz “se cancelan entre sí” para que los siguientes sean equivalentes:

&somestring[0]    somestring

Veamos un ejemplo de cómo podría usar punteros en lugar de indexación de matriz normal. Escribiremos nuestra propia versión de strcpy () para copiar una cadena a otra. La función toma dos argumentos, la dirección de una cadena de origen y la dirección de una cadena de destino. Copiaremos sobre un personaje a la vez hasta que lleguemos a la terminación nula. Primero, la forma normal del índice de matriz:

void strcpy1( char dest[], char source[] )
{
    int i=0;        /* index variable, init to first char */

    while( source[i] != 0 )     /* if it’s not null...*/
    {
        dest[i] = source[i];    /* copy the char */
        i++;                    /* increment index */
    }
    dest[i] = 0;                /* null terminate */
}

Parece bastante sencillo, ¿verdad? Hay algunas mejoras menores que puedes hacer, como cambiar el bucle a while (source [i]), pero eso no es gran cosa. Ahora en contraste, escribamos lo mismo usando punteros.

void strcpy2( char *dest, char *source )
{
    while( *dest++ = *source++ );
}

Eso es. Así es como funciona. dest y source son las direcciones iniciales de las cadenas. Si usted dice:

*dest = *source;

entonces lo que sucede es que el valor al que apunta la fuente se copia a la dirección a la que se refiere dest. Eso copia a un personaje. Ahora, a esto le sumamos el operador de incremento post ++:

*dest++ = *source++;

Esta línea copia el primer carácter como arriba y luego incrementa cada puntero. Por lo tanto, cada puntero contiene la dirección del siguiente carácter en la matriz (tienes que amar esa matemática de puntero, esto funcionará con cualquier dato de tamaño). Al colocar este código dentro del bucle while (), si el contenido (es decir, el carácter copiado) no es cero, el bucle continuará. El bucle no se detendrá hasta que se haya copiado el nulo de terminación. Como puedes imaginar, el código de máquina subyacente para strcpy2 () será mucho más simple, más compacto y más rápido de ejecutar que el de strcpy1 (). Como se dijo al inicio del curso, ¡se puede hacer mucho en C con solo un poco de código!