Sintaxe Ponteiros

Amigos, por favor, me corrijam onde eu estiver errado na sintaxe!

Vetor bidimensional:
int a[1][2]; = acesso à 3ª coluna da 2ª linha do vetor a
*((int *) a+12); = ponteiro p\ acesso à 3ª coluna da 2ª linha do vetor a

Aritimetica de ponteiro:
Precedência:
y = *p +1; = adiciona 1 ao valor da variavel apontada por p e atribui o valor à y
*p += 1; ou ++*p; = incrementa em 1 o valor da variavel apontada por p
*p++; = incrementa endereço do ponteiro p, pois expressão é
avaliada da direita p\ esquerda fazendo operador ++ ter precedência sobre *
(*p)++; = incrementa valor da variável apontada pelo ponteiro p, pois dá precedência de * sobre ++
p1 = p1 + 9; = incrementa ponteiro p1 em 9 endereços
return *p1 + 1; = soma um ao valor apontado por ponteiro p1
return *(p1 + 1); = incrementa o valor apontado por ponteiro p1 em um ou seu endereço?
int puts(const char *s) { = função puts() recebe argumento string
while(*s) putchar(*s++); = incrementa o endereço do ponteiro pois expressão é avaliada da direita p\ esquerda
return 1;
};

Ponteiros e Vetores:
char str[80], *p1;
p1 = str;
str[4]; ou p1+4; = acessa o 5º elemento do vetor str
str[4]; ou *(p1+4); = acessa o valor do 5º elemento do vetor str?
p1[j]; é o mesmo que *(p1 + j); = o ponteiro é indexado
int (*tab)[12]; = ponteiro p\ vetor tab de 12 int
int *tab[12]; = vetor tab de 12 ponteiros int

Ponteiros p\ funções:
int (*comp) (void*, void*); = declara ponteiro *comp p\ função c\ 2 argumentos void e retorna int
(*comp) (v[j], v[esq]); = chamada à função apontada por *comp
void (*options[ ]) (void) = { = declaração vetor de ponteiros de funções
...
};

Função retornando ponteiro:
int *comp(void*, void*); = declara função *comp que retorna ponteiro int

Conto c\ vcs.

Abraço à todos!

Eu não sou muito bom com ponteiros, vetores e afins. Mas...

Mas eu acho que você não pode declarar uma função com um * precedendo o seu nome.

E essa coisa de p1+4 = str[4] está errada, com certeza. Ou então eu não sei que era possível fazer uma coisa dessas.

Cara, seguinte...

1.
"return *(p1 + 1); = incrementa o valor apontado por ponteiro p1 em um ou seu endereço?"

Os parentesis tem precedencia maior, ai o que vai acontecer: Vai acontecer um incremento de 1 no endereço de p1 e a função vai retornar o valor desse novo endereço (isso normalmente gera erro..)

2.
while(*s) putchar(*s++); = incrementa o endereço do ponteiro pois expressão é avaliada da direita p\ esquerda

Esse tipo de loop sempre me confundia... Bom, o que ele faz é o seguinte:
while(*s)
Leia iss o como: enquando houver um valor no endereço atual de S....
puts(*s++);
Como isso é uma função, é lido da Esquerda para direita, então ele vai imprimir o valor do endereço atual e incrementar esse endereço logo em seguida...

3.
str[4]; ou p1+4; = acessa o 5º elemento do vetor str

Essa é legal... :) Bom... se você fizer o seguinte: printf("%c", str[4]); e printf("%c", p1+4); certamente notará que os resultados apresentados serão diferente... Então é fácil concluir que o que você afirmou é ERRADO. str[4] acessa o valor do 4° endereço de str, e d1+4 é o proprio endereço do 4° endereço de str. Complicado? Para testar.. rode esse programa que tudo se esclarecerá...
************************
ponteiros.c
************************
#include <stdio.h>

int main(void){
char s[6]="Slack\n";
char *d;
d = s;
printf("%c\n", s[2]); // valor do endereço de s[2]
printf("%p\n", (d+2)); // endereço de s[2]
printf("%p\n", &s[2]); // endereço de s[2]
printf("%c\n", *(d+2)); // valor do endereço de s[2]
}
*********************

4.
str[4]; ou *(p1+4); = acessa o valor do 5º elemento do vetor str

Essa está está certa... :)

5.
int (*tab)[12]; = ponteiro p\ vetor tab de 12 int
int *tab[12]; = vetor tab de 12 ponteiros int

Ambos são ponteiros para vetores INT. Não há diferençãs.

6.
void (*options[ ]) (void)

Cara... até onde tudo que eu já estudei.. eu nunca vi alguem citar declaração de vetor de funções... vc pode declara ponteiros pra vetores, ou até funções do tipo ponteiro pra ponteiro... mas seria algo do tipo:

int **função(void){...}

Eu sinceramente nunca vi nenhum programa usar esse tipo de declaração... Se um dia você ver, me mande o link... :) (brincadeiras à parte)

7.
int (*comp) (void*, void*); = declara ponteiro *comp p\ função c\ 2 argumentos void e retorna int
(*comp) (v[j], v[esq]); = chamada à função apontada por *comp

Saca só, você não precisa fazer com funções o que voce faz com variáveis... O int *funcao() significa que o valor de retorno da função vai ser um ponteiro para int, e não que para acessá-la você tem que fazer como se fosse um ponteiro para int....

comp(&v[j],&v[esp);
Lembre-se: Você está passando ENDEREÇOS.. Mais uma coisa... num declara função com ponteiro pra void não cara... eles são realmente chatos quando a noção de ponteiros é menor que a do Dennis M. Ritchie ou do meu amigo Brian K. :)

Cara... qualquer dúvida... é so postar denovo...
Abraços,
Espero ter ajudado,
Slackware_10

Aqui no VOL tem dois artigos muito bons sobre ponteiros void caso fique interessado...

Parte 1:
http://www.vivaolinux.com.br/artigos/verArtigo.php?codigo=994

Parte 2:
http://www.vivaolinux.com.br/artigos/verArtigo.php?codigo=1004

Té mais,
Qualquer duvida: enzo@veloxmail.com.br

Olá Slack, valeu a ajuda, o programa esclareceu bem!!

Em alguns topicos talvez vc não conheça bem alguns usos, vou esclarecer melhor:

5º)
int (*tab)[12]; // ponteiro p\ vetor c\ (12 int
não ponteiros)
int *tab[12]; // agora é um (vetor não ponteiro) de (12 ponteiros do tipo int)

6º) Um vetor de funções é mais rapido que um switch e pode substitui-lo. Cada elemento do vetor aponta p\ uma função. Ex de interface p\ interagir c\ um DB:
Ex. interface p\ DB:
void (*options[ ]) (void) = { /* declaração vetor de ponteiros de função */
enter, /* elementos */
del,
quit
};
int main(void) {
int i;
i = menu( ); /* função menu( ) é atribuída à i */
(*options[i]) ( ); /* menu( ) através de i serve de índice p\ vetor options( ) */
return 0;
}
int menu(void) { /* função menu( ) vai retornar int p\ main e será usado por options( ) */
char ch; /* char ch vai receber seleção do keyb em ASCII */
do { /* imprime as opções que serão os elementos do vetor */
printf(“1. Entrar\n”);
printf(“2. Apagar\n”);
printf(“3. Sair\n”);
printf(“Selecione um numero\n”);
ch = getche( ); /* recebe a seleção char */
} while(!strchr(“123”, ch));
/* enquanto não houver a 1ª ocorrência de algum char na string 123 */
return ch-49; /* retorna p\ main seleção char convertida p\ int. Subtrai ASCII um */
} /* Ex. 1 = ASCII 49. 49 - 49 = 0 = 1º elemento vetor */
void enter(void) { /* funções apontadas no vetor */
printf(“\nEntre”);
}
void del(void) {
printf(“\nApague”);
}
void quit(void) {
exit(0);
}

7º) Aqui nas funções são duas coisas diferentes:
int (*comp) (void*, void*); // ponteiro p\ função. Aponta p\ endereço inicial da função
int *comp(void*, void*){
return 0;
}; // vai retornar ponteiro do tipo int
O tipo void na declaração de parametros é um ponteiro generico que substitui qualquer tipo básico.

Peguei estas dicas no livro do Dennis Ritchie e no C completo e total (aquela biblia), porém como os ponteiros tem muitos usos e a sintaxe varia, acabei me confundindo um pouco.

Espero ter esclarecido.
Grande abraço!

Netwarrior,

Você pode sim(e é muito utilizado) declarar funções com o * antes do nome.
Isto serve para indicar que ela retornará um ponteiro do tipo especificado.

E sobre o s[4] ser a mesma coisa que *(p+4), se p==s também está corretissimo, assim como *(s+4) também é a mesma coisa.

Estas duas práticas são extremamente comuns no dia-a-dia de um programador C/C++. Posso dizer com segurança mesmo não sendo um(ainda, quem quiser me contratar me manda um e-mail hehehe).

Faça o teste:

qualquer_tipo s[8], *p;
int i;
p=s;
while(p<s+8){
printf("%d\n",*p);
p++;
}
p=s;
for(i=0;i<8;i++){
printf("%d\n",p[i]);
}
for(i=0;i<8;i++){
printf("%d\n",s[i]);
}
while(s<p+8){
printf("%d\n",*s);
s++;
}

No caso da função com * antes do nome(função do tipo ponteiro), nem precisamos escrever um exemplo... Estimo que no mínimo 10% das funções da libc retornem ponteiros. Exemplos: malloc, realloc, strtok, fopen, etc...

Valeu gente!!!
Agora que me familiarizei um pouco mais c\ a linguagem ficou + claro p\ mim.

Abraços!