Тип данных word c

Обновлено: 23.01.2025

Почти все целочисленные типы данных относятся к порядковым типам. Эти типы данных представляют целые числа в определённом диапазоне. Конкретные наименования целочисленных типов и диапазоны значений зависят от конкретного языка программирования, от компилятора и от режима компиляции. Подробнее об этом надо узнавать в документации на компилятор.

Например, тип данных Integer в Delphi имеет диапазон -2147483648…2147483647, в то время как в Turbo Pascal тип данных Integer представляет числа в диапазоне -35768…32767. В Free Pascal диапазон значений типа Integer определяется выбранным режимом.

Так как Lazarus использует компилятор Free Pascal, то всё сказанное о типах данных по отношению к Free Pascal справедливо и для Lazarus.

Итак, целочисленные типы данных Free Pascal перечислены в таблице 13.1.

Таблица 13.1. Целочисленные типы данных Free Pascal (Lazarus).

Тип	Размер, байт	Диапазон значений
Byte	1	0…255
Shortint	1	-128…127
Smallint	2	-35768…32767
Word	2	0…65535
Integer	2 или 4	Зависит от режима компиляции
Cardinal	4	0…4294967295
Longint	4	-2147483648…2147483647
Longword	4	0. 4294967295
Int64	8	-9223372036854775808. 9223372036854775807
QWord	8	0. 18446744073709551615

ПРИМЕЧАНИЕ
В Free Pascal типы Int64 и QWord не являются порядковыми! Это означает, что вы не можете использовать их, например, для индексных переменных в циклах. Однако я привёл их здесь, чтобы отдельно не описывать в будущем и собрать в одном месте все целочисленные типы Free Pascal. Если какие-то слова вам не понятны - не пугайтесь. В своё время я обо всём расскажу подробнее.

А теперь несколько пояснений к таблице.

В колонке ТИП приведены идентификаторы типов данных (ключевые слова, которые указывают компилятору, к какому типу относятся те или иные данные). Как использовать эти идентификаторы, вы узнаете в следующих уроках.

В колонке РАЗМЕР указан размер, который занимает тип данных в памяти компьютера. Например, целое положительное число можно представить разными типами: Byte, Word, Cardinal и др. Однако число типа Cardinal будет занимать в памяти 4 байта, в то время как число типа Byte – всего лишь 1 байт. Поэтому, если вы точно знаете, что число, с которым вы работаете, никогда не примет значение больше 255, то лучше определять его как тип Byte, так как это позволит сэкономить место в памяти компьютера. Хотя здесь не всё так однозначно (нюансы распределения памяти и других ресурсов компьютера выходят за рамки данного курса).

В колонке ДИАПАЗОН указан диапазон значений, которым оперирует тип данных. Например, число типа Byte может принимать значения от 0 до 255.

А теперь практика. Напишем программу, которая выводит на экран диапазоны значений всех целочисленных типов данных. Исходный код этой программы приведён ниже:

Листинг 13.1. Программа вывода на экран диапазонов целых чисел.

Стандартная функция Low определяет минимальное значение типа данных. Фунцкия High определяет максимальное значение. С функциями WriteLn и ReadLn вы уже немного знакомы. Более подробно о подпрограммах (процедурах и функциях) мы будем говорить в соответствующем разделе курса.

Напоследок скажу, как записываются целочисленные данные в программе. Да также как и везде - просто пишите число, без кавычек и каких-либо дополнительных символов. Например, так

Правда, это относится к числам в десятичной системе счисления. Наверняка вы уже знаете, что есть и другие системы. Наиболее широко распространены двоичная, десятичная и шестнадцатеричная системы счисления.

Free Pascal поддерживает четыре формата записи целого числа:

Десятичная запись. Просто число, например 10.
Шестнадцатеричная запись. Число с префиксом $. Например, шестнадцатеричное число $10 равно десятичному 16.
Восьмеричная запись. Число с префиксом &. Например, восьмеричное число &10 равно десятичному 8.
Двоичная запись. Число с префиксом %. Например, двоичное число %10 равно десятичному 2.

Если для вас это пока слишком сложно, то пропустите эту часть. Просто добавьте страницу в закладки и вернётесь к ней когда будет нужно.

Домашнее задание:

Создайте программу, которая выводит на экран диапазоны значений целых чисел (листинг 13.1). Откомпилируйте программу и запустите её. Убедитесь, что эти значения соответствуют указанным в таблице 13.1.

В исходном коде программы найдите строку, которая задаёт режим компиляции:

В этой строке вместо слова objfpc напишите слово tp. То есть итоговая строка должна выглядеть так:

Запустите программу. Посмотрите диапазон значений типа Integer. Сделайте выводы.

Учитесь думать как программист, то есть логически. Никто вам до пенсии не будет всё разжёвывать, как это делаю сейчас я. Надо привыкать думать самостоятельно. Иначе вы скатитесь к “обезьяньему принципу обучения”, и тогда ваши шансы стать классным программистом приблизятся к нулю. Чтобы помочь вам не скатиться на уровень “зубрёжки”, я буду периодически оставлять пробелы в вашем обучении, чтобы вы постарались сами додуматься до каких-то вещей.

Намного лучше, если вы сами додумаетесь до неправильного решения, сами найдёте ошибку и сами её исправите, чем будете всегда использовать чужие правильные решения и тупо их копировать.

Концепция типа очень важна в C++. Каждая переменная, аргумент функции и возвращаемое значение функции должны иметь тип, чтобы их можно было скомпилировать. Кроме того, перед вычислением каждого выражения (включая литеральные значения) компилятор неявно назначает ему тип. Некоторые примеры типов включают int в себя хранение целочисленных значений double для хранения значений с плавающей запятой (также известных как скалярные типы данных) или класс стандартной библиотеки std:: basic_string для хранения текста. Вы можете создать собственный тип, определив class или struct . Тип определяет объем памяти, выделяемой для переменной (или результата выражения), типы значений, которые могут храниться в этой переменной, способ интерпретации значений (например, битовые шаблоны), и операции, допустимые с переменной. Эта статья содержит неформальный обзор основных особенностей системы типов C++.

Терминология

Переменная: символическое имя количества данных, чтобы имя можно было использовать для доступа к данным, на которые он ссылается в области кода, где он определен. В C++ переменная обычно используется для ссылки на экземпляры скалярных типов данных, тогда как экземпляры других типов обычно называются объектами.

Объект. для простоты и согласованности в этой статье используется объект term для ссылки на любой экземпляр класса или структуры, и когда он используется в общем смысле, включает все типы, даже скалярные переменные.

Тип POD (обычные старые данные): Эта неофициальная Категория типов данных в C++ относится к скалярным типам (см. раздел фундаментальные типы) или к классам Pod. Класс POD не содержит статических данных-членов, которые не являются типами POD, а также не содержит пользовательских конструкторов, пользовательских деструкторов или пользовательских операторов присваивания. Кроме того, класс POD не имеет виртуальных функций, базового класса и ни закрытых, ни защищенных нестатических данных-членов. Типы POD часто используются для внешнего обмена данными, например с модулем, написанным на языке С (в котором имеются только типы POD).

Указание типов переменных и функций

C++ — это строго типизированный язык, который также является статически типизированным; Каждый объект имеет тип, и этот тип никогда не изменяется (не следует путать с статическими объектами данных). При объявлении переменной в коде необходимо либо явно указать ее тип, либо использовать auto ключевое слово, чтобы указать компилятору вывести тип из инициализатора. При объявлении функции в коде необходимо указать тип каждого аргумента и его возвращаемое значение или void значение, если функция не возвращает никакого значения. Исключением является использование шаблонов функции, которые допускают аргументы произвольных типов.

После объявления переменной изменить ее тип впоследствии уже невозможно. Однако можно скопировать значения переменной или возвращаемое значение функции в другую переменную другого типа. Такие операции называются преобразованиями типов, которые иногда являются обязательными, но также являются потенциальными источниками потери или неправильности данных.

При объявлении переменной типа POD настоятельно рекомендуется инициализировать ее, т. е. указать начальное значение. Пока переменная не инициализирована, она имеет "мусорное" значение, определяемое значениями битов, которые ранее были установлены в этом месте памяти. Необходимо учитывать эту особенность языка C++, особенно при переходе с другого языка, который обрабатывает инициализацию автоматически. При объявлении переменной типа, не являющегося классом POD, инициализация обрабатывается конструктором.

В следующем примере показано несколько простых объявлений переменных с небольшим описанием для каждого объявления. В примере также показано, как компилятор использует сведения о типе, чтобы разрешить или запретить некоторые последующие операции с переменной.

Базовые (встроенные) типы

В отличие от некоторых других языков, в C++ нет универсального базового типа, от которого наследуются все остальные типы. Язык включает множество фундаментальных типов, известных также как встроенные типы. К ним относятся такие числовые типы int , как, double ,, long bool , а также char wchar_t типы и для символов ASCII и Юникода соответственно. Большинство интегральных фундаментальных типов (за исключением bool double wchar_t типов, и связанных) имеют unsigned версии, которые изменяют диапазон значений, которые может хранить переменная. Например, объект int , хранящий 32-разрядное целое число со знаком, может представлять значение от-2 147 483 648 до 2 147 483 647. Объект unsigned int , который также хранится как 32-бит, может хранить значение от 0 до 4 294 967 295. Общее количество возможных значений в каждом случае одинаково, отличается только диапазон.

Базовые типы распознаются компилятором, в котором предусмотрены встроенные правила, управляющие операциями, выполняемыми с такими типами, а также преобразованием в другие базовые типы. Полный список встроенных типов, а также их размер и числовые ограничения см. в разделе Встроенные типы.

На следующем рисунке показаны относительные размеры встроенных типов в реализации Microsoft C++:

В следующей таблице перечислены наиболее часто используемые фундаментальные типы и их размеры в реализации Microsoft C++:

Тип	Размер	Комментировать
int	4 байта	Выбор по умолчанию для целочисленных значений.
double	8 байт	Выбор по умолчанию для значений с плавающей запятой.
bool	1 байт	Представляет значения, которые могут быть или true, или false.
char	1 байт	Используйте для символов ASCII в старых строках в стиле C или в объектах std::string, которые никогда не будут преобразовываться в Юникод.
wchar_t	2 байта	Представляет "расширенные" символы, которые могут быть представлены в формате Юникод (UTF-16 в Windows, в других операционных системах возможно другое представление). Это символьный тип, используемый в строках типа std::wstring .
unsigned char	1 байт	C++ не имеет встроенного типа Byte. Используется unsigned char для представления байтового значения.
unsigned int	4 байта	Вариант по умолчанию для битовых флагов.
long long	8 байт	Представляет очень большие целочисленные значения.

Другие реализации C++ могут использовать разные размеры для определенных числовых типов. Дополнительные сведения о размерах и отношениях размеров, необходимых стандарту C++, см. в разделе Встроенные типы.

Тип void

void Тип является специальным типом; нельзя объявить переменную типа void , но можно объявить переменную типа void * (указатель на void ), которая иногда необходима при выделении необработанной памяти (нетипизированной). Однако указатели на void не являются строго типизированными и обычно их использование не рекомендуется в современных C++. В объявлении функции void возвращаемое значение означает, что функция не возвращает значение. это общее и допустимое использование void . Хотя в языке C обязательны функции, которые имеют нулевые параметры для объявления void в списке параметров, fou(void) такой подход не рекомендуется в современных C++ и должен быть объявлен fou() . Дополнительные сведения см. в разделе преобразования типов и типизация.

Квалификатор типа const

Любой встроенный или пользовательский тип может квалифицироваться ключевым словом const. Кроме того, функции-члены могут быть const полными и даже const перегруженными. Значение const типа не может быть изменено после инициализации.

const Квалификатор широко используется в объявлениях функций и переменных, и "правильность констант" является важной концепцией в C++; по сути это означает const , что во время компиляции эти значения не изменяются случайным образом. Дополнительные сведения см. на веб-сайте const .

const Тип отличается от неконстантной версии, например, имеет тип, отличный const int от int . Оператор C++ можно использовать const_cast в редких случаях, когда необходимо удалить const-rvalue характеристики из переменной. Дополнительные сведения см. в разделе преобразования типов и типизация.

Строковые типы

Определяемые пользователем типы

При определении,, class struct union или enum , эта конструкция используется в остальной части кода так, как если бы это был фундаментальный тип. Он имеет известный размер в памяти, и в его отношении действуют определенные правила проверки во время компиляции и во время выполнения в течение срока использования программы. Основные различия между базовыми встроенными типами и пользовательскими типами указаны ниже:

Компилятор не имеет встроенных сведений о пользовательском типе. Он узнает о типе при первом обнаружении определения во время процесса компиляции.

Пользователь определяет, какие операции можно выполнять с типом и как его можно преобразовать в другие типы, задавая (через перегрузку) соответствующие операторы, либо в виде членов класса, либо в виде функций, не являющихся членами. Дополнительные сведения см. в разделе перегрузка функций .

типы указателей

Датировано назад к самой ранней версии языка C, C++ позволяет объявить переменную типа указателя с помощью специального декларатора * (звездочка). Тип указателя хранит адрес расположения в памяти, в котором хранится фактическое значение данных. В современных C++ они называются необработанными указателями и доступны в коде с помощью специальных операторов * (звездочки) или -> (тире с символом «больше»). Это называется разыменованием, и какой из используемых объектов зависит от того, выполняется ли разыменование указателя на скаляр или указатель на член в объекте. Работа с типами указателя долгое время была одним из наиболее трудных и непонятных аспектов разработки программ на языках C и C++. В этом разделе приводятся некоторые факты и рекомендации по использованию необработанных указателей, если вы хотите, но в современной версии C++ больше не требуется (или рекомендуется) использовать необработанные указатели для владения объектами, так как при развитии интеллектуального указателя (см. Дополнительные сведения в конце этого раздела). Все еще полезно и безопасно использовать необработанные указатели для отслеживания объектов, но если требуется использовать их для владения объектом, необходимо делать это с осторожностью и после тщательного анализа процедуры создания и уничтожения объектов, которые им принадлежат.

Первое, что необходимо знать, — это то, что при объявлении переменной необработанного указателя выделяется только память, необходимая для хранения адреса расположения памяти, на который будет ссылаться указатель при разыменовывании. Выделение памяти для самого значения данных (также называемое резервным хранилищем) еще не выделено. Другими словами, объявив переменную необработанного указателя, вы создаете переменную адреса памяти, а не фактическую переменную данных. Разыменовывание переменной указателя до проверки того, что она содержит действительный адрес в резервном хранилище, приведет к неопределенному поведению (обычно неустранимой ошибке) программы. В следующем примере демонстрируется подобная ошибка:

Пример разыменовывает тип указателя без выделения памяти для хранения фактических целочисленных данных или без выделенного допустимого адреса памяти. В следующем коде исправлены эти ошибки:

В исправленном примере кода используется локальной память стека для создания резервного хранилища, на который указывает указатель pNumber . Базовый тип используется для простоты. На практике резервное хранилище для указателей — это наиболее часто определяемые пользователем типы, динамически выделяемые в области памяти, называемой кучей (или свободным хранилищем) с помощью new ключевого выражения (в программировании в стиле c malloc() использовалась старая функция библиотеки времени выполнения c). После выделения эти переменные обычно называются объектами, особенно если они основаны на определении класса. Память, выделенная с помощью, new должна быть удалена соответствующим delete оператором (или, если вы использовали malloc() функцию для ее выделения, функция времени выполнения C free() ).

Однако можно легко забыть удалить динамически выделенный объект, особенно в сложном коде, который вызывает ошибку ресурса, называемую утечкой памяти. По этой причине в современном С++ настоятельно не рекомендуется использовать необработанные указатели. Почти всегда лучше обернуть необработанный указатель в Интеллектуальный указатель, который автоматически освобождает память при вызове его деструктора (когда код выходит за пределы области для смарт-указателя); с помощью смарт-указателей вы практически устраняете целый класс ошибок в программах на C++. В следующем примере предположим, что MyClass — это пользовательский тип, который имеет открытый метод DoSomeWork();

Дополнительные сведения о смарт-указателях см. в разделе интеллектуальные указатели.

Дополнительные сведения о преобразовании указателей см. в разделе преобразования типов и типизация.

Дополнительные сведения об указателях в целом см. в разделе указатели.

Типы данных Windows

Дополнительные сведения

Дополнительные сведения о системе типов C++ см. в следующих разделах.

Типы значений
Описывает типы значений , а также проблемы, связанные с их использованием.

Преобразования типов и безопасность типов
Описание типовых проблем преобразования типов и способов их избежать.

Данные каким-либо образом необходимо представлять в памяти компьютера. Существует множество различных типов данных, простых и довольно сложных, имеющих большое число компонентов и свойств. Однако, для компьютера необходимо использовать некий унифицированный способ представления данных, некоторые элементарные составляющие, с помощью которых можно представить данные абсолютно любых типов. Этими составляющими являются числа, а вернее, цифры, из которых они состоят. С помощью цифр можно закодировать практически любую дискретную информацию. Поэтому такая информация часто называется цифровой (в отличие от аналоговой, непрерывной).

Первым делом необходимо выбрать систему счисления, наиболее подходящую для применения в конкретных устройствах. Для электронных устройств самой простой реализацией является двоичная система: есть ток - нет тока, или малый уровень тока - большой уровень тока. Хотя наиболее эффективной являлась бы троичная система. Наверное, выбор двоичной системы связан еще и с использование перфокарт, в которых она проявляется в виде наличия или отсутствия отверстия. Отсюда в качестве цифр для представления информации используются 0 и 1.

Таким образом данные в компьютере представляются в виде потока нулей и единиц. Один разряд этого потока называется битом. Однако в таком виде неудобно оперировать с данными вручную. Стандартом стало разделение всего потока на равные последовательные группы из 8 битов - байты или октеты. Далее несколько байтов могут составлять слово. Здесь следует разделять машинное слово и слово как тип данных. В первом случае его разрядность обычно равна разрядности процессора, т.к. машинное слово является наиболее эффективным элементом для его работы. В случае, когда слово трактуется как тип данных (word), его разрядность всегда равна 16 битам (два последовательных байта). Также как типы данных существую двойные слова (double word, dword, 32 бита), четверные слова (quad word, qword, 64 бита) и т.п.

Теперь мы вплотную подошли к представлению целых чисел в памяти. Т.к. у нас есть байты и различные слова, то можно создать целочисленные типы данных, которые будут соответствовать этим элементарным элементам: byte (8 бит), word (16 бит), dword (32 бита), qword (64 бита) и т.д. При этом любое число этих типов имеет обычное двоичное представление, дополненное нулями до соответствующей размерности. Можно заметить, что число меньшей размерности можно легко представить в виде числа большей размерности, дополнив его нулями, однако в обратном случае это не верно. Поэтому для представления числа большей размерности необходимо использовать несколько чисел меньшей размерности. Например:

qword (64 бита) можно представить в виде 2 dword (32 бита) или 4 word (16 бит) или 8 byte (8 бит);
dword (32 бита) можно представить в виде 2 word (16 бит) или 4 byte (8 бит);
word (16 бит) можно представить в виде 2 byte (8 бит);

Если A - число, B₁..B_k - части числа, N - разрядность числа, M - разрядность части, N = k*M, то:

A = F1E2D3C4B5A69788 (qword)
A = 2 32 * F1E2D3C4 (dword) + 2 0 * B5A69788 (dword)
A = 2 48 * F1E2 (word) + 2 32 * D3C4 (word) + 2 16 * B5A6 (word) + 2 0 * 9788 (word)
A = 2 56 * F1 (byte) + 2 48 * E2 (byte) + . + 2 8 * 97 (byte) + 2 0 * 88 (byte)

Существуют понятия младшая часть (low) и старшая часть (hi) числа. Старшая часть входит в число с коэффициентом 2 N-M , а младшая с коэффициентом 2 0 . Например:

Байты числа можно хранить в памяти в различном порядке. В настоящее время используются два способа расположения: в прямом порядке байт и в обратном порядке байт. В первом случае старший байт записывается в начале, затем последовательно записываются остальные байты, вплоть до младшего. Такой способ используется в процессорах Motorola и SPARC. Во втором случае, наоборот, сначала записывает младший байт, а затем последовательно остальные байты, вплоть до старшего. Такой способ используется в процессорах архитектуры x86 и x64. Далее приведен пример:

Используя подобные целочисленные типы можно представить большое количество неотрицательных чисел: от 0 до 2 N -1, где N - разрядность типа. Однако, целочисленный тип подразумевает представление также и отрицательных чисел. Можно ввести отдельные типы для отрицательных чисел от -2 N до -1, но тогда такие типы потеряют универсальность хранить и неотрицательные, и отрицательные числа. Поэтому для определения знака числа можно выделить один бит из двоичного представления. По соглашению, это старший бит. Остальная часть числа называется мантиссой.

Если старший бит равен нулю, то мантисса есть обычное представление числа от 0 до 2 N-1 -1. Если же старший бит равен 1, то число является отрицательным и мантисса представляет собой так называемый дополнительный код числа. Поясним на примере:

Как видно из рисунка, дополнительный код равен разнице между числом 2 N-1 и модулем исходного отрицательного числа (127 (1111111) = 128 (10000000) - |-1| (0000001)). Из этого вытекает, что сумма основного и дополнительного кода одного и того же числа равна 2 N-1 .

Из вышеописанного получается, что можно использовать только целочисленные типы со знаком для описания чисел. Однако существует множество сущностей, которые не требуют отрицательных значений, а значит, место под знак можно включить в представление неотрицательного числа, удвоив количество различных неотрицательных значений. Как результат, в современных компьютерах используются как типы со знаком или знаковые типы, так и типы без знака или беззнаковые типы.

В итоге можно составить таблицу наиболее используемых целочисленных типов данных:

Я занимаюсь автоматизацией, и в своей работе нередко использую панели оператора российского производителя ОВЕН. Эти панели по цене в 1,5-2 раза дешевле таких же импортных, и при этом по функционалу и качеству импортным не уступают.

Для того, чтобы приспособить панель для работы на определённом производстве, данную панель надо настроить соответствующим образом. Для этого существует специальная программа-конфигуратор, где создаются экраны, диалоговые окна, рисунки, кнопки и другие графические элементы, с помощью которых оператор взаимодействует с системой управления (см. видео выше).

Обычно этого вполне достаточно. Однако я часто работаю над сложными проектами, где обойтись только конфигурированием не получается. Приходится применять и программирование. К счастью, для этих панелей можно создавать макросы на языке Си, и тем самым решать почти любые задачи.

Также в программе-конфигураторе есть эмулятор работы панели. С его помощью на экране компьютера можно посмотреть, как будут выглядеть экраны панели, проверить действие кнопок и других элементов.

Но! Есть одна маленькая неприятность - в этом эмуляторе нельзя проверить работу макросов.

Конечно, можно загрузить конфигурацию в панель и проверить работу макросов непосредственно в панели. На этапе проектирования я так и делаю.

Но как быть, если проект уже работает и панель уже используется на объекте, который может находиться очень далеко от вашего рабочего места, и понадобится внести изменения в какой-либо макрос?

Изменения то внести можно, но проверить правильность работы макроса будет нельзя, если у вас нет под рукой панели. И может случиться так, что вы приедете за 300 вёрст на объект, зальёте конфигурацию в панель, а макрос работать не будет. Как быть?

Как говорится, “голь на выдумки хитра”. Если мы не можем себе позволить держать всегда панель в запасе для экспериментов, то мы сможем проверить работу макроса иначе.

Как? Используя творческий подход и некоторые возможности языка Си…

Программа на языке Си

Поскольку для создания макросов в панели используется язык Си, то мы можем написать исходный код макроса в любой среде разработки, где можно создавать программы на Си, откомпилировать его и проверить, правильно ли работает этот код. Я для этих целей использую Dev-C++, потому что это простая и шустрая среда, которая поддерживает языки программирования С/С++.

ВАЖНО!
Советую создавать программу именно на языке Си, а не на С++. Потому что при использовании С++ можно случайно применить в исходном коде конструкции, которые не поддерживаются языком Си, и это не позволит использовать исходный код в панели оператора, где применяется чистый Си.

Однако и это ещё не всё. В конфигураторе панели оператора имеются стандартные функции, которых нет в языке Си (например, функция SetPSB, которая устанавливает указанный регистр панели). Кроме того, чистый Си не поддерживает такие типы данных, как WORD, которые поддерживаются конфигуратором панели.

Поэтому придётся творчески отнестись к созданию и проверке программы на компьютере, которую потом можно будет использовать в виде макроса в панели.

Тип данных WORD в Си

Как известно, в языке Си нет типа данных WORD. А вот в программе-конфигураторе, где мы пишем макросы для панели, такой тип есть.

Можно, конечно, использовать другие типы данных. Но тогда не получится просто скопировать код из Dev-C++ в панель - придётся потом исправлять типы данных.

Лучше сразу сделать так, чтобы не пришлось тратить время на исправление кода в панели. Например, создать свой тип данных с именем WORD.

Сделать это можно с помощью директивы define следующим образом:

Здесь мы для типа unsigned short, который имеется в Си, определяем новое имя WORD. И далее в программе мы можем сделать, например, так:

То есть объявить переменную типа WORD. Хотя на самом деле, это, конечно, будет переменная типа unsigned short. Но нам это не важно, потому что оба этих типа имеют одинаковый диапазон значений, а слово WORD для нас удобнее.

И вот таким вот образом мы можем написать программу на компьютере, проверить её работу, а потом просто скопировать исходный код в макрос панели.

Ну и напоследок немного о директиве define.

Директива define используется в языке С для того, чтобы назначить новое имя для какого либо типа или другой конструкции языка. С помощью этой директивы можно создавать новые типы данных или, например, объявлять константы:

После этого вместо числа 100 можно использовать в программе константу А.

У меня есть книга о директивах компилятора, где я подробно рассказал о том, что это и для чего. Правда, там речь идёт о директивах в Паскале. Директивы в С/С++ - это немного другое, хотя их назначение и применение по сути похожи на директивы Паскаля.

Читайте также: