C# | Tipos de datos

Los tipos de datos especifican el tipo de datos que puede contener una variable de C# válida. C# es un lenguaje de programación fuertemente tipado porque en C# , cada tipo de datos (como enteros, caracteres, flotantes, etc.) está predefinido como parte del lenguaje de programación y todas las constantes o variables definidas para un programa determinado deben describirse con uno de los tipos de datos.

Los tipos de datos en C# se dividen principalmente en tres categorías

  • Tipos de datos de valor
  • Tipos de datos de referencia
  • Tipo de datos de puntero
  1. Tipos de datos de valor: en C# , los tipos de datos de valor almacenarán directamente el valor de la variable en la memoria y también aceptarán literales con y sin signo. La clase derivada para estos tipos de datos es System.ValueType . Los siguientes son diferentes tipos de datos de valor en el lenguaje de programación C# :
    • Tipos integrales con signo y sin signo: hay 8 tipos integrales que brindan soporte para valores de 8 bits, 16 bits, 32 bits y 64 bits en formato con signo o sin signo.
      Alias Escribe un nombre Escribe Tamaño (bits) Rango Valor por defecto
      sbyte Sistema.Sbyte entero con signo 8 -128 a 127 0
      corto Sistema.Int16 entero con signo dieciséis -32768 a 32767 0
      En t Sistema.Int32 entero con signo 32 -2 31 a 2 31 -1 0
      largo Sistema.Int64 entero con signo 64 -2 63 a 2 63 -1 0L
      byte Sistema.byte entero sin signo 8 0 a 255 0
      corto Sistema.UInt16 entero sin signo dieciséis 0 a 65535 0
      uint Sistema.UInt32 entero sin signo 32 0 a 2 32 0
      largo Sistema.UInt64 entero sin signo 64 0 a 2 63 0
    • Tipos de punto flotante: hay 2 tipos de datos de punto flotante que contienen el punto decimal.

      • Flotante : es un tipo de punto flotante de precisión simple de 32 bits . Tiene precisión de 7 dígitos. Para inicializar una variable flotante, use el sufijo f o F. Como, float x = 3.5F;. Si el sufijo F o f no se usa, entonces se trata como doble.
      • Doble : es un tipo de punto flotante de precisión doble de 64 bits . Tiene una precisión de 14 a 15 dígitos. Para inicializar una variable doble, use el sufijo d o D. Pero no es obligatorio usar el sufijo porque, por defecto, los tipos de datos flotantes son de tipo doble.
      Alias Escribe un nombre Tamaño (bits) Rango (aproximado) Valor por defecto
      flotar Sistema.Único 32 ±1,5 × 10 -45 a ±3,4 × 10 38 0.0F
      doble Sistema.Doble 64 ±5,0 × 10 -324 a ±1,7 × 10 308 0.0D
    • Tipos decimales: el tipo decimal es un tipo de datos de 128 bits adecuado para cálculos financieros y monetarios. Tiene una precisión de 28-29 dígitos. Para inicializar una variable decimal, use el sufijo m o M. Como, decimal x = 300.5m;. Si el sufijo m o M no se usa, entonces se trata como doble.
      Alias Escribe un nombre Tamaño (bits) Rango (aproximado) Valor por defecto
      decimal Sistema.Decimal 128 ±1,0 × 10 -28 a ±7,9228 × 10 28 0.0M
    • Tipos de caracteres: los tipos de caracteres representan una unidad de código UTF-16 o representan el carácter Unicode de 16 bits.
      Alias Escribe un nombre Tamaño en (bits) Rango Valor por defecto
      carbonizarse Sistema.Char dieciséis U +0000 a U +ffff ‘\0’
    • Ejemplo :

      // C# program to demonstrate 
      // the above data types
      using System;
      namespace ValueTypeTest {
            
      class GeeksforGeeks {
            
          // Main function
          static void Main()
          {
                
              // declaring character
              char a = 'G';
        
              // Integer data type is generally
              // used for numeric values
              int i = 89;
        
              short s = 56;
                
              // this will give error as number
              // is larger than short range
              // short s1 = 87878787878;
        
              // long uses Integer values which 
              // may signed or unsigned
              long l = 4564;
        
              // UInt data type is generally
              // used for unsigned integer values
              uint ui = 95;
        
              ushort us = 76;
              // this will give error as number is
              // larger than short range
        
              // ulong data type is generally
              // used for unsigned integer values
              ulong ul = 3624573;
        
              // by default fraction value
              // is double in C#
              double d = 8.358674532;
        
              // for float use 'f' as suffix
              float f = 3.7330645f;
        
              // for float use 'm' as suffix
              decimal dec = 389.5m;
        
              Console.WriteLine("char: " + a);
              Console.WriteLine("integer: " + i);
              Console.WriteLine("short: " + s);
              Console.WriteLine("long: " + l);
              Console.WriteLine("float: " + f);
              Console.WriteLine("double: " + d);
              Console.WriteLine("decimal: " + dec);
              Console.WriteLine("Unsinged integer: " + ui);
              Console.WriteLine("Unsinged short: " + us);
              Console.WriteLine("Unsinged long: " + ul);
          }
      }
      }

      Producción :

    char: G
    integer: 89
    short: 56
    long: 4564
    float: 3.733064
    double: 8.358674532
    decimal: 389.5
    Unsinged integer: 95
    Unsinged short: 76
    Unsinged long: 3624573
    

    Ejemplo :

    // C# program to demonstrate the Sbyte
    // signed integral data type
    using System;
    namespace ValueTypeTest {
      
    class GeeksforGeeks {
      
        // Main function
        static void Main()
        {
            sbyte a = 126;
      
            // sbyte is 8 bit 
            // singned value
            Console.WriteLine(a);
      
            a++;
            Console.WriteLine(a);
      
            // It overflows here because
            // byte can hold values 
            // from -128 to 127
            a++;
            Console.WriteLine(a);
      
            // Looping back within 
            // the range
            a++;
            Console.WriteLine(a);
        }
    }
    }

    Producción :

    126
    127
    -128
    -127
    

    Ejemplo :

    // C# program to demonstrate 
    // the byte data type
    using System;
    namespace ValueTypeTest {
      
    class GeeksforGeeks {
          
        // Main function
        static void Main()
        {
            byte a = 0;
      
            // byte is 8 bit 
            // unsigned value
            Console.WriteLine(a);
      
            a++;
            Console.WriteLine(a);
      
            a = 254;
              
            // It overflows here because
            // byte can hold values from
            // 0 to 255
            a++;
            Console.WriteLine(a);
      
            // Looping back within the range
            a++;
            Console.WriteLine(a);
        }
    }
    }

    Producción :

    0
    1
    255
    0
    
  2. Tipos booleanos: se le debe asignar un valor verdadero o falso. Los valores de tipo bool no se convierten implícita o explícitamente (con conversiones) a ningún otro tipo. Pero el programador puede escribir fácilmente el código de conversión.
    Alias Escribe un nombre Valores
    bool Sistema.Booleano Verdadero Falso

    Ejemplo :

    // C# program to demonstrate the
    // boolean data type
    using System;
    namespace ValueTypeTest {
          
        class GeeksforGeeks {
              
        // Main function
        static void Main() 
        {
              
            // boolean data type
            bool b = true;     
            if (b == true)
                Console.WriteLine("Hi Geek");
        
    }
    }

    Producción :

    Hi Geek
    
  3. Tipos de datos de referencia: los tipos de datos de referencia contendrán una dirección de memoria de valor variable porque los tipos de referencia no almacenarán el valor variable directamente en la memoria. Los tipos de referencia incorporados son string, objeto.
    • String: Representa una secuencia de caracteres Unicode y su nombre de tipo es System.String . Entonces, string y String son equivalentes.
      Ejemplo :
      string s1 = "hello"; // creating through string keyword  
      String s2 = "welcome"; // creating through String class  
      
    • Objeto: en C#, todos los tipos, predefinidos y definidos por el usuario, tipos de referencia y tipos de valor, heredan directa o indirectamente de Objeto. Básicamente, es la clase base para todos los tipos de datos en C#. Antes de asignar valores, necesita conversión de tipos. Cuando una variable de un tipo de valor se convierte en objeto, se denomina boxeo . Cuando una variable de tipo objeto se convierte en un tipo de valor, se denomina unboxing . Su nombre de tipo es System.Object .
    • Ejemplo :

      // C# program to demonstrate 
      // the Reference data types
      using System;
      namespace ValueTypeTest {
            
      class GeeksforGeeks {
            
          // Main Function
          static void Main() 
          {
                
              // declaring string
              string a = "Geeks"
                
              //append in a
              a+="for";
              a = a+"Geeks"
              Console.WriteLine(a);
                
              // declare object obj
              object obj;
              obj = 20;
              Console.WriteLine(obj);
                
              // to show type of object
              // using GetType()
              Console.WriteLine(obj.GetType()); 
          
      }
      }

      Producción :

    GeeksforGeeks
    20
    System.Int32
    
  4. Tipo de datos de puntero: los tipos de datos de puntero contendrán una dirección de memoria del valor de la variable.
    Para obtener los detalles del puntero, tenemos dos símbolos ampersand (&) y asterisco (*) .
    ampersand (&) : se conoce como operador de direcciones. Se utiliza para determinar la dirección de una variable.
    asterisco (*) : También conocido como Operador de Indirección. Se utiliza para acceder al valor de una dirección.
    Sintaxis:
    type* identifier;
    

    Ejemplo :

    int* p1, p;   // Valid syntax
    int *p1, *p;   // Invalid 
    

    Ejemplo :

    // Note: This program will not work on
    // online compiler
    // Error: Unsafe code requires the `unsafe' 
    // command line option to be specified
    // For its solution:
    // Go to your project properties page and
    // check under Build the checkbox Allow
    // unsafe code.
    using System;
    namespace Pointerprogram {
          
    class GFG {
      
        // Main function
        static void Main()
        {
            unsafe
            {
                  
                // declare variable
                int n = 10;
                  
                // store variable n address 
                // location in pointer variable p
                int* p = &n;
                Console.WriteLine("Value :{0}", n);
                Console.WriteLine("Address :{0}", (int)p);
            }
        }
    }
    }

Publicación traducida automáticamente

Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *