De Objective Caml para C e C++/Construção de tipos: diferenças entre revisões

Origem: Wikilivros, livros abertos por um mundo aberto.
[edição não verificada][edição não verificada]
Conteúdo apagado Conteúdo adicionado
Linha 371: Linha 371:


====O ponteiro nulo====
====O ponteiro nulo====

O ponteiro nulo é um valor comum a todos os tipos "ponteiro para". Corresponde a um endereço inválido, e interpretado como um inteiro é o valor 0. O arquivo <tt>stddef.h</tt> da biblioteca padrão de C contem uma definição do valor <tt>NULL</tt> como sendo o ponteiro nulo. Em C, esse arquivo pode ser utilizado com a diretiva
#include <stddef.h>
Em C++ pode ser utilizado com a diretiva
#include <cstddef>

Para qualquer variável ou <i>lvalue</i>, o endereço daquela variável (ou <i>lvalue</i>) é diferente do ponteiro nulo. Note que se aplicamos o operador de dereferenciamento a um ponteiro cujo valor é o ponteiro nulo, então haverá um erro de execução. Considere por exemplo o seguinte programa:
#include <cstddef>
int main ()
{
int * p = NULL;
* p = 0;
}
Na função <tt>main</tt>, é declarada uma variável <tt>p</tt> cujo tipo é ponteiro para <tt>tt</int>. O valor inicial é o ponteiro nulo. Na linha seguinte, ocorre uma atribuição do valor 0 a <tt>*p</tt>, que denota o trecho de memória apontado por <tt>p</tt>. Como <tt>p</tt> é o ponteiro nulo, ele corresponde a nenhum trecho de memória, e ocorrerá um erro de execução. Por exemplo, apareceu a seguinte mensagem de erro quando executamos o programa acima e a execução foi interrompida:
Bus error


====Confusões possíveis com os símbolos <tt>*</tt> e <tt>&</tt>====
====Confusões possíveis com os símbolos <tt>*</tt> e <tt>&</tt>====

Revisão das 13h39min de 6 de agosto de 2007

Conceitos iniciais Ficheiro:2de8.png

As linguagens C e C++ possuem muitos mecanismos para construir e estruturar dados complexos. Diferentemente dos tipos básicos, onde há uma forte correspondência entre essas linguagens e a linguagem Objective Caml, a construção de tipos complexos em C e C++ é bem diferente daquela provida por Objective Caml. Esse capítulo não aborda a construção de tipos via classes de objetos, que é um paradigma presente nas linguagens Objective Camle e C++, mas que é ausente da linguagem C.

O sistema de tipos de C e C++ é bastante complexo e, em prol da lisibilidade desse texto, algumas aproximações e simplificações foram realizadas. Apresentaremos as seguintes construções para a criação e manipulação de tipos complexos:

  • Enumerações correspondem a uma forma muito básica de tipos variantes de Objective Caml.
  • Arranjos correspondem aos arranjos de Objective Caml, embora sejam objetos muito mais simples. A linguagem C++ provê, através da sua biblioteca, uma outra implementação de arranjos que tem um nível de abstração mais próximo ao dos arranjos de Objective Caml.
  • Registros correspondem aos tipos registros de Objective Caml.
  • Ponteiros correspondem às referências de Objective Caml.
  • As referências, presentes apenas na linguagem C++, não tem correspondência direta em Objective Caml, embora possam ser simuladas por ponteiros, logo pelas referências de Objective Caml.
  • As uniões correspondem aproximadamente aos tipos variantes de Objective Caml, embora não sejam tão práticas para serem manipuladas.
  • Enfim, terminaremos com a apresentação dos tipos funcionais, que existem em C e em C++. Embora não sejam tão flexíveis quanto os tipos funcionais de Objective Caml, permitem ainda programação de ordem superior.

Vale destacar que em C e em C++, pode-se dar um nome a um tipo, utilizando a seguinte construção, ou alguma variação:

typedef expressaodetipo nome;

Por exemplo, podemos definir um tipo chamado inteiro que é idêntico ao tipo básico int com a seguinte construção:

typedef int inteiro; // exemplo de definição de um tipo chamado "inteiro", que nada mais é que o tipo int

Então a mais simples expressão de tipo que exista é um nome de um tipo básico, ou de outro tipo que já foi definido dessa forma. Uma vez definido um nome para um tipo, ele pode ser usado para declarar variáveis ou funções da mesma forma que os tipos básicos. Por exemplo:

inteiro soma3 (inteiro a, inteiro b, inteiro c) // exemplo (artificial) onde usamos um nome de tipo definido por nós
{
  inteiro resultado = a;
  resultado += b;
  resultado += c;
  return resultado;
}

Também pode ser utilizar uma expressão de tipo diretamente na declaração de uma variável. Assim esse código:

struct Spoint { // nesse exemplo, usamos uma expressão de tipo registro, detalhes sobre essa construção seguem mais adiante
  double x;
  double y;
} point; // point é uma variável cujo tipo é um tipo registro struct Spoint

é equivalente a

typedef struct Spoint {
 double x;
 double y;
} Tpoint; // definimos Tpoint como o nome de um tipo registro struct Spoint
Tpoint point; // point é uma variável cujo tipo é Tpoint, ou seja o tipo registro struct Spoint

Enumerações Ficheiro:3de8.png

Com relação ao sistema de tipos de Objective Caml, os tipos enumerados lembram de forma superficial os tipos variantes. Os tipos enumerados são porém muito mais limitados, e correspondem mais precisamente a tipos variantes onde as alternativas devem ser todas constantes.

Um tipo enumerado contem um número finito de valores. Cada valor tem um nome que o identifica. Por exemplo a seguinte definição:

enum Ecor {vermelho, azul, amarelo};

introduz um tipo enumerado, que possui como rótulo Ecor, e três enumeradores, que são valores inteiros constantes com identificadores vermelho, azul, amarelo.

Pode-se dar um nome a esse tipo, utilizando uma definição de tipo:

typdef enum Ecor {vermelho, azul, amarelo} Tcor;

Em seguida, podemos declarar e utilizar variáveis com esse tipo, e os valores que foram introduzidos na operação podem também aparecer no programa, onde serão consideradas como valores inteiros. Segue um trecho de programa que utiliza a definição acima:

void imprime_cor_em_ingles (Tcor c) // o parâmetro poderia também ter sido declarado como enum Ecor c
{
  switch (c1) {
    case vermelho:
      printf("red");
      break;
    case azul:
      printf("blue");
      break;
    case vermelho:
      printf("amarelo");
      break;
  }
}

Afirmamos que um valor inteiro é associado a cada valor de uma enumeração. Podemos realizar essa associação de forma implícita ou explícita. A forma explícita é realizada associando o número inteiro na definição da enumeração, como demostrado no seguinte exemplo:

enum Edirecao { norte = 0; oeste = 90; sul = 180; leste = 270 };

Caso não aparece associação explícita, a associação é realizada de maneira implícita, utilizando as seguintes regras: o primeiro valor da enumeração recebe o valor zero, e um valor que não está na primeira posição é associado com a soma de um com o inteiro associado ao valor anterior.

Finalmente, podemos também misturar as associações explícitas e implícitas, como no seguinte exemplo:

enum Ecodigo { NO_ERROR = 0; IO_ERROR = 10; FORMAT_ERROR; TIMEOUT_ERROR };

Nesse exemplo, FORMAT_ERROR e TIMEOUT_ERROR denotam respectivamente os inteiros e .

Exercício

Considere o seguinte tipo de dados definido em Objective Caml

type card_suit_t = Spades | Hearts | Diamonds | Clubs

Define um tipo equivalente em C/C++.

Arranjos Ficheiro:3de8.png

A linguagem C permite declarar arranjos uni-dimensionais, dando as seguintes informações: o tipo dos elementos, e o tamanho do arranjo. Por exemplo, o seguinte código define uma variável notas para guardar quatro valores do tipo float, utilizaremos o seguinte código:

float notas [4];

Portanto a sintaxe consiste em identificar o tipo dos elementos, através de uma expressão de tipos, o nome do arranjo, e entre colchetes o tamanho do arranjo.

Opcionalmente, podemos associar um valor inicial aos elementos do arranjo assim definido. Há duas possibilidades

  • Para definir o mesmo valor em todas as posições do arranjo, colocamos apenas o valor do primeiro elemento. Por exemplo, o código seguinte corresponde à definição de um arranjo similar ao exemplo anterior, mas onde todas as posições do arranjo armazenam o valor :
float notas [4] = { 0.0f };

Portanto a sintaxe exige que a expressão de inicialização seja colocada entre chaves.

  • Também pode-se definir individualmente cada posição do arranjo. Isso é realizado colocando entre chaves, a enumeração dos valores do arranjo. O exemplo seguinte portanto é equivalente ao anterior:
float notas [4] = {0.0f, 0.0f, 0.0f, 0.0f};

A sintaxe exige que os elementos da inicialização sejam separados por vírgulas.

Operadores sobre arranjos

C e C++ oferecem a possibilidade de acessar cada posição do arranjo individualmente. Como em Objective Caml, o endereço da primeira posição é e as demais posições são obtidas somando um à anterior. Por exemplo, o código seguinte declara um arranjo e inicializa todas as suas posições em seqüência.

float notas [4];
notas[0] = 0.0f;
notas[1] = 0.0f;
notas[2] = 0.0f;
notas[3] = 0.0f;

Evidentemente, uma repetição for é uma construção particularmente adequada para percorrer todas as posições de um arranjo. Por exemplo:

float notas [4];
for (int i = 0; i < 4; ++i)
  notas[i] = 0.0f;

Objective Caml possui uma função que, aplicada a um arranjo, retorna o número de posições do arranjo. Isso não existe nem C nem em C++ (C++ tem uma outra implementação de arranjo, chamada vector que tem essa funcionalidade; será apresentada mais adiante). Objective Caml possui também mecanismos para verificar que o acesso aos arranjos é realizado dentro dos limites. C e C++ não oferecem esses mecanismos, e podemos perfeitamente escrever o seguinte programa:

#include <cstdio>
int main ()
{
  int arranjo[2] = {1, 2};
  arranjo[2] = 3;
  printf("arranjo[0] = %i, arranjo[1] = %i, arranjo[2] = %i\n", arranjo[0], arranjo[1], arranjo[2]);
}

Observe que a função main inclui a definição de uma variável arranjo, com duas posições armazenando valores do tipo int. As posições válidas portanto são e . O programa realiza um acesso em escrita na posição , portanto fora dos limites e também um acesso em leitura. Utilizando g++ versão 4.0.1, esse programa é compilado sem erro (nem aviso). Ele pode até ser executado! E funciona! Olhe:

daviddeharbe $ g++ -Wall prog.cpp -o prog
daviddeharbe $ ./prog
arranjo[0] = 1, arranjo[1] = 2, arranjo[2] = 3

Então o programa está correto? Claro que não. Nessa oportunidade ele executou normalmente, mas pode ser que em alguma outra plataforma, tenha um erro em tempo de execução. Nesse exemplo, é bastante fácil detectar esse erro lendo o código, mas em programas mais extensos essa tarefa de verificação por leitura é muito mais difícil.

Esse pequeno programa ilustra uma diferença de filosofia entre as linguagens C e C++ de um lado, e a linguagem Objective Caml do outro. As primeiras privilegiam o desempenho em tempo de execução, mas não oferecem suporte para verificações elementares, criando grandes riscos do que erros passam despercebidos durante muito tempo até eles causarem problemas. Objective Caml, do outro lado, é muito mais rigorosa, e aplica um maior número de regras, tanto em tempo de compilação, quanto em tempo de execução. A implementação em Objective Caml de um dado algoritmo, será mais lenta que a implementação em C ou em C++, mas em compensação, oferecerá muito mais garantias de correção e de segurança.

Arranjos como parâmetros de funções

Nas linguagens C e C++, como em Objective Caml, os parâmetros são passados por valor. Isso significa que quando uma função é chamada, as variáveis que correspondem aos parâmetros formais da função comportam se como se fossem variáveis locais ao corpo da função que são inicializadas com o valor dos argumentos que foram utilizados para chamar essa função.

No caso dos arranjos, o parâmetro formal é o mesmo arranjo que o argumento efetivo da chamada da função. O seguinte exemplo ilustra essa particularidade:

#include <cstdio>
void swap1 (int i, int j)
{
  int tmp = i;
  i = j;
  j = tmp;
}
void swap2 (int tab[2])
{
  int tmp = tab[0];
  tab[0] = tab[1];
  tab[1] = tmp;
}
int main ()
{
  int a = 1, b = 2;
  printf("antes: a = %i, b = %i\n", a, b);
  swap1(a, b);
  printf("depois: a = %i, b = %i\n", a, b);
  int arranjo[2] = {1, 2};
  printf("antes: arranjo[0] = %i, arranjo[1] = %i\n", arranjo[0], arranjo[1]);
  swap2(arranjo);
  printf("depois: arranjo[0] = %i, arranjo[1] = %i\n", arranjo[0], arranjo[1]);
}   

A execução desse programa resultará na seguinte impressão na saída padrão

antes: a = 1, b = 2
depois: a = 1, b = 2
antes: arranjo[0] = 1, arranjo[1] = 2
depois: arranjo[0] = 2, arranjo[1] = 1

Resumidamente, a explicação disso é que, em C e C++, um arranjo corresponde ao endereço da primeira posição do arranjo. Quando a função swap2 é chamada com o argumento arranjo, o endereço da primeira posição de arranjo é copiada para tab, que passa a ter então a sua primeira posição nesse endereço. Logo tab[0] e tab[1] são respectivamente idênticos a arranjo[0] e arranjo[1].

Arranjos como resultados de funções

As linguagens C e C++ não permitem que o tipo de retorno de uma função seja um tipo arranjo. Uma possibilidade para contornar essa limitação é ter um parâmetro a mais que será atualizado no corpo da função. O exemplo seguinte ilustra essa técnica.

Um primeiro exemplo

O seguinte programa provê uma implementação em C++ de um algoritmo que calcula e imprime os números primos até um certo valor . Esse algoritmo é conhecido como o crivo de Eratosthenes.

// programa que lê um número n da entrada padrão e imprime na saída padrão todos os números primos até n
// implementa o crivo de Eratosthenes
#include <cstdio>

Observe que o exemplo inclui uma função tal que um dos parâmetros é um arranjo de booleanos.

void compute_primes (bool sieve[], int n) // preenche o crivo de 0 até n-1
{
  sieve[0] = sieve[1] = false;
  for (int i = 2; i * i < n; ++i) {
    if (sieve[j]) {
      for (int j = i + i; j < n; j += i) {
        sieve[j] = false;
      }
    }
  }
}
int main ()
{
  int i, n;
  scanf("%d", &n);
  if (n < 2) return;
  bool sieve [n+1] = {true};
  compute_primes(sieve, n+1);
  for (int i = 2; i < n+1; ++i) {
    if (sieve[i]) printf("%d ", i);
  }
  printf("\n");
}

Detalhes sobre o crivo podem ser obtidos em: Weisstein, Eric W. "Sieve of Eratosthenes." From MathWorld--A Wolfram Web Resource. http://mathworld.wolfram.com/SieveofEratosthenes.html

Arranjos multi-dimensionais

Como em Objective Caml, um arranjo de dimensão de valores de um tipo t podem ser implementados em C e em C++ usando um arranjo de arranjos de dimensão de valores do tipo t.

Uma matriz bi-dimensional de inteiros, de dimensão por , pode então ser declarada como:

int matriz [n][m];

Um segundo exemplo

float media (float tab[], int n) // calculo da media de um arranjo tab de floats de tamanho n.
{
  float sum = 0.0f;
  for (int i = 0; i < n; ++i)
    sum += tab[i];
  return sum/n;
}
int main()
{
  int n;
  cin >> n; // o numero de alunos e lido
  if (n == 0) return 0;
  float notas[3][n];
  for (int i = 0; i < n; ++i) // para cada aluno
    cin >> notas[0][i] >> notas[1][i] >> notas[2][i]; // ler as tres notas e guardar no arranjo notas
  for (int i = 0; i < 3; ++i) { // calculo e impressao da media de cada prova
    cout << "A media da " << i << "a prova e " << media(tab[i], n) << endl;
  }
}

Tipos registros

Um tipo em c++ é parecido com o tipo registro em ocaml e sua sintaxe è:

struct NOME {
 Corpo
 };

Onde NOME é o nome do tipo a ser criado e Corpo será oque ele deverá armazenar exemplo:

struct ponto {
 int x;
 int y;
 }

Isso criaria um tipo ponto que armazanaria 2 valores inteiros e equivaleria ao seguinte codigo escrito em ocaml:

type ponto = { x : int ; y : int };;

E para acessar os campos é a mesma coisa que em ocaml nome do tipo seguido do campo exemplo :

ponto a;
a.x = 3;
a.y = 4;

Isso faria uma varivel a do tipo ponto com x = 3 e y = 4.

Ponteiros

Introdução

Uma variável C/C++ é a abstração de um trecho de memória que guarda um valor de um certo tipo, onde um trecho de memória é uma seqüëncia de posições contíguas na memória. Um trecho de memória é definido pelo endereço da primeira posição e o número de posições no trecho. Mais precisamente, qualquer lvalue (variável, campo de variável de tipo registro, posição de variável de tipo arranjo) é a abstração de um trecho de memória. Na seqüência, empregaremos o termo variável ao invés de lvalue.

Para cada variável, o compilador deve associar algum trecho de memória para aquela variável. Para evitar qualquer problema de superposição e conflito, se o escopo de duas variáveis tem alguma interseção, os trechos de memória aos quais essas variáveis correspondem devem ser disjunAssim, uma variável de tipo long long int vai corresponder a um trecho de oito bytes na memória. O tamanho do tipo vai então depender diretamente do tipo de dados a ser representado. Por exemplo, quando temos um tipo registro, o tamanho de memória necessário para a representação de valores desse tipo é a soma dos tamanhos para representar cada campo do registro. Quando temos um tipo arranjo, o tamanho de memória necessário é igual a produto do número de elementos do arranjo com o tamanho necessário para armazenar cada elemento do arranjo.

As linguagens C e C++ possuem um operador unário, prefixado, nomeado sizeof que, aplicado a uma variável, ou a uma expressão de tipo (entre parênteses), retorna o tamanho em bytes do trecho de memória necessário para representar essa variável, ou valores do dado tipo. O pequeno programa seguinte ilustra os conceitos discutidos:

#include <cstdio>
int main ()
{
  int a;
  struct point {
    double x;
    double y;
  } p;
  float tab [4];
  printf("tamanho de a = %lu\n", sizeof a);
  printf("tamanho de p = %lu\n", sizeof p);
  printf("tamanho de p.x = %lu\n", sizeof p.x);
  printf("tamanho de p.y = %lu\n", sizeof p.y);
  printf("tamanho de tab = %lu\n", sizeof tab);
  printf("tamanho de tab[0] = %lu\n", sizeof tab[0]);
  printf("tamanho de tab[1] = %lu\n", sizeof tab[1]);
  printf("tamanho de tab[2] = %lu\n", sizeof tab[2]);
  printf("tamanho de tab[3] = %lu\n", sizeof tab[3]);
}

A execução desse programa resulte na seguinte impressão na saída padrão:

tamanho de a = 4
tamanho de p = 16
tamanho de p.x = 8
tamanho de p.y = 8
tamanho de tab = 16
tamanho de tab[0] = 4
tamanho de tab[1] = 4
tamanho de tab[2] = 4
tamanho de tab[3] = 4

O operador de endereço

Em C e C++, há um operador que permite saber qual o endereço do trecho de memória associado a uma variável: é o operador &. É um operador unário, e é prefixado. Segue um pequeno programa que ilustra o uso desse operador.

#include <cstdio>
int main ()
{
  int a;
  struct point {
    double x;
    double y;
  } p;
  float tab [4];
  printf("endereco de a = %p\n", &a);
  printf("endereco de p = %p\n", &p);
  printf("endereco de p.x = %p\n", &p.x);
  printf("endereco de p.y = %p\n", &p.y);
  printf("endereco de tab = %p\n", &tab);
  printf("endereco de tab[0] = %p\n", &tab[0]);
  printf("endereco de tab[1] = %p\n", &tab[1]);
  printf("endereco de tab[2] = %p\n", &tab[2]);
  printf("endereco de tab[3] = %p\n", &tab[3]);
  printf("tab = %p\n", tab);
}

Observe que foi usada a diretiva de formatação %p para imprimir um endereço. A execução desse programa resulte na seguinte impressão na saída padrão:

endereco de a = 0xbffff8d8
endereco de p = 0xbffff8e0
endereco de p.x = 0xbffff8e0
endereco de p.y = 0xbffff8e8
endereco de tab = 0xbffff8f0
endereco de tab[0] = 0xbffff8f0
endereco de tab[1] = 0xbffff8f4
endereco de tab[2] = 0xbffff8f8
endereco de tab[3] = 0xbffff8fc
tab = 0xbffff8f0

Algumas observações devem ser feitas:

  • os endereços são impressos em base hexadecimal.
  • em um registro, campos sucessivos ficam em endereços sucessivos
  • o endereço de um registro é o mesmo endereço do primeiro campo do registro
  • em um arranjo, posições sucessivas ficam em endereços sucessivos
  • o endereço de um arranjo é o mesmo endereço da primeira posição
  • um arranjo nada mais é que o endereço da primeira posição desse arranjo (como discutimos no parágrafo sobre arranjos como parâmetros de funções).

O leitor atento e curioso pode então fazer a seguinte pergunta. No programa exemplo, quando aplico o operador de endereço a uma variável ou a qualquer lvalue, qual é o tipo dessa expressão? A resposta é que trata-se de um tipo ponteiro, para o qual reservamos o parágrafo seguinte.

Os tipos ponteiros

O conceito de ponteiro é fundamental em programação. Um valor de algum tipo ponteiro é o (endereço de) um trecho de memória que corresponde a alguma variável. Portanto um ponteiro é algo que indica onde fica algo, digamos então que aponta para algo. Se uma variável v tem o tipo t, a expressão &v é portanto uma expressão de tipo ponteiro para t, que é denotada t * (é o mesmo símbolo que o da multiplicação aritmética).

A sintaxe para declarar uma variável de um tipo ponteiro é a seguinte:

tipo * nome;

Nesse caso, nome é o nome da variável, e tipo é o tipo do valor que está na locação de memória apontada. Assim, o trecho de código seguinte fornece exemplos de uso dessa sintaxe:

int * a;
float x;
float * pf = &x;

Foram declaradas três variáveis:

  • A variável a é um ponteiro para um trecho de memória que guarda um valor do tipo int. Observe que não tem inicialização e o valor de a é qualquer. Como uma variável de qualquer tipo, a variável a deverá ser inicializada antes de ser lida, caso contrário o comportamento do programa é indefinido.
  • A variável x é uma variável não ponteiro, do tipo float.
  • A variável pf é uma variável de tipo ponteiro para float, ou float *. É inicializada com o endereço da variável x. Diz-se que pf aponta para x.

Oo símbolo * é associado a nome e não a tipo. Assim, se quisermos declarar mais de um ponteiro para o mesmo tipo de uma vez só, devemos repetir * antes de cada nome. Por exemplo:

int * p1, * p2;
Ponteiros e Objective Caml

Em Objective Caml, um conceito similar, embora mais geral, é o de referência. O conceito de referência OCaml corresponde ao de uma variável C/C++ e também ao de ponteiro. Assim, em OCaml, um valor de tipo int ref é alguma locação de memória que contem um valor do tipo int e que pode ser alterado (dizemos que é mutável). Ou seja é exatamente a mesma coisa que uma variável C ou C++ do tipo int. Tal variável pode ser lida em expressões e alterada com atribuições. O equivalente a um ponteiro C para um inteiro, ou seja a um valor do tipo int * seria, em OCaml, um valor do tipo int ref ref: corresponde à memorização de um local onde um inteiro é memorizado.

O operador de dereferenciamento

Dado um valor de algum tipo ponteiro, o operador de dereferenciamento permite acessar o valor do trecho de memória apontado. É um operador prefixado, que se escreve *. Se p é um valor de tipo t * (ponteiro para o tipo t), então a expressão * p é do tipo t. O valor dela é o valor guardado na memória no endereço guardado por p. Por exemplo, o seguinte trecho de código

int n = 42;
int * pi = &n;
printf("O valor apontado por pi é %i.\n", *pi);

resultará na impressão da seguinte mensagem na saída padrão:

O valor apontado por pi é 42.

O resultado do operador de referenciamento é um lvalue, significando que pode ser alvo de atribuição. Atribuir um valor a * p consiste em alterar o conteúdo do trecho de memória apontado por p. Por exemplo:

int n = 42;
int * pi = &n;
* pi = 44;
printf("O valor apontado por pi é %i.\n", *pi);
printf("O valor de n é %i.\n", *n);

resultará na seguinte impressão na saída padrão:

O valor apontado por pi é 44.
O valor de n é 44.

Efetivamente, n é uma variável que abstrai algum trecho de memória. pi é um ponteiro cujo valor é inicializado com o endereço desse trecho de memória. A atribuição a *pi resultará então em atribuição do trecho de memória apontado por pi, ou seja em atribuição da variável n.

O ponteiro nulo

O ponteiro nulo é um valor comum a todos os tipos "ponteiro para". Corresponde a um endereço inválido, e interpretado como um inteiro é o valor 0. O arquivo stddef.h da biblioteca padrão de C contem uma definição do valor NULL como sendo o ponteiro nulo. Em C, esse arquivo pode ser utilizado com a diretiva

#include <stddef.h>

Em C++ pode ser utilizado com a diretiva

#include <cstddef>

Para qualquer variável ou lvalue, o endereço daquela variável (ou lvalue) é diferente do ponteiro nulo. Note que se aplicamos o operador de dereferenciamento a um ponteiro cujo valor é o ponteiro nulo, então haverá um erro de execução. Considere por exemplo o seguinte programa:

#include <cstddef>
int main ()
{
  int * p = NULL;
  * p = 0;
}

Na função main, é declarada uma variável p cujo tipo é ponteiro para tt</int>. O valor inicial é o ponteiro nulo. Na linha seguinte, ocorre uma atribuição do valor 0 a *p, que denota o trecho de memória apontado por p. Como p é o ponteiro nulo, ele corresponde a nenhum trecho de memória, e ocorrerá um erro de execução. Por exemplo, apareceu a seguinte mensagem de erro quando executamos o programa acima e a execução foi interrompida:

Bus error

Confusões possíveis com os símbolos * e &

Até o momento, já vimos que o símbolo * possui três papeis diferentes nas linguagens C e C++. São eles:

  • operador de multiplicação para os diferentes tipos numéricos,
  • construtor de expressão de tipo ponteiro.
  • operador de dereferenciamento.

Também vimos dois papeis para o símbolo &, são:

  • operador de conjunção bit a bit,
  • operador de endereço.

Ainda tem um terceiro papel explicado mais adiante.

Para poder entender programas escritos nessas linguagens, é necessário então conhecer a existência desses diferentes papeis e saber identificar qual papel está sendo realizada por cada ocorrência destes símbolos. No caso do símbolo *, quando sucede a uma expressão de tipo e precede um nome, então é um construtir de tipo ponteiro. Quando precede um lvalue sem suceder a uma expressão de tipo, é o operador de dereferenciamento. Finalmente, quando está entre duas expressões numéricas, é o operador de multiplicação. No caso do símbolo &, quando precede um lvalue, sem suceder a uma expressão de tipo, é o operador de endereço. Quando está entre duas expressões inteiras, é o operador de conjunção bit a bit.

Aritmética de ponteiros

Tipos referências

Tipos uniões

Tipos funções