C/Punteiros: Diferenzas entre revisións

Contido eliminado Contido engadido
Gallaecio (conversa | contribucións)
mSen resumo de edición
m Bot: Cambios estética
 
Liña 7:
Os punteiros son un tipo de variable que non contén un valor ou valores, senón 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 e mailo identificador da variable. A sintaxe fundamental da declaración dun punteiro é a seguinte:
<source lang=c>
Liña 18:
:'''<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#Declaración|''inicializar'']] os punteiros co valor nulo (<code>NULL</code>) para que se saiba que non se reservou aínda espazo en memoria para o enderezo de memoria ao que sinala o punteiro. Isto ademais evita problemas con algunhas funcións, coma [[{{BASEPAGENAME}}/stdlib.h#realloc|<source lang=c enclose=none>realloc()</source>]], usada para traballar con memoria dinámica.
 
=== 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>
Liña 32:
</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>
Liña 39:
</source>
 
=== Tamaño ===
O tamaño dos punteiros, o que ocupan en memoria, non ven dado polo tipo de dato especificado na [[#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 arquitectura do sistema operativo, xa que esta define a forma en que o procesador traballa coa memoria. Así, nun sistema de 32 bits, este será o tamaño do punteiro (32 bits = 4 bytes), e nun de 64 bits o tamaño será de 8 bytes.
 
=== 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. Véxanse os seguintes exemplos:
<source lang=c>
Liña 51:
</source>
 
=== Traballar cos enderezos doutras variables ===
Mediante o símbolo «<code>&</code>» 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>
Liña 68:
</source>
 
=== Punteiros a matrices ===
As [[{{BASEPAGENAME}}/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.
 
=== Matrices de punteiros ===
Pódense declarar matrices de punteiros. Vexamos un exemplo:
<source lang=c>
Liña 81:
Isto será unha matriz con 66 celas, cada unha das cales é un punteiro a un dato de tipo carácter ([[{{BASEPAGENAME}}/Tipos fundamentais#char|<source lang=c enclose=none>char</source>]]).
 
=== Operadores ===
Hai certos operadores que presentan, para o noso ben, un comportamento lixeiramente distinto cos punteiros do que presentan con outro tipo de variables.
* «<source lang=c enclose=none>punteiro++</source>» equivale a «<source lang=c enclose=none>punteiro = punteiro + sizeof(tipo)</source>».
* «<source lang=c enclose=none>punteiro--</source>» equivale a «<source lang=c enclose=none>punteiro = punteiro - sizeof(tipo)</source>».
* «<source lang=c enclose=none>punteiro = punteiro + número</source>» equivale a «<source lang=c enclose=none>punteiro = punteiro + número * sizeof(tipo)</source>».
 
Estes comportamentos especiais para punteiros permiten moverse comodamente por matrices de datos, etc.
Liña 91:
:''Nota: lémbrese que o “tipo” é o tipo de dato da que sinala o punteiro, xa que o punteiro non ten un tipo definido.''
 
== Programa de resumo ==
Cómpre comprender por riba o funcionamento do seguinte código, que amosa claramente o principio do funcionamento dos punteiros.
<source lang=c>
Liña 145:
</pre>
 
== Véxase tamén ==
* [[{{BASEPAGENAME}}/stdlib.h|<code>stdlib.h</code>]] contén funcións para traballar con punteiros e a memoria dinámica.
 
 
Liña 152:
 
<!-- Categorías: -->
 
[[Categoría:C ─ Variables|Punteiros]]