Размер_t в C++

Razmer T V C



C++ — самый популярный и обширный язык, богатый функциями, делающими нашу работу более удобной. Это облегчает нам использование типа «size_t», который помогает хранить максимальный размер любого типа данных. Уникальный целочисленный тип без знака, называемый «size_t», определен в стандартных библиотеках C++. Константа SIZE_MAX — это наибольшее значение, которое можно присвоить типу «size_t». Наибольший размер массива или объектов, который теоретически возможен, может храниться в «size_t». Используйте его только тогда, когда нам нужны огромные матрицы, массивы и т. д. «size_t» не может быть отрицательным в программировании на C++.

Пример 1:

Сюда импортируются различные файлы заголовков: «stddef.h», «limits» и «iostream». Определения часто используемых переменных, типов и указателей можно найти в «stddef.h», а заголовочный файл «limits» используется в качестве констант, которые представляют границы целочисленных типов, например минимальные и максимальные значения для различных типов данных. , которые доступны через этот заголовочный файл. Затем добавляется «iostream», поскольку в нем определены функции, используемые для ввода/вывода данных.

После этого сюда добавляется пространство имен «std». При этом вызывается метод «main()». Внутри него мы помещаем «cout», который помогает визуализировать данные, которые мы сюда поместим. «numeric_limits::max()» вводится, поскольку он возвращает наибольшее конечное значение, которое может представлять числовой тип «T». Оно значимо для каждого ограниченного типа, но не может быть отрицательным.







Код 1:



#include
#include <пределы>
#include
с использованием пространство имен стандартный ;
интервал основной ( ) {
расчет << 'Максимальный размер size_t равен ' << numeric_limits :: Макс ( ) << конец ;
}

Выход:
Мы могли заметить, что теперь отображается максимальный размер типа «T», что является очень большим значением, как показано ниже:







Пример 2:

Сюда импортируются два заголовочных файла, включая «limits» и «iostream. Поскольку в нем определены функции, необходимые для ввода и вывода данных, сюда добавляется «iostream». Затем заголовочный файл «limits» используется для доступа к константам, которые описывают границы целочисленных типов, такие как минимальные и максимальные значения для разных типов данных.

Впоследствии здесь вводится пространство имен «std» и вызывается функция «main()». При этом мы используем «INT_MAX» внутри «cout» для визуализации наивысшего значения верхней границы целочисленного типа данных в программировании на C++. Затем в следующей строке мы используем «size_t», который дает наибольшее значение.



Код 2:

#include
#include <климаты>
с использованием пространство имен стандартный ;
интервал основной ( ) {
расчет << 'Максимальное целое значение: ' << INT_MAX << конец ;

расчет << 'Размер, который хранит функция size_t: ' << ( size_t ) 0 - 1 << конец ;
возвращаться 0 ;
}

Выход :
Сначала отображается максимальный размер целого числа, который мы получаем с помощью «INT_MAX». Затем визуализируется максимальный размер, хранящийся в «size_t», который мы получаем с помощью «size_t» в этом коде.

Пример 3:

Здесь импортируются два заголовочных файла: «climits» и «iostream». Сюда включен «iostream», поскольку в нем определены функции, необходимые для ввода и вывода данных. Далее, доступ к константам, описывающим границы целочисленных типов, такие как минимальное и максимальное значения для различных типов данных, осуществляется с помощью заголовочного файла «climits».

Здесь теперь вызывается функция «main()» и впоследствии вводится пространство имен «std». Ниже мы используем «INT_MAX» внутри «cout» для вывода верхней границы максимального значения целочисленного типа данных в программировании на C++. При этом мы используем «INT_MIN», который возвращает нижнее значение типа данных «int». Затем мы используем «size_t», который дает максимальное значение, которое он хранит в следующей строке:

Код 3:

#include
#include <климаты>
с использованием пространство имен стандартный ;
интервал основной ( ) {
расчет << 'Самое большое целое значение: ' << INT_MAX << конец ;
расчет << 'Наименьшее целое число: ' << INT_MIN << конец ;
расчет << 'Размер, который хранит функция size_t: ' << ( size_t ) 0 - 1 << конец ;
возвращаться 0 ;
}

Выход:
Сначала отображается максимальный размер целого числа, который мы получаем с помощью «INT_MAX». Во-вторых, отображается минимальный размер целого числа, который мы получаем с помощью «INT_MIN». Затем с помощью «size_t» в этом коде отображается максимальный размер, хранящийся в «size_t».

Пример 4:

В этот код включены заголовочные файлы «cstddef», «iostream», а также «array». Эти файлы заголовков включены для того, чтобы мы могли использовать те функции, определения которых определены в этих файлах заголовков. Сюда добавляется заголовочный файл «массив», поскольку нам приходится работать с «массивами» и функциями в этом коде. Здесь мы объявляем переменную «my_sVar» с «const size_t» и инициализируем ее значением «1000», чтобы отобразить ее размер.

После этого мы также объявляем массив «num[]» типа данных «int» и передаем «my_sVar» в качестве его размера. Затем мы используем функцию «size_of()», в которой помещаем переменную «num» в качестве параметра и сохраняем ее в переменной «my_size» типа «size_t». Затем мы используем «cout» и набираем здесь «SIZE_MAX», чтобы он отображал максимальный размер переменной «my_sVar».

Далее мы показываем элементы типа массива меньшими числами. Мы выбираем его только для отображения 10 как 1000, что слишком много, чтобы поместиться в выходные данные. Используя тип «size_t», мы начинаем с индекса 0, чтобы показать, как «size_t» можно использовать как для индексации, так и для подсчета. Поскольку числа будут уменьшаться, массив отображается в порядке убывания, поскольку мы поместили «-a» в код.

Код 4:

#include
#include
#include <массив>
с использованием пространство имен стандартный ;
интервал основной ( ) {
константа size_t my_sVar '=' 1000 ;
интервал на одной [ my_sVar ] ;
size_t мой размер '=' размер ( на одной ) ;
расчет << 'Максимальный размер my_sVar = ' << SIZE_MAX << конец ;
расчет << «При работе с массивом чисел тип size_t имеет следующий вид.» ;
множество < size_t , 10 > мой_арр ;
для ( size_t а '=' 0 ; а ! '=' мой_арр. размер ( ) ; ++ а )
мой_арр [ а ] '=' а ;
для ( size_t а '=' мой_арр. размер ( ) - 1 ; а < мой_арр. размер ( ) ; -- а )
расчет << мой_арр [ а ] << ' ' ;
возвращаться 0 ;
}

Выход:
Сначала он отображает максимальный размер переменной, а затем отображает массив в порядке убывания.

Пример 5:

Этот код включает файлы заголовков «cstddef», «iostream» и «array». Поскольку этот код требует от нас работы с «массивами» и функциями, здесь размещается заголовочный файл «массива». Чтобы отобразить размер переменной «var», мы объявляем ее здесь со значением «const size_t» и инициализируем ее значением «1000». Затем здесь отображается максимальный размер переменной «var», поскольку мы использовали функцию «cout» и указали «SIZE_MAX» в этом поле.

Далее мы пытаемся отображать элементы типа массива в меньших количествах. До сих пор мы выбрали отображение только 20, потому что 1000 заполнит выходные данные. Мы демонстрируем, как «size_t» можно использовать как для индексации, так и для подсчета, используя тип «size_t» и начиная с индекса 0. Затем массив отображается в порядке убывания, поскольку числа будут уменьшаться, как указано размещением «-a» в следующий код:

Код 5:

#include
#include
#include <массив>
с использованием пространство имен стандартный ;
интервал основной ( ) {
константа size_t был '=' 1000 ;
расчет << 'Максимальный размер var = ' << SIZE_MAX << конец ;
расчет << 'Тип size_t, используемый с массивом чисел, задается как ' ;

множество < size_t , двадцать > array_num ;
для ( size_t я '=' 0 ; я ! '=' массив_номер. размер ( ) ; ++ я )
array_num [ я ] '=' я ;
для ( size_t я '=' массив_номер. размер ( ) - 1 ; я < массив_номер. размер ( ) ; -- я )
расчет << array_num [ я ] << ' ' ;
возвращаться 0 ;
}

Выход :
Он визуализирует массив в убывающей последовательности после рендеринга переменной до максимального размера.

Заключение

В этой статье подробно рассмотрен тип size_t в программировании на C++. Мы определили, что используем «size_t» в наших кодах C++, поскольку он хранит наибольшее значение. Мы также объяснили, что это беззнаковый тип и он не может быть отрицательным. В этой статье мы продемонстрировали коды программирования на C++, в которых мы использовали «size_t», а затем представили их результаты.