C/Punteiros

C
← Volver a Enumeracións	Punteiros	Seguir con Nomear tipos →

Os punteiros son un tipo de variable que non contén un valor ou valores, senón un enderezo de memoria. Neste enderezo de memoria é onde residen os valores, mentres que o punteiro será simplemente un enderezo. Hai que aprender a traballar tanto co valor que contén o punteiro (o enderezo de memoria) como co valor do espazo de memoria sinalado polo punteiro.

Declaración

Para declarar un punteiro, sitúase na declaración da variable un asterisco, «*», entre o tipo e mailo identificador da variable. A sintaxe fundamental da declaración dun punteiro é a seguinte:

tipo * identificador;

Onde:

tipo é o tipo de dato ao que sinala o punteiro,

* sinala que se trata dun punteiro, e

identificador é o identificador (nome) do punteiro.

Identificador

Ao elixir identificadores para punteiros, non sería mala idea seguir unha sintaxe fixa que permita ao que lea o código saber que unha variable é un punteiro tan só con ler o seu identificador.

Algúns programadores optan por prefixar ou sufixar os identificadores dos punteiros con algunha combinación de caracteres (coma p, pt ou punt).

Inicialización

Considérase unha boa práctica inicializar os punteiros co valor nulo (NULL) para que se saiba que non se reservou aínda espazo en memoria para o enderezo de memoria ao que sinala o punteiro. Isto ademais evita problemas con algunhas funcións, coma realloc(), usada para traballar con memoria dinámica.

Punteiro a un punteiro

Se ben a algúns lles resulta difícil comprender isto, pódese declarar un punteiro a un punteiro. Para facelo bastará con engadir á declaración un asterisco adicional. Vexamos un exemplo:

float * * punteiro_a_un_punteiro;

Traballo con punteiros

Valor nulo

O valor nulo nos punteiros escríbese NULL, non 0. Asignándolle este valor a un punteiro, este deixa de apuntar a un enderezo de memoria. Queda baleiro. Vexamos como se lle dá o valor nulo a un punteiro:

punteiro = NULL;

Tamaño

O tamaño dos punteiros, o que ocupan en memoria, non ven dado polo tipo de dato especificado na declaración do punteiro. O tipo de dato da declaración corresponde ao tipo de dato ao que sinala o punteiro.

O verdadeiro tamaño do punteiro, posto que o punteiro garda un enderezo de memoria, dependerá da arquitectura do sistema operativo, xa que esta define a forma en que o procesador traballa coa memoria. Así, nun sistema de 32 bits, este será o tamaño do punteiro (32 bits = 4 bytes), e nun de 64 bits o tamaño será de 8 bytes.

Traballar co valor sinalado

Se queremos traballar ou asignarlle un valor ao espazo de memoria ao que sinala un punteiro (e non ao espazo de memoria que ocupa o punteiro), precédese o identificador do punteiro cun asterisco. Véxanse os seguintes exemplos:

*punteiro = 0; // Asígnaselle o valor 0 ao espazo de memoria sinalado
resultado = *punteiro_ao_primeiro_operando + *punteiro_ao_segundo_operando;

Traballar cos enderezos doutras variables

Mediante o símbolo «&» pode obterse o enderezo de memoria dunha variable que non sexa un punteiro, o cal pode resultar moi útil á hora de traballar con punteiros. Véxase o seguinte exemplo:

// Declaramos unha variable de tipo int:
int variable;

// Declaramos unha variable punteiro para recoller o
// enderezo de memoria en que se garda a variable:
int * punteiro;

// Ao choio:
punteiro = &variable;

// Agora "punteiro" sinala ao enderezo de memoria
// en que está gardada "variable".

Punteiros a matrices

As matrices non son máis que unha forma especial de traballar con punteiros. Unha matriz é en realidade un punteiro cuxo valor (o enderezo de memoria ao que sinala) non pode cambiar, e para o que se reserva un certo espazo en memoria estática ao declaralo ─que dependerá do tipo de datos e a cantidade deles que leve a matriz─.

Se se lle asigna a un punteiro “normal” o enderezo de memoria dunha matriz, poderase traballar co punteiro do mesmo xeito que se fai coa matriz.

Matrices de punteiros

Pódense declarar matrices de punteiros. Vexamos un exemplo:

char * lista[66];

Isto será unha matriz con 66 celas, cada unha das cales é un punteiro a un dato de tipo carácter (char).

Operadores

Hai certos operadores que presentan, para o noso ben, un comportamento lixeiramente distinto cos punteiros do que presentan con outro tipo de variables.

«punteiro++» equivale a «punteiro = punteiro + sizeof(tipo)».
«punteiro--» equivale a «punteiro = punteiro - sizeof(tipo)».
«punteiro = punteiro + número» equivale a «punteiro = punteiro + número * sizeof(tipo)».

Estes comportamentos especiais para punteiros permiten moverse comodamente por matrices de datos, etc.

Nota: lémbrese que o “tipo” é o tipo de dato da que sinala o punteiro, xa que o punteiro non ten un tipo definido.

Programa de resumo

Cómpre comprender por riba o funcionamento do seguinte código, que amosa claramente o principio do funcionamento dos punteiros.

// Ficheiros de cabeceira
#include <stdio.h>
  // Para utilizar:
  // printf()
#include <stdlib.h>
 // Para usar:
 // free()
 // malloc()

// FUNCIÓN PRINCIPAL
int main(void)
{
  // Declaración de variables
  int * punteiro;
  
  // Facémoslle espazo en memoria ao enteiro...
  punteiro = (int *) malloc(sizeof(int));
  
  // Operacións
  *punteiro = 666; // Ao "int" ao que sinala en memoria o punteiro dámoslle o valor 666.
  
  // Impresións en pantalla dos datos interesantes
  printf("Punteiro:\n");
    printf("\tValor:\t\t%p\n",punteiro); // Valor do punteiro, un enderezo de memoria
    printf("\tEnderezo:\t\t%p\n",&punteiro); // Enderezo de memoria en que se garda o punteiro
    printf("\tTamaño:\t\t%d bytes\n",sizeof(punteiro));
  printf("Espazo de memoria apuntado:\n");
    printf("\tValor:\t\t%d\n",*punteiro); // Valor ao que sinala o punteiro
    printf("\tEnderezo:\t\t%p\n",&(*punteiro)); // Enderezo, que debería coincidir co valor do punteiro
    printf("\tTamaño:\t\t%d bytes\n",sizeof(*punteiro));
  
  // Liberamos a memoria reservada para o punteiro (este paso é obrigatorio)
  free(punteiro);
  
  // Saída normal do programa
  return 0;
}

O programa debería permitirnos comprender a diferencia entre o punteiro e o dato ao que apunta. Cómpre copiar o código nun ficheiro de texto, compilalo e executalo. Un posible resultado sería o seguinte:

Punteiro:
        Valor:          0x1104010
        Enderezo:       0x7fff9f9b42e8
        Tamaño:         8 bytes
Espazo de memoria apuntado:
        Valor:          666
        Enderezo:       0x1104010
        Tamaño:         4 bytes

Véxase tamén

stdlib.h contén funcións para traballar con punteiros e a memoria dinámica.

C
← Volver a Enumeracións	Punteiros	Seguir con Nomear tipos →