Чем word отличается от int
Тип данных WORD
Здравствуйте.
Хотелось бы использовать тип данных WORD для управления множеством выходов, поскольку для массового изменения очень подходит битовые операции. Но не могу понять как грамотно привязвыать выходы к такой переменной. Получаются совсем уж нелепые конструкции.
Для чего этот тип данных используется на практике, в реальной работе?
Тип данных WORD
egjar писал(а): ↑ 22 мар 2021, 22:39 Для чего этот тип данных используется на практике, в реальной работе?
Тип Word - это целочисленный беззнаковый тип данных, в два байта. Диапазон 0-65535. Используется везде, где оказывается нужным.
Где конкретно, в какой среде, с каким ПЛК, по какому протоколу Вы работете с выходами?
Тип данных WORD
egjar писал(а): ↑ 22 мар 2021, 22:39 Для чего этот тип данных используется на практике, в реальной работе?
Вот для упаковки-распаковки битовых переменных и используется в основном.
И, например, в Step7 тип Word интерпретируется как массив бит.
А как использовать. по разному в различных системах например Var_Bool0:=Var_Word.0, где-то операторы есть Pack- UnPack, а в софте для программирования есть кнопка "HELP", если что не понятно жмем и ищем-читаем там.
Тип данных WORD
stesl писал(а): ↑ 23 мар 2021, 10:37 Тип Word - это целочисленный беззнаковый тип данных, в два байта. Диапазон 0-65535. Используется везде, где оказывается нужным.
Не путайте Word с UInt (unsigned integer16), он не относится к целочисленным, так как не кодирует числовые значения и не совместим с математическими операциями.
Потому что:
Sergy6661 писал(а): ↑ 23 мар 2021, 12:54 Вот для упаковки-распаковки битовых переменных и используется в основном.
Но не в основном, а только для этого. Если конечно в конкретном ПЛК не срабатывает неявное преобразование, из-за которого кажется, что Word - это целое число.
Это разные типы данных, хотя все они 16 бит.
Тип данных WORD
Михайло писал(а): ↑ 23 мар 2021, 21:52 Не путайте Word с UInt (unsigned integer16), он не относится к целочисленным, так как не кодирует числовые значения и не совместим с математическими операциями.
Ну, допустим, в CoDeSys WORD по большему счету как UINT16, но в CoDeSys можно по биту к любому целочисленному обращаться.
В общем все от системы разработки зависит и опять же кнопка "HELP" рулит.
Тип данных WORD
Михайло писал(а): ↑ 23 мар 2021, 21:52 Не путайте Word с UInt (unsigned integer16), он не относится к целочисленным, так как не кодирует числовые значения и не совместим с математическими операциями.
Тип данных WORD
Почему именно беззнаковое? Значения в диапазоне -32767. 32767 в какие-то другие типы укладывается?
[+] В начале было слово.
И слово было - два байта.
Сначала приводит A и B , к указанному типу, а потом вычисляет результат A+B .
Приводит указатель A к указанному типу указателя.
Спецификаторы памяти:
(указываются перед типом)
Объявление переменной в виде константы, её можно читать, но нельзя менять, т.к. она хранится в области flash памяти.
Объявление переменной, значение которой может быть изменено без явного использования оператора присвоения =. Используются для работы с прерываниями.
Объявление локальной переменной, значение которой не теряется, между вызовами функции. Если переменная объявлена глобально (вне функций), то её нельзя подключить в другом файле.
Объявление глобальной переменной, которая определена во внешнем файле.
Объявление локальной переменной, значение которой требуется хранить в регистрах процессора, а не в ОЗУ, для обеспечения ускоренного доступа.
Значения некоторых констант:
Ложь, используются вместо 0
Истина, используется вместо 1
Низкий уровень
Высокий уровень
Конфигурация вывода как вход
Конфигурация вывода как выход
Конфигурация вывода как вход с подтяжкой
Передача младшим битом вперёд
Передача старшим битом вперёд
Тактовая частота Arduino в Гц
Число Пи
Половина числа Пи
Два числа Пи
Число Эйлера
Префиксы:
Запись числа в 2ой системе ( 0b 10101)
Запись числа в 2ой системе ( B 10101)
Запись числа в 8ой системе ( 0 12345)
Запись числа в 16ой системе ( 0x 1234A)
Модификаторы:
Число типа long (12345 L )
Число типа long lond (12345 LL )
Число беззнакового типа (12345 U )
Комбинация модификаторов (12345 UL )
Показатель экспоненты (3 E -5 = 3•10-5)
Переменные, массивы, объекты, указатели, ссылки, . :
Это указание имени и типа переменной.
int A; // объявление переменной А
Это выделение памяти под переменную.
A =1; // определение ранее объявленной A
Действуют постоянно, в любом месте кода.
Создаются внутри функций, циклов и т.д.
удаляются из памяти при выходе из них.
Указывается в одинарных кавычках.
char A=' Z '; // присвоение символа «Z»
Указывается в двойных кавычках.
String A ; // присвоение строки «XY»
Это переменная с указанием класса, вместо типа, через объект можно обращаться к методам класса
Ссылка, это альтернативное имя переменной, она возвращает значение переменной, на которую ссылается.
int A=5; // создана переменная A = 5
int & C=A; // создана ссылка C на переменную A
A++; C++; // в результате A=7 и C=7
// Ссылку нельзя переопределить: &C=Z;
Указатель, это переменная, значением которой является адрес.
int * Y1=&A; // указателю Y1, передан адрес переменной A
int ( * Y2)(int)=F; // указателю Y2, передан адрес функции F
B=Y1; // получаем адрес переменной A из указателя Y1
B= * Y1; // получаем значение A разыменовывая указатель
// Указатель можно переопределять: Y1=&Z;
Создание альтернативного имени для типа
typedef bool dbl; // создаём свой тип «dbl», как тип bool
dbl A=1; // создаём переменную A типа bool
Это переменная состоящая из нескольких однотипных элементов, доступ к значениям которых осуществляется по их индексу.
int A[5]; // объявлен массив A из 5 элементов типа int
int A[2]=; // объявлен и определён массив A из 2 эл-тов
char A[ ]="Hi"; // создана строка A, как массив символов
Это объединение нескольких переменных под одним именем.
struct < int A=5; float B=3; >C; // создана структура «С»
int D = C.A; // получаем значение переменной A структуры С
int Z = C.A; // присваиваем Z значение A структуры С
Значения некоторых констант:
Ложь, используются вместо 0
Истина, используется вместо 1
Операторы:
Циклы:
for( инициализация ; условие ; приращение )
Инициализация - выполняется однократно. Условие - проверяется перед каждым проходом. Приращение - выполняется после каждого прохода. Код в теле цикла - выполняется, если выполняется условие.
while ( условие )
Условие - проверяется перед каждым проходом. Код в теле цикла - выполняется, если выполняется условие.
do < тело цикла; >while ( условие );
Условие - проверяется после каждого прохода. Код в теле цикла - выполняется, если выполняется условие.
Условные операторы:
if ( условие )
Код в теле оператора - будет выполнен если выполняется условие.
if ( условие ) < тело1; >else
Если условие выполняется, то будет выполнен код тела1, иначе, код тела2.
if ( условие1 ) < тело1; >else if ( условие2 )
Если выполняется условие1, то будет выполнен код тела1, иначе, если выполняется условие2, то будет выполнен код тела2. Можно указать любое количество условий
переменная = условие ? значение1 : значение2 ;
Если условие выполняется, то оператор ?: вернёт значение1, иначе, значение2. Аналог конструкции: if( условие )else
switch (переменная) < // проверяемое значение
case константа1: код; break; // сравнение и код
case константа2: код; break; // сравнение и код
default: код; // не обязательно
>
Будет выполнен весь код, который следует после константы, значение которой совпало с переменной. Если совпадений нет, то выполняется весь код, который следует после, необязательного, ключевого слова default. Оператор break описан ниже.
Прерывающие операторы:
Прерывает выполнение кода, в теле любого цикла или оператора switch . case, завершая его выполнение.
Прерывает выполнение кода в теле любого цикла, но не завершает его выполнение, а переходит к следующему проходу этого цикла.
void функция(параметры)
Прерывает выполнение кода в теле функции и передаёт управление коду, вызвавшему эту функцию. После оператора return можно указать значение, которое вернёт функция.
метка : . код ; . goto метка ;
Прерывает выполнение кода и передаёт управление коду, следующему за меткой.
Получение адреса и разыменование указателя:
B=&C; // значением B станет адрес переменной C.
(взятие адреса) Возвращает адрес переменной или функции, а не значение.
B=*C; // значением B станет значение на которое ссылается указатель C.
(разыменование) Возвращает значение переменной по указателю, а не её адрес.
Директивы:
Арифметические:
Присвоение
int A = 18; // A = 18
Сложение
int A = 18 + 4; // A = 22
Умножение
int A = 18 * 4; // A = 72
Деление
int A = 18 / 4; // A = 4
Остаток от деления
int A = 18 % 4; // A = 2
Операторы сравнения: (возвращают true или false)
Ложь, используются вместо 0
Истина, используется вместо 1
Операторы сравнения: == Если равно bool A = 18 == 4; // A = 0 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - != Если не равно bool A = 18 != 4; // A = 1 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Если больше bool A = 18 > 4; // A = 1 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - >= Если больше или равно bool A = 18 >= 4; // A = 1
похоже, что общий шаблон принятия / возвращения Int (ie ByteString.hGet и Data.List.length ) противоречит шаблону Haskell использования типов strongly-descrbing, поскольку многие из этих случаев могут обрабатывать только положительные числа. Не лучше ли использовать Word , или есть причина, по которой эти функции частично на Int ?
верно, что выразительность системы типов Haskell побуждает пользователей назначать точные типы сущностям, которые они определяют. Однако опытные Хаскеллеры с готовностью признают, что необходимо соблюдать баланс между предельной точностью типа (которая, кроме того, не всегда достижима, учитывая текущие пределы системы типа Haskell) и удобством. Короче говоря, точные типы полезны только в определенной степени. За пределами этого момента они часто просто вызывают дополнительную бюрократию для little to no прибыль.
проиллюстрируем проблему на примере. Рассмотрим факторную функцию. Для всех n больше 1, факториал n является четным числом,и факториал 1 не очень интересен, поэтому давайте проигнорируем это. Поэтому, чтобы убедиться, что наша реализация факториальной функции в Haskell верна, у нас может возникнуть соблазн ввести новый числовой тип, который может представлять только беззнаковые четные целые числа:
мы запечатайте этот тип данных внутри модуля, который не экспортирует конструктор, чтобы сделать его абстрактным и сделать его экземпляром всех соответствующих классов типов, которые Int - это экземпляр. Теперь мы можем дать факториалу следующую подпись:
тип factorial конечно, более точно, чем если бы мы просто сказали, что он возвращает Int . Но вы найдете, что Defining factorial С таким типом действительно довольно раздражает, потому что вам нужна версия умножения, которая умножает (четное или нечетное) Int С Even производит и Even . Более того, вам может потребоваться ввести посторонние вызовы toInteger в результате вызова factorial в коде клиента, который может быть значительным источником помех и шумов мало приобрести. Кроме того, все эти функции преобразования потенциально могут оказать негативное влияние на производительность.
другая проблема заключается в том, что при введении нового, более точного типа вам часто приходится дублировать всевозможные библиотечные функции. Например, если ввести тип List1 a непустых списков, то вам придется переопределить многие из функций, которые Data.List уже обеспечивает, но для [a] только. Конечно, можно затем сделать эти методы функций ListLike тип класса. Но вы быстро заканчиваете все виды классов типа adhoc и других шаблонных, с снова не большим выигрышем.
последний момент заключается в том, что не следует рассматривать Word быть неподписанным вариант Int . The отчет Хаскелл оставляет фактический размер Int не указано, и только гарантирует, что этот тип должен быть способен представлять целые числа в диапазоне [- 2 29 , 2 29 - 1]. Тип Word написано целых чисел без знака неуказанной ширину. Не гарантируется, что в любой соответствующей реализации ширина a Word соответствует ширине Int .
хотя я защищая от чрезмерного распространения типа, Я признаю, что введение типа Natural из naturals может быть хорошо. В конечном счете, однако, должен ли Haskell иметь выделенный тип для натуральных чисел, в дополнение к Int , Integer , и различных Word* типы, в основном это вопрос вкуса. И нынешнее положение дел, вероятно, в значительной степени является просто случайностью истории.
то же самое рассуждение применяется, как и в C. Причина использования более точных типов заключается в предотвращении ошибок. Ошибки, в данном случае, такие как попытка использовать отрицательные числа там, где они не имеют смысла. Но поведение Word on over-или underflow, начиная с unsigned int в C, чтобы обернуть вокруг. Если вы попытаетесь использовать отрицательное число, где Word (или ), вы не получите компилятор, кричащий на вас, или даже исключение во время выполнения. Вы получаете большое положительное число. Что вы не имеют возможности отличить от любого другого ("законного") большого положительного числа!
взгляните на это:
вместо того, чтобы делать ошибки нельзя совершать, их невозможно обнаружить. С Int (и int ), у вас, по крайней мере, есть возможность проверить отрицательные значения вручную. С Word и unsigned int , у вас ничего нет.
что было бы ценным, это беззнаковый тип, который реагирует на перетекание или перетекание, бросая исключение. Это все равно не сделало бы ошибки невозможными, но это сделало бы их легче обнаружить. Однако это обойдется недешево.* Я не знаю, можно ли исключить их во время компиляции, но это не кажется легким.
* по крайней мере, x86 требует дополнительной инструкции -- после каждой операции! -- чтобы проверить, произошло ли переполнение или утечка. Я не знаю, есть ли архитектура, которая делает это "бесплатно", хотя было бы неплохо. Или, может быть, отличительная ценность NaN как и для чисел с плавающей запятой (возможно, вместо самое отрицательное число), который будет использоваться для обозначения непредставимых значений.
мое первое предположение, что беззнаковая арифметика имеет некоторые проблемы, которые вызовут глупые ошибки, если вы не обращаете внимания:
у него будут некоторые проблемы с полиморфными функциями, которые кажутся правильными:
С помощью стандартной функции length:
и используя функцию длины returing Word :
и, конечно, если эти функции возвращены Word вместо Int , вы вводите необходимость чтобы продолжать преобразовывать ваш Word на Int s, чтобы использовать его в других общих местах.
в Delphi, в чем разница между LongInt и Integer, LongWord и Cardinal ?
и иногда я нахожу использование DWORD, что это такое?
являются ли они согласованными во всех версиях Delphi? какой из них я должен придерживаться?
короче говоря: Longint и Longword-это целые числа фиксированного размера, первый подписан, последний без знака, и оба обычно 32 бита размера. их размер зависит от платформы в XE8, но фиксированный размер (32 бита) в XE7 и более ранних версиях.
Integer и Cardinal не являются фиксированным размером. Они называются "родовыми" целыми числами (не путайте это с дженериками, которые являются другой парой обуви), т. е. они должны предпочтительно использоваться, когда требуется интегральный тип, независимо от размера. В зависимости от версии и платформы размер Integer и Cardinal может отличаться. В настоящее время они имеют тот же размер и тип, что и Longint и Longword.
размеры типов фиксированного размера не отличаются между версиями или платформами. Вы должны использовать эти типы, где вы должны взаимодействовать с кодом или данными из других источников, чем ваша собственная программа, другими словами, где важна точная двоичная совместимость, например, при вызове функций API. Следовательно, использование типов например, DWORD и т. д.
обратите внимание, что текущие версии имеют псевдонимы для таких типов, как Byte или Smallint. Они Int8, тип uint8, INT16 в, типа uint16 и т. д. до типа uint64. ISTM, что эти имена легче запомнить, чем, например, " Smallint "(16 бит со знаком) или" Shortint " (8 бит со знаком).
поэтому используйте Integer и Cardinal, когда это возможно, поскольку это, вероятно, идеальные типы для платформы и версии. Используйте типы фиксированного размера, такие как Byte, Smallint, Longint или UInt64, только для имени несколько, когда требуется точная бинарная совместимость с другими данными.
обновление
поскольку возникла некоторая путаница (см. ссылку вверху), и поскольку в настоящее время не Longint и Longword считаются независимыми от платформы фиксированного размера, но, как ни странно, Integer и Cardinal считаются фиксированным размером, я все больше и больше склонен использовать версии (U)IntXX, такие как UInt16 или Int32. Одним из исключений является использование байта, который я не могу себе представить, когда-либо меняя его размер (1).
и, конечно, я буду использовать Integer и Cardinal для всего, что нуждается в интегральном типе, для которого размер не так важен, например, для счетчиков циклов и т. д.
- Дельфи Integer является базовой платформой C++ int .
- Дельфи LongInt является базовой платформой C++ long int .
- Дельфи Cardinal является базовой платформой C++ unsigned int .
- Дельфи LongWord является базовой платформой C++ unsigned long int .
все четыре из этих типов зависит от платформы.
на всех поддерживаемых платформах на момент написания статьи, Integer и Cardinal есть 32 бит типы. Типы зависят от платформы, так случается, что на всех поддерживаемых платформах типы имеют одинаковый размер.
на 64-битных платформах * nix, LongInt и LongWord являются 64-разрядными типами. На всех других поддерживаемых платформах на момент написания статьи типы являются 32-разрядными типами.
ключевым моментом является то, что все эти типы зависят от платформы.
DWORD - псевдоним типа, используемый API Windows. Используйте его только при использовании этого API.
если вы используете Integer или LongInt ? Это зависит от вашего использования. Как правило, для взаимодействия используется тот тип, который соответствует коду c++. В противном случае, для большинства применений Integer уместно. Конечно, это общий ответ на ваш общий вопрос.
в чем разница между int , System.Int16 , System.Int32 и System.Int64 кроме их размеров?
каждый тип целого числа имеет различный диапазон емкости хранения
как заявил Джеймс Сазерленд в ответ:
int и Int32 действительно синонимы; int будет немного больше знакомый вид, Int32 делает 32-разрядность более явной для тех читаю ваш код. Я был бы склонен использовать int, где мне просто нужно "целое число", Int32 где важен размер (криптографический код, структуры) так будущие сопровождающие будут знать безопасно увеличить int при необходимости, но следует позаботиться меняется Int32 переменные точно так же.
результирующий код будет идентичным: разница является чисто одной из читаемость или внешний вид кода.
единственная реальная разница-это размер. Все типы int здесь являются целочисленными значениями со знаком, которые имеют различные размеры
- Int16 : 2 байт
- Int32 и int : 4 байт
- Int64 : 8 байт
есть одна небольшая разница между Int64 и все остальное. На 32 разрядных назначений платформы к Int64 место хранения не гарантируется атомарным. Он гарантирован для всех других типов.
int
Он сопоставляется с Int32 типа FCL.
Это тип значения и представляет систему.Int32 struct.
Он подписан и занимает 32 бита.
Он имеет минимальное -2147483648 и максимальное значение +2147483647.
INT16 в
Это является типом значения и представляет систему.Int16 struct.
Он подписан и занимает 16 бит.
Он имеет минимальное -32768 и максимальное значение +32767.
int32 значение
Это тип значения и представляет систему.Int32 struct.
Он подписан и занимает 32 бита.
Он имеет минимум и -2147483648 до +2147483647 значение.
тип int64
Это тип значения и представляет систему.Int64 struct.
Он подписан и занимает 64 бита.
Он имеет минимальное -9,223,372,036,854,775,808 и максимальное значение 9,223,372,036,854,775,807.
очень важное замечание по 16, 32 и 64 типам:
Если вы запустите этот запрос. Матрица.IndexOf (новый Int16[], 1)
вы должны получить ноль (0), потому что вы спрашиваете. является 1 в массиве 1, 2 или 3. если вы получаете -1 в качестве ответа, это означает, что 1 не находится в массиве 1, 2 или 3.
Ну зацени, что я нашел: Все следующее должно дать вам 0, а не -1 (Я тестировал это во всех версиях framework 2.0, 3.0, 3.5, 4.0)
Итак, моя точка зрения, для массива.IndexOf сравнения, только доверять Int32!
ничего. Единственное различие между типами is их размер (и, следовательно, диапазон значений, которые они могут представлять).
- int и int32 являются одним и тем же (32-разрядное целое число)
- int16 короткий int (2 байта или 16 бит)
- int64 - Это длинная тип данных (8 байт или 64-бит)
все они представляют целые числа различных размеров.
тем не менее, есть очень маленькая разница.
int16, int32 и int64 все имеют основные размер.
размер int зависит от архитектуры, для которой вы компилируете - спецификация C определяет только int как больше или равен короткому, хотя на практике это ширина процессора, на который вы нацелены, что наверное 32bit, но вы должны знать, что это может быть не так.
они оба действительно синонимы, однако я нашел небольшую разницу между ними,
1)Вы не можете использовать Int32 при создании enum
2) Int32 входит в системное объявление. если убрать using.System вы получите ошибку компиляции, но не в случае к int
Int=Int32 -- > оригинальный длинный тип
Int16 -- > Оригинал int
Int64 --> новый тип данных становится доступным после 64-битных систем
" int " доступен только для обратной совместимости. Мы должны использовать новые типы int, чтобы сделать наши программы более точными.
еще одна вещь я заметил по пути нет класса с именем Int подобно Int16, Int32 и Int64. Все полезные функции, такие как TryParse для целого числа из Int32.TryParse .
Читайте также: