Saltar al contenido principal
LibreTexts Español

8.2: Uso de direcciones y punteros

  • Page ID
    82042
  • \( \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}}\)

    Si declaramos una variable así:

    char a;
    

    luego hacer referencia a nos conseguirá el valor almacenado en a, como en el código b=a;. El uso de la dirección del operador, como en &a, obtendrá la ubicación de memoria de un, no de un valor o contenido. Este es el tipo de cosas que usamos con scanf () y strcpy (). Es posible declarar variables que están diseñadas para contener estas direcciones. Se les llama punteros. Para declarar un puntero, prefacias la variable con un asterisco así:

    char *pc;
    

    La variable pc no es un char, es un puntero a un char. Es decir, sus contenidos son la dirección de una variable char. El contenido de cualquier puntero es una dirección. Este es un punto muy importante. Considere los siguientes fragmentos de código con base en las declaraciones anteriores:

    pc = a; /* unhappy */
    pc = &a; /* just fine */
    

    La primera línea no tiene sentido ya que estamos tratando de asignar manzanas a las naranjas, por así decirlo. La segunda línea tiene mucho sentido ya que tanto pc como &a son el mismo tipo de cosas, es decir, la dirección de una variable que contiene un char. ¿Y si queremos punteros a otro tipo de cosas? No hay problema, solo tienes que seguir los siguientes ejemplos:

    float *pf;        /* pointer to a float */
    long int *pl;     /* pointer to a long int */
    double *pd, *p2;  /* two pointers to doubles */
    short int *ps, i; /* ps is a pointer to a short int */
                      /* i is just a short int */
    

    Como se mencionó, todos los punteros contienen direcciones. Por lo tanto, no importa a qué apunte el puntero, todos los punteros tienen el mismo tamaño (mismo número de bytes). En la mayoría de los sistemas modernos, los punteros son 32 bits (4 bytes) o 64 bits (8 bytes) aunque algunos controladores pequeños usan direccionamiento de 16 bits. En caso de duda, puedes verificar tu código con sizeof (). Si todos los punteros son del mismo tamaño, entonces ¿por qué declaramos diferentes tipos de punteros? Hay dos razones. Primero, esto ayuda con la verificación de tipos. Las funciones que toman punteros como argumentos o que devuelven punteros estarán utilizando ciertas formas de datos. No querría enviar accidentalmente un puntero a un flotador cuando la función espera la dirección de un int corto, por ejemplo. Segundo, al especificar el tipo de cosa a la que apunta el puntero, podemos confiar en el compilador para generar matemáticas de puntero adecuadas (más sobre esto en un momento).


    This page titled 8.2: Uso de direcciones y punteros is shared under a CC BY-NC-SA 4.0 license and was authored, remixed, and/or curated by James M. Fiore via source content that was edited to the style and standards of the LibreTexts platform; a detailed edit history is available upon request.