|
[[pl:C/Zmienne]]
[[fi:C/Muuttujat]]
=Artigo traducido da wikibooks en castelán=
Na linguaxe C existen tres tipos básicos de datos: '''<code>int</code>''', '''<code>float</code>''' e '''<code>char</code>'''. A partires destes tipos créanse outros que funcionan do mesmo xeito pero difiren no seu tamaño coma o '''<code>long</code>''', o '''<code>double</code>''', e outros. Estes que son parte da linguaxe considéranse tipos "primitivos", e máis adiante veremos que co uso de [[Programación en C/Estruturas e unións|estruturas e unións]] pódense facer tipos compostos de datos a partires destes tipos primitivos.
==Enteiros==
Os enteiros son o tipo máis primitivo. Úsanse para representar números enteiros, como ben di o seu nome. Pero sempre se poden atopar outras aplicacións para os números enteiros. En xeral pódense usar para representar calquera variable discreta.
Para a linguaxe C esiste diferentes tamaños de números enteiros que poden ter desde 1 byte ata 8. A linguaxe C fai dintinción entre os enteiros con e sen signo (<code>signed</code> ou <code>unsigned</code>). A forma de declarar un enteiro é cun dos tipos de datos que sexan enteiros segundo o tamaño desexado. No caso de non se declarar o signo do número, interpretarase que éste é positivo.
Algunhas formas de declaracións de enteiros:
<code>
int a;
unsigned int a;
signed long a;
signed long long a = 10000000;</code>
Represéntanse en memoria cunha cadea de bits e para os que teñen signo, é o primeiro bit da esquerda o que se utiliza para o representar. Este método para representar números enteiros coñécese co nome de "exceso de dous", xa que existen dúas representacións do 0 (é dicir, coma se o cero tivese signo). Esta ineficiencia non existe na linguaxe C porque se utiliza outro método que se coñece como "exceso de un" en que un dos dous ceros (+0 e -0), o negativo para sermos exactos, úsase como a primeira cifra negativa, é dicir, -1.
Polo tanto a representación en memoria dun -8 nunha variable enteira con signo de 2 bytes sería a seguinte:
<code>
1000000000001000</code>
==Flotantes==
Os valores flotantes son máis modernos e úsanse moito en aplicacións que traballan con gráficos ou que precisan de grande precisión. O tipo de dato flotante en linguaxe C só ten dous tamaños: o float e mailo double, que son 4 bytes e 8 bytes nesa orde. A diferencia dos enteiros o tipo de dato flotante soporta números decimais e máis números con exponente.
O xeito de declararen unha variable flotante é escribir nunha liña un dos tipos de dato flotante e de seguido o noma da variable e se cadra algún valor que se lles quera dar.
Velaquí uns exemplos:
<code>
float a;
double a = 1e23;
double a = 3.1416;
float a = 4e-9;
double a = -78;
</code>
Hai que ter en conta que a pesar de que os valores flotantes son máis axeitados para algunhas aplicacións, nalgúns casos prefírense os enteiros, e isto ten a súa razón. Resulta que os números flotantes non teñen soporte de hardware na maioría das plataformas. Unha alternativa é a de interpretaren os números enteiros coma se fosen decimais. Deste xeito, 660 podería interpretarse coma 6'6, e 3145 coma 31'45.
Os flotantes represéntanse en memoria con cadeas de bits de 4 ou 8 bytes. Os flotantes de 4 bytes divídense nun bit para o signo, 8 bits para o exponente e 23 bits para o valor do número. O procedemento para pór un número nunha variable flotante é o seguinte:
# Convírtese a binario a parte enteira.
# Colócase o signo no primeiro bit do mesmo xeito que nos enteiros (1 para negativo e 0 para positivo).
# Ródase o punto (na representacion binaria da parte enteira) ata poñelo á dereita do primeiro un e éste descártase (o primeiro un de esquerda a dereita). O valor do expoñente vai ser o número de posicións que se moveu o punto. O exponente usa unha representación dun enteiro con exceso de 2.
# Convírtese en binaria a parte decimal do número. Isto usando o peso dos bits, o primeiro bitdecimal de esquerda a dereita vale 1/2, o seguinte 1/4, outro 1/8, e o outro 1/16, e así ata completar o que resta dos 23 bits do valor.
# Concaténase todo e ése é o valor flotante representado na memoria.
==Caracteres==
Os caracteres ou o tipo char só contan cun byte de tamaño e usa a mesma representación ca os números enteiros. A única diferencia é o seu tamaño e máis que o char úsase para representar os 255 caracteres da táboa ASCII.
Respecto ao xeito de declarar variables de tipo <code>char</code> é o mesmo xeito que cos outros tipos.
<code>
char a;
char a = 's';
char a = 48;
</code>
Como podes observar, pódeselle asignar un número enteiro a unha variable <code>char</code>, e isto porque como xa se dixo o tipo char é outro enteiro. Mesmo acostuma usarse o tipo <code>char</code> para contadores nos casos en que non se requiren variables moi grandes.
==Cadeas==
Trátase dun tipo particular de arranxo, que surxe da necesidade de contar con cadeas de caracteres. Particular porque o tipo de dato coñecido coma "cadea" ("string" en inglés) '''non existe''' en rigor nesta linguaxe, para o cal faise uso dun conxunto de caracteres (pódese dicir de tipo char) determinando a súa fin co carácter nulo: \0. Este elemento é fundamental, xa que permite ao compilador -e ao propio programa- recoñecer onde remata a cadea.
En efecto, este tipo de dato son un conxunto de variables do mesmo tipo (char ou carácter en galego) que suplen esta carencia de C.
Exemplos:
char nome[]="Rosalia de Castro";
/* Ou tamén */
char nome[]={'R','o','s','a','l','i','a',
'd','e',
'C','a','s','t','r','o','\0'};
Agora si, o anterior permite destacar e escribir algúns aspectos importantes de arranxos (tamén coñecidos coma formacións) de caracteres, ou simplemente cadeas. En primeiro lugar, falaremos da extensión e a sintaxe básica dunha cadea.
Cando se traballa con cadeas débese ter especial coidado coa extensión que otorgaremos: isto é, o número de casiñas que asignaremos. Xa que as cadeas sempre rematan co carácter nulo, debemos ter "n+1" celas para a nosa cadea (xa que temos que agregar o carácter nulo). Porén moitas veces os estilos de programación oriéntanse por deixar os corchetes baleiros: [] e que sexa o compilador o que determine a lonxitude -algo que pode resultar moi útil-. De todos xeitos, é preciso facer a distinción para poder comprender o concepto.
Se a cadea a almacenar é "isto mola", en C podo facer:
/* Con lonxitude a determinar polo compilador */
char frase[]={'i','s','t','o',' ','m','o','l','a','\0'};
char frase[]="isto mola";
/* Con lonxitude definida polo programador */
char frase[11]={'i','s','t','o',' ','m','o','l','a','\0'};
char frase[11]="isto mola";
Calquera das dúas opcións é válida. Coa segunda é máis probable cometer algún erro, pero en certas circunstancias pode chegar a se precisar dela. O importante -como xa se dixo- é comprender o comportamento das cadeas.
Na práctica, quizáis necesitemos declarar un espazo para capturar un nome ou algunha cadea de caracteres, e mesmo entender de maneira perfecta de qué trata o tema dos punteiros e o uso dinámico de memoria, deberemos levar a cabo estas operacións utilizando espazos declarados pensando nos posíbeis valores que podería chegar ter este campo ou variable. Isto quere dicir que se necesitamos un arranxo para un nome, por exemplo, débese pensar na cantidade máxima de caracteres que podería ter un nome para poder declarar un arranxo que poda acoller todos os nomes que podan ser inseridos. En caso de que se trate de inserir, nunha captura ou algunha asignación, un valor que sobrepase o tamaño do noso arranxo entón estariamos escribindo quizáis nunha posición de memoria que non nos pertence ou de algunha outra variable (o que é considerado un erro gravísimo en calquera programa).
Cando xa posuímos datos nunha cadea e precisamos facer algún tipo de procesamento, as operacións habería que logralas facendo uso das características dos arranxos (que serán tratados máis adiante) que dito sexa de paso resultan algo tediosas nestes casos. Entón, co fin de evitarmos este problema podemos facer uso das funcións da biblioteca "string.h", e que forman parte das funcións estándar que soporta calquera dialecto da linguaxe de programación C. Nesta biblioteca atoparemos funcións para concatenar cadeas, para comparalas, para buscar a súa lonxitude, ou mesmo para facer algún tipo de busca nelas, entre outras duncións de utilidade. Explicarase o uso dalgunhas destas funcións máis adiante.
| 