Tutoriales

Tamaño_t en C++

C++ es el lenguaje más popular y extendido y sus ricas funciones hacen que nuestro trabajo sea más conveniente. Nos ayuda a utilizar el tipo «size_t» para ayudar a almacenar el tamaño máximo de cualquier tipo de datos. La biblioteca estándar de C++ define un tipo entero sin signo único llamado «size_t». La constante TAMAÑO_MAX es el valor máximo que se puede asignar al tipo «size_t». El tamaño máximo teórico que se puede imaginar para una matriz u objeto se puede almacenar en «size_t». Úselo solo cuando necesitemos matrices enormes, matrices, etc.

Ejemplo 1:

Aquí se importan diferentes archivos de encabezado, a saber, «stddef.h», «limits» e «iostream». Las definiciones de variables, tipos e indicadores de uso común se pueden encontrar en «stddef.h». El archivo de encabezado «límites» se utiliza para representar constantes que representan los límites de tipos enteros, como los valores mínimo y máximo de varios. tipos de datos. Este archivo de encabezado se puede utilizar para acceder. Luego, agregue «iostream» ya que define las funciones para datos de entrada/salida.

Más tarde, se agregó aquí el espacio de nombres «std». Debajo de esto, se llama al método «main()». En él colocamos «cout», lo que ayuda a renderizar el material que colocaremos aquí. Se escribe «numeric_limits::max()» porque devuelve el valor limitado más alto que se puede representar mediante el tipo numérico «T». Es significativo para todos los tipos acotados, pero no puede ser negativo.

Código 1:

#incluir
#incluir
#incluir
usar espacio de nombres estándar;
entero principal() {
kut <«El tamaño máximo de size_t es» < Límite de dígitos::máximo() < endel;
}

Producción:
Podemos notar que el tamaño máximo del tipo «T» representado actualmente es un valor muy grande, como se muestra a continuación:

Ejemplo 2:

Aquí se importan dos archivos de encabezado, incluidos «limits» y «iostream.h». «iostream» se agrega aquí ya que define las funciones requeridas para los datos de entrada y salida. Luego, el archivo de encabezado «límites» se utiliza para acceder a constantes que describen los límites del tipo entero, como los valores mínimo y máximo de diferentes tipos de datos.

Posteriormente, aquí se introduce el espacio de nombres «std» y se llama a la función «main()». A continuación, usamos «INT_MAX» en «cout» para representar el valor más alto del límite superior del tipo de datos entero en el programa C++. Luego, en la siguiente línea, usamos «size_t» que da el valor más alto.

Código 2:

#incluir
#incluir
usar espacio de nombres estándar;
entero principal() {
kut < «Valor entero máximo:» < INT_MAX < endel;

kut < «El tamaño guardado por la función size_t:» < (tamaño_t) 1 < endel;
devolver ;
}

producción:
Primero renderice el tamaño máximo del número entero que obtenemos con la ayuda de «INT_MAX». Luego, renderice el tamaño máximo almacenado en «size_t», que obtuvimos con la ayuda de «size_t» en este código.

Ejemplo 3:

Aquí se importan dos archivos de encabezado «climits» y «iostream». «iostream» se incluye aquí porque define las funciones necesarias para ingresar y generar datos. A continuación, utilice el archivo de encabezado «climits» para acceder a constantes que describen los límites del tipo entero, como los valores mínimo y máximo de varios tipos de datos.

Aquí, ahora se llama a la función «main()» y luego se introduce el espacio de nombres «std». A continuación, usamos «INT_MAX» dentro de «cout» en la programación C++ para generar el límite superior del valor máximo del tipo de datos entero. Debajo de esto, utilizamos «INT_MIN» para devolver el valor más bajo del tipo de datos «int». Luego usamos «size_t» para producir el valor máximo que se almacena en la siguiente línea:

Código 3:

#incluir
#incluir
usar espacio de nombres estándar;
entero principal() {
kut < «Valor entero máximo:» < INT_MAX < endel;
kut < «Entero más pequeño:» < INT_MIN < endel;
kut < «El tamaño guardado por la función size_t:» < (tamaño_t) 1 < endel;
devolver ;
}

Producción:
Primero, muestre el tamaño máximo del número entero que obtenemos con la ayuda de «INT_MAX». En segundo lugar, muestra el tamaño mínimo del número entero que obtuvimos con la ayuda de «INT_MIN». Luego, con «size_t» en este código, se representa el tamaño máximo almacenado en «size_t».

Ejemplo 4:

Los archivos de encabezado incluidos en este código son «cstddef», «iostream» y «array». Estos archivos de encabezado se incluyen para que podamos aprovechar las funciones definidas en estos archivos de encabezado. El encabezado «Array» se agrega aquí porque debemos usar «Array» y funciones en este código. Aquí declaramos la variable «my_sVar» usando «const size_t» y la inicializamos con el valor «1000» para representar su tamaño.

Después de eso, también declaramos «num[]Una matriz de tipo de datos «int», pasando «my_sVar» como tamaño. Luego, utilizamos la función «size_of()», tomando como parámetro la variable «num» y almacenándola en la variable «my_size» de tipo «size_t». Luego aprovechamos «cout» e ingresamos «SIZE_MAX» aquí para que represente el tamaño máximo de la variable «my_sVar».

A continuación, mostramos elementos de tipo matriz en cantidades más pequeñas. Simplemente lo seleccionamos para mostrar 10 como 1000, lo cual es demasiado para el resultado. Usando el tipo «size_t», comenzamos en el índice 0 y mostramos cómo se usa «size_t» para indexar y contar. Dado que los números disminuirán, cuando pongamos «-a» en el código, la matriz se mostrará en orden descendente.

Código 4:

#incluir
#incluir
#incluir
usar espacio de nombres estándar;
entero principal() {
constante tamaño_t mi_sVar = 1000;
entero número de serie[my_sVar];
tamaño_t mi medida = tamaño(número de serie);
kut < «tamaño máximo de my_sVar=» < TAMAÑO_MAX < endel;
kut < «Cuando se utilizan matrices numéricas, el tipo size_t es el siguiente».;
en grandes cantidades < tamaño_t, 10 > mi_arr;
para (tamaño_t A = ; A != mi_arr.tamaño(); ++A)
mi_arr[a] = A;
para (tamaño_t A = mi_arr.tamaño() 1; A < mi_arr.tamaño(); A)
kut < mi_arr[a] < «»;
devolver ;
}

Producción:
Primero representa el tamaño máximo de la variable y luego representa la matriz en orden descendente.

Ejemplo 5:

Este código contiene archivos de encabezado «cstddef», «iostream» y «array». Dado que este código requiere que usemos «matrices» y funciones, el encabezado «matriz» se coloca aquí. Para presentar el tamaño de la variable «var», aquí la declaramos con un valor «const size_t» y la inicializamos con «1000». Cuando usamos la función «cout» y especificamos «SIZE_MAX» en este campo, aquí se presentará el tamaño máximo de la variable «var».

A continuación, intentamos mostrar elementos de tipo matriz en un número menor. Hasta ahora, sólo hemos elegido mostrar 20 porque 1000 llenarán el resultado. Demostramos cómo usar el tipo «size_t» y usar «size_t» para indexar y contar a partir del índice 0.

Código 5:

#incluir
#incluir
#incluir
usar espacio de nombres estándar;
entero principal() {
constante tamaño_t variable = 1000;
kut < «tamaño máximo de var=» < TAMAÑO_MAX < endel;
kut < «El tipo size_t para usar con matrices numéricas se proporciona como»;

en grandes cantidades < tamaño_t, 20 > número de matriz;
para (tamaño_t I = ; I != Número de matriz.tamaño(); ++I)
número de matriz[i] = I;
para (tamaño_t I = Número de matriz.tamaño() 1; I < Número de matriz.tamaño(); I)
kut < número de matriz[i] < «»;
devolver ;
}

producción:
Después de representar las variables al tamaño máximo, representa la matriz en orden descendente.

en conclusión

Este artículo proporciona una discusión en profundidad sobre el tipo «size_t» en la programación en C++. Definimos «size_t» en código C++ porque almacena su valor máximo. También explicamos que es un tipo sin firmar y no puede ser negativo. Demostramos el código C++ usando «size_t» y luego presentamos sus resultados en este artículo.

LEER  ¿Introducción a Linux? ¿Y cómo funciona Linux?

Publicaciones relacionadas

Deja una respuesta

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

Botón volver arriba