Declaraciones de puntero

Una declaración de puntero asigna un nombre a una variable de puntero y especifica el tipo del objeto al que apunta la variable. Una variable declarada como puntero contiene una dirección de memoria.

Sintaxis

declarator:
  pointer _optardirect-declarator

direct-declarator:
 identifier
  ( declarator )
  direct-declarator [ constant-expression _optar]
  direct-declarator ( parameter-type-list )
  direct-declarator ( identifier-list _optar)

pointer:
  * type-qualifier-list _optar
  * type-qualifier-list _optarpointer

type-qualifier-list:
 type-qualifier
  type-qualifier-list type-qualifier

type-specifier proporciona el tipo del objeto , que puede ser cualquier tipo básico, estructura o unión. Las variables de puntero también pueden apuntar a funciones, matrices y otros punteros. (Para obtener información sobre cómo declarar e interpretar tipos de puntero más complejos, consulte Interpretación de declaradores más complejos).

Al realizar , type-specifiervoidpuede retrasar la especificación del tipo al que hace referencia el puntero. Este elemento se conoce como "puntero a void" y se escribe como void *. Una variable declarada como puntero a void se puede usar para apuntar a un objeto de cualquier tipo. Sin embargo, para realizar la mayoría de las operaciones en el puntero o en el objeto al que apunta, el tipo al que apunta debe especificarse explícitamente para cada operación. (Las variables de tipo char * y tipo son compatibles con la asignación sin una conversión de tipos void * ). Esta conversión se puede realizar con una conversión de tipos. Para obtener más información, consulte Type-Cast Conversiones.

type-qualifier puede ser const o volatile, o ambos. Estas palabras clave especifican, respectivamente, que el puntero no se puede modificar mediante el propio programa (const) o que el puntero puede modificarse legítimamente por algún proceso más allá del control del programa (volatile). Para obtener más información sobre const y volatile, vea Calificadores de tipos.

Asigna declarator un nombre a la variable y puede incluir un modificador de tipo. Por ejemplo, si declarator representa una matriz, el tipo del puntero se modifica para que sea un puntero a una matriz.

Puede declarar un puntero a un tipo de estructura, unión o enumeración antes de definir la estructura, unión o tipo de enumeración. El puntero se declara mediante la estructura o la etiqueta de unión, como se muestra en los ejemplos. Estas declaraciones se permiten porque el compilador no necesita conocer el tamaño de la estructura o unión para asignar espacio a la variable de puntero.

Ejemplos

En los ejemplos siguientes se muestran las declaraciones de puntero.

char *message; /* Declares a pointer variable named message */

El message puntero apunta a una variable con char tipo.

int *pointers[10];  /* Declares an array of pointers */

La pointers matriz tiene 10 elementos; cada elemento es un puntero a una variable con int tipo.

int (*pointer)[10]; /* Declares a pointer to an array of 10 elements */

La pointer variable apunta a una matriz con 10 elementos. Cada elemento de esta matriz tiene int el tipo .

int const *x;      /* Declares a pointer variable, x,
                      to a constant value */

El puntero x se puede modificar para que apunte a un valor diferente int , pero el valor al que apunta no se puede modificar.

const int some_object = 5 ;
int other_object = 37;
int *const y = &fixed_object;
int volatile *const z = &some_object;
int *const volatile w = &some_object;

La variable y de estas declaraciones se declara como un puntero constante a un int valor. El valor al que apunta se puede modificar, pero el propio puntero siempre debe apuntar a la misma ubicación: la dirección de fixed_object. Del mismo modo, z es un puntero constante, pero también se declara para que apunte a un int cuyo valor no se puede modificar mediante el programa. El volatile especificador indica que, aunque el programa no puede modificar el valor del const int objeto al que apunta z el programa, podría modificarse legítimamente mediante un proceso que se ejecuta simultáneamente con el programa. La declaración de w especifica que el programa no puede cambiar el valor al que apunta y que el programa no puede modificar el puntero.

struct list *next, *previous; /* Uses the tag for list */

En este ejemplo se declaran dos variables de puntero (next y previous) que apuntan al tipo listde estructura . Esta declaración puede aparecer antes de la definición del list tipo de estructura (vea el ejemplo siguiente), siempre que la definición de list tipo tenga la misma visibilidad que la declaración.

struct list
{
    char *token;
    int count;
    struct list *next;
} line;

La variable line tiene el tipo de estructura denominado list. El list tipo de estructura tiene tres miembros: el primer miembro es un puntero a un char valor, el segundo es un int valor y el tercero es un puntero a otra list estructura.

struct id
{
    unsigned int id_no;
    struct name *pname;
} record;

La variable record tiene el tipo idde estructura . pname se declara como puntero a otro tipo de estructura denominado name. Esta declaración puede aparecer antes de definir el name tipo.

Consulte también

Declaradores y declaraciones de variables