C/Variables
En Wikibooks, o Galilibros en galego.
| C | ||
| ← Volver a Estrutura e estilo | Variables | Seguir con Expresións → |
Coma a maioría das linguaxes de programación, C é quen de usar e procesar as chamadas variables e mailo seu contido. As variables son simples verbas usadas para referirse a unha localización na memoria - unha localización pode conter un valor co que esteamos a traballar.
Axudaría pensar nas variables coma aquelas que lle gardan un sitio a un valor. Podes pensar nunha variable como aquilo que equivale ao seu valor. Polo tanto, se tes unha variable i que recibe o valor 4, entón i+1 será equivalente a 5.
Posto que C é relativamente unha linguaxe de programación de baixo nivel, antes de que un programa en C poida utilizar memoria para almacenar unha variable debe reclamar a memoria requerida para almacenar os valores desa variable. Isto faise ao declarar variables. Declarar variables é a forma que ten un programa en C para amosar o número de variables que precisa, o nome que van ter, e a cantidade de memoria que necesitarán.
Na linguaxe de programación C, ao manexar e traballar con variables, é importante coñecer o tipo de variables e o seu tamaño. Xa que C é unha linguaxe de programación de nivel bastante baixo, estes aspectos dos seu funcionamento poden ser específicos para cada hardware, é dicir, como a linguaxe está feita para traballar nunha tipo de computadora pode ser distinta de como é para traballar noutra.
Todas as variables en C están suxeitas a un "tipo". Isto quere dicir que toda variable declarada deberá asignarse a un certo tipo.
Índice |
[editar] Declarar, inicializar e asignar variables
No seguinte exemplo declararase un número enteiro (integer en inglés), que chamaremos numero_calquera. Non esquezas facer fincapé no punto e coma en que remata a liña, pois así rematarán todas as declaracións.
int numero_calquera;
Esta declaración significa que estamos a reservar espazo para unha variable chamada numero_calquera, a cal será usada para almacenar datos dun número enteiro (intteger en inglés). Nótese que temos que especificar o tipo de datos que almacenará a variable. Hai palabras clave específicas para facer isto, e verémolas a continuación.
Pódense declarar múltiples variables cunha soa declaración, deste xeito:
int un_numero, outro_numero, outro_mais;
Tamén podemos declarar e asignarlle algún contido á variable ao mesmo tempo. Isto chámase inicialización porque é cando o se lle asigna á variable o valor inicial.
int numero_calquera=3;
En C, todas as declaracións de variables (agás as globais) deberían de facerse ao comezo dun bloque. Algúns compiladores non permiten declarar variables, engadir outras declaracións, e declarar entón máis variables. As declaracións de variables (se hai algunha) deberían de ser sempre o principio de cada bloque.
Tras declarar as variables, podes asignarlle un valor a unha variable máis adiante mediante a seguinte declaración:
numero_calquera=3;
Tamén lle podes asignar a unha variable o valor doutra, deste xeito:
un_numero = outro_numero;
Ou asígnalles a máis dunha variable o mesmo valor con esta declaración:
un_numero = outro_numero = outro_mais = 3;
[editar] Nomear variables
Os nomes das variables en C compóñense de letras (maiúsculas e minúsculas) e cifras. Tamén está permitida a barra baixa (_). Os nomes non poden comezar cunha cifra, e ao contrario que outras linguaxes coma Perl e algúns dialectos de BASIC), C non fai uso de ningún prefixo especial nos nomes das variables.
Estes son algúns exemplos de variables válidas (no referente á sintaxe, claro):
mexanpornosetemosquedicirquechove Cervexa BIC non_si _e_logo _ IsoSi
Agora exemplos de variables que non valen:
2_cervexas // Non pode comezar cunha cifra non si // Non se poden usar espazos nos nomes while // Tampouco valen as palabras clave da linguaxe C, tales coma "for", "if", "else" Quero_€_e_$ // Carácteres coma € e $ non se poden usar, só letras, números e _ E_logo? // E dalle! "?" non é unha letra, nin un número, nin moito menos _ isto_é_algo // Non, nada de tils, así que nada de á, é, í, ó, ú pingüin_voador // Nada de lle poñer puntiños enriba ao u ñu // Dá a casualidade de que o ñ tampouco vale çà&#... // En fin, ante as dúbidas, comprobade se o que escribides está no alfabeto latino // fundamental, é unha cifra ou é '''_'''
Como dí o terceiro exemplo, algunhas verbas están reservadas coma parabras clave na linguaxe C, polo que non se poden usar coma nomes de variable.
Ademáis, hai certas verbas que , aínda que non son palabras clave en C, están reservadas por unha ou outra razón. Pero un principiante non debería preocuparse disto, e posto que estas verbas están escritas en inglés, se utilizas o galego ou outra lingua e evitas os caracteres non válidos non deberías de ter maior problema.
As regras para nomear variables en C aplícanse tamén a outras construccións da linguaxe tales coma nomes de funcións, etiquetas de estrutura, macros... e demáis que veremos máis adiante.
[editar] Literais
En calqura momento nun programa no que especifiques un valor esplícito en vez de te referires a unha variable ou outro tipo de dato, ese valor considérase literal. No exemplo anterior de inicialización, 3 é un literal. Os literais poden tomar unha forma definida polo seu tipo (verémolo máis adiante) ou pódese usar o sistema hexadecimal (hex) para inserir directamente datos na variable sen ter en conta o seu tipo. Os números hexadecimais van sempre precedidos de 0x. Polo de agora, non tes por que estar interesado nos números hexadecimais, non te preocupes.
[editar] Tipos
Na linguaxe C estándar hai catro tipos básicos de variable:
[editar] int
As variables de tipo int almacenan números enteiros. O seu tamaño habitual é de 32 bits, aínda que as computadoras de 64 están a extenderse. Exemplos de literais son números enteiros coma 1, 2, 3, 6, 13, 102... Cando un int é de 32 bits, pode almacenar calquera número enteiro entre o -2147483648 e o 2147483647. Pero tampouco te preocupes de memorizar isto.
Se queres declarar unha nova variable de tipo int, utiliza a palabra clave int:
int NumeroDePaxinas, i, l=5;
Nesta declaración declaramos tres variables: NumeroDePaxinas, i e l, séndolle a éste último asignado o literal 5.
[editar] char
As variables de tipo char poden ter como valor calquera carácter. Almacena o mesmo tipo de datos ca un int, pero sempre ten un byte (8 bits) de tamaño. Unha variable de tipo char úsase habitualmente para almacenar datos de carácteres. A maioría das veces utilízace o sistema ASCII para os carácteres, pero disto non hai que preocuparse de momento.
Exemplos de carácteres literais son "a", "b", "1", etc., así coma algúns carácteres especiais coma "0", o caracter nulo, e "\n, o salto de liña.
Cando inicializamos unha variable de caracter, podemos facelo de dúas maneiras. A primeira é a favorita, e a segunta considérase un mal xeito de programar.
char letra1 = 'a';
Isto é "boa" programación xa que permite que calquera que lea o código vexa que letra1 inicialízace coa letra 'a'.
A segunda forma, que non debería de usarse, é
car letra2 = 97; // En ASCII, "a" equivale a 97
Algúns considérano unha moi mala práctica de programación, se estamos a usalo para almacenar un carácter, non un número pequeno, xa que se alguén le o código, verase na obriga de buscar o carácter que equivale ao número 97. A fin de contas, letra1 e letra2 veñen ser o mesmo, pero é moito máis recomendable usar a primeira forma.
Hai que destacar que os caracteres de números represéntanse de xeito diferente aos propios números. Non é o mesmo '1' (carácter) que 1.
Hai outro tipo de literal que ten que ser explicado en relación aos caracteres: o literal de cadea. Unha cadea son unha serie de caracteres, xeralmente con intención de ser amosados. Están delimitados por comiñas dobres ("). Exemplo de literal de cadea é o
"Ola mundo!\n"
[editar] float
float é a abreviatura en inglés de punto flotante (explicación en castelán). Este tipo de variables almacenan números reais tamén, mais é só de unha palabra máquina de tamaño. Polo tanto, utilízase cando se precisa menos precisión da que proporciona unha variable de tipo double. Os literais float deben levar o sufixo F ou f, do contrario interpretaranse coma doubles. Son exemplos: 3,1415926f, 4,0f, 6,022e+23f. As variables de tipo float poden declararse usando a palabra clave float.
[editar] double
As variables de tipo double e float soi moi parecidas. As de tipo float permítenche almacenar números de punto flotante de single-precision (explicación en inglés), noutras verbas, números reais, con valores enteiros ou non. O seu tamaño é habitualmente de dúas palabras máquina, ou 8 bytes na maioría das computadoras. Son exemplos de literais de tipo double 3,1415926535897932, 4,0, 6,022e+23 (artigo sobre notación científica en castelán). Se usases 4 en lugar de 4,0, o 4 interpretaríase coma un enteiro (int).
A distinción entre floats e doubles fíxose no seu momento para diferenciar os tamaños dos dous tipos. A primeira vez que se utilizou C, o espazo estaba en mínimos polo que o uso dun float en lugar dun double xustificábase por aforrar algo de memoria. A día de hoxe, con moita máis memoria dispoñible, non é realmente necesario conservar memoria deste xeito. Sería mellor usar sempre doubles. Ademais, algunhas implementacións de C utilizan doubles en lugar de floats cando declaras unha variable de tipo float.
Para usar unha variable de tipo double, utiliza a palabra clave double.
[editar] sizeof
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 sizeof para descubrilo con exactitude. A súa sintaxe é:
sizeof object sizeof(type)
As dúas expresións anteriores devolven o tamaño do obxecto e tipo especificado, en bytes. O tipo do dato devolto é size_t (definido na cabeceira <stddef.h>) que é un valor sen asignar. A continuación un exemplo do seu uso:
size_t size; int i; size = sizeof(i);
size pasará a ter o valor 4, xa que o byte son 8 bits, e un enteiro son 32 bits. O valor do resultado de sizeof é o número de bytes.
Nótese que cando se aplica o sizeof a unha variable de tipo char, o resultado sempre é 1. Isto é:
sizeof(char);
Sempre devolverá 1.
[editar] Modificadores do tipo de datos
Pódese alterar o tipo almacenamento de datos ao precedelos de certos modificadores.
long e short son modificadores que fan posible que un tipo de datos use máis ou menos memoria. A palabra clave int non necesita ir tras as palabras clave long e short. Un short pode usarse onde os valores se atopan ao redor dun rango menor ca o dun int, normalmente de -32768 a 32767. Un long pode usarse para conter un rango estendido de valores. Non está garantido que un short use menos memoria ca un int, nin o está que un long use máis. O único garantido é que sizeof(short) <= sizeof(int) <= sizeof(long). Normalmente un short ten 2 bytes, un int 4 bytes, e un long 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 unsigned para usar esa parte para almacenar outros datos, dobrando así o rango de valores ao asegurar que estes serán positivos. O modificador unsigned tamén pode usarse sen necesidade de incluír o int, en cuxo caso o tamaño defínese coma o dun int. Tamén hai un modificador signed que fai o contrario, pero non é necesario, agás para certos usos de char, pois todos os tipos (agás o char) están predefinidos coma signed.
Para usar un modificador, simplemente declara a variable co tipo de datos e os modificadores relevantes:
unsigned short int e; // Completamente cualificado: unsigned short int short logo; // short int unsigned long pois; // unsigned long int
[editar] Cualificador const
Cando se usa o cualificador const, 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 const. 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 const de pi, de xeito que un programa ou outra función escrita por outra persoa non pode cambiar o valor de pi.
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 const, mais despois de facelo o compilador é libre de ignorar o cualificador const.
[editar] 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.
[editar] const
A palabra clave const axuda a eliminar os números máxicos. Ao declarar unha variable const latamexillons_marcax 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 const, e tamén máis problemático en moitos aspectos. Ademais en lugar de implicar ao compilador, implica ao preprocesador.
[editar] #define
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:
#define custo_dos_mexillons
Isto serviría para se, por exemplo, para facer referencia ao custo dos mexillóns por custo_dos_mexillons en lugar de 0.71 (recorda que en inglés usan o punto (.) para separar os decimais), de xeito que o precompilador buscará todos os custo_dos_mexillons para substituílos polo literal de tipo double 0.71.
Hai que facer especial fincapé en que a funcionalidade do #define é a mesma que a do "Buscar e substituír" dos editores de texto. Para algunhas cousas, o #define pode ser nocivo, e por regra xeral é preferible usar o const se o #define non é imprescindible. Así mesmo, é aconsellable escribir as palabras #define en maiúsculas (CUSTO_DOS_MEXILLONS), para indicarlle ao resto dos programadores que se trata dun macro.
[editar] Ámbito
É importante ter sempre en conta a diferencia entre tipos locais e globais, e como declarar variables de cada un deles. Para declarar unha variable local, hai que emprazar a declaración ao comezo do bloque para o que a variable será local. Para declarar unha variable global, declara a variable fóra de calquera bloque. As variables globais poden ser lidas e escritas dende calquera punto do teu programa.
As variables locais estan consideradas coma unha mala práctica de programación, e deberían evitarse sempre que fose posible. Dificultan a lectura do código, crean conflitos cos nomes e poden dificultar a localización de erros de programación (bugs). O uso abusivo de variables locais adoita ser signo de pereza e/ou pobreza no deseño. De todos xeitos, nunha situación en que as variables locais poderían crear código máis difícil de ler, non hai problema en utilizar as globais. Máis adiante veremos exemplos de funcións que son máis difíciles de escribir se o facemos sen unha variable global.
[editar] Outros modificadores
Velaquí máis modificadores fornecidos polo estándar C para completar. Para o programador principiante poderán ser de utilidade static e extern. volatile resultaralle máis interesante aos programadores avanzados. register e auto son amplamente desprezados e non adoitan ser de interese para os programadores, sen importar o seu nivel.
static 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 (static) 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 static inicialízanse co valor nulo (0) por defecto.
Podes utilizar static de, polo menos, dúas maneiras. Imaxinemos un código que forma parte do ficheiro gfile.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; }
A variable g é accesible a través de arriba e abaixo e mantén o seu valor. As variables l 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:
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
extern úsase cando un ficheiro necesita acceder a unha variable noutro ficheiro que podería non estar incluída (#include) directamente. Pero en realidade extern non crea espazo para unha nova variable, senón que fornece ao compilador de información abondo para acceder á variable remota.
volatile é 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 volatile o compilador podería asumir que certas operacións relativas á variable pódense optimizar cando en realidade non poden. volatile é 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.
auto é 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 auto é 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.
register é 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 register.
| C | ||
| ← Volver a Estrutura e estilo | Variables | Seguir con Expresións → |
