Enviado em 02/01/2015 - 00:11h
danielcrvg escreveu:
Na verdade, não é bem isso.
O fato incontornável é que C não possui um tipo específico para strings. Todo string em C
é um array de caracteres (podendo ser declarado como tal ou ser um bloco alocado dinamicamente e manipulado através de um ponteiro). A única coisa que distingue um vetor que contém um string de outro que é mera coleção de caracteres é a presença (ou a expectativa da presença) do terminador, que é um caráter de valor inteiro igual a zero.
char arr1[]="daniel";
A sintaxe de texto entre aspas é uma conveniência oferecida pela linguagem para simplificar a definição e o uso de arrays de caracteres constantes destinados a representar strings. Os caracteres entre aspas são dispostos sequencialmente na memória, e automaticamente sucedidos por um caráter nulo. Além disso, o tipo de uma expressão como
"daniel" (incluindo as aspas) é
endereço (ou ponteiro) para caráter , com a informação adicional de que esse caráter é o primeiro de um bloco de sete caracteres que constituem o array.
Bom agora vem minha duvida:
char xxx[]="daniel";
Aqui você cometeu um erro. O certo seria fazer
ptnome=xxx . Num outro tópico aberto por você aqui no fórum, eu disse que é errado usar o operador de obtenção de endereço de variável (
& ) sobre o nome de um array, porque esse nome não constitui uma variável, mas sim uma representação constante de um endereço.
No entanto, provavelmente o seu código compilou e até possivelmente rodou. Então que estória é essa que eu estou contando, de que não pode fazer do jeito como você fez?
Bom, esse é um daqueles lugares em que o C é um tanto obscuro. Se não entender parte do que eu vou apresentar, não se acanhe nem desista do C (essas coisas obscuras têm sua utilidade no momento certo -- que geralmente não é quando se é iniciante).
Existe um caso em que é válido aplicar
& sobre algo declarado com aspecto de array, que é quando o objeto declarado é parâmetro de função. Veja o exemplo.
void func(char param[10]){
A aparente doideira começa na já primeira linha: você diz que o parâmetro
param é um array de dez caracteres, mas o compilador entende que ele é um mero ponteiro para caracteres, e permite que você chame a função com um argumento array de caracteres de qualquer tamanho ou, na verdade, com qualquer ponteiro. Mas por quê?
Porque se o compilador exigisse que o argumento fosse declarado com o mesmo aspecto da declaração do parâmetro, isso impediria chamar a função com um argumento dinamicamente alocado. Dito de outro modo, se o fato de o parâmetro ter a forma de um array com dez elementos obrigasse os argumentos a serem arrays com dez argumentos, você não poderia ter o seguinte código -- ainda que ele seja logicamente válido.
char *dyn_array;
Então, a declaração da função
func (), acima, acaba fazendo com que a forma de array seja só um comentário de luxo, e normalmente é usada somente quando o número esperado de elementos tem de ser fixo. Na prática, ela é funcionalmente idêntica ao que se teria se a declaração tivesse sido a seguinte.
void func(*param)
Um dos aspectos dessa equivalência é o fato de que
param passa a ser uma variável ponteiro dentro da função. Como tal, não apenas o seu valor pode ser manipulado e alterado, mas também possui um endereço próprio, que pode ser obtido com
& . No entanto, a opção pela sintaxe de array tem uma implicação mais profunda, não apenas nesse código, mas sobre a linguagem como um todo.
A implicação é esta: se um parâmetro de função pode ser declarado como array e, ainda assim, pode receber a aplicação do operador
& , então qualquer array, declarado em qualquer parte do programa (quer como parâmetro, quer como variável estática, quer como variável automática, quer como campo de uma estrutura), também pode. Nos casos em que o nome do array
X com
N elementos não indicar uma variável (porque é constante), então o endereço resultando da expressão
&X deve ser idêntico ao endereço da expressão
X ;
entretanto, o tipo de &X não será igual ao tipo de X , mas sim “ponteiro para array com N elementos do mesmo tipo que X[0] ” . Então, se você tiver
int arr_int[15];
, terá que
arr_int e
&arr_int designam o mesmo endereço, mas o tipo de
arr_int é “array com 15 elementos inteiros”, ao passo que
&arr_int é do tipo “ponteiro para array com 15 elementos inteiros”.
(Eu não sei se existe uma justificativa plausível para tal comportamento, definido pelo comitê de padronização da linguagem C. Lendo as memórias do falecido Dennis Ritchie, criador do C, parece que duas linhas que orientaram o projeto original da linguagem C e dos primeiros compiladores foram a consistência de operações entre os diferentes tipos de dados, incluindo arrays e estruturas, e a construção de compiladores simples, que não impusessem limitações ao usuário ao custo de aumentar muito sua complexidade. No entanto, eu não creio que os princípios de Ritchie se apliquem nesse caso: tanto para transformar array na lista de parâmetros em ponteiros quanto para tratar não-variáveis como se variáveis fossem, o compilador tem de ter código especializado. Minha opinião pessoal é de aceitação sem entusiasmo do primeiro caso e radicalmente contrária ao segundo, porque cria inconsistência e abre espaço para erros acidentais.)
Dentro da função, eu trabalhei com três tipos de ponteiros: ponteiro para caracteres (
char * ), ponteiro para arrays de caracteres com dez elementos (
char (*)[10] ) e ponteiro para ponteiro de caracteres (
char ** ), e experimentei fazer atribuições a eles com os valores de
arr ,
param ,
&arr e
¶m .
Por razões históricas, o C é relativamente leniente com atribuições entre ponteiros de tipos diferentes (e, às vezes, até entre ponteiros e inteiros). É possível que você não receba erro ou aviso nenhum ao tentar compilar a função
func () que eu mostrei. É comum que alertas sobre essas operações só sejam mostrados se você usar certas opções de compilação que servem para identificar e alertar sobre código potencialmente perigoso (com o GCC, eu geralmente recomendo as opções “-Wall”, que habilita todos os avisos, “-Werror”, que transforma os avisos em erros, o que obriga a tratar os avisos recebidos, “-O2”, que ajuda a detectar variáveis não inicializadas ou blocos de código redundantes, e, às vezes, “-pedantic”, que avisa sobre construções que, apesar de válidas, poderiam dar problema se usadas com outro compilador).
Se você tiver compilado (sem as opções de diagnóstico) e tido a curiosidade de chamar a função
func (), provavelmente viu uma saída parecida com a seguinte.
p1=0x7fffdc074900
É interessante notar que os valores dos ponteiros
p1 ,
p2 ,
pac1 e
ppc1 são idênticos, embora
p1 tenha sido obtido de
arr e os demais a partir de
&arr . Isso difere do que ocorreu com
p3 ,
p4 ,
pac2 e
ppc2 , em que o primeiro recebeu o valor de
param , que é uma cópia do ponteiro (na verdade, um array constante) usado para invocar a função, e os outros recebem o endereço de onde o valor recebido ficou guardado durante a execução da função.
Compilando com as opções de diagnóstico que alertam a respeito ou inibem o uso leniente de ponteiros, pode-se ver as inconsistências.
$ gcc -Wall -Werror -o lixo lixo.c -std=c11
Se você compilar o seu programa com as mesmas opções, vai obter indicações de erro semelhantes.
printf("ENDENTENDO O BASICO SOBRE PONTEIROS\n"););
Esse “++” depois de [i]ptnome2 parece estar sobrando. Não creio que ele se adeque ao que você quer imprimir.
[quote]
}
Na primeira parte eu apenas imprimi na tela valores, enderecos de memoria, etc apenas para manipular os ponteiros..
Ai quando eu resolvi imprimir o vetor de char que me bateu a duvida:
Se o char tem apenas 1 byte, pq o seu endereco de memoria esta sendo de 2 em 2, ao inves de ser de 1 em 1 ??
Respondido acima.
Tipo uma string mesmo com 1 caracter tem tamanho dois, por que é o caracter + o 'barra0' delimitador do tamanho certo?
Veja a explicação lá em cima sobre o uso conveniente de texto entre aspas.
