Revisión como estaba o 13 de marzo de 2010 ás 12:50 editar Gallaecio (conversa \| contribucións) 4.675 edicións Sen resumo de edición ← Edición máis vella		Revisión como estaba o 6 de agosto de 2010 ás 06:35 editar desfacer Gallaecio (conversa \| contribucións) 4.675 edicións Revisión inicial, continuará... Edición máis nova →
Liña 1: {{Navegador\|Tipos ~~de datos~~ fundamentais\|~~Punteiros~~Conversións de tipo}} {\| align="right" style="margin-left: 1em;" ~~==<code>signed</code> e <code>unsigned</code>==~~ \| __TOC__ A todos os tipos [[{{BASEPAGENAME}}/Tipos de datos fundamentais#Enteiros\|enteiros]] se lles pode poñer un modificador, coma un adxectivo que determina se os seus valores poderán ser ou non negativos. Noutras palabras, modifica o rango de valores que pode conter unha variable dese tipo. Estes modificadores son <code>signed</code> (valores negativos e positivos) e <code>unsigned</code> (só valores positivos). Por defecto, todos os tipos enteiros son de tipo <code>signed</code>. \|} <!-- Isto sitúa o índice á dereita --> Os modificadores son como adxectivos que se utilizan nas declaracións de variables para modificar as súas propiedades. ~~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:~~ ==Signo e lonxitude== Aos tipos [[{{BASEPAGENAME}}/Tipos fundamentais#Enteiros\|enteiros]] pódeselles engadir un modificador de signo, que permite establecer se a variable pode ou non conter valores negativos. Deste xeito, os rangos de valores dos tipos <source lang=c enclose=none>int</source> e <source lang=c enclose=none>char</source> poden modificarse. Os modificadores de signo son <source lang=c enclose=none>signed</source>, que indica que a variable pode conter números tanto negativos como positivos, e <source lang=c enclose=none>unsigned</source>, que indica que a variable só pode conter valores positivos, duplicando ─en realidade, ampliando na metade máis un─ a cantidade de valores positivos que pode conter. Para indicar se un tipo de dato vai ser <source lang=c enclose=none>signed</source> ─valor por defecto, non é preciso indicalo─ ou <source lang=c enclose=none>unsigned</source>, precédese o tipo da variable desa palabra na súa declaración, coma no exemplo: <source lang=c> signed int variable1; unsigned ~~long~~char variable2, variable3; </source> Facendo uso dos modificadores de signo e lonxitude pódense obter as seguintes combinacións: ~~==<code>const</code>==~~ <table border=1 cellspacing=0 cellpadding=5> <code>const</code> é un [[{{BASEPAGENAME}}/Cualificadores\|cualificador]] que, situado fronte ao tipo dunha variable na súa declaración, mantén para unha variable durante toda a execución do programa o valor co que esta se [[{{BASEPAGENAME}}/Variables#Inicializar variables\|''inicializa'']]. É dicir, non hai xeito de modificar o seu valor ao longo do programa. <tr style="text-align: center;"> <th>Modificadores</th> <th>Tipo</th> <th>Tamaño</th> <th>Rango de valores</th> <th>Declaracións alternativas</th> </tr> <tr> <td style="text-align: center;"><source lang=c enclose=none></source></td> <td style="text-align: center;"><source lang=c enclose=none></source></td> <td style="text-align: right;"></td> <td style="text-align: center;"></td> <td style="text-align: center;"><source lang=c enclose=none> </source></td> </tr> </table> ==<source lang=c enclose=none>const</source>== Mentres que a idea dunha variable que nunca cambia pode non parecer moi útil, hai boas razóns para usar <code>const</code>. Ademais dos beneficios mencionados no [[{{PAGENAME}}#define\|método anterior]] para declarar constantes simbólicas, moitos compiladores poden efectuar algunhas optimizacións nos datos ao saber que estes nunca van cambiar. Este modificador indica que o valor co que se ''inicializa'' unha variable non se pode modificar ao longo do programa. Aínda que isto pode non parecer moi útil, en certas situacións o seu uso cobra sentido, e permite a optimización do programa durante o proceso de compilación ─ao saber o compilador que o valor da variable non cambia─. En xeral trátase dun método máis elegante de definir valores constantes do que é utilizar as [[{{BASEPAGENAME}}/Directrices para o preprocesador#.23define\|directrices para o ''preprocesador'']]. Un exemplo podería ser a declaración de π (Pi) para poder usar o seu valor ao longo do programa: Por exemplo, se necesitas o valor de π (Pi). Nos teus cálculos, podes declarar a variable <code>const</code> <code>pi</code>, de xeito que un programa ou outra función escrita por outra persoa non pode cambiar o valor de <code>pi</code>: <source lang=c> const double pi = 3.14159; </source> Cómpre ter en conta que un compilador que siga a normativa estándar debería amosar unha alerta avisando do intento de cambiar o valor dunha variable deco ~~tipo~~modificador <~~code~~source lang=c enclose=none>const</~~code~~source>, mais despois de facelo, algúns compiladores poderían ignorar dito modificador ─é dicir, permitir o ~~cualificador~~cambio ~~<code>const</code>~~do valor da variable─. Así que ~~mellor~~cómpre ~~evitar~~ter o coidado de non intentar cambiarlle o valor á variable durante o código, non vaia ser que ose ~~consigamos~~consiga. ==<source lang=c enclose=none>static</source>== ~~==Outros modificadores==~~ Ao declarar unha función ou variable '''global''' como estática (<source lang=c enclose=none>static</source>) vólvese “interna”, ou o que é o mesmo, inaccesible dende o código fonte doutros ficheiros. 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. Ao declarar unha variable '''local''' como estática, créase coma calquera outra variable. Así e todo, ao saíren do [[{{BASEPAGENAME}}/Variables#Ámbito\|ámbito da variable]] (por exemplo, ao rematar o bloque para o cal é local) a variable permanece na memoria ata finalizar a execución do programa, conservando o seu valor. Aínda que este comportamento aseméllase ao das variables globais, diferéncianse destas en que as variables estáticas locais seguen a obedecer ás regras do ámbito e por tanto non pode accederse a elas dende fóra deste. ~~<tt>'''static'''</tt> pode ser ás veces unha palabra clave útil.~~ As variables declaradas coma <source lang=c enclose=none>static</source> ''inicialízanse'' co valor nulo (<code>0</code>) por defecto. 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. ==<source lang=c enclose=none>auto</source>== 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. Este modificador ─que en certos aspectos podería considerarse o ''alter ego'' do <source lang=c enclose=none>static</source>─ indica que a variable en cuestión debe ser “destruída” ao saír o programa do seu [[{{BASEPAGENAME}}/Variables#Ámbito\|ámbito]]. Dado que este é o comportamento por defecto das variables, o seu uso é completamente innecesario. ==<source lang=c enclose=none>extern</source>== ~~As variables declaradas coma <tt>static</tt> inicialízanse co valor nulo (<tt>0</tt>) por defecto.~~ Este modificador utilízase cando un ficheiro necesita acceder a unha variable noutro ficheiro que podería non estar incluído (<source lang=c enclose=none>#include</source>) no código fonte do programa. O modificador non crea espazo para unha nova variable, senón que fornece ao compilador información abondo para acceder á variable do ficheiro remoto. ~~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. ==<source lang=c enclose=none>volatile</source>== '''<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. Este modificador 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, dado que se non se definise unha variable como <source lang=c enclose=none>volatile</source> o compilador podería asumir que certas operacións relativas á variable pódense optimizar cando en realidade non poden. Este modificador resulta particularmente relevante ao traballarmos con sistemas integrados ─nos que o programa podería non ter un control total dunha variable─ e programación “de varios fíos”. <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. ==<source lang=c enclose=none>register</source>== '''<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>. Este modificador indícalle ao compilador que pode 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 sen necesidade de que se especifique no código fonte, polo que o uso deste modificador non adoita ser necesario. De feito moitos compiladores ignoran directamente este modificador. {{Navegador\|Tipos ~~de datos~~ fundamentais\|~~Punteiros~~Conversións de tipo}} <!-- Categorías: --> [[Categoría:C ─ ~~Tipos de datos~~Variables\|Modificadores]]

C/Modificadores: Diferenzas entre revisións