C/Punteiros: Diferenzas entre revisións
Contido eliminado Contido engadido
Ampliación importante do artigo |
|||
Liña 3:
Os punteiros son un tipo de variables que non conteñen un valor ou valores, senón que conteñen un enderezo de memoria. Neste enderezo de memoria é onde residen os valores, mentres que o punteiro será simplemente un enderezo. Hai que aprender a traballar tanto co valor que contén o punteiro (o enderezo de memoria) como co valor do espazo de memoria sinalado polo punteiro.
==Declaración
Para declarar un punteiro, sitúase na declaración da variable un asterisco ('''<code>*</code>''') entre o tipo de dato e mailo identificador da variable. A sintaxe fundamental da declaración dun punteiro é a seguinte:
<source lang=c>
</source>
Onde:
Considérase unha boa práctica [[{{BASEPAGENAME}}/Variables#Inicializar variables|''inicializar'']] os punteiros co valor nulo (<code>NULL</code>), entre outras cousas porque isto evita problemas con funcións coma [[{{BASEPAGENAME}}/realloc|<code>realloc()</code>]], usada para traballar con memoria dinámica.▼
:'''<code>tipo</code>''' é o tipo de dato ao que sinala o punteiro.
:'''<code>*</code>''' sinala que se trata dun punteiro.
:'''<code>identificador</code>''' é o identificador (nome) do punteiro.
===Identificador===
Ao elixir identificadores para punteiros, non sería mala idea seguir unha sintaxe fixa que permita ao que lea o código saber que unha variable é un punteiro tan só con ler o seu identificador.
Algúns programadores optan por prefixar ou sufixar os identificadores dos punteiros con algunha combinación de caracteres (coma <code>p</code>, <code>pt</code> ou <code>punt</code>).
===''Inicialización''===
▲Considérase unha boa práctica [[{{BASEPAGENAME}}/Variables#Inicializar variables|''inicializar'']] os punteiros co valor nulo (<code>NULL</code>)
===Punteiro a un punteiro===
Se ben a algúns lles resulta difícil comprender isto, pódese declarar un punteiro a un punteiro. Para facelo bastará con engadir á declaración un asterisco adicional. Vexamos un exemplo:
<source lang=c>
float * * punteiro_a_un_punteiro;
</source>
==Traballo con punteiros==
===Valor nulo===
O valor nulo nos punteiros escríbese <code>NULL</code>, non <code>0</code>. Asignándolle este valor a un punteiro, este deixa de apuntar a un enderezo de memoria. Queda baleiro. Vexamos como se lle dá o valor nulo a un punteiro:
<source lang=c>
punteiro = NULL;
</source>
===Tamaño===
Se queremos traballar ou asignarlle un valor ao espazo de memoria ao que sinala un punteiro (e non ao espazo de memoria que ocupa o punteiro), precédese o identificador do punteiro cun asterisco ('''<code>*</code>'''). Véxanse os seguintes exemplos:▼
O tamaño dos punteiros, o que ocupan en memoria, non ven dado polo tipo de dato especificado na [[{{PAGENAME}}#Declaración|declaración do punteiro]]. O tipo de dato da declaración corresponde ao tipo de dato ao que sinala o punteiro. O verdadeiro tamaño do punteiro, posto que o punteiro garda un enderezo de memoria, dependerá da memoria do sistema. Por tanto, nun mesmo sistema todos os punteiros terán o mesmo tamaño.
===Traballar co valor sinalado===
▲Se queremos traballar ou asignarlle un valor ao espazo de memoria ao que sinala un punteiro (e non ao espazo de memoria que ocupa o punteiro), precédese o identificador do punteiro cun asterisco ('''<code>*</code>'''<ref name=operadores>Disto xa se falara no capítulo sobre [[{{BASEPAGENAME}}#Operadores#Operadores aritméticos|operadores]].</ref>). Véxanse os seguintes exemplos:
<source lang=c>
*punteiro = 0; // Asígnaselle o valor 0 ao espazo de memoria sinalado
resultado = *punteiro_ao_primeiro_operando + *punteiro_ao_segundo_operando;
</source>
===Traballar cos enderezos doutras variables===
Mediante o símbolo '''<code>&</code>'''<ref name=operadores /> pode obterse o enderezo de memoria dunha variable que non sexa un punteiro, o cal pode resultar moi útil á hora de traballar con punteiros. Véxase o seguinte exemplo:
<source lang=c>
// Declaramos unha variable de tipo int:
int variable;
// Declaramos unha variable punteiro para recoller o
// enderezo de memoria en que se garda a variable:
int * punteiro;
// Ao choio:
punteiro = &variable;
// Agora "punteiro" sinala ao enderezo de memoria
// en que está gardada "variable".
</source>
===Matrices===
As [[{{BASEPAGENAME}}/Tipos de datos estruturados#Matrices|matrices]] non son máis que unha forma especial de traballar con punteiros. Unha matriz é en realidade un punteiro cuxo valor (o enderezo de memoria ao que sinala) non pode cambiar, e para o que se reserva un certo espazo en memoria estática ao declaralo ─que dependerá do tipo de datos e a cantidade deles que leve a matriz─.
Se se lle asigna a un punteiro "normal" o enderezo de memoria dunha matriz, poderase traballar co punteiro do mesmo xeito que se fai coa matriz.
==Programa de resumo==
Liña 56 ⟶ 103:
// Liberamos a memoria reservada para o punteiro (este paso é obrigatorio)
free(punteiro);
// Saída normal do programa
return 0;
}
</source>
Liña 70 ⟶ 120:
Tamaño: 4 bytes
</pre>
==Notas==
<references />
{{Navegador|Cadeas de caracteres|Tipos de datos estruturados}}
<!-- Categorías -->
[[Categoría:C|Punteiros]]
| |||