|
numero=numero+1; // Podes mesmo asignarlle a unha variable o resultado dunha operación na que participa dita variable.
</source>
==<tt>sizeof</tt> ==
Se te xurde calquera dúbida respecto do uso de memoria que fai en realidade calquera tipo (e isto vai tamén por tipos que se explicarán máis adiante), podes utilizar o operador <tt>'''sizeof'''</tt> para descubrilo con exactitude. A súa sintaxe é:
<source lang="c">
sizeof object
sizeof(type)
</source>
As dúas expresións anteriores devolven o tamaño do obxecto e tipo especificado, en bytes. O tipo do dato devolto é <tt>size_t</tt> (definido na cabeceira <tt><stddef.h></tt>) que é un valor sen asignar. A continuación un exemplo do seu uso:
<source lang="c">
size_t size;
int i;
size = sizeof(i);
</source>
<tt>size</tt> pasará a ter o valor <tt>4</tt>, xa que o byte son 8 bits, e un enteiro son 32 bits. O valor do resultado de <tt>sizeof</tt> é o número de bytes.
Nótese que cando se aplica o <tt>sizeof</tt> a unha variable de tipo <tt>char</tt>, o resultado sempre é <tt>1</tt>. Isto é:
<source lang="c">
sizeof(char);
</source>
Sempre devolverá <tt>1</tt>.
==Modificadores do tipo de datos==
Pódese alterar o tipo almacenamento de datos ao precedelos de certos modificadores.
<tt>'''long'''</tt> e <tt>'''short'''</tt> son modificadores que fan posible que un tipo de datos use máis ou menos memoria. A palabra clave <tt>int</tt> non necesita ir tras as palabras clave <tt>'''long'''</tt> e <tt>'''short'''</tt>. Un <tt>short</tt> pode usarse onde os valores se atopan ao redor dun rango menor ca o dun <tt>int</tt>, normalmente de <tt>-32768</tt> a <tt>32767</tt>. Un <tt>long</tt> pode usarse para conter un rango estendido de valores. Non está garantido que un <tt>short</tt> use menos memoria ca un <tt>int</tt>, nin o está que un <tt>long</tt> use máis. O único garantido é que <tt>sizeof(short) <= sizeof(int) <= sizeof(long)</tt>. Normalmente un <tt>short</tt> ten 2 bytes, un <tt>int</tt> 4 bytes, e un <tt>long</tt> entre 4 e 8 bytes.
En todos os tipos descritos anteriormente, unha parte úsase para indicar o signo (positivo ou negativo) dun valor. Se decides que a variable nunca vai ter un valor negativo, poderías usar o modificador <tt>'''unsigned'''</tt> para usar esa parte para almacenar outros datos, dobrando así o rango de valores ao asegurar que estes serán positivos. O modificador <tt>unsigned</tt> tamén pode usarse sen necesidade de incluír o <tt>int</tt>, en cuxo caso o tamaño defínese coma o dun <tt>int</tt>. Tamén hai un modificador <tt>'''signed'''</tt> que fai o contrario, pero non é necesario, agás para certos usos de <tt>char</tt>, pois todos os tipos (agás o <tt>char</tt>) están predefinidos coma <tt>signed</tt>.
Para usar un modificador, simplemente declara a variable co tipo de datos e os modificadores relevantes:
<source lang="c">
unsigned short int e; // Completamente cualificado: unsigned short int
short logo; // short int
unsigned long pois; // unsigned long int
</source>
==Cualificador <tt>const</tt>==
Cando se usa o cualificador <tt>'''const'''</tt>, a variable declarada debe inicializarse ao declararse. A partires de entón non pode cambiar o seu valor.
Mentres que a idea dunha variable que nunca cambia pode non parecer moi útil, hai boas razóns para usar <tt>const</tt>. Por un lado, moitos compiladores poden efectuar algunhas optimizacións nos datos ao saber que estes nunca van cambiar. Por exemplo, se necesitas o valor de &pi. Nos teus cálculos, podes declarar a variable <tt>const</tt> de <tt>pi</tt>, de xeito que un programa ou outra función escrita por outra persoa non pode cambiar o valor de <tt>pi</tt>.
Teña 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 <tt>const</tt>, mais despois de facelo o compilador é libre de ignorar o cualificador <tt>const</tt>.
==Número máxicos==
Ao escribir programas en C, pode que che dé por escribir código que dependera de certos números. Por exemplo, poderías estar a escribir un programa para uns almacéns de comestibles. Este programa ten milleiros e milleiros de liñas de código. O programador decide representar o importe dunha lata de mexillóns, actualmente 71 céntimos, como un literal en todo o código. Agora imaxina que coa crise isto aumenta a 701 céntimos. O programador tería entón que cambiar manualmente as entradas de 71 polas de 701. Ben pensado, isto tampouco é un gran problema. Para algo temos o "Buscar e substituír todos". Pois ben, agora pensa que unha lata de sardiñas custa tamén 71 céntimos. Vas bo, rapaz, vaia choio que vas levar para comprobar a man cando é un e cando outro e substituír o que corresponda.
C posúe certa funcionalidade para evitar isto. As formas para facelo son case equivalentes, pero nalgúns casos será preferible usar un método concreto en detrimento doutro.
===<tt>const</tt>===
A palabra clave <tt>const</tt> axuda a eliminar os '''números máxicos'''. Ao declarar unha variable <tt>const latamexillons_marcax</tt> ao principio dun bloque, un programador pode limitarse a cambiar esa variable constante, e non se preocupar de establecer o seu valor en todos os lugares onde sexa preciso.
Tamén temos outro xeito de evitar os números máxicos. É moito máis flexible que o <tt>const</tt>, e tamén máis problemático en moitos aspectos. Ademais en lugar de implicar ao compilador, implica ao preprocesador.
===<tt>#define</tt>===
Ao escribir prorgamas, podes crear o que se coñece coma un ''macro'', de xeito que ao ler a computadora o teu código, substituirá todas as instancias dunha verba pola expresión especificada. Velaquí un exemplo:
<source lang="c">
#define custo_dos_mexillons
</source>
Isto serviría para se, por exemplo, para facer referencia ao custo dos mexillóns por <tt>custo_dos_mexillons</tt> en lugar de <tt>0.71</tt> (recorda que en inglés usan o punto ('''.''') para separar os decimais), de xeito que o precompilador buscará todos os <tt>custo_dos_mexillons</tt> para substituílos polo literal de tipo double <tt>0.71</tt>.
Hai que facer especial fincapé en que a funcionalidade do <tt>#define</tt> é a mesma que a do "Buscar e substituír" dos editores de texto. Para algunhas cousas, o <tt>#define</tt> pode ser nocivo, e por regra xeral é preferible usar o <tt>const</tt> se o <tt>#define</tt> non é imprescindible. Así mesmo, é aconsellable escribir as palabras <tt>#define</tt> en maiúsculas (<tt>CUSTO_DOS_MEXILLONS</tt>), para indicarlle ao resto dos programadores que se trata dun macro.
==Ámbito==
| 