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 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
- 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.
- 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
- String: Representa una secuencia de caracteres Unicode y su nombre de tipo es System.String . Entonces, string y String son equivalentes.
- 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