C/Modificadores: Diferenzas entre revisións
Contido eliminado Contido engadido
Nova páxina: {{Navegador|Tipos de datos derivados|Constantes literais}} A todos os tipos [[{{BASEPAGENAME}}/Tipos de datos fundamentais#Enteiros|enteiros]] se lles pode poñer un cualificador, com... |
Sen resumo de edición |
||
Liña 1:
{{Navegador|Tipos de datos derivados|Constantes literais}}
==<code>signed</code> e <code>unsigned</code>==
A todos os tipos [[{{BASEPAGENAME}}/Tipos de datos fundamentais#Enteiros|enteiros]] se lles pode poñer un
Para indicar se un tipo de dato vai ser <code>signed</code> (non é preciso indicalo) ou <code>unsigned</code>, precédese o tipo de variable desa palabra na súa declaración, coma no exemplo:
Liña 8 ⟶ 9:
unsigned long variable2, variable3;
</source>
==Outros modificadores==
Velaquí máis modificadores fornecidos polo estándar C para completar. Para o programador principiante poderán ser de utilidade <tt>static</tt> e <tt>extern</tt>. <tt>volatile</tt> resultaralle máis interesante aos programadores avanzados. <tt>register</tt> e <tt>auto</tt> son amplamente desprezados e non adoitan ser de interese para os programadores, sen importar o seu nivel.
<tt>'''static'''</tt> pode ser ás veces unha palabra clave útil.
Existe a falsa crenza de que o seu único propósito é o de facer que unha variable permaneza na memoria. Cando declaras unha función ou variable global como estática (<tt>static</tt>) vólvese interna. Non poderás acceder a esa función ou variable dende a palabra clave exterior dos outros ficheiros do teu proxecto.
Cando declaras unha variable local como estática, créase coma calquera outra variable. Así e todo, ao saíren do ámbito da variable (por exemplo, remata o bloque para o cal era local) a variable permanece na memoria, quedándose co seu valor. A variable permanece na memoria ata que remata o programa. Aínda que este comportamento aseméllase ao das variables globais, diferéncianse en que as variables estáticas seguen a obedecer ás regras do ámbito e por tanto non pode accederse a elas dende fóra deste.
As variables declaradas coma <tt>static</tt> inicialízanse co valor nulo (<tt>0</tt>) por defecto.
Podes utilizar <tt>static</tt> de, polo menos, dúas maneiras. Imaxinemos un código que forma parte do ficheiro <tt>gfile.c</tt>:
<source lang=c>
#include <stdio.h>
static int g = 0;
void arriba(void)
{
/* Asígnaselle o valor 0 a l cando se inicia o programa. Daquela o resto
* do programa ignora a liña (por exemplo, non se lle asigna o valor 0 a
* l cada vez que se chama a arriba()
*/
static int l = 0;
g++;
l++;
printf("Chamouse a arriba(). l= %2d, g= %2d\n", l , g);
}
void abaixo(void)
{
static int l = 0;
g--;
l--;
printf("Chamouse a abaixo(). l= %2d, g= %2d\n", l , g);
}
int main(void)
{
int i;
// Chama á función arriba 3 veces, e logo á función abaixo dúas.
for (i= 0; i < 3; i++)
arriba();
for (i= 0; i < 2; i++)
abaixo();
return 0;
}
</source>
A variable <tt>g</tt> é accesible a través de <tt>arriba</tt> e <tt>abaixo</tt> e mantén o seu valor. As variables <tt>l</tt> tamén manteñen o seu valor, pero hai dúas variables distintas en cada un dos ámbitos. As variables estáticas son un bo xeito de utilizar ''encapsulación'', un termo sacado do modo de pensar orientado a obxectos que ben significando non admitir a realización de cambios nunha variable agás por chamadas de funcións.
O programa producirá a seguinte saída:
<source lang=c>
Chamouse a arriba(). l= 1, g= 1
Chamouse a arriba(). l= 2, g= 2
Chamouse a arriba(). l= 3, g= 3
Chamouse a abaixo(). l= -1, g= 2
Chamouse a abaixo(). l= -2, g= 1
</source>
<tt>'''extern'''</tt> úsase cando un ficheiro necesita acceder a unha variable noutro ficheiro que podería non estar incluída (<tt>#include</tt>) directamente. Pero en realidade <tt>''extern''</tt> non crea espazo para unha nova variable, senón que fornece ao compilador de información abondo para acceder á variable remota.
'''<tt>volatile</tt>''' é un tipo de modificador especial que informa ao compilador de que o valor da variable podería cambiarse por entidades externas alleas ao propio programa. Isto é necesario para certos programas compilados con optimizacións -se non se definise unha variable como <tt>volatile</tt> o compilador podería asumir que certas operacións relativas á variable pódense optimizar cando en realidade non poden. <tt>volatile</tt> é particularmente relevante ao traballarmos con sistemas integrados (nos que o programa podería non ter un control total dunha variable) e aplicacións multifío.
<tt>'''auto'''</tt> é un modificador que especifica unha variable "automática" que se crea automaticamente ao estar no ámbito e se destrúe ao saír. Se pensas que isto semella o que levas facendo todo o tempo ao declarar unha variable, estás no certo: tódolos elementos dentro dun bloque son de maneira implícita "automáticos". Por esta razón, a palabra clave <tt>auto</tt> é máis a resposta a unha pregunta trivial que un modificador útil, e existen unha morea de programadores moi competentes que nin sequera están ao tanto da súa existencia.
'''<tt>register</tt>''' é unha chamada ao compilador para que intente optimizar o almacenamento da variable dada almacenándoa nun rexistro do procesador da computadora ao iniciar o programa. A maioría dos compiladores con optimización fano de todos xeitos, polo que o uso desta palabra clave non adoita ser necesario. De feito, ANSI C di que un compilador pode ignorar esta palabra clave se quere -e moitos fano. O Visual C++ de Microsoft é un exemplo dunha implementación que ignora completamente a clave <tt>register</tt>.
| |||