C# | Tipos de datos – Part 1

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

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 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 ³¹ a 2 ³¹ -1	0
largo	Sistema.Int64	entero con signo	64	-2 ⁶³ a 2 ⁶³ -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 ³²	0
largo	Sistema.UInt64	entero sin signo	64	0 a 2 ⁶³	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 ³⁸	0.0F
doble	Sistema.Doble	64	± 5,0 × 10 ^-324 a ±1,7 × 10 ³⁰⁸	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 ²⁸ 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’

Alias	Escribe un nombre	Tamaño (bits)	Rango (aproximado)	Valor por defecto
decimal	Sistema.Decimal	128	±1,0 × 10 ^-28 a ±7,9228 × 10 ²⁸	0.0M

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 :

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 :

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

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

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 dirección. 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 Cancelar la respuesta