Структуры. Перечисления. Объединения. Битовые поля .

1.1. Перечисления.

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

Объявляются перечисления следующим образом:

enum color { r, g, b }; // объявление типа

где enum – ключевое слово, color – имя типа перечисления, r, g, b – сами перечислимые константы. При объявлении типа перечисления его значения могут инициализироваться произвольными целочисленными константами или константным выражением. Например,

enum color { r = 2, g = r = 2, b = 6 }; // объявление типа

Если инициализация отсутствует, то перечислимым константам присваиваются последовательные значения: 0, 1, 2, … Например,

enum color { r, g, b }; // r = 0, g = 1, b = 2

Переменная типа перечисление объявляется следующим образом:

enum color c; // объявление переменной c, которая имеет тип color (язык С)

color d; // объявление переменной d, которая имеет тип color (язык С++)

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

enum turn { off, on } a; // а – переменная типа turn

Переменным перечислимого типа можно присваивать только именованные значения перечислимых констант. Например,

color c = r; // правильно

color c = 0; // ошибка

Целочисленным переменным можно присваивать значения перечислимых констант. Например,

int e = r; // правильно

1.2. Структуры.

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

Объявляются структуры следующим образом:

где struct – ключевое слово, emp – имя типа структуры, empno, name, salary – члены структуры.

Переменная типа структура объявляется следующим образом:

struct emp e; // объявление переменной e, которая имеет тип emp (язык С)

emp d; // объявление переменной d, которая имеет тип emp (язык С++)

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

} director; // director – переменная типа emp

Инициализируются структуры также как и массивы. Например,

struct emp a = { 10, “Paul”, 2000 };

Так как члены структуры описываются в блоке, то их имена принадлежат локальной области видимости внутри этого блока. Для доступа к элементу структуры используется оператор точка ‘.’. Например,

director.empno = 20;

strcpy(director.name, “John”); // нельзя выполнить присваивание, так как director.name - константа

director.salary = 3000;

Членами структуры могут быть массивы и другие структуры. Для доступа к членам вложенной структуры оператор ‘.’ используется столько раз, какова вложенность структуры. Например,

#include

struct demo c = { 1, {2, 3} };

printf("%d %d %d\n", c.a, c.b.b, c.b.c); // печатает: 1 2 3

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

struct node /* вершина двоичного дерева */

struct node *left; /* левый потомок */

struct node *right; /* правый потомок */

Структуры одного типа можно присваивать друг другу. В этом случае оператор присваивания выполняет по членное копирование структур. Например,

struct emp boss;

boss = director;

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

1.3. Объединения.

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

Объявляются объединения следующим образом:

где union – это ключевое слово, num – имя типа объединения, n, f – члены объединения.

Переменная типа объединение объявляется следующим образом:

union num d; // объявление переменной d, которая имеет тип num (язык С)

num d; // объявление переменной d, которая имеет тип num (язык С++)

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

} d; // d – переменная типа num

При объявлении переменной типа объединение её можно инициализировать значением, которое должно иметь тип первого члена объединения. Например,

union num d = { 1 }; // правильно, d = 1

union num d = { 1.0 }; // ошибка

Как и в случае со структурами, для доступа к элементу объединения используется оператор точка ‘.’. Например,

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

Также как и структуры объединения нельзя сравнивать.

1.4. Битовые поля.

Битовым полем называется член структуры или объединения, который определяет последовательность бит. Битовое поле может иметь один из следующих типов: int, unsigned или signed. При объявлении битового поля после его имени указывается длина поля в битах. Например,

unsigned a1: 1; // 1 бит

signed b1: 3; // 3 бита

int c1: 6; // 6 бит

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

Инициализируются битовые поля так же, как и обычные элементы структуры. Например,

} s = { 0, 1 }; // a1 = 0, a2 = 1

Доступ к элементам битового поля осуществляется так же, как и доступ к обычным членам структуры. Например,

#include

printf("s.a = %u\n", s.a); // печать: s.a = 1

printf("s.b = %d\n", s.b); // печать: s.b = -1

printf("s.c = %d\n", s.c); // печать: s.c = -4

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

1.5. Передача структур в функции.

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

void print(struct emp s) // или просто: void print(emp s)

printf(“%d %s %f\n”, s.empno, s.name, s.salary);

Для того чтобы функция могла изменить значения членов структуры, она должна получить указатель на эту структуру. Для доступа к членам структуры через указатели используется оператор ‘->’. Например,

void init_emp(emp *ps, int en, char *nm, double sal)

ps->empno = en;

strcpy(ps->name, nm);

ps->salary = sal;

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

void print(char c, num *n)

printf(“n = %d\n”, n->n);

printf(“f = %f\n”, n->f);

Многие задачи требуют создания минимальных по размеру программ. Один из
способов экономии памяти в программах на Си заключается в использовании битовых
полей для представления совокупности данных целого типа. Битовое поле может
иметь тип либо signed int либо unsigned int и занимать от 1 до 16 битов.

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

обеспечивает размещение в памяти структурной переменной flags,
включающей в себя битовые поля с именами a, b, c и d, как показано на рис. 9.3.

Рис. 9.3. Размещение в памяти битовых полей.

Поля не могут переходить через границы памяти целого числа. Например,
если бы поле d имело размер более 5-ти битов, то оно было бы размещено в
следующем слове. Для принудительного выравнивания к границе следующего слова
используется размер 0. Если в рассматриваемой структуре BITFLDS описать поле
без имени int:3; как int:0; , то поле d будет размещено в новом слове.
Битовые поля обрабатываются как целые укороченного размера. Их можно
использовать в любых выражениях и с любыми операциями за исключением операции
взятия адреса. Обращение к полям осуществляется аналогично обращению к другим
элементам структуры, то есть с использованием операции точка, например так:

if(flags.b == flags.d)...

Наиболее частым применением битовых полей является использование их в
качестве набора переключателей, характеризующих состояние некоторого объекта
программы. Например, структурнаяпеременная key:

struct { unsigned shift:1;

unsigned cups:1;

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

а проверка состояния
переключателей - условным оператором:

if(key.shift==1 && key.cups==1)...

Заметим, что битовое поле внутри структурного шаблона не может быть
массивом, хотя описание массива структур, каждый элемент которого может
содержать битовые поля, вполне обосновано и не противоречит синтаксису Турбо
Си. Используя ранее приведенный структурный шаблон BITFLDS, можно сделать
описание:

struct BITFLDS system;

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

struct COORDINATES {

float a; /* Длина */

float b; /* Ширина */

float c; /* Высота */

char name; /* Шифризделия */

struct COORDINATES point;

struct DETAL rez, /* Резисторы */

cond; /* Конденсаторы */

и доступ к битовому
полю осуществляется также, как и в случае вложенных структурных переменных,
например, rez.point.x

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

    при ограниченной памяти вы можете хранить несколько булевых (истина, ложь) переменных в одном байте;

    интерфейсы некоторых устройств передают информацию, которая кодируется в биты внутри одного байта;

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

Метод, который использует язык программирования Си для доступа к битам, базируется на структуре.

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

struct имя типа структуры {

имя типа 1: длина;

имя типа 2: длина;

имя типа 3: длина;

Можно объявить битовое поле как int (целое) либо unsigned (без знака), либо signed (со знаком). Битовое поле единичной длины вы должны объявлять как unsigned, так как единичный бит не может иметь знака.

Переменные битового поля имеют некоторые ограничения.

    вы не можете принять адрес переменной битового поля.

    вы не можете иметь переменные битового поля типа массива.

    вы не можете выходить за границы целого.

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

Можно смешивать обычные элементы структуры с элементами битовых полей так:

struct addr address;

unsigned lay_off:1; /* временно уволен или активен */

unsigned hourly:1: /* почасовая оплата или оклад */

unsigned deductions:3: /* IRS вычеты */ };

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

Объединения

В языке программирования Си union (объединение) - это участок памяти, который используется несколькими разными переменными, которые могут быть различных типов. Определение union аналогично определению структуры, как это показано ниже:

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

union u_type cnvt;

В cnvt как целое i, так и символьное ch разделяют одну и ту же область памяти. (Однако i занимает два байта, а ch - только один.) Рис 12-3 показывает, каким образом i и ch разделяют один и тот же адрес.

Когда вы объявляете union, Турбо Си будет автоматически создавать переменную, достаточно большую для того, чтобы хранить переменную самого большого типа в этом union.

Для доступа к элементу union вы используете тот же самый синтаксис, который вы использовали бы в случае структур: оператор точки и оператор стрелки. Если вы обращаетесь к элементу union непосредственно, то используйте оператор точки. Если вы обращаетесь к union переменной посредством указателя, используйте оператор стрелки. Например, для присваивания целого 10 элементу i из cnvt вы могли бы написать

В следующем примере код передает указатель на cnvt в функцию:

union u_type *un;

un->i=10; /* присвоить 10 cnvt, используя указатель */

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

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

Например, стандартная библиотечная функция putw() будет записывать в дисковый файл двоичное представление целого. Хотя есть множество способов запрограммировать эту функцию, показанный здесь код использует union. Сначала он создает union, который включает в себя одно целое и двубайтовый массив символов:

putw(word,fp) /*putw с union*/

putc(word->ch); /*запись первой половины*/

putc(word->ch); /*запись второй половины*/

Интересная программа, которая объединяет unions с битовыми полями, представляет в двоичном виде ASCII КОД, который генерируется, когда вы нажимаете клавишу на клавиатуре. Union позволяет функции gecthe() присваивать значение нажимаемой клавиши символьной переменной, в то время как программа использует битовое поле для демонстрации отдельных битов.

/* визуализация двоичных ASCII кодов символов */

/* битовое поле, которое будет декодироваться */

struct byte bit;

ascii.ch=getche();

decode(ascii.bit);

} while(ascii.ch!="q");

/* демонстрация битовой структуры каждого символа */

if(b.bit.h) printf("1");

else printf("0");

if(b.bit.g) printf("1");

else printf("0");

if(b.bit.f) printf("1");

else printf("0");

if(b.bit.e) printf("1");

else printf("0");

if(b.bit.d) printf("1");

else printf("0");

if(b.bit.c) printf("1");

else printf("0");

if(b.bit.b) printf("1");

else printf("0");

if(b.bit.a) printf("1");

else printf("0");

¦ A:\>ascii ¦

¦ a: 0 1 1 0 0 0 0 1 ¦

¦ b: 0 1 1 0 0 0 1 0 ¦

¦ c: 0 1 1 0 0 0 1 1 ¦

¦ d: 0 1 1 0 0 1 0 0 ¦

¦ e: 0 1 1 0 0 1 0 1 ¦

¦ f: 0 1 1 0 0 1 1 0 ¦

¦ g: 0 1 1 0 0 1 1 1 ¦

¦ h: 0 1 1 0 1 0 0 0 ¦

¦ i: 0 1 1 0 1 0 0 1 ¦

¦ j: 0 1 1 0 1 0 1 0 ¦

¦ k: 0 1 1 0 1 0 1 1 ¦

¦ l: 0 1 1 0 1 1 0 0 ¦

¦ m: 0 1 1 0 1 1 0 1 ¦

¦ n: 0 1 1 0 1 1 1 0 ¦

¦ o: 0 1 1 0 1 1 1 1 ¦

¦ p: 0 1 1 1 0 0 0 0 ¦

¦ =: 0 0 1 1 1 1 0 1 ¦

¦ -: 0 0 1 0 1 1 0 1 ¦

¦ 0: 0 0 1 1 0 0 0 0 ¦

¦ 9: 0 0 1 1 1 0 0 1 ¦

¦ 8: 0 0 1 1 1 0 0 0 ¦

Битовое поле - это последовательность битов. Минимальная длина битового поля, естественно, равняется 1 (одному биту), максимальная длина зависит от реализации. Битовое поле длинной в восемь бит - не байт. Байт - это минимальная адресуемая область памяти ЭВМ, битовое поле - языковая конструкция. Среди форм Бэкуса-Наура, посвящённых объявлению класса, напомним соответствующую БНФ:

ОписательЧленаКласса::= [Идентификатор ] : КонстантноеВыражение

Вот такой описатель члена класса и задаёт битовое поле. Битовое поле может существовать исключительно как элемент класса. Идентификатор (необязательный!) задаёт имя поля, константное выражение - размеры этого поля в битах. Согласно ранее приведённым БНФ, подобному описателю должны предшествовать спецификаторы объявления. Как известно, они специфицируют тип объявляемого члена класса.

В C++ существует ограничения на тип битового поля. Это всегда целочисленный тип. Вполне возможно, что тип знаковый. По крайней мере, в Borland C++, максимально допустимый размер поля равняется длине (количеству бит), объекта соответствующего типа.

Рассмотрим пример объявления битового поля:

ОбъявлениеЧленаКласса ::= [СписокСпецификаторовОбъявления ] [СписокОписателейЧленовКласса ]; ::= СпецификаторОбъявления ОписательЧленаКласса ; ::= int [Идентификатор ] : КонстантноеВыражение ; ::= int MyField:5; А вот как объявления битовых полей выглядят в контексте объявления класса: struct BitsFields { int IntField: 1; char CharField: 3; int: 3 unsigned UnsignedField: 1; };

Неименованное битовое поле также является членом класса. Существует множество ситуаций, в которых оправдано использование неименованных битовых полей. В конце концов, они ничем не хуже неименованных параметров функций. Неименованные поля могут использоваться для заполнения соответствующей области памяти. Если это поле является полем нулевой длины (для неименованного поля возможно и такое), оно может задавать выравнивание следующего битового поля по границе очередного элемента памяти. Хотя и здесь, в конечном счёте, многое зависит от реализации.

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

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

BitsFields QWE; ::::: QWE.CharField = 100; QWE.IntField = 101; QWE.UnsignedField = 1;

Но фактически значения в битовом поле ограничиваются размерами битового поля. Было поле объявлено размером в три бита - диапазон его значений и будет ограничен этими самыми тремя битами:

Cout << QWE.CharField << "....." << endl; cout << QWE.IntField << "....." << endl; cout << QWE.UnsignedField << "....." << endl; :::::

В Borland C++ у битового поля знакового типа, независимо от размеров этого поля, один из битов остаётся знаковым. В результате, однобитовое знаковое поле способно принимать только одно из двух значений: либо -1, либо 0.

В ряде книг утверждается, что битовые поля способствуют "рациональному использованию памяти". В "Справочном руководстве по C++" на этот счёт высказывается мнение, что подобные усилия "наивны и вместо цели (экономии памяти) могут привести к лишним тратам памяти". Даже если в конкретной реализации и удастся упаковать несколько маленьких элементов в одно слово, то извлечение значения битового поля может потребовать дополнительных машинных команд.

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

Битовое поле

Битовое поле - в программировании число, занимающее некоторый набор битов, напрямую не адресуемый процессором. Например: при 8-битном байте первые два поля протокола - версия и IHL - будут битовыми полями. На машинах с 32-битным байтом все поля IP-пакета (кроме IP-адресов отправителя и получателя) будут битовыми.

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

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

Операции над многобитовыми полями

Пусть в одном байте находятся три битовых поля: 1-битовые a и b , 2-битовое c и 4-битовое d , то есть .

[старший бит] d d d d c c b a [младший бит]

Например: при a =1, b =0, c =2=10 2 , d=5=0101 2 получаем x =01011001 2 =89.

Сборка одного числа из битовых полей

Двоичные компьютеры обычно имеют команды побитового сдвига, которые позволяют быстро умножать на степени двойки - 2, 4, 8 и т. д. Вместо сложения можно применить команду логического «ИЛИ». Таким образом, число x можно собрать и по-другому:

X = (d << 3) | (c << 2) | (b << 1) | a

Извлечение битового поля

Для извлечения битового поля нужно провести две операции:

  1. Умножить операцией логического «И» число на битовую маску - число, у которого в соответствующих разрядах единицы, а в остальных нули.

C = (x & 00001100b) >> 2

  1. Провести побитовый сдвиг вправо.
  2. Умножить операцией логического «И» число на битовую маску соответствующей длины.
c = (x >> 2) & 00000011b

Для младшего поля побитовый сдвиг не нужен, то есть:

A = x & 00000001b

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

D = x >> 4

Замена битового поля

  1. Очистить x от предыдущего значения побитовым умножением на маску с нулями в соответствующих битах.
  2. Побитово сложить x с новым значением (сдвинутым на нужное количество битов)

Например, если нам нужно заменить d , то

Xnew = (x & 00001111b) | (d << 4)

Операции над однобитовыми полями

Поля a и b имеют длину 1 бит - это позволяет работать с ними несколько другими средствами.

Проверка отдельного бита

Для проверки надо побитово умножить x операцией «И» на маску, у которой одна единица - в соответствующей позиции. Если получился 0, бит равен 0.

B = ((x & 00000010b) != 0)

Проверка, равен ли единице хотя бы один бит из нескольких:

A_or_b = ((x & 00000011b) != 0)

Проверка, равны ли единице все биты из нескольких:

A_and_b = ((x & 00000011b) == 00000011b)

Установка битов

Для этого надо сложить операцией «ИЛИ» x с маской, у которой единицы в соответствующих позициях. Например, чтобы включить бит a :

X1 = x | 00000001b

Чтобы включить и a , и b :

X2 = x | 00000011b

Снятие битов

Чтобы снять один или несколько битов, надо сложить x операцией «И» с маской, у которой в соответствующих позициях нули. В частности, чтобы выключить бит b , нужно дать команду:

X3 = x & 11111101b

Переключение битов

Для переключения битов (с 0 на 1, с 1 на 0) надо сложить x командой «Исключающее ИЛИ » с маской, у которой в соответствующих позициях единицы. Например, бит b переключается так:

X4 = x ^ 00000010b

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

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

1 = 11111111b -2 = 11111110b -3 = 11111101b -4 = 11111100b и т. д.

Считаем, что поля c и d имеют именно такой формат. Тогда поле c может хранить числа от −2=10 2 до 1=01 2 , а поле d - от −8=1000 2 до 7=0111 2 .

Сборка и замена чисел

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

X = (d << 4) + ((c & 00000011b) << 2) + (b << 1) + a

Извлечение чисел

Для извлечения чисел требуется сдвинуть поле на нужное количество битов вправо, заодно размножив знаковый бит. Например, для этого можно воспользоваться арифметическим сдвигом . Если x имеет длину 8 битов, то

C = (x << 4) >>a 6 d = x >>a 4

Внимание! В языке программирования Java всё наоборот: знаком >> обозначается арифметический сдвиг, знаком >>> - простой.

Если арифметического сдвига нет, то…

C1 = x >> 2 если (c1 & 00000010b ≠ 0) то c = c1 | 0x11111100b иначе c = c1 & 0x00000011b

Объявления битовых полей

В языке C/C++

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

Struct rgb { unsigned r:3; unsigned g:3; unsigned b:3; };

Примечания


Wikimedia Foundation . 2010 .

Смотреть что такое "Битовое поле" в других словарях:

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

    дополнительное битовое поле - Битовое поле, которое иногда вставляется (для кодирования абстрактного значения), а иногда опускается (МСЭ Т Х.692). Тематики электросвязь, основные понятия EN optional bit field … Справочник технического переводчика

    Поле многозначное понятие, связанное с протяжённостью в пространстве: Понятие в математике Поле алгебраическая структура с двумя операциями. Скалярное, векторное и тензорное поля в дифференциальной геометрии (см. вектор и тензор) и матанализе … Википедия

    поле маршрутной информации - Битовое поле, содержащее маршрутную информацию. Тематики сети вычислительные EN routing information fieldRIF … Справочник технического переводчика - Битовое поле, которое указывает, присутствует ли дополнительное битовое поле (МСЭ Т Х.692). Тематики электросвязь, основные понятия EN presence determinant … Справочник технического переводчика

    детерминант выбора - Битовое поле, которое определяет, какие из нескольких возможных кодовых последовательностей (каждая из которых представляет разные абстрактные значения) имеются в некотором другом битовом поле (МСЭ Т Х.692). }