DPRN1_U1_A2_JOCD

Programación net I (DS-DPRN1-1602-B1-001) Actividad 2. Tipos de datos y operadores. Elaborado por: José Antonio Casales Díaz. Matricula: ES1511104179 Presentado a la Tutora. LILIANA CORONA GRANADOS. Universidad Nacional Abierta y a Distancia UNADM

¿Qué es un Operador? Cuando nos referimos a un operador es a un elemento que se aplica una o varias veces en una instrucción, los operadores que necesitan un operando, como el operador de incremento y son operadores unarios. Los operadores que emplean dos operandos son operadores binarios. Los operadores condicionales empelan a tres operandos. Los operadores según su función son:  Aritméticos  Relacionales  De Asignación  Lógicos  De dirección  Manejo de Bit Operador = *= /= += -= %= = &= ^= |=

Acción Asignación básica Asigna producto Asigna división Asigna suma Asigna resta Asigna modulo Asigna desplazamiento izquierda Asigna desplazamiento derecha Asigna ADN entre bits Asigna XOR entre bits Asigna OR entre bits

Aritméticos: Se usan para realizar cálculos y operaciones con números reales y punteros, básicamente permiten hacer cualquier operación aritmética que se necesite. Operador + * / % -++

Acción Resta Suma Multiplicación División Módulo Decremento Incremento

Relacionales: También se denominan operadores binarios lógicos o de comparación, son respuestas a preguntas para ver si es cierto o falso y producen un resultado booleano.

Operador < > = == ¡=

Relación Menor Mayor Menor o igual Mayor o igual Igual Diferente

Lógicos: Son productos de resultados booleanos y sus operandos son también son valores lógicos a ellos (siendo los valores numéricos asimilados a cierto o falso según su valor sea cero o distinto de cero). ADN Lógico: Devuelve un valor lógico true si ambos operandos son ciertos. En caso contrario el resultado es false. OR Lógico: Este operador binario devuelve true si alguno de los operandos es cierto. En caso contrario devuelve false. Negación Lógica: Este operador es denominado también NO lógica y se representa en el texto escrito por la palabra NOT. El operador evalúa el resultado cierto / falso y cambia su valor si es cierto a falso o viceversa. Operador && || ¡

Acción ADN Lógico OR Lógico Negación Lógica

De Bits: Convierten una determinada cantidad a su equivalente en bits para posteriormente realizar un desplazamiento de dicho valor. Operador > ~ & ^ |

Relación Desplazamiento a izquierda Desplazamiento a derecha Complemento ADN XOR OR

De direcciones: Además de los operadores aritméticos, de los que existen versiones para los tipos numéricos y para los punteros, C++ dispone de dos operadores específicos para estos últimos (punteros de cualquier tipo): la indirección “*” y la referencia “&” . Además existen dos operadores específicos para punteros-a-clases. Operador * & .* ->

Nombre Deferencia o indirección Referencia o dirección Indireccion de puntero a miembro Indirección de puntero a clase

Operadores Principales C# Operad or (símbol o)

Operador (descripción)

Clasificac ión

x.y:

Acceso a miembros.

Aritmético s

x?.y:

Acceso a miembros condicional null. Devuelve null si el operando izquierdo es null.

Relacional

f(x):

Invocación de función.

Aritmético s

a[x]:

Indización de objeto agregado.

Relacional

a?[x]:

Indización condicional null. Devuelve null si el operando izquierdo es null.

Relacional

x++:

Incremento de postfijo. Devuelve el valor de x y, a continuación, actualiza la

Lógicos

Ejemplo de Aplicación // The class Console in namespace System: System.Console.WriteLine("hello"); int? length = customers?.Length; // null if customers is null Customer first = customers?[0]; // null if customers is null double x = 1234.7; int a; a = (int)x; // Cast double to int int[] fib; // fib is of type int[], "array of int". fib = new int[100]; // Create a 100element int array. int? length = customers?.Length; // null if customers is null Customer first = customers?[0]; // null if customers is null int? count = customers? [0]?.Orders?.Count(); // null if customers, the first customer, or Orders is null //++ operator class MainClass {

static void Main() { double x; x = 1.5; Console.WriteLine(++x); x = 1.5; Console.WriteLine(x++); Console.WriteLine(x); }

ubicación de almacenamiento con el valor de x que es uno mayor.

} /* Output 2.5 1.5 2.5 */ class MainClass5 { static void Main() { double x; x = 1.5; Console.WriteLine(--x); x = 1.5; Console.WriteLine(x--); Console.WriteLine(x); } } /* Output: 0.5 1.5 0.5 */

x--:

Decremento de postfijo. Devuelve el valor de x; a continuación, actualiza la ubicación de almacenamiento con el valor de x que es uno menos.

Lógicos

New:

Creación de instancias de tipo.

Aritmético s

Class1 obj = new Class1();

Relacional

System.Type type = typeof(int);

Relacional

// The following example causes compiler error CS0220 because 2147483647 // is the maximum value for integers. //int i1 = 2147483647 + 10;

Typeof: Checked:

Devuelve el objeto System.Type que representa el operando. Habilita la comprobación de desbordamiento para operaciones con enteros.

// The following example, which

includes variable ten, does not cause // a compiler error. int ten = 10; int i2 = 2147483647 + ten;

Uncheck ed:

default(T ):

Deshabilita la comprobación de desbordamiento para operaciones con enteros. Este es el comportamiento predeterminado del compilador. Devuelve el valor inicializado predeterminado de tipo T, null para tipos de referencia, cero para tipos numéricos y cero o null en miembros para tipos de struct.

Relacional

Lógico

// By default, the overflow in the previous statement also does // not cause a run-time exception. The following line displays // -2,147,483,639 as the sum of 2,147,483,647 and 10. Console.WriteLine(i2); unchecked { int1 = 2147483647 + 10; } int1 = unchecked(ConstantMax + 10); namespace ConsoleApplication1 { class Program { static void Main(string[] args) { // Test with a non-empty list of integers. GenericList gll = new GenericList(); gll.AddNode(5); gll.AddNode(4); gll.AddNode(3); int intVal = gll.GetLast(); // The following line displays 5. System.Console.WriteLine(intVal); // Test with an empty list of integers. GenericList gll2 = new GenericList(); intVal = gll2.GetLast(); // The following line displays 0. System.Console.WriteLine(intVal); // Test with a non-empty list of strings. GenericList gll3 = new GenericList(); gll3.AddNode("five"); gll3.AddNode("four"); string sVal = gll3.GetLast(); // The following line displays five. System.Console.WriteLine(sVal); // Test with an empty list of strings. GenericList gll4 = new GenericList(); sVal = gll4.GetLast(); // The following line displays a blank line. System.Console.WriteLine(sVal);

} } // T is the type of data stored in a particular instance of GenericList. public class GenericList { private class Node { // Each node has a reference to the next node in the list. public Node Next; // Each node holds a value of type T. public T Data; } // The list is initially empty. private Node head = null; // Add a node at the beginning of the list with t as its data value. public void AddNode(T t) { Node newNode = new Node(); newNode.Next = head; newNode.Data = t; head = newNode; } // The following method returns the data value stored in the last node in // the list. If the list is empty, the default value for type T is // returned. public T GetLast() { // The value of temp is returned as the value of the method. // The following declaration initializes temp to the appropriate // default value for type T. The default value is returned if the // list is empty. T temp = default(T); Node current = head; while (current != null) { temp = current.Data; current = current.Next; } return temp; } } }

Delegate :

Declara y devuelve instancia de delegado.

una

Relacional

void StartThread() { System.Threading.Thread t1 = new System.Threading.Thread (delegate() {

System.Console.Write("Hello, ");

Sizeof:

Devuelve el tamaño en bytes del operando de tipo.

Relacional

System.Console.WriteLine("World!"); }); t1.Start(); } // Constant value 4: int intSize = sizeof(int); // compile with: /unsafe struct Point { public int x, y; }

->:

Tipo de dato byte

sbyte

short

Referenciación del puntero combinada con acceso a miembros.

Clase C# Indica un tipo integral que almacena valores Indica un tipo integral que almacena valores de acuerdo con el tamaño y el rango: -128 to 127 Entero de 8 bits. Denota un tipo de datos integral que almacena valores de acuerdo con el

Lógico

class MainClass12 { unsafe static void Main() { Point pt = new Point(); Point* pp = &pt; pp->x = 123; pp->y = 456; Console.WriteLine("{0} {1}", pt.x, pt.y); } } /* Output: 123 456 */

Tipo de datos C# Rango de Ejemplo de declaración valores Sbyte o byte x = 10, y = 20; char byte , ushort, public static void SampleMethod(int i) {} uint, public static void SampleMethod(sbyte b) {} ulong o char sbyte , public static void SampleMethod(int i) {} byte, public static void SampleMethod(short s) {} ushort,

ushort

tamaño y el rango: -32,768 to 32,767 tamaño Entero de 16 bits Indica un tipo de datos integral que almacena valores de acuerdo con el tamaño y el rango: 0 a 65,535 Entero sin signo de 16 bits

int

Denota un tipo integral que almacena valores de acuerdo con el tamaño y el rango: -2,147,483,648 to 2,147,483,647 Entero de 32 bits

unit

Significa un tipo integral que almacena valores de acuerdo con el tamaño y el rango: 0 a 4,294,967,295 Entero sin signo de 32 bits

long

Indica un tipo integral que almacena valores de acuerdo con el tamaño y el rango: – 9,223,372,036,854,775,80 8 to 9,223,372,036,854,775,80 7 Entero de 64 bits

ulong

Denota un tipo integral que almacena valores de acuerdo con el tamaño y el rango: 0 a 18,446,744,073,709,551,6 15 Entero de 64 bits

char

Se utiliza para declarar una instancia de la estructura System.Char que el .NET Framework utiliza para representar un carácter Único. El valor de un objeto Char es un valor numérico ( ordinal ) de 16 bits . Caracteres Unicode se utilizan para

uint, ulong o char sbyte , byte, short o char sbyte , byte, short, ushort, uint, ulong,o char sbyte , byte, short, ushort, int o char sbyte , byte, short, ushort, int, uint, ulong o char sbyte , byte, short, ushort, int, uint, long o char sbyte , byte o short

public static void SampleMethod(int i) {} public static void SampleMethod(ushort s) {}

// '123' is an int, so an implicit conversion takes place here: float f = 123;

Console.WriteLine(44U.GetType()); Console.WriteLine(323442434344U.GetType( ));

public static void SampleMethod(int i) {} public static void SampleMethod(long l) {}

Console.WriteLine(9223372036854775808L. GetType()); Console.WriteLine(123UL.GetType()); Console.WriteLine((123UL + 456).GetType()); char[] chars = new char[4]; chars[0] chars[1] chars[2] type chars[3]

= 'X'; // Character literal = '\x0058'; // Hexadecimal = (char)88; // Cast from integral = '\u0058'; // Unicode

foreach (char c in chars) {

representar la mayoría de los idiomas escritos en todo el mundo. Su rango U+0000 to U+FFFF Su tamaño de caracteres Unicode de 16 bits

float

double

decim al

Console.Write(c + " "); } // Output: X X X X

Significa un tipo simple que almacena valores de coma flotante de 32 bits. Intervalo aproximado -3.4 × 1038to +3.4 × 1038 Precisión 7 dígitos

sbyte , byte, short, ushort, int, uint, long, ulong, char o decimal

Significa un tipo simple que almacena valores de coma flotante de 64 bits. Rango aproximado ±5.0 × 10−324 to ±1.7 × 10308 Precisión 15 – 16 digitos.

sbyte , byte, short, ushort, int, uint, long, ulong, char, float o decimal

Indica un tipo de datos de 128 bits. En comparación con los tipos de coma flotante, el tipo decimal tiene más precisión y un

sbyte , byte, short, ushort, int, uint,

class FloatTest { static void Main() { int x = 3; float y = 4.5f; short z = 5; var result = x * y / z; Console.WriteLine("The result is {0}", result); Type type = result.GetType(); Console.WriteLine("result is of type {0}", type.ToString()); } } /* Output: The result is 2.7 result is of type System.Single //'float' is alias for 'Single' */ // Mixing types in expressions class MixedTypes { static void Main() { int x = 3; float y = 4.5f; short z = 5; double w = 1.7E+3; // Result of the 2nd argument is a double: Console.WriteLine("The sum is {0}", x + y + z + w); } } // Output: The sum is 1712.5 double dub = 9; // The following line causes an error that reads "Operator '+' cannot be applied to // operands of type 'double' and 'decimal'" Console.WriteLine(dec + dub);

rango más pequeño , lo que hace que sea adecuada para los cálculos financieros y monetarios. Rango aproximado (-7.9 x 1028 to 7.9 x 1028) / (100 to 28) Precisión 28-29 dígitos significativos

long, ulong, char, float o double

// You can fix the error by using explicit casting of either operand. Console.WriteLine(dec + (decimal)dub); Console.WriteLine((double)dec + dub);

Conversión Tipos

Conversiones Implícitas

Conversiones explicitas

Descripción En los tipos numéricos integrados, pude realizarse una conversión implícita cuando el valor que se va a almacenar puede ajustar a la variable sin necesidad de truncamiento o redondeo. Ejemplo: Una variable de tipo long (entero de 8 bytes) puede almacenar cualquier valor que pueda almacenar a su vez un elemento int (4 bytes en un equipo de 32 bits). El compilador convierte implícitamente el valor de la derecha en un tipo long antes de asignarlo a bigNum. // Implicit conversion. num long can // hold any value an int can hold, and more! int num = 2147483647; long bigNum = num; Sin embargo, si no se puede realizar una conversión sin riesgo de perder información, el compilador requiere que se realice una conversión explícita, denominada conversión de tipo. Una conversión de tipo es una manera de informar al compilador de forma explícita de que pretende realizar la conversión y que está al tanto de que puede producirse una pérdida de datos. Para realizar una conversión de tipo, especifique entre paréntesis el tipo al que se va a aplicar dicha conversión delante del valor o la variable que se va a convertir. El programa siguiente convierte un tipo double a un tipo int. El programa no se compilará sin el operador de conversión de tipo. class Test { static void Main() { double x = 1234.7; int a; // Cast double to int. a = (int)x; System.Console.WriteLine(a); }

}

Bibliografía: UNADM. (2016). Unidad 1 Introduccion a .NET. 2016, de UNADM Sitio web: https://unadmexico.blackboard.com/bbcswebdav/institution/DCEIT/2016_S2_B1/ DS/05/DPRN1/U1/Unidad_1_Introduccion_a_NET.pdf Microsoft. (2016). Developer Network. 2016, de Microsoft Sitio web: https://msdn.microsoft.com/en-us/default.aspx