O que é um apontador em C (type pointer in C)?

O que é um apontador em C (type pointer in C)? Um apontador é uma variável que contém um endereço de outra variável. int x = 10;//variável inteira iniciada com o valor 10 int *px = &x;//variável apontadora iniciada com o endereço de localização na memória do x Neste caso temos x, como uma variável que armazena um valor do tipo inteiro e px como um apontador ou ponteiro do tipo inteiro que que armazena o endereço da variável x do tipo inteiro. Se a variável fosse do tipo char o apontador teria de ser do tipo char. O valor do apontador armazenado em px é o endereço na memória da variável x, obtido com o operador &, i.e., o endereço de x é dado por &x. Definição de variável apontadora? type* nomevarapontadora; //o type são os estudados em C Operador & O endereço de uma variável é obtido através do operador &. Operador referenciação de memória. int a = 43; // um inteiro iniciado a 43 int* ptrint; // apontador para inteiro não iniciado ptrint = &a; // ptrint passa a guardar o endereço de a- faz referencia ao endereço de a /* definir e iniciar ptrint1 na mesma linha com &a */ int *ptrint1 = &a; //O valor de a, de *ptrin e de prtint1 referem-se o mesmo valor 43 Operador * O operador * permite aceder ao conteúdo de uma posição memória para onde a apontador aponta. Operador desreferenciação. int b; //definição da variável b que irá armazenar um valor inteiro //ptrint foi definido e iniciado no exemplo anterior com endereço de a b =*ptrint;//b é afectado com o valor 43 *ptrint = 12; //o conteúdo apontado (referido) por prtint é alterado com 12. O valor do a, //exemplo anterior é alterado de 43 para 12. #include <stdio.h> int main() { int y, x = 1; //declara dois inteiros, um com o valor 1 int *px; //px é apontador para int. Não está iniciado com qualquer endereço px = &x; //px fica com o valor do endereço de x y = *px;//y fica com conteúdo do endereço de memória apontado por px, o valor 1 *px = 0;//conteúdo da posição de memória apontador por px, a variável x, fica a 0 printf("x=%d y=%d\n", x, y); // output: x=0 y=1 int* p;//apontador não iniciado, mas quando for usado o conteúdo terá que estar *P=2; //usar "conteúdo de " antes de p iniciado com o "endereço de " dá ERRO

NOTA IMPORTANTE: inicie apontador com o endereço de.. antes de usar o seu conteúdo Uso de apontadores * O valor de retorno de uma função pode ser um ponteiro: int* blabla(); O parametros de uma função pode ser um ponteiro: int abcd(char* a, int* b); A prioridade de & e * é superior à dos operadores aritméticos. int y, x=2; // define y e x com valor de 2 int* px=&x; //define e inicia px com endereço de x y = *px + 1; //funciona como esperado. Incrementa o valor de ++*px; //incrementa o valor de x, em que x é a variável apontada por px; (*px)++; //(os parênteses são necessários). Como discutido em aulas anteriores, em C os parâmetros são passados por valor. Por exemplo, no seguinte caso, o comportamento não é o esperado, a troca de valores apenas ocorre no contexto da função, não se manifestando fora da mesma. void trocas( int a, int b ) { int aux = a; a = b; b = aux; Podemos no entanto passar a ter parâmetros definidos como apontadores que recebem dos argumentos os valores de endereços das variáveis passadas e dentro da função acedemos aos conteúdos das variáveis passadas, podendo deste modo alterar o seu valor. No exemplo anterior não é possível alterar os argumentos. void trocap( int* a, int* b ) {//recebe valores quer são endereços de int aux = *a; //acesso aos conteúdos através operação desreferenciação (*a) *a = *b; *b = aux; Neste caso, esta função deverá ser chamada da seguinte forma: int x = 5, y = 6; trocarp(&x, &y); // Os valores dos endereços de &x e de &y Podemos também passar em parâmetros um array e dois índices que recebem como argumentos os valores armazenados do array e os valores dos índices. Uma variável array é naturalmente um endereço de memória onde se armazena os valores e dentro da função acede-se aos conteúdos da variável array através dos índices. void trocaa( int a[], int p, int q ) {//recebe em a o array e em p e q os índices int aux = a[p]; //acesso ao conteúdo de a através do índice p a[p] = a[q]; a[q] = aux; //o mesmo que void trocaa( int* a, int p, int q ) {//recebe em a o array e em p e q os índices int aux = *(a+p); //a[p]; //acesso ao conteúdo de a através do índice p *(a+p) = *(a+q); *(a+q) = aux;

Ponteiro nulo / Endereço zero O ponteiro nulo representa ou referencia o endereço 0. int *prt = NULL; O NULL está definido em stdlib.h, pelo que é necessário incluir este ficheiro se quisermos utilizar o NULL. Em C existe uma relação estreita entre apontadores e vectores (array). #include <stdio.h> int main() { int a[6] = {1, 2, 3, 4, 5, 6; int *pa = a; printf("%d %d %d\n", a[2], *(a+2), *(pa+2)); O a é em particular um ponteiro para a primeira posição do vector. Notar que os ponteiros têm uma aritmética própria, quando fazemos pa+2 estamos a avançar na realidade 2*sizeof(int)bytes, ou seja, pa+2 aponta para uma posição de memória 2*sizeof(int) bytes depois da posição apontada por pa. Podemos efectuar quer a operação + quer a operação - sobre variáveis apontadoras. Ainda que exista uma relação estreita entre ponteiros e tabelas, devemos ter em conta que: ainda que a declaração int* p1; declare o mesmo que int p2[];, temos que p1 pode ser alterado, mas p2 não pode ser alterado e int p2[]; só pode ser utilizado em certos casos; a declaração int p3[100]; declara uma tabela com 100 inteiros e aloca memória na quantidade necessária; a declaração char *text; não aloca qualquer memória, no entanto char *text = "ola"; aloca. Qual a diferença entre as duas declarações seguintes? char t1[] = "ola"; char *t2 = "ola"; Ambas alocam 4 bytes e copiam para essa posição de memória a sequência de caracteres 'o','l','a','\0' Em ambos os casos é possível modificar o conteúdo da memória alocada. Não é possível alterar o valor de t1, ou seja não é possível por t1 a apontar para outra posição de memória. É possível alterar o valor de t2. Exercícios e exemplos Exercício 1: Seja float a[100]; float *p=a; Indique para cada uma das seguintes afirmações é verdadeira ou falsa: a[i] é equivalente a *(a+i) &a[i] é equivalente a a+i

a[i] é equivalente a p[i] p[i] é equivalente a *(p+i) *a, a[0] e a são equivalentes a p[0] Exemplo 1: Cópia de sequências de caracteres. void strcpy( char* s, const char* t ){ int i = 0 while( (s[i] = t[i])!= \0 ) i++; ou void strcpy( char* s, const char* t ){ while( (*s = *t)!= \0 ) { s++; t++; ou void strcpy(char *s, const char *t){ while( (*s++ = *t++) ); Exercício 2: Quando fazemos int a; scanf("%d",&a); o que estamos a passar ao scanf? E Porque não precisamos do & no seguinte caso? char s[100]; scanf("%s",s);/o s neste caso já é o endereço Exemplo 2: A passagem por referência consegue-se, porque é passado o apontador: void levector(int *v, int tamanho ) { int i; for( i=0 ; i<tamanho ; i++) scanf("%d", &v[i]); Podemos escrever int* v ou int v[]. Como v já é um endereço, podemos alterar o v dentro da função. Argumentos da linha de comandos int main( int argc, char* argv[] ) { int i; for(i=1; i<argc; i++ ) printf("%s ", argv[i]); printf("\n"); O argumento argc fica com o número de argumentos passados ao programa na linha de comando, argv[0] é o nome com que o programa fui invocado e argv[i] é i-ésimo argumento. Se o código acima for compilado e se o executarmos com a seguir se apresenta produz a escrita em terminal de: isel@linuxvm:~/exemplo$ teste hello world hello world

Alocação dinâmica de memória Até ao momento utilizámos sempre alocação estática: int tab[100]; Neste caso a memória é alocada durante o scope da variável, não é possível libertar a mesma quando já não é necessária, e não é possível utilizar a mesma fora do scope. A solução para ultrapassar estas limitações passa por utilizar alocação dinâmica. Função malloc void *malloc(size_t size); Esta função recebe como argumento o número de bytes o tipo size_t representa uma dimensão em bytes e devolve um apontado (endereço) para o primeiro byte do bloco de memória contígua alocada. O tipo de retorno void* indica um ponteiro para um tipo não especificado, o que permite a utilização desta função com qualquer tipo de dados. Posteriormente faz-se conversão para o tipo correcto por type cast. int *vec; vec = (int*) malloc(sizeof(int)*37); Função realloc void *realloc(void *ptr, size_t size); A função realloc recebe como argumentos um ponteiro ptr para bloco de memória já existente e a dimensão size que o novo bloco de memória deverá ter. Esta função devolve um ponteiro para novo bloco de memória e copia os valores do bloco antigo para o novo, em que se novo bloco for mais pequeno, só copia até caber, se o novo bloco for maior, copia tudo e deixa o resto sem ser inicializado. Se o argumento ptr for NULL, então a função realloc tem um comportamento idêntico ao da função malloc. Função free Para libertar memória podemos utilizar a função: void free(void *ptr); O argumento é um ponteiro para a primeira posição do bloco de memória contígua a libertar. Esta função não retorna nada. Como libertar a memória reservada com o malloc anterior? free(vec); Todas estas função estão definidas em stdlib.h, pelo que é necessário incluir este ficheiro (#include <stdlib.h> ).

Outras funções úteis Existem outras funções úteis para, por exemplo, inicializar a memória alocada ou para copiar segmentos de memória. De facto, a função void *calloc(size_t nelems, size_t size) permite tal como a função malloc alocar memória, neste caso para um vector com nelems elementos em que cada elemento tem size bytes, mas em que a memória é inicializada a zero. Em geral podemos inicializar qualquer segmento de memória com a função void *memset(void *s, int c, size_t n), definida em string.h, que inicializa os primeiros n bytes de memória apontada por s com o valor c. Qual deve ser o valor de c se quisermos inicializar um vector de inteiros com valor -1 em todas as entradas? A função void *memcpy(void *dest, const void *src, size_t n) é também útil para copiar segmentos de memória. Dados dois ponteiros src e dest para dois segmentos de memória sem sobreposição, esta função copia os primeiros n bytes apontados por src para os primeiros n bytes apontados por dest. É do programador a responsabilidade de garantir que não existe sobreposição entre os segmentos de memória e que os acessos de leitura e escrita ocorrem dentro dos limites da memória alocada. Exercício já resolvido: Envolve alocação dinâmica. #include <stdio.h> #include <string.h> #include <stdlib.h> int main() { char *str1=null, *str2=null; //definir e iniciar um array dinámico de char str1 = (char *)malloc(11); //10+1 (1 é para o \0) strcpy(str1, "ABCDEFGHIJ");//faz cópia para str1 de "ABC..J" //O str2 é NULL então esta função tem comportamento do malloc str2 = (char *)realloc(str2, 20);//20 é o tamanho do novo bloco. printf("endereço de str1= %p\n", str1); printf("endereço de str2= %p\n", str2); //Este novo bloco de memória tem a cópia dos valores do str1 que ocupa 11 chars str1 = (char *)realloc(str1, 200);//novo bloco de memória de tamanho 100 strcat(str1, " acrescentar ABCD"); printf("novo endereço de str1= %p\n", str1); printf("conteudo de str1= %s tamanho=%d\n", str1, strlen(str1)); char* s=strchr(str1,'z'); if( s== NULL ) printf("o Z não existe\n"); s=strchr(str1,'t'); if( s!= NULL ) printf("o t existe e a string a partir de t é =%s\n",s); free(str1);//libertar o bloco de memoria, porque não é mais necessário free(str2); Mais uma funções com uso de alocação dinâmica de memória //capacidade inicial 10 que vai crescendo com o factor de duplicação #define MAX 10 /*lê valores inteiros para o array a ser criado, preenchido e retornado por quem *chamar esta função. O total de valores é passado em parâmetro por referência. */ int* preencherarray(int* fact ){//fact recebe endereço-passagem por referência printf("digite inteiros e termine com uma letra\n"); int* v = malloc( sizeof(int)*(*fact) );//alocar um bloco de memória array v int i; for( i=0 ; ; i++ ) { if( scanf("%d", &v[i])!=1 ) break;//o for(;;) termina quando se digita letra if( i==*fact-1 ) { *fact *=2; //factor de duplicação v = realloc( v, sizeof(int)*(*fact) );//realocar novo bloco de memória *fact=i;//actualizar o parametro de referencia com o total return v; //retorna para quem chama este array de inteiros