Enviado em 03/02/2022 - 22:44h
ApprenticeX escreveu:
Não é isso, não. E você tem de saber a diferença entre ponteiros para dados que são constantes e variáveis ponteiros que podem ser elas próprias constantes mas podem apontar para dados que não são constantes.
Compare as declarações abaixo.
int *pi; // Ponteiro (não-constante) para dado inteiro (não-constante).
Isso porque declarei elas como Ponteiro! Constantes porque foram alocadas em um endereço de memória e como o Ponteiro apenas aponta para um endereço, eu NUNCA poderei mudar os valores registrados e alocados na memória, o que faço apenas é apontar o Ponteiro para outro local sempre!
const int *Numbers[] = { 3, 0, 1, 8, 7, 2, 5, 4, 9, 6 }; // Constante pq declarei como um ponteiro. Certo?
As duas primeiras declarações estão erradas:
• você declarou
Numbers como um
array de ponteiros para inteiros constantes, mas tentou atribuir valores inteiros diretamente a cada elemento do
array , sendo que tais elementos são ponteiros (talvez algum compilador mais antigo ou com opções de compilação que o deixem mais tolerante a tipos incompatíveis deixe isso passar, providenciando a conversão implícita de cada valor inteiro na lista de inicialização para um valor absoluto de endereço correspondente, mas eu não creio que era isso que você queria que acontecesse);
• a declaração de
Number está com um erro de sintaxe (“
const *int ” não é uma construção permitida, e eu não sei se você quis dizer “
const int *Number ”, para declarar um ponteiro para valor inteiro constante, ou “
int *const Number ”, para declarar um ponteiro constante para valor inteiro (não-constante), mas, de um jeito ou de outro, a atribuição a esse ponteiro do valor inteiro
10 seria errônea.
Declarar alguma coisa como ponteiro não implica, por si só, nem que o ponteiro será constante nem que o objeto apontado será constante, então os comentários que acompanham cada declaração acima podem não fazer muito sentido.
Recapitulando, e quiçá esclarecendo, o que já foi dito acima e e em outros tópicos:
• Um ponteiro para dados constantes significa que o objeto referenciado não poderá ter seu valor alterado quando o acesso for feito por meio desse ponteiro, quer seja tal ponteiro contido numa variável ponteiro, quer seja obtido por avaliação de alguma expressão.
• Como caso particular, é perfeitamente válido ter um ponteiro para dados constantes apontando para um objeto que inicialmente não é constante, e isso significa, como dito explicitamente acima, que esse ponteiro, em particular, não poderá ser usado para modificar o objeto original.
• O contrário, isto é, um ponteiro para dados não-constantes referenciando um objeto que é constante, é que normalmente indica algum erro cometido no projeto ou na codificação do programa, ou pode induzir a erros de execução.
• Essa observação continua válida mesmo quando esse uso é tolerado pela linguagem, como é o caso particular, em C (mas não em C++), de ponteiros para caracteres (não-constantes) podendo receber valores provenientes de constantes literais
strings entre aspas.
/* 01 */ #include <stdio.h>
• Um ponteiro constante significa um valor constante para o endereço que ele indica, o que não necessariamente significa que o dado contido nesse endereço será constante: o tipo do dado apontado só vai ser considerado constante se você disser que ele o é.
char some_chars[]="abcde";
paulo1205 escreveu: Ponteiros funcionam como referências ou indireções, isto é, formas indiretas de chegar a um dado ou de referir-se a eles.
Então entendi que em muitos casos, não é o ideal usar ponteiros, o ideal mesmo então seria ter um tipo declarado e referenciado como é o caso das variáveis normais.
Como praticamente todos os recursos de uma linguagem de programação, você deve dar preferência a uma determinada funcionalidade quando ela for a melhor (ou, às vezes, a única) maneira de fazer aquilo que você precisa que seja feito.
Esses exemplos toscos em que se uma uma variável ponteiro para referir-se a uma variável escalar que foi declara numa linha logo acima ou num contexto muito semelhante não são a principal razão de ser de ponteiros. Eis os principais motivos pelos quais ponteiros são muito usados em C:
• Para evitar cópias de dados, sobretudo quando os dados envolvidos são muito grandes.
• Isso é particularmente verdadeiro quando você tem dados que são
arrays ou estruturas com vários campos e você quer passar tais dados como argumentos para funções. Em lugar de copiar dezenas, centenas ou mesmo milhares de bytes para cada argumento de um tipo composto ao chamar a função, você copia apenas o endereço de onde esses dados residem, e a função usa o endereço recebido para ter acesso aos dados que nele estão armazenados.
• Também no momento de retornar dados que ocupam muitos bytes, pode ser melhor retornar um ponteiro para uma estrutura,
array ou bloco de memória do que fazer uma cópia de um centenas ou milhares de bytes de dentro da função para o destino que reside fora dela.
• Porque não existe cópia direta de
arrays em C.
• Isso implica que sempre que um
array tiver de ser passado como argumento para uma função, não existe alternativa ao uso de ponteiros para receber esse parâmetro. Mesmo que você declare um parâmetro de função com aspecto de
array , até mesmo colocando um valor numéro entre colchetes para especificar a suporta quantidade de elementos). o compilador silenciosamente vai converter aquele parâmetro em ponteiro, e vai converter também o argumento que você usar quando invocar a função.
O que me fez pensar neste caso específico em C++, pois todas as janelas e objetos, usam ponteiros para acessá-las ao menos parece ser o padrão, mas também no caso da FLTK que estou estudando e vi exemplos aqui no VOL, ela pode usar as janelas sem serem ponteiros.
O C++ tem um recurso chamado referências, que não existe em C, e que são uma forma disfarçada de ponteiro na qual só é possível apontar objetos válidos, correspondentes a alguma variável. Quando você chama uma função cujos parâmetros são referências, a forma escrever os argumentos pode dar a entender que você os está passando por (cópia de) valor, mas o compilador automaticamente obtém os endereços dos argumentos e passa tais endereços.
Eu não conheço o FLTK, mas pode ser que esses objetos que você diz que não são ponteiros sejam justamente referências.
O que me fez pensar também em funções onde em seu cabeçalho muitas vezes usamos ponteiros, então seria melhor se possível não usar ponteiros e usar variáveis normais no lugar, isso seria o mais ideal, tipo:
void funcao(int vector[]) // Melhor assim
Ambos são absolutamente sinônimos e implicam que o parâmetro é um ponteiro para
int .
Há quem prefira usar a sintaxe com colchetes quando semanticamente fizer mais sentido chamar com um objeto que seja um
array , e com asterisco num caso mais geral, em que a relação dos eventuais argumentos com algum
array declarado como tal não for garantida ou garantidamente não existir. Mas isso é mera convenção, e nem tudo mundo usa (eu mesmo não uso: sempre uso apenas a sintaxe com asteriscos).
... Então Jesus afirmou de novo: “(...) eu vim para que tenham vida, e a tenham plenamente.” (João 10:7-10)
