Tipos de datos y operaciones en lenguaje C. expresiones. Tipos de datos en lenguaje C

El programador dice:

¡Hola! Leí tu artículo. Estaba muy triste y divertido al mismo tiempo. Esta frase tuya es especialmente matadora: "Dado que una variable de tipo char se usa a menudo como una matriz, se determina el número de valores posibles". 😆 😆 😆
No me estoy riendo de ti. Crear un sitio web es realmente una hazaña. Sólo quiero apoyarte con consejos y señalar algunos errores.

1. El valor de una variable de tipo char se asigna de la siguiente manera:

Aquí:

Carácter a = *"A";

Se elimina la dirección del puntero a la matriz y, como resultado, se devuelve el valor del primer elemento de la matriz, es decir 'A'

2. El reinicio se produce de la siguiente manera:

Carácter a = NULO;
carácter b = ();

//Y así se borra la línea del cuerpo del programa

"" - este símbolo se llama terminador cero. Se coloca al final de la línea. Usted mismo, sin saberlo, llenó la matriz s1 de su artículo con este símbolo. Pero fue posible asignar este símbolo sólo al elemento cero de la matriz.

3. Siéntete libre de utilizar terminología.
El signo = es una operación de asignación.
El signo * es una operación de eliminación de direcciones.
Me refiero a este fragmento del artículo: “Todo resultó tan sencillo, había que poner un signo * delante del signo = y había que declarar el número del elemento (el cero corresponde al primero)”

No me malinterpretes, el artículo no puede existir en su forma actual. No seas perezoso, reescríbelo.
¡Tienes una gran responsabilidad! Lo digo en serio. Las páginas de su sitio están incluidas en la primera página de resultados de Yandex. Mucha gente ya ha empezado a repetir tus errores.

¡Buena suerte! ¡Puedes hacerlo!

:
Lo sé desde hace mucho tiempo, simplemente es difícil releer 200 artículos constantemente para corregir algo. Y algunos tipos groseros escriben de tal manera que, aun sabiendo qué es mejor corregir, no están en absoluto dispuestos a corregirlo.

Estaré encantado de corregir otros errores. corregir cualquier inexactitud si aparece. Aprecio tu ayuda. Gracias, lo sé desde hace mucho tiempo, es difícil releer 200 artículos constantemente para corregir algo. Y algunos tipos groseros escriben de tal manera que, aun sabiendo qué es mejor corregir, no están en absoluto dispuestos a corregirlo.
Con tu char b = (); Esto no es reducción a cero en absoluto. Al menos deberían comprobarlo.
si hablamos del caracter nulo "" ; Cuando llené la línea, sabía bien que el objetivo era mostrar una limpieza real, y no algo visible a simple vista, porque la línea incluye basura, que a veces estorba. Debería tener más cuidado con los términos "símbolo de terminación nula" o simplemente "símbolo nulo", no un terminador))) Y el símbolo de terminador suena genial.

Modernizaré el artículo, pero no cambiaré al estilo de otra persona. Si creo que es más fácil para un principiante entenderlo de esta manera que como quiere, lo dejaré así. No me malinterpretes tampoco. La palabra "signo" es mucho más fácil de entender y recordar para un principiante débil que la definición y el nombre de cada signo. No hay ningún error en esto, es una señal, una señal. Menos énfasis en uno da más énfasis en el otro.

Estaré encantado de corregir otros errores. corregir cualquier inexactitud si aparece. Aprecio tu ayuda. Gracias.

¡Hola de nuevo!
Quiero aclarar. Mi profesor en la universidad utilizó el término "terminador cero" (terminador del inglés limitador). ¡Aparentemente esto es de la vieja escuela!
En cuanto a restablecer filas.
carácter b = (); Esto es realmente un reinicio. Toda la matriz está llena de ceros. Si no me crees, ¡compruébalo!
Si consideramos una línea en su sentido natural y cotidiano, entonces una línea "vacía" será una línea en la que no hay un solo carácter. Por tanto, en el 99,9% de los casos basta con poner un carácter nulo al principio. Normalmente, una cadena se procesa hasta el primer carácter nulo y los caracteres que vienen después ya no son importantes. Entiendo que querías restablecer la línea. Simplemente decidí ofrecer una opción clásica probada en el tiempo.

:
Cuando "normalmente el procesamiento de cadenas llega hasta el primer carácter nulo y los caracteres que vienen después ya no son importantes", sí, la cadena se anula
Si consideramos la "puesta a cero real de todas las celdas de una fila (sobre la cual escribí)", no, no es la puesta a cero, e incluso el primer carácter no es cero. Marqué esta opción. MinGW(CodeBlock): toda la matriz proporciona el carácter "a"
No creo que esto sea motivo de debate.

Las variables se utilizan para almacenar diversos datos en lenguajes de programación. Una variable es un área de memoria que tiene un nombre, también llamado identificador.

Al darle un nombre a una variable, el programador al mismo tiempo nombra el área de memoria donde se escribirán los valores de la variable para su almacenamiento.

Es un buen estilo nombrar las variables de manera significativa. Se permite el uso de letras minúsculas y mayúsculas, números y el guión bajo, que se considera una letra en C. El primer carácter debe ser una letra y no debe haber espacios en el nombre de la variable. En las versiones modernas de los compiladores, la longitud del nombre es prácticamente ilimitada. El nombre de la variable no puede coincidir con las palabras clave reservadas. Las letras mayúsculas y minúsculas en los nombres de las variables son diferentes, las variables a Y A- diferentes variables.

Palabras clave reservadas auto double int struct break else registro de cambio largo tupedef char extern return void case float unsigned default para unión firmada hacer si sizeof volátil continuar enumeración por poco tiempo
En C, todas las variables deben declararse. Esto significa que, en primer lugar, al inicio de cada programa o función debes proporcionar una lista de todas las variables utilizadas, y en segundo lugar, indicar el tipo de cada una de ellas.

Cuando se declara una variable, el compilador le asigna espacio de memoria según su tipo. AVR GCC trabaja con tipos de datos utilizando herramientas estándar carbonizarse(tipo de carácter) y En t(tipo entero).

Escriba carácter

carbonizarse- es el tipo más económico. El tipo de carácter puede estar firmado o sin firmar. Denotado en consecuencia como " carácter firmado" (tipo firmado) y " carácter sin firmar" (tipo sin signo). El tipo con signo puede almacenar valores en el rango de -128 a +127. Sin signo: de 0 a 255. Una variable char tiene 1 byte de memoria (8 bits).

Palabras clave (modificadores) firmado Y no firmado indique cómo se interpreta el bit cero de la variable declarada, es decir, si se especifica la palabra clave sin signo, entonces el bit cero se interpreta como parte de un número; de lo contrario, el bit cero se interpreta como con signo.

Escribe entero

Valor entero En t Tal vez corto(corto) o largo(largo).

Palabra clave (modificador) corto colocado después de las palabras clave firmado o no firmado. Así, se distinguen los siguientes tipos: int corto con signo, int corto sin signo, int largo con signo, int largo sin signo.

Tipo de variable int corto firmado(entero corto con signo) puede tomar valores de -32768 a +32767, int corto sin firmar(entero corto sin signo): de 0 a 65535. Para cada uno de ellos se asignan exactamente dos bytes de memoria (16 bits).

Al declarar una variable de tipo int corto firmado palabras clave firmado Y corto se puede omitir, y dicho tipo de variable se puede declarar simplemente En t. También es posible declarar este tipo con una palabra clave. corto.

Variable int corto sin firmar puede ser declarado como entero sin firmar o corto sin firmar.

Para cada tamaño firmado int largo o int largo sin firmar Se asignan 4 bytes de memoria (32 bits). Los valores de variables de este tipo pueden estar en los rangos de -2147483648 a 2147483647 y de 0 a 4294967295, respectivamente.

También hay variables como largo largo int, para el cual se asignan 8 bytes de memoria (64 bits). También pueden estar firmados o sin firmar. Para un tipo con signo, el rango de valores es de -9223372036854775808 a 9223372036854775807, para un tipo sin signo, de 0 a 18446744073709551615. Un tipo con signo se puede declarar simplemente mediante dos palabras clave largo largo.

Las variables se declaran en una declaración de declaración. La declaración consta de una especificación de tipo y una lista de nombres de variables separados por comas. Debe haber un punto y coma al final.

Una declaración de variable tiene el siguiente formato:

[modificadores] identificador de especificador de tipo [, identificador] ...

Modificadores- palabras clave firmado, no firmado, corto, largo.
Especificador de tipo- palabra clave carbonizarse o En t, que determina el tipo de variable declarada.
Identificador- nombre de la variable.

Ejemplo: carácter x; ent a, b, c; sin firmar, largo, largo y;
De esta manera se declararán las variables. X, a, b, C, y. a una variable X será posible escribir valores desde -128 hasta 127. En variables a, b, C- de -32768 a +32767. a una variable y- de 0 a 18446744073709551615.

Inicializar el valor de una variable tras la declaración

Cuando se declara, una variable se puede inicializar, es decir, se le puede asignar un valor inicial. Puedes hacer esto de la siguiente manera. entero x = 100; Así, en la variable X Cuando se anuncie, el número 100 se anotará inmediatamente.

Es mejor evitar mezclar variables inicializadas en una declaración de declaración, es decir, es mejor declarar las variables inicializadas en líneas separadas.

Una variable de cualquier tipo puede declararse no modificable. Esto se logra agregando la palabra clave constante al especificador de tipo. Variables con tipo constante Son datos de solo lectura, lo que significa que a la variable no se le puede asignar un nuevo valor. Si después de la palabra constante Si no hay un especificador de tipo, las constantes se tratan como valores con signo y se les asigna un tipo. En t o largo int según el valor de la constante: si la constante es menor que 32768, entonces se le asigna el tipo En t, de lo contrario largo int.

Ejemplo: const long int k = 25; constante m = -50; // implícita constante int m=-50 constante n = 100000; // implícita const long int n=100000

El signo "=" se utiliza para la asignación en C. Se evalúa la expresión a la derecha del signo de asignación y el valor resultante se asigna a la variable a la izquierda del signo de asignación. En este caso, el valor anterior almacenado en la variable se borra y se reemplaza por uno nuevo.

El operador "=" no debe entenderse como igualdad.
Por ejemplo, la expresión a = 5; debe leerse como "asignar variable a a 5".

Ejemplos: x = 5 + 3; // suma los valores 5 y 3, // asigna el resultado a la variable x (escribe en la variable x) b = a + 4; // suma 4 al valor almacenado en la variable a, // asigna el resultado resultante a la variable b (escribe en la variable b) segundo = segundo + 2; // suma 2 al valor almacenado en la variable b, // asigna el resultado resultante a la variable b (escribe en la variable b)
En el lado derecho, el valor de la variable se puede utilizar varias veces: c = b * b + 3 * b;

Ejemplo: x = 3; // a la variable x se le asignará el valor 3 y = x + 5; // el número 5 se sumará al valor almacenado en la variable x, // el resultado resultante se escribirá en la variable y z = x * y; // los valores de las variables x e y se multiplicarán, // el resultado se escribirá en la variable z z = z - 1; // se restará 1 del valor almacenado en la variable z // el resultado se escribirá en la variable z
Así, en la variable z el número 23 será almacenado

Además del operador de asignación simple "=", hay varios operadores de asignación combinados más en C: "+=", "-=", "*=
Ejemplos: x += y; // igual que x = x + y; - suma x e y // y escribe el resultado en la variable x x-= y; // igual que x = x - y; - restar el valor y de x // y escribir el resultado en la variable x x *= y; // igual que x = x * y; - multiplica x por y // y escribe el resultado en la variable x x /= y; // igual que x = x / y; - divide x por y // y escribe el resultado en la variable x x %= y; // igual que x = x % y; // calcula el resto entero al dividir x por y // y escribe el resultado en la variable x

Si necesita cambiar el valor de una variable a 1, utilice incremento o decremento.

Incremento- la operación de aumentar en 1 el valor almacenado en una variable.

Ejemplo: x++; // el valor de la variable x se incrementará en 1$WinAVR = ($_GET["avr"]); si($WinAVR) incluye($WinAVR);?>
Decremento- la operación de disminuir en 1 el valor almacenado en una variable.

Ejemplo: x--; // el valor de la variable x se reducirá en 1
Incremento y decremento son operadores de asignación. Cuando utilice decremento e incremento junto con el operador de asignación "=", utilice la notación de sufijo (x++) o prefijo (++x). La entrada del prefijo se ejecuta primero.

Ejemplos: y = x++;
Supongamos que en la variable X Luego se almacenó el valor 5. y se escribirá el valor 5, después de lo cual el valor de la variable X se incrementará en 1. Así, en y serán 5, y en X- 6. y = --x;
si en X Si se almacenó el valor 5, entonces la disminución se realizará primero X a 4 y luego este valor será asignado a la variable y. De este modo, X Y y se le asignará el valor 4.

Todos los datos en lenguaje C tienen su propio tipo. Las variables de determinados tipos ocupan algo de espacio en la memoria, que varía según el tipo. En C no existe una asignación clara de la cantidad de memoria a ciertos tipos. Esto se da para la implementación de un compilador específico para una plataforma específica. Por ejemplo, una variable como En t en un compilador puede ocupar 16 bits en la memoria, en otro, 32 bits, en un tercero, 8 bits. Todo está determinado por el compilador específico. Es cierto que todo el mundo se esfuerza por lograr la universalización y, básicamente, en la mayoría de los compiladores el tipo En t , por ejemplo, ocupa 2 bytes y el tipo carbonizarse - uno.

He sido un poco tonto últimamente, no podía recordar cuántos bytes ocupa un tipo. doble V AVR-CCG. Normalmente, al programar controladores, se trabaja con tipos de números enteros, como En t Y carbonizarse , y no se suele recurrir a tipos de punto flotante debido a su consumo de recursos.

Por lo tanto, para el futuro, me dejaré aquí un recordatorio indicando el tamaño de la memoria ocupada por los tipos de datos para el compilador AVR-GCC y el rango de cambios en las variables de este tipo.

Tipos de datos en lenguaje C para el compilador AVR-GCC

nota

Implementación de tipo doble AVR-GCC se desvía del estándar. Según estándar doble Ocupa 64 bits. En AVR-GCC, una variable de este tipo ocupa 32 bits y, en consecuencia, equivale a una variable de tipo flotar!

Además de esto, las bibliotecas AVR-GCC introducen varios derivados de los tipos estándar. Están descritos en el archivo. stdint.h . Probablemente esto se hizo para mejorar la claridad y reducir el texto de los programas (acelerar su escritura :)). Aquí está la placa de conformidad:

Tipos derivados de los estándar en lenguaje C para el compilador AVR-GCC

tipo vacío

Hay otro tipo en el lenguaje C: tipo vacío . Vacío se utiliza para indicar que la función no devuelve nada como resultado o no toma ningún parámetro como entrada. Este tipo no se utiliza para declarar variables, por lo que no ocupa espacio en la memoria.

Última actualización: 17/09/2017

Cada variable tiene un tipo específico. Y este tipo determina qué valores puede tener una variable, qué operaciones se pueden realizar sobre ella y cuántos bytes en la memoria ocupará. Los siguientes tipos de datos básicos están definidos en el lenguaje C++:

bool: tipo booleano. Puede tomar uno de dos valores: verdadero y falso. La huella de memoria para este tipo no está definida con precisión.

char: representa un único carácter ASCII. Ocupa 1 byte (8 bits) en memoria. Puede almacenar cualquier valor de -128 a 127 o de 0 a 255

char firmado: Representa un solo carácter. Ocupa 1 byte (8 bits) en memoria. Puede almacenar cualquier valor de -128 a 127

carácter sin firmar: representa un solo carácter. Ocupa 1 byte (8 bits) en memoria. Puede almacenar cualquier valor de 0 a 255

wchar_t: Representa un carácter amplio. En Windows ocupa 2 bytes (16 bits) de memoria, en Linux ocupa 4 bytes (32 bits). Puede almacenar cualquier valor en el rango de 0 a 65.535 (para 2 bytes) o de 0 a 4.294.967.295 (para 4 bytes)

char16_t: representa un único carácter Unicode. Ocupa 2 bytes (16 bits) en memoria. Puede almacenar cualquier valor de 0 a 65.535

char32_t: representa un único carácter Unicode. Ocupa 4 bytes (32 bits) en memoria. Puede almacenar cualquier valor de 0 a 4.294.967.295

corto: representa un número entero en el rango –32768 a 32767. Ocupa 2 bytes (16 bits) de memoria.

Este tipo también tiene sinónimos short int, short int con signo, short con signo.

corto sin signo: representa un número entero en el rango de 0 a 65535. Ocupa 2 bytes (16 bits) de memoria.

Este tipo también tiene un sinónimo unsigned short int .

int: representa un número entero. Dependiendo de la arquitectura del procesador, puede ocupar 2 bytes (16 bits) o 4 bytes (32 bits). En consecuencia, el rango de valores límite también puede variar de –32768 a 32767 (con 2 bytes) o de −2 147 483 648 a 2 147 483 647 (con 4 bytes). Pero en cualquier caso, el tamaño debe ser mayor o igual al tamaño del tipo corto y menor o igual al tamaño del tipo largo.

Este tipo tiene sinónimos firmado int y firmado.

int sin signo: representa un número entero positivo. Dependiendo de la arquitectura del procesador, puede ocupar 2 bytes (16 bits) o 4 bytes (32 bits), por lo que el rango de valores límite puede variar: de 0 a 65535 (para 2 bytes), o de 0 a 4.294.967.295 (para 4 bytes).

sin firmar se puede utilizar como sinónimo de este tipo

de largo: representa un número entero en el rango de −2,147,483,648 a 2,147,483,647. Ocupa 4 bytes (32 bits) de memoria.

Este tipo también tiene sinónimos long int, firmado long int y firmado largo

largo sin signo: representa un número entero en el rango de 0 a 4.294.967.295. Ocupa 4 bytes (32 bits) de memoria.

Tiene un sinónimo de int largo sin firmar.

long long: representa un número entero en el rango −9,223,372,036,854,775,808 a +9,223,372,036,854,775,807. Normalmente ocupa 8 bytes (64 bits) de memoria.

Tiene sinónimos long long int, firmado long long int y firmado long long.

unsigned long long: representa un número entero en el rango de 0 a 18.446.744.073.709.551.615 normalmente 8 bytes (64 bits) en la memoria.

Tiene el sinónimo unsigned long long int .

float: representa un número real de punto flotante de precisión simple en el rango +/- 3,4E-38 a 3,4E+38. Ocupa 4 bytes (32 bits) en memoria

double: Representa un número real de coma flotante de doble precisión en el rango +/- 1,7E-308 a 1,7E+308. Ocupa 8 bytes (64 bits) en memoria

long double: representa un número real de punto flotante de doble precisión de al menos 8 bytes (64 bits). Dependiendo del tamaño de la memoria ocupada, el rango de valores válidos puede variar.

vacío: tipo sin valor

Por lo tanto, todos los tipos de datos, excepto void, se pueden dividir en tres grupos: caracteres (char, wchar_t, char16_t, char32_t), enteros (short, int, long, long long) y tipos de números de punto flotante (float, double, long double).

Tipos de personajes

Los tipos utilizados para representar caracteres en la aplicación son char, wchar_t, char16_t y char32_t.

Definamos varias variables:

Char c="d"; wchar_t d="c";

Una variable char toma como valor un carácter entre comillas simples: char c ="d" . También puede asignar un número del rango especificado arriba en la lista: char c = 120. En este caso, el valor de la variable c será el carácter que tiene el código 120 en la tabla de caracteres ASCII.

Vale la pena considerar que para enviar caracteres wchar_t a la consola, no se debe usar std::cout, sino el flujo std::wcout:

#incluir int main() ( char a = "H"; wchar_t b = "e"; std::wcout<< a << b << "\n"; return 0; }

En este caso, la secuencia std::wcout puede funcionar tanto con char como con wchar_t. Y la secuencia std::cout para la variable wchar_t generará su código numérico en lugar de un carácter.

El estándar C++ 11 agregó los tipos char16_t y char32_t, que están orientados al uso de Unicode. Sin embargo, los subprocesos para trabajar con estos tipos aún no se han implementado a nivel del sistema operativo. Por lo tanto, si necesita mostrar los valores de variables de estos tipos en la consola, debe convertir las variables a tipos char o wchar_t:

#incluir int main() ( char a = "H"; wchar_t b = "e"; char16_t c = "l"; char32_t d = "o"; std::cout<< a << (char)b << (char)c << (char)d << "\n"; return 0; }

En este caso, al generar, las variables van precedidas por una operación de conversión al tipo char - (char) , por lo que los valores de las variables b, cyd se convierten al tipo char y se pueden enviar a la consola usando la secuencia std::cout.

tipos de enteros

Los tipos de enteros se representan mediante los siguientes tipos: short, unsigned short, int, unsigned int, long, unsigned long, long long y unsigned long long:

Corto a = -10; corto sin firmar b= 10; int c = -30; int sin signo d = 60; largo e = -170; f larga sin firmar = 45; largo largo g = 89;

Tipos de números de coma flotante

Los tipos de números de coma flotante y fraccionarios se representan mediante flotante, doble y doble largo:

Flotante a = -10,45; doble b = 0,00105; doble c larga = 30,890045;

Tamaños de tipos de datos

La lista anterior muestra para cada tipo el tamaño que ocupa en la memoria. Sin embargo, vale la pena señalar que los desarrolladores de compiladores pueden elegir los límites de tamaño para los tipos de forma independiente, según las capacidades del hardware de la computadora. La norma establece sólo los valores mínimos que deben ser. Por ejemplo, para los tipos int y short el valor mínimo es 16 bits, para el tipo largo - 32 bits, para el tipo long double. En este caso, el tamaño del tipo largo no debe ser menor que el tamaño del tipo int, y el tamaño del tipo int no debe ser menor que el tamaño del tipo corto, y el tamaño del tipo doble largo debe ser mayor que el doble. Por ejemplo, el compilador g++ para Windows usa 12 bytes para dobles largos, y el compilador integrado en Visual Studio y que también se ejecuta en Windows usa 8 bytes para dobles largos. Es decir, incluso dentro de la misma plataforma, diferentes compiladores pueden tener diferentes enfoques para los tamaños de ciertos tipos de datos. Pero en general se utilizan los tamaños que se indican anteriormente al describir los tipos de datos.

Sin embargo, hay situaciones en las que es necesario saber exactamente el tamaño de un determinado tipo. Y para ello C++ tiene el operador sizeof(), que devuelve el tamaño de la memoria en bytes que ocupa la variable:

#incluir int main() ( número doble largo = 2; std::cout<< "sizeof(number) =" << sizeof(number); return 0; }

Salida de la consola al compilar en g++:

tamaño de (número) = 12

Al mismo tiempo, al definir variables, es importante comprender que el valor de una variable no debe ir más allá de los límites establecidos para su tipo. Por ejemplo:

Número corto sin firmar = -65535;

El compilador de G++, al compilar un programa con esta línea, generará un error indicando que el valor -65535 no está dentro del rango de valores válidos para el tipo corto sin firmar y será truncado.

En Visual Studio, la compilación puede continuar sin errores, pero la variable numérica recibirá el valor 2, el resultado de convertir el número -65535 a un tipo corto sin signo. Es decir, nuevamente el resultado no será exactamente el esperado. El valor de una variable es simplemente una colección de bits en la memoria que se interpretan según un tipo específico. Y para diferentes tipos, el mismo conjunto de bits se puede interpretar de manera diferente. Por lo tanto, es importante considerar los rangos de valores para un tipo determinado al asignar un valor a una variable.

especificador automático

A veces puede resultar difícil determinar el tipo de expresión. Y de acuerdo con los últimos estándares, puede dejar que el compilador infiera el tipo del objeto en sí. Y para esto se utiliza el especificador automático. Además, si definimos una variable con el especificador auto, esta variable debe inicializarse con algún valor:

Número automático = 5;

Según el valor asignado, el compilador inferirá el tipo de variable. No se permiten variables no inicializadas con el calificador automático.

Tipos de datos

Los tipos de datos son especialmente importantes en C# porque es un lenguaje fuertemente tipado. Esto significa que todas las operaciones están sujetas a una estricta verificación de tipos por parte del compilador y las operaciones ilegales no se compilan. En consecuencia, la verificación estricta de tipos elimina errores y aumenta la confiabilidad de los programas. Para imponer la verificación de tipos, todas las variables, expresiones y valores deben ser de un tipo específico. No existe nada parecido a una variable "sin tipo" en este lenguaje de programación. Además, el tipo de valor determina las operaciones que se pueden realizar sobre él. Una operación que es legal para un tipo de datos puede no ser válida para otro.

Hay dos categorías generales de tipos de datos integrados en C#: tipos de valor Y tipos de referencia. Se diferencian en el contenido de la variable. Conceptualmente, la diferencia entre los dos es que un tipo de valor almacena datos directamente, mientras que un tipo de referencia almacena una referencia a un valor.

Estos tipos se almacenan en diferentes ubicaciones de la memoria: los tipos de valor se almacenan en un área conocida como pila y los tipos de referencia se almacenan en un área conocida como montón administrado.

Vamos a ver tipos de valor.

tipos de enteros

C# define nueve tipos de números enteros: char, byte, sbyte, corto, ushort, int, uint, largo y ulong. Pero el tipo char se utiliza principalmente para representar caracteres y, por tanto, se trata por separado. Los ocho tipos de números enteros restantes son para cálculos numéricos. A continuación se muestran su rango de representación numérica y profundidad de bits:

Como muestra la tabla anterior, C# define variantes con y sin signo de los distintos tipos de enteros. Los tipos de enteros con signo se diferencian de sus homólogos sin signo en la forma en que interpretan el bit más significativo del número entero. Por lo tanto, si un programa especifica un valor entero con signo, el compilador de C# generará código que utiliza el bit más significativo del número entero como indicador de signo. Un número se considera positivo si el signo es 0 y negativo si es 1.

Los números negativos casi siempre se representan mediante el método del complemento a dos, mediante el cual todos los dígitos binarios del número negativo se invierten primero y luego se suma 1 a ese número.

Probablemente el tipo de número entero más común en programación es tipo entero. Las variables de tipo int se utilizan a menudo para control de bucles, indexación de matrices y cálculos matemáticos de propósito general. Cuando necesita un valor entero con un rango de representaciones numéricas mayor que el tipo int, hay otros tipos de enteros disponibles para este propósito.

Entonces, si el valor necesita almacenarse sin un signo, entonces puede seleccionar tipo único, para valores con signo grandes - tipo largo y para valores grandes sin signo, escriba ulong. A modo de ejemplo, a continuación se muestra un programa que calcula la distancia de la Tierra al Sol en centímetros. Para almacenar un valor tan grande, utiliza una variable larga:

Usando el Sistema; usando System.Collections.Generic; usando System.Linq; usando System.Text; espacio de nombres ConsoleApplication1 ( clase Programa ( static void Main(string args) ( resultado largo; const long km = 149800000; // distancia en km. resultado = km * 1000 * 100; Console.WriteLine(resultado); Console.ReadLine(); ) ) )

A todas las variables enteras se les pueden asignar valores en notación decimal o hexadecimal. En el último caso, se requiere un prefijo 0x:

Largo x = 0x12ab;

Si existe alguna incertidumbre sobre si un valor entero es de tipo int, uint, long o ulong, entonces por defecto Se acepta int. Para especificar explícitamente qué otro tipo de entero debe tener un valor, se pueden agregar los siguientes caracteres a un número:

Uint ui = 1234U; largo l = 1234L; ulong ul = 1234UL;

U y L también se pueden escribir en minúsculas, aunque una L minúscula puede confundirse visualmente fácilmente con el número 1 (uno).

Tipos de coma flotante

Los tipos de coma flotante le permiten representar números con una parte fraccionaria. Hay dos tipos de datos de punto flotante en C#: flotar Y doble. Representan valores numéricos con precisión simple y doble, respectivamente. Por tanto, el ancho del tipo flotante es de 32 bits, lo que corresponde aproximadamente al rango de representación de números desde 5E-45 hasta 3,4E+38. Y el ancho del tipo doble es de 64 bits, lo que corresponde aproximadamente al rango de representación de números desde 5E-324 hasta 1,7E+308.

El tipo de datos flotante está destinado a valores de punto flotante más pequeños que requieren menos precisión. El tipo de datos doble es mayor que el flotante y ofrece un mayor grado de precisión (15 bits).

Si un valor no entero está codificado en el código fuente (por ejemplo, 12.3), entonces el compilador generalmente asume que se pretende un valor doble. Si es necesario especificar el valor como flotante, deberá agregarle el carácter F (of):

Flotador f = 12,3F;

Tipo de datos decimales

También se proporciona un tipo decimal para representar números de punto flotante de alta precisión. decimal, que está destinado a ser utilizado en cálculos financieros. Este tipo tiene un ancho de 128 bits para representar valores numéricos que van desde 1E-28 hasta 7,9E+28. Probablemente sepa que la aritmética normal de punto flotante es propensa a errores de redondeo decimal. Estos errores se eliminan utilizando el tipo decimal, que permite representar los números con 28 (y a veces 29) decimales. Debido a que este tipo de datos puede representar valores decimales sin errores de redondeo, es especialmente útil para cálculos relacionados con finanzas:

Usando el Sistema; usando System.Collections.Generic; usando System.Linq; usando System.Text; espacio de nombres ConsoleApplication1 ( clase Programa ( static void Main(string args) ( // *** Cálculo del costo de una inversión con *** // *** tasa de rendimiento fija*** decimal dinero, porcentaje; int i; años de bytes constantes = 15; dinero = 1000,0 m; por ciento = 0,045 m;

El resultado de este programa será:

Símbolos

En C#, los caracteres no se representan en código de 8 bits, como en muchos otros lenguajes de programación como C++, sino en código de 16 bits, llamado Unicódigo. El conjunto de caracteres de Unicode es tan amplio que cubre caracteres de casi todos los lenguajes naturales del mundo. Si bien muchos idiomas naturales, incluidos el inglés, el francés y el alemán, tienen alfabetos relativamente pequeños, algunos otros idiomas, como el chino, utilizan conjuntos de caracteres bastante grandes que no se pueden representar en código de 8 bits. Para superar esta limitación, C# define tipo char, que representa valores de 16 bits sin signo que van de 0 a 65,535. Sin embargo, el conjunto de caracteres ASCII estándar de 8 bits es un subconjunto de Unicode que va de 0 a 127. Por lo tanto, los caracteres ASCII siguen siendo válidos en C#.