Ingeniería en Desarrollo de Software Felipe de Jesús Gutiérrez García (Al12535104) 5to Semestre Juan Carlos Rojo Méndez Facilitador Programación NET 1 Unidad 1 Introducción a .NET Actividad 3 Cuadro comparativo de los tipos de datos y operadores Con la presente actividad identificarás los tipos de datos y operadores, además de que conocerás cuáles son las características de cada uno de ellos de forma individual.
Tipos de datos comunes en C# Tipo
Descripción
Tamaño de Memoria Utilizada
sbyte
Las variables con tipo sbyte pueden contener números enteros de 8 bits con signo. La ‘s’ de sbyte significa 'con signo', lo que quiere decir que el valor de la variable puede ser positivo o negativo. El menor valor posible para una variable sbyte es -128 y el mayor es 127.
1 byte
byte
Las variables con tipo byte pueden contener números enteros de 8 bits sin signo. A diferencia de las variables sbyte, las variables byte no tienen signo y sólo pueden contener números positivos. El valor más pequeño posible para una variable byte es O; el valor más alto es 255.
1 byte
short
Las variables con tipo short pueden contener números enteros de 16 bits con signo. El menor valor posible para una variable short es -32,768; el valor más alto es 32,767.
2 bytes
ushort
Las variables con tipo ushort pueden contener números enteros de 16 bits sin signo. La 'u' de ushort significa sin signo. El menor valor posible para una variable ushort es O; el valor más alto es 65,535.
2 bytes
int
Las variables con tipo in t pueden contener números enteros de 32 bits con signo. El menor valor posible para una variable int es -2,147,483,648; el valor más alto es 2,147,483,647.
4 bytes
uint
Las variables con tipo uint pueden contener números enteros de 32 bits sin signo. La 'u' en uint significa sin signo. El menor valor posible para una variable uint variable es O; el valor más alto posible es 4.294.967.295.
4 bytes
long
Las variables con tipo long pueden contener números enteros de 64 bits con signo. El menor valor posible para una variable long es -9.223.372.036.854.775.808 el valor más alto es 9.223.372.036.854.775.807.
8 bytes
ulong
Las variables con tipo ulong pueden contener números enteros de 64 bits sin signo. La 'u' en ulong significa sin signo. El menor valor posible para una variable ulong es O; el valor más alto es 18.446.744.073.709.551.615.
8 bytes
char
Las variables con tipo char pueden contener caracteres Unicode de 16 bits. El menor valor posible para una variable char es el carácter Unicode cuyo valor es O; el valor más alto posible es el carácter Unicode cuyo valor es 65.535.
2 bytes
float
Las variables con tipo float pueden contener un valor de coma flotante de 32 bits con signo. El menor valor posible para una variable float es aproximadamente 1.5 por 10 elevado a 45; el valor más alto es aproximadamente 3.4 por 10 elevado a 38.
4 bytes
double
Las variables con tipo double pueden contener un valor de coma flotante de 64 bits con signo. El menor valor posible para una variable
8 bytes
double es aproximadamente 5 por 10 elevado a 324; el valor más alto es aproximadamente 1,7 por 10 elevado a 308. decimal
Las variables con tipo decimal pueden contener un valor de coma flotante de 128 bits con signo. El menor valor posible para una variable decimal es aproximadamente 1 por 10 elevado a 28; el valor más alto es aproximadamente 7.9 por 10 elevado a 28. Las variables de tipo decimal son buenas para cálculos financieros.
16 bytes
bool
Las variables con tipo bool pueden tener uno de los dos posibles valores: true o falseo El uso del tipo bool es una de las partes en las que C# se aparta de su legado C y C++. En ellos, el valor entero O era sinónimo de false y cualquier valor que no fuese cero era sinónimo de true. Sin embargo, en C# los tipos no son sinónimos. No puede convertir una variable entera en su valor equivalente bool. Si quiere trabajar con una variable que necesita tener una condición verdadera o falsa, use una variable bool y no una variable int.
1 byte
datetim e
Almacena un instante de tiempo que va comprendido 01/01/0001 12:00:00 am a 31/12/9999 11:59:59 pm
8 bytes
string
Almacena una secuencia de caracteres
desde
2 bytes carácter
por
Nos estaremos preguntando por qué C# admite todos estos tipos de variables diferentes. Los valores más pequeños pueden colocarse en variables de mayores tipos; por lo tanto ¿por qué usar los tipos más pequeños? Si una variable short puede contener valores desde -32.768 hasta 32.767, y una grande puede contener valores desde -9.223.372.036.854.775.808 hasta 9.223.372.036.854.775.807, entonces es evidente que todos los posibles valores short pueden ser almacenados en una variable long. Entonces, ¿para qué sirven los tipos short? ¿Por qué no usar un variable long para todo? Una respuesta es el consumo de memoria. Una variable long puede contener valores más grandes, pero también necesita más memoria. Una variable short usa 16 bits (dos bytes), mientras que una grande usa 32 bits (cuatro bytes de memoria). Si se va a trabajar con valores que no van más allá del límite de una variable short, usar la variable short. Es una buena costumbre usar toda la memoria que necesite, pero no usar más de la necesaria.
Operadores de C#
Estos operadores están puestos en orden de precedencia, es decir, en el caso de haber una expresión con varios de ellos, se ejecutan por ese orden. Los operadores primarios son operadores de expresión.
Operadores (expresión)
Uso Control
de
Tipo
Descripción
Primario
En el caso de (expresión), los operadores son realmente los paréntesis. Sirven para modificar la precedencia y darle prioridad a la expresión que se encuentra dentro del paréntesis.
precedencia
var++, var--
Postincremento
Primario
y postdecremento
+
Operando
en
Unitario
forma original
-
Cambio
de
Unitario
signo
!
Not lógico
Unitario
++var, --var
Preincremento
Unitario
y predecremento
Los operadores de incremento (++) y decremento (--) sirven para incrementar o disminuir el valor de una variable en una unidad. Esto lo realiza después de realizar cualquier operación. Por ejemplo: a = ++num; b = a--; Los operadores unitarios + y - sirven sencillamente para mantener o cambiar el signo de un operando. Si se desea mantener el signo de un operando sin cambios, el + se puede omitir. El operador - cambia el valor. En el siguiente ejemplo, como i valía 10, el valor que se guardaría en b sería -10. int i=10; int b=-i; El operador unitario ! es un not lógico, es decir, invierte el valor de un dato de tipo boolean. En el siguiente ejemplo, i valdría true y b valdría false: bool i=true; bool b=!i; Se utiliza para incrementar una variable, antes de realizar cualquier operación. Ejemplo: int a = 10; int b=++a; En este ejemplo, incrementaría a que vale 10 y después guardaría el valor 11 en b.
(conversión
Conversión
) var
tipos
*, /
de
Multiplicación,
Unitario
Binario
división
%
Resto
de
En el operador (conversión), lo que ha de ir entre paréntesis es el tipo al que se quiere convertir (int), (uint), (long)... Los operadores * y / son, respectivamente, para multiplicar y dividir. Es muy sencillo. Si, por ejemplo, tenemos la siguiente expresión: 4*6/2, el resultado sería el que se supone: 12.
Binario
El operador % devuelve el resto de una división. Por ejemplo, 8 % 3 devolvería 2.
Los operadores + y - (binarios) son para sumar o restar. 4+7-3 devolvería 8.
división
+, -
Suma, resta
Binario
<<, >>
Desplazamiento
Binario
de bits
<,
>,
<=,
Relacionales
Binario
>=, is, ==, ! =
Los operadores << y >> efectúan un desplazamiento de bits hacia la izquierda o hacia la derecha. Los operadores relacionales < (menor que), > (mayor que), <= (menor o igual que), >= (mayor o igual que), is, == (igual que), != (distinto de) establecen una comparación entre dos valores y devuelven como resultado un valor de tipo boolean (true o false). Veamos un ejemplo: int i; int b; Console.Write("Escribe el valor de i: "); i=Int32.Parse(Console.ReadLine()); Console.Write("Escribe el valor de b: "); b=Int32.Parse(Console.ReadLine()); Console.WriteLine("ib devuelve: {0}", (i>b)); Console.WriteLine("i>=b devuelve: {0}", (i>=b)); Console.WriteLine("i==b devuelve: {0}", (i==b)); Console.WriteLine("i!=b devuelve: {0}", (i!=b)); La salida de estas líneas de programa sería la siguiente (en rojo está lo que se ha escrito durante la ejecución de las mismas): Escribe el valor de i: 2 Escribe el valor de b: 3 ib devuelve: False i>=b devuelve: False i==b devuelve: False i!=b devuelve: True
&&
AND lógico
Binario
Los operadores && (AND lógico) y || (OR lógico) se ocupan de
comparar dos valores de tipo boolean y retornan como resultado otro valor de tipo boolean. El operador && devuelve true cuando ambos operandos son true, y false cuando uno de ellos o los dos son false. Por ejemplo, la siguiente expresión devolvería true si un número es mayor que 10 y menor que 20: (num > 10) && (num < 20) ||
OR lógico
Binario
El operador || devuelve true cuando al menos uno de los operandos es true (pudiendo ser también true los dos), y false cuando los dos operandos son false. Suelen combinarse con las operaciones relacionales para establecer condiciones más complejas. Para que veas otro ejemplo, la siguiente expresión devolvería true si el número es igual a 10 o igual a 20: (num == 10) || (num == 20)
?:
QUESTION
Binario
El operador ? : (question) evalúa una expresión como true o false y devuelve un valor que se le especifique en cada caso (Si programabas en Visual Basic, equivale más o menos a la función iif). Vamos a verlo con un ejemplo: string mensaje = (num == 10) ? "El número es 10": "El número no es 10"; Fíjate bien. Delante del interrogante se pone la expresión que debe retornar un valor boolean. Si dicho valor es true, el operador retornará lo que esté detrás del interrogante, y si es false retornará lo que esté detrás de los dos puntos. No tiene por qué retornar siempre un string. Puede retornar un valor de cualquier tipo. Por lo tanto, si en este ejemplo num valiera 10, la cadena que se asignaría a mensaje sería "El número es 10", y en caso contrario se le asignaría "El número no es 10".
=,
*=,
/=,
%=, +=, -=, <<=,
>>=,
&=, ^=, |=
De asignación
Binario
El operador de asignación (=) (sí, sí, ya sé que nos hemos hartado de usarlo, pero vamos a verlo con más profundidad) asigna lo que hay a la derecha del mismo en la variable que está a la izquierda. Por ejemplo, la expresión a = b asignaría a la variable a lo que valga la variable b. La primera norma que no debes olvidar es que ambas variables han de ser compatibles. Por ejemplo, no puedes asignar un número a una cadena, y viceversa, tampoco puedes asignar una cadena a una variable de algún tipo numérico. El resto de operadores de asignación son operadores compuestos a partir de otro operador y el operador de asignación. Veamos a qué equivalen los operadores *=, /=, %=, +=, -=, <<=, >>=, &=, ^=, |= num num num num num num
*= 10; // Equivale a num = num * 10 /= 10; // Equivale a num = num / 10 %= 10; // Equivale a num = num % 10 += 10; // Equivale a num = num + 10 -= 10; // Equivale a num = num - 10 <<= 10; // Equivale a num = num << 10
num num num num
>>= 10; // Equivale a num = num >> 10 &= 10; // Equivale a num = num & 10 ^= 10; // Equivale a num = num ^ 10 |= 10; // Equivale a num = num | 10
La precedencia de operadores determina la prioridad con la que se ejecutan cuando hay varios de ellos en una misma expresión. Efectivamente, el resultado puede ser distinto en función del orden en que se ejecuten. Vamos con un ejemplo. La expresión 4 + 3 * 6 - 8 devolvería 14, ya que primero se hace la multiplicación y después las sumas y las restas. Si hubiéramos querido modificar dicha precedencia habría que haber usado paréntesis: (4+3)*6-8 devolvería 34, ya que primero se ejecuta lo que hay dentro del paréntesis, después la multiplicación y, por último, la resta. La Asociatividad de los operadores indica el orden en que se ejecutan cuando tienen la misma precedencia. Obviamente, esto es aplicable solamente a los operadores binarios. Todos los operadores binarios son asociativos por la izquierda salvo los de asignación, que son asociativos por la derecha. Por ejemplo, en la expresión 4+3+2, primero se hace 4+3 y a este resultado se le suma el dos, dado que el operador + es asociativo por la izquierda. Sin embargo, en la expresión b = c = d, como el operador de asignación es asociativo por la derecha, primero se asigna a c el valor de d, y después se asigna a b el valor de c, es decir, que tras esta expresión las tres variables valdrían lo mismo.
Conversiones de Tipo de C# Las conversiones de tipo de variables en C# se representan en la siguiente tabla en donde la fila es el origen y la columna el destino. Leyenda Rojo
Conversión incompatible (I).
Verde
Conversión automática o implícita (A).
Azul
Conversión explícita (E).
Conversiones de tipo de datos byte sbyte short ushort int uint long ulong float double decimal char bool byte
E
A
A
A
A
A
A
E
E
E
E
I
A
E
A
E
A
A
E
E
E
E
I
E
A
A
A
A
E
E
E
E
I
A
A
A
A
E
E
E
E
I
E
A
A
E
E
E
E
I
A
A
E
E
E
E
I
E
E
E
E
E
I
E
E
E
E
I
A
E
I
I
E
I
I
I
I
sbyte
E
short
E
E
ushort
E
E
E
int
E
E
E
E
uint
E
E
E
E
E
long
E
E
E
E
E
E
ulong
E
E
E
E
E
E
E
float
E
E
E
E
E
E
E
E
double
E
E
E
E
E
E
E
E
E
decimal
E
E
E
E
E
E
E
E
E
E
char
E
E
E
A
A
A
A
A
A
A
A
bool
I
I
I
I
I
I
I
I
I
I
I
I I
• Toda conversión implícita no ocasiona pérdida de información, truncamientos o redondeos. • Es posible (pero no siempre ocurre) que en una conversión explícita haya pérdida de información, truncamientos o redondeos. • En toda conversión implícita el tipo de dato destino es mayor que el tipo de dato origen. • La conversión explícita se realiza indicando el tipo de dato al que se quiere convertir entre paréntesis, seguido del valor: long valor = 123; // Conversión implícita long valor = (long)123; // Conversión explícita Además de realizarse dentro de una asignación, las conversiones de tipos también tienen lugar dentro de una expresión, pues en cada operación ambos operandos deben de ser del mismo tipo. Si la conversión es del tipo implícito se efectúa el siguiente algoritmo en dicho orden:
1. Si un operando es decimal, el otro operando se transforma a decimal. 2. Si un operando es double, el otro operando se transforma a double. 3. Si un operando es float, el otro operando se transforma a float. 4. Si un operando es ulong, el otro operando se transforma a ulong. 5. Si un operando es long, el otro operando se transforma a long. 6. Si un operando es uint, y si el otro operando es de tipo sbyte, short o int, los dos se transforman a long. 7. Si un operando es uint, el otro operando se transforma a uint. 8. Si no es ninguno de los casos anteriores, los dos operandos se transforman a int.
Tipos de datos C# (Definición) Cuando definimos un objeto debemos especificar su tipo. El tipo determina qué valores puede almacenar ese objeto (clase y rango) y las operaciones que pueden efectuarse con él. Como cualquier lenguaje de programación, C# proporciona una serie de tipos predefinidos (int, byte, char, string,...) y mecanismos para que el usuario cree sus propios tipos (class y struct). La estructura de tipos de C# es una gran novedad ya que establece una relación jerárquica entre éstos, de manera que todos los tipos son clases y se construyen por herencia de la clase base Object. Esta particularidad hace que la creación y gestión de tipos de datos en C# sea una de las principales novedades y potencialidades del lenguaje.
Tipos de datos compuestos El concepto de clase como tipo de datos compuesto de campos, métodos y eventos es similar en Java y C#. (La herencia de clases se describe independientemente en el tema titulado Herencia y clases derivadas (C# y Java).) C# introduce el concepto de estructura como tipo de datos compuesto asignado por pila que no admite la herencia. En la mayoría de los otros aspectos, las estructuras son muy similares a las clases. Las estructuras proporcionan una manera ligera de agrupar campos y métodos relacionados para el uso en los bucles de pequeñas dimensiones y otros escenarios donde el rendimiento es crucial. C# permite crear un método de destructor al que se llama antes de que se destruyan las instancias de una clase. En Java, se puede utilizar un método finalize para contener código que limpia los recursos antes de que se recolecten los elementos no utilizados del objeto. En C#, el que realiza esta función es el destructor de clase. El destructor se parece a un constructor sin los argumentos y con un carácter de tilde delante (~).
Tipos de datos integrados C# proporciona todos los tipos de datos que están disponibles en Java y agrega compatibilidad para los números sin signo y un nuevo tipo de punto flotante de 128 bits de alta precisión. Para cada tipo de datos primitivo en Java, la biblioteca de clases principal proporciona una clase contenedora, que lo representa como un objeto de Java. Por ejemplo, la clase Int32 contiene el tipo de datos int y la clase Double contiene el tipo de datos double. Por otro lado, todos los tipos de datos primitivos en C# son objetos en el espacio de nombres System. Para cada tipo de datos, se proporciona un nombre corto o alias. Por ejemplo, int es el nombre corto correspondiente a System.Int32 y double es la forma abreviada de System. Double. En la tabla siguiente se proporciona la lista de tipos de datos de C# y sus alias. Como puede ver, los primeros ocho de estos tipos corresponden a los tipos primitivos disponibles en Java. Sin embargo, tenga en cuenta que el tipo boolean de Java se denomina bool en C#. Tipos de operadores en C# (Definición) Existen tres tipos de operadores:
Unarios: Se asocian a un solo operando. Algunos pueden ir adelante (++x, -x) y otros detrás del operando (x++) Binarios: Se asocian a dos operandos. Por ejemplo: x+y. Ternarios: Se asocian a tres operandos. Sólo existe un operador ternario, ? : . Por ejemplo: var1? valor2: valor3.
El orden de evaluación de os operadores en una expresión está determinado por la precedencia y asociatividad de los operadores. Los operadores son símbolos que permiten realizar operaciones con uno o más datos, para dar un resultado. El ejemplo clásico y obvio de operador es el símbolo de la suma (+), aunque hay otros muchos. Tipos de operadores que tenemos en C#:
Operadores Aritméticos: Son la suma (+), resta (-), producto (*), división (/) y módulo (%) Operadores Lógicos: Son "and" (&& y &), "or" (|| y |), "not" (!) y "xor" (^)
La diferencia entre && y &, y entre || y | es que && y || hacen lo que se llama "evaluación perezosa": si evaluando sólo la primera parte de la operación se puede deducir el resultado, la parte derecha no se evaluará. Es decir, si tenemos por ejemplo: false && (otra cosa)
El resultado de esta operación siempre será false, y (otra cosa) ni siquiera se evalúa. De igual forma, si tenemos true || (otra cosa) el resultado será true, y la parte derecha nunca se evaluará.
Operadores relacionales: igualdad (==), desigualdad (!=), "mayor que" (>), "menor que" (<), "mayor o igual que" (>=) y "menor o igual que" (<=) Operadores de Manipulación de Bits: Tenemos las siguientes operaciones: and (&), or (|), not (~), xor (^), desplazamiento a la izquierda (<<), y desplazamiento a la derecha (>>). El desplazamiento a la izquierda rellena con ceros. El desplazamiento a la derecha, si se trata de un dato con signo, mantiene el signo. Si no, rellena con ceros. Operadores de Asignación: El operador básico de asignación es =. Además, tenemos las clásicas abreviaturas +=, -=, *=, /=, &=, |=, ^=, <<= y >>=
Estas abreviaturas se usan para evitar tecleo en operaciones como esta: variable1 = variable1 + variable2; Se puede escribir de esta forma abreviada: variable1 += variable2; También tenemos operadores de incremento (++) y decremento (--), que incrementan en una unidad el valor de la variable sobre la que se aplican. Por tanto, estas tres líneas de código son casi iguales: variable1 = variable1 + 1; variable1 += 1; variable1++; El "casi iguales" lo ponemos porque en muchas máquinas, el operador ++ es más rápido que la operación "+ 1", ya que el compilador lo traduce a una única instrucción máquina. Hay que tener en cuenta que no es lo mismo poner variable++ que ++variable. Ambas formas son correctas, pero no significan lo mismo. Lo vemos con un ejemplo: variable1 = ++variable2; variable1 = variable2++; En el primer caso, primero se incrementa variable2 y luego se hace la asignación. En el segundo caso primero se hace la asignación, y luego el incremento.
Operador Condicional: Es el único operador de C# que tiene tres operandos. Su sintaxis es esta:
? : Quiere decir que si la condición es true, se evalúa expresión1, y si es falsa, se evalúa expresión2. Ojo: No confundir con un "if". Este operador devuelve un valor, mientras que el if es sólamente una instrucción.
Operadores de Acceso a Objetos: El operador para acceder a los miembros de un objeto es el punto. Así esta expresión:
A.metodo1 (); nos permite acceder al método "metodo1" del objeto A.
Operadores de Punteros: Tenemos varios operadores. Para acceder a la dirección de memoria a la que apunta el puntero, lo hacemos con &puntero. Para acceder al contenido de la dirección de memoria, tenemos *puntero. Si lo que referencia el puntero es un objeto, podemos acceder a sus miembros con puntero>miembro. Operadores de Obtención de Información sobre Tipos: Para averiguar el tipo de una variable, usamos el operador sizeof(variable). Nos devolverá un objeto de tipo System.Type. Si queremos hacer una comparación, usamos algo como esto: (expresion) is TIPO que, como es lógico, nos devolverá un true o un false. Operadores de Conversión: Para convertir el tipo de un objeto en otro, precedemos el objeto que queremos cambiar con el tipo al que queremos convertir, entre paréntesis, de esta forma: variable1 = (int) variable2; De esta forma, variable2 será tratada como si fuera un dato de tipo int, aunque no lo sea.
Veamos un ejemplo del uso de los operadores unarios: using System; class Operadores1 { public static void Main() { int unario = 0; int preIncremento; int preDecremento; int postIncremento; int postDecremento; sbyte bitNot; bool logNot; preIncremento = ++unario; Console.WriteLine("Pre-Incremento: {0}", preIncremento); preDecremento = --unario;
Console.WriteLine("Pre-Decremento: {0}", preDecremento); postDecremento = unario--; Console.WriteLine("Post-Decremento: {0}", postDecremento); postIncremento = unario++; Console.WriteLine("Post-Incremento: {0}", postIncremento); Console.WriteLine("Valor final de unario: {0}", unario); bitNot = 0; bitNot = (sbyte)(~bitNot); Console.WriteLine("Negación a nivel de bit: {0}", bitNot); logNot = false; logNot = !logNot; Console.WriteLine("Negación lógica: {0}", logNot); } } Bajar ejemplo ej6.cs Otro ejemplo, ahora del uso de operadores binarios: using System; class Operadores2 { public static void Main() { int x,y,resultado; x = 7; y = 5; resultado = x + y; Console.WriteLine(" x+y = {0}", resultado); resultado = x - y; Console.WriteLine(" x-y = {0}", resultado); resultado = x * y; Console.WriteLine(" x*y = {0}", resultado); resultado = x / y; Console.WriteLine(" x/y = {0}", resultado); } }
FUENTES DE CONSULTA:
https://msdn.microsoft.com/es-es/library/ms228360%28v=vs.90%29.aspx https://msdn.microsoft.com/es-es/library/ms228601(v=vs.90).aspx http://es.wikipedia.org/wiki/C_Sharp http://www.mundonet.es/operadores.html?Pg=Entrega4.htm http://www.ehu.eus/mrodriguez/archivos/csharppdf/Lenguaje/Tipos.pdf http://mercurio.ugr.es/pedro/tutoriales/cursos/csharp/variables.htm https://msdn.microsoft.com/es-es/library/s0b0c0z1%28v=vs.90%29.aspx
Blibliografía: Español | PDF | 44 MB | Autor: J. Ferguson, B. Patterson, J. Beres, P. Boutquin, M. Gupta | Anaya Multimedia | 835 Págs.
