Definición de variables Una variable puede verse simplemente como un hueco en el que se puede almacenar un objeto de un determinado tipo al que se le da un cierto nombre. Para poderla utilizar sólo hay que definirla indicando cual erá su nombre y cual será el tipo de datos que podrá almacenar, lo que se hace siguiendo la siguiente intaxis:
<tipoVariable> <nombreVariable>;
|
Una variable puede ser definida dentro de una definición de clase, en cuyo caso se correspondería con el tipo de miembro que hasta ahora hemos denominado campo. También puede definirse como un variable local a un método, que es una variable definida dentro del código del método a la que sólo puede accederse desde dentro de dicho código. Otra posibilidad es definirla como parámetro de un método, que son variables que almacenan los valores de llamada al método y que, al igual que las variables locales, sólo puede ser accedidas desde código ubicado dentro del método. El siguiente ejemplo muestra como definir variables de todos estos casos:
class A
{
int x, z;
int y;
void F(string a, string b)
{
Persona p;
}
}
|
En este ejemplo las variables x, z e y son campos de tipo int, mientras que p es una variable local de tipo Persona y a y b son parámetros de tipo string. Como se muestra en el ejemplo, si un método toma varios parámetros las definiciones de éstos se separan mediante comas (carácter ,), y si queremos definir varios campos o variables locales (no válido para parámetros) de un mismo tipo podemos incluirlos en una misma definición incluyendo en sus nombres separados por comas.
Con la sintaxis de definición de variables anteriormente dada simplemente definimos variables pero no almacenamos ningún objeto inicial en ellas. El compilador dará un valor por defecto a los campos para los que no se indique explícitamente ningún valor según se explica en el siguiente apartado. Sin embargo, a la variables locales no les da ningún valor inicial, pero detecta cualquier intento de leerlas antes de darles valor y produce errores de compilación en esos casos.
Ya hemos visto que para crear objetos se utiliza el operador new. Por tanto, una forma de asignar un valor a la variable p del ejemplo anterior sería así:
Persona p;
p = new Persona("José", 22, "76543876-A");
|
Sin embargo, C# también proporciona una sintaxis más sencilla con la que podremos asignar un objeto a una variable en el mismo momento se define. Para ello se la ha de definir usando esta otra notación:
<tipoVariable> <nombreVariable> = <valorInicial>;
|
Así por ejemplo, la anterior asignación de valor a la variable p podría rescribirse de esta otra forma más compacta:
Persona p = new Persona("José", 22, "76543876-A");
|
La especificación de un valor inicial también combinarse con la definición de múltiples variables separadas por comas en una misma línea. Por ejemplo, las siguientes definiciones son válidas:
Persona p1 = new Persona("José", 22, "76543876-A"),
p2 = new Persona("Juan", 21, "87654212-S");
|
Y son tratadas por el compilador de forma completamente equivalentes a haberlas declarado como:
Persona p1 = new Persona("José", 22, "76543876-A");
Persona p2 = new Persona("Juan", 21, "87654212-S");
|
Tipos de datos básicos
Los tipos de datos básicos son ciertos tipos de datos tan comúnmente utilizados en la escritura de aplicaciones que en C# se ha incluido una sintaxis especial para tratarlos. Por ejemplo, para representar números enteros de 32 bits con signo se utiliza el tipo de dato System.Int32 definido en la BCL, aunque a la hora de crear un objeto a de este tipo que represente el valor 2 se usa la siguiente sintaxis:
Como se ve, no se utiliza el operador new para crear objeto System.Int32, sino que directamente se indica el literal que representa el valor a crear, con lo que la sintaxis necesaria para crear entero de este tipo se reduce considerablemente. Es más, dado lo frecuente que es el uso de este tipo también se ha predefinido en C# el alias int para el mismo, por lo que la definición de variable anterior queda así de compacta:
System.Int32 no es el único tipo de dato básico incluido en C#. En el espacio de nombres System se han incluido todos estos:
| Tipo |
Descripción |
Bits |
Rango de valores |
Alias |
|
SByte |
Bytes con signo |
8 |
[-128, 127] |
sbyte |
|
Byte |
Bytes sin signo |
8 |
[0, 255] |
byte |
|
Int16 |
Enteros cortos con signo |
16 |
[-32.768, 32.767] |
short |
|
UInt16 |
Enteros cortos sin signo |
16 |
[0, 65.535] |
ushort |
|
Int32 |
Enteros normales |
32 |
[-2.147.483.648, 2.147.483.647] |
int |
|
UInt32 |
Enteros normales sin signo |
32 |
[0, 4.294.967.295] |
uint |
|
Int64 |
Enteros largos |
64 |
[-9.223.372.036.854.775.808,
9.223.372.036.854.775.807] |
long |
|
UInt64 |
Enteros largos sin signo |
64 |
[0-18.446.744.073.709.551.615] |
ulong |
|
Single |
Reales con 7 dígitos de precisión |
32 |
[1,5×10-45 - 3,4×1038] |
float |
|
Double |
Reales de 15-16 dígitos de precisión |
64 |
[5,0×10-324 - 1,7×10308] |
double |
|
Decimal |
Reales de 28-29 dígitos de precisión |
128 |
[1,0×10-28 - 7,9×1028] |
decimal |
|
Boolean |
Valores lógicos |
32 |
true, false |
bool |
|
Char |
Caracteres Unicode |
16 |
[‘\u0000’, ‘\uFFFF’] |
char |
|
String |
Cadenas de caracteres |
Variable |
El permitido por la memoria |
string |
|
Object |
Cualquier objeto |
Variable |
Cualquier objeto |
object |
Tabla 5 : Tipos de datos básicos
Pese a su sintaxis especial, en C# los tipos básicos son tipos del mismo nivel que cualquier otro tipo del lenguaje. Es decir, heredan de System.Object y pueden ser tratados como objetos de dicha clase por cualquier método que espere un System.Object, lo que es muy útil para el diseño de rutinas genéricas que admitan parámetros de cualquier tipo y es una ventaja importante de C# frente a lenguajes similares como Java donde los tipos básicos no son considerados objetos.
El valor que por defecto se da a los campos de tipos básicos consiste en poner a cero todo el área de memoria que ocupen. Esto se traduce en que los campos de tipos básicos numéricos se inicializan por defecto con el valor 0, los de tipo bool lo hacen con false, los de tipo char con ‘\u0000’, y los de tipo string y object con null.
Ahora que sabemos cuáles son los tipos básicos, es el momento de comentar cuáles son los sufijos que admiten los literales numéricos para indicar al compilador cuál es el tipo que se ha de considerar que tiene. Por ejemplo, si tenemos en una clase los métodos:
public static void F(int x)
{...}
public static void F(long x)
{...}
|
Ante una llamada como F(100), ¿a cuál de los métodos se llamara? Pues bien, en principio se considera que el tipo de un literal entero es el correspondiente al primero de estos tipos básicos que permitan almacenarlo: int, uint, long, ulong, por lo que en el caso anterior se llamaría al primer F() Para llamar al otro podría añadirse el sufijo L al literal y hacer la llamada con F(100L) En la Tabla 6 se resumen los posibles sufijos válidos:
|
Sufijo |
Tipo del literal entero |
|
ninguno |
Primero de: int, uint, long, ulong |
|
L ó l[9] |
Primero de: long, ulong |
|
U ó u |
Primero de: int, uint |
|
UL, Ul, uL, ul, LU, Lu, lU ó lu |
ulong |
Tabla 6: Sufijos de literales enteros
Por su parte, en la Tabla 7 se indican los sufijos que admiten los literales reales:
|
Sufijo |
Tipo del literal real |
|
F ó f |
float |
|
ninguno, D ó d |
double |
|
M ó m |
decimal |
Tabla 7: Sufijos de literales reales |