template

inline Type* MP::operator->() const

Дескрипторы в C++

Итак, после небольшого подогрева умные указатели превратились в ведущие. Теперь в нашем вареве появляется еще один ингредиент - дескрипторы (handles) C++. Не путайте этот термин с дескрипторами, используемыми в операционных системах Macintosh и Windows. Некоторое сходство существует, но идиома дескрипторов C++ имеет собственную уникальную семантику и набор правил.

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

	MP)) {} // См. Ниже
H(MP& mp)

MP& operator->() const { return ptr; }

Безаргументный конструктор Н создает новый ведущий указатель. Этот ведущий указатель, в свою очередь, создает указываемый объект. Существует второй конструктор, который получает ведущий указатель и инициализирует им переменнуюptr . Конструктор копий и оператор= по умолчанию годятся, поскольку любому ведущему указателю может соответствовать несколько дескрипторов. Работа оператора -> основана на рекурсивном алгоритме, используемом компилятором: оператор -> дескриптора возвращает ведущий указатель; затем оператор -> ведущего указателя возвращает указательType* который является одним из базовых типов компилятора.

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

Что же получается?

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

Подсчет объектов

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

class CountedStuff { private:

static int current; public:

CountedStuff() { current++; } CountedStuff(const CuntedStuff&) { current++; } CountedStuff& operator=(const CountedStuff&)

{} // Не менять счетчик для присваивания

~CountedStuff() { current--; }

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

template class CMP {

static int current; Type* ptr;

CMP() : ptr(new Type) { current++; }

CMP(const CMP& cmp) : ptr(new Type(*(mp.t))) { current++; } CMP& operator=(const CMP& cmp)

if (this != &cmp) { delete ptr;

ptr = new Type(*(cmp.ptr));

~CMP() { delete ptr; current--; }

Type* operator->() const { return ptr; } Static int Current() { return current; }

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

Этот пример тривиален, но даже он демонстрирует важный принцип программирования на C++, справедливость которого со временем становится очевидной: пользуйтесь умными указателями, даже если сначала кажется, что они не нужны. Если программа написана для умных указателей, все изменения вносятся легко и быстро. Если же вам придется переделывать готовую программу и заменять все операторы * умными указателями, приготовьтесь к ночным бдениям.

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

Указатели только для чтения

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

Достаточно сделать операторную функцию operator->() константной функцией класса.

ROMP& operator=(const ROMP&); const Type* operator->() const;

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

Указатели для чтения/записи

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

Это было бы легко сделать при наличии двух перегруженных версий оператора -> , одна из которых возвращаетFoo* , а другая -const Foo* . К сожалению, разные возвращаемые типы не обеспечивают уникальности сигнатур, поэтому при попытке объявить два оператора -> компилятор от души посмеется. Программисту придется заранее вызвать функцию, которая осуществляет переход от одного представления к другому.

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

• Перевод

Краткий обзор

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

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

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

Пример дескриптора

Следующий код создаёт класс, чьи объекты являются дескрипторам данных и всё, что они делают - это печатают сообщение на каждый вызов get или set . Переопределение __getattribute__ - это альтернативный подход, с помощью которого мы могли бы сделать это для каждого атрибута. Но если мы хотим наблюдать только за отдельными атрибутами, то это проще сделать с помощью дескриптора.
class RevealAccess(object): """Дескриптор данных, который устанавливает и возвращает значения, и печатает сообщение о том, что к атрибуту был доступ. """ def __init__(self, initval=None, name="var"): self.val = initval self.name = name def __get__(self, obj, objtype): print "Получаю", self.name return self.val def __set__(self, obj, val): print "Обновляю" , self.name self.val = val >>> class MyClass(object): x = RevealAccess(10, "var "x"") y = 5 >>> m = MyClass() >>> m.x Получаю var "x" 10 >>> m.x = 20 Обновляю var "x" >>> m.x Получаю var "x" 20 >>> m.y 5
Этот простой протокол предоставляет просто увлекательные возможности. Некоторые из них настолько часто используются, что были объединены в отдельные функции. Свойства, связанные и несвязанные методы, статические методы и методы класса - все они основаны на этом протоколе.

Свойства

Вызова property() достаточно, чтобы создать дескриптор данных, который вызывает нужные функции во время доступа к атрибуту. Вот его сигнатура:
property(fget=None, fset=None, fdel=None, doc=None) --> атрибут, реализующий свойства
В документации показано типичное использование property() для создания управляемого атрибута x:
class C(object): def getx(self): return self.__x def setx(self, value): self.__x = value def delx(self): del self.__x x = property(getx, setx, delx, "Я свойство "x".")
Вот эквивалент property на чистом питоне, чтобы было понятно как реализовано property() с помощью протокола дескрипторов:
class Property(object): "Эмуляция PyProperty_Type() в Objects/descrobject.c" def __init__(self, fget=None, fset=None, fdel=None, doc=None): self.fget = fget self.fset = fset self.fdel = fdel self.__doc__ = doc def __get__(self, obj, objtype=None): if obj is None: return self if self.fget is None: raise AttributeError, "нечитаемый атрибут" return self.fget(obj) def __set__(self, obj, value): if self.fset is None: raise AttributeError, "не могу установить атрибут" self.fset(obj, value) def __delete__(self, obj): if self.fdel is None: raise AttributeError, "не могу удалить атрибут" self.fdel(obj)
Встроенная реализация property() может помочь, когда существовал интерфейс доступа к атрибуту и произошли какие-то изменения, в результате которых понадобилось вмешательство метода.

Например, класс электронной таблицы может давать доступ к значению ячейки через Cell("b10").value . В результате последующих изменений в программе, понадобилось сделать так, чтобы это значение пересчитывалось при каждом доступе к ячейке, однако программист не хочет менять клиентский код, который обращается к атрибуту напрямую. Эту проблему можно решить, если обернуть атрибут value с помощью дескриптора данных, который будет создан с помощью property() :
class Cell(object): . . . def getvalue(self, obj): "Пересчитываем ячейку прежде чем вернуть значение" self.recalc() return obj._value value = property(getvalue)

Функции и методы

В питоне все объектно-ориентированные возможности реализованы с помощью функционального подхода. Это сделано совсем незаметно с помощью дескрипторов не данных.

Словари классов хранят методы в виде функций. При определении класса, методы записываются с помощью def и lambda - стандартных инструментов для создания функций. Единственное отличие этих функций от обычных в том, что первый аргумент зарезервирован под экземпляр объекта. Этот аргумент обычно называется self , но может называться this или любым другим словом, которым можно называть переменные.

Для того, чтобы поддерживать вызов методов, функции включают в себя метод __get__ , который автоматически делает их дескрипторами не данных при поиске атрибутов. Функции возвращают связанные или не связанные методы, в зависимости от того, через что был вызван этот дескриптор.
class Function(object): . . . def __get__(self, obj, objtype=None): "Симуляция func_descr_get() в Objects/funcobject.c" return types.MethodType(self, obj, objtype)
С помощью интерпретатора мы можем увидеть как на самом деле работает дескриптор функции:
>>> class D(object): def f(self, x): return x >>> d = D() >>> D.__dict__["f"] # Внутренне хранится как функция >>> D.f # Доступ через класс возвращает несвязанный метод >>> d.f # Доступ через экземпляр объекта возвращает связанный метод >
Вывод интерпретатора подсказывает нам, что связанные и несвязанные методы - это два разных типа. Даже если они могли бы быть реализованы таким образом, на самом деле, реализация PyMethod_Type в файле Objects/classobject.c содержит единственный объект с двумя различными отображениями, которые зависят только от того, есть ли в поле im_self значение или там содержится NULL (C эквивалент значения None).

Таким образом, эффект вызова метода зависит от поля im_self . Если оно установлено (т.е. метод связан), то оригинальная функция (хранится в поле im_func) вызывается, как мы и ожидаем, с первым аргументом, установленным в значение экземпляра объекта. Если же она не связана, то все аргументы передаются без изменения оригинальной функции. Настоящая C реализация instancemethod_call() чуть более сложная, потому что включает в себя некоторые проверки типов и тому подобное.

Статические методы и методы класса

Дескрипторы не данных предоставляют простой механизм для различных вариантов привязки функций к методам.

Повторим ещё раз. Функции имеют метод __get__ , с помощью которых они становятся методами, во время поиска атрибутов и автоматического вызова дескрипторов. Дескрипторы не данных преобразуют вызов obj.f(*args) в вызов f(obj, *args) , а вызов klass.f(*args) становится f(*args) .

В этой таблице показано связывание и два наиболее популярных варианта:

Статические методы возвращают функцию без изменений. Вызовы c.f или C.f эквиваленты вызовам object.__getattribute__(c, "f") или object.__getattribute__(C, "f") . Как результат, функция одинаково доступна как из объекта, так и из класса.

Хорошими кандидатами для статических методов являются методы, которым не нужна ссылка на переменную self .

Например, пакет для статистики может включать класс для экспериментальных данных. Класс предоставляет обычные методы для расчёта среднего, ожидания, медианы и другой статистики, которая зависит от данных. Однако, там могут быть и другие функции, которые концептуально связаны, но не зависят от данных. Например, erf(x) это простая функция для преобразования, которая нужна в статистике, но не зависит от конкретного набора данных в этом классе. Она может быть вызвана и из объекта, и из класса: s.erf(1.5) --> 0.9332 или Sample.erf(1.5) --> 0.9332 .

Так как staticmethod() возвращает функцию без изменений, то этот пример не удивляет:
>>> class E(object): def f(x): print x f = staticmethod(f) >>> print E.f(3) 3 >>> print E().f(3) 3
Если использовать протокол дескриптора не данных, то на чистом питоне staticmethod() выглядел бы так:
class StaticMethod(object): "Эмуляция PyStaticMethod_Type() в Objects/funcobject.c" def __init__(self, f): self.f = f def __get__(self, obj, objtype=None): return self.f
В отличие от статических методов, методы класса подставляют в начало вызова функции ссылку на класс. Формат вызова всегда один и тот же, и не зависит от того, вызываем мы метод через объект или через класс.
>>> class E(object): def f(klass, x): return klass.__name__, x f = classmethod(f) >>> print E.f(3) ("E", 3) >>> print E().f(3) ("E", 3)
Это поведение удобно, когда нашей функции всегда нужна ссылка на класс и ей не нужны данные. Один из способов использования classmethod() - это создание альтернативных конструкторов класса. В питоне 2.3, метод класса dict.fromkeys() создаёт новый словарь из списка ключей. Эквивалент на чистом питоне будет таким:
class Dict: . . . def fromkeys(klass, iterable, value=None): "Эмуляция dict_fromkeys() в Objects/dictobject.c" d = klass() for key in iterable: d = value return d fromkeys = classmethod(fromkeys)
Теперь новый словарь уникальных ключей можно создать таким образом:
>>> Dict.fromkeys("abracadabra") {"a": None, "r": None, "b": None, "c": None, "d": None}
Если использовать протокол дескриптора не данных, то на чистом питоне classmethod() выглядел бы так:
class ClassMethod(object): "Эмуляция PyClassMethod_Type() в Objects/funcobject.c" def __init__(self, f): self.f = f def __get__(self, obj, klass=None): if klass is None: klass = type(obj) def newfunc(*args): return self.f(klass, *args) return newfunc

In this article

The handle declarator (^ , pronounced "hat"), modifies the type specifier to mean that the declared object should be automatically deleted when the system determines that the object is no longer accessible.

Accessing the Declared Object

A variable that is declared with the handle declarator behaves like a pointer to the object. However, the variable points to the entire object, cannot point to a member of the object, and it does not support pointer arithmetic. Use the indirection operator (*) to access the object, and the arrow member-access operator (->) to access a member of the object.

Windows Runtime

The compiler uses the COM reference counting mechanism to determine if the object is no longer being used and can be deleted. This is possible because an object that is derived from a Windows Runtime interface is actually a COM object. The reference count is incremented when the object is created or copied, and decremented when the object is set to null or goes out of scope. If the reference count goes to zero, the object is automatically and immediately deleted.

The advantage of the handle declarator is that in COM you must explicitly manage the reference count for an object, which is a tedious and error prone process. That is, to increment and decrement the reference count you must call the object"s AddRef() and Release() methods. However, if you declare an object with the handle declarator, the compiler generates code that automatically adjusts the reference count.

For information on how to instantiate an object, see ref new .

Requirements

Compiler option: /ZW

Common Language Runtime

The system uses the CLR garbage collector mechanism to determine if the object is no longer being used and can be deleted. The common language runtime maintains a heap on which it allocates objects, and uses managed references (variables) in your program indicate the location of objects on the heap. When an object is no longer used, the memory that it occupied on the heap is freed. Periodically, the garbage collector compacts the heap to better use the freed memory. Compacting the heap can move objects on the heap, which invalidates the locations referred to by managed references. However, the garbage collector is aware of the location of all managed references, and automatically updates them to indicate the current location of the objects on the heap.

Because native C++ pointers (*) and references (&) are not managed references, the garbage collector cannot automatically update the addresses they point to. To solve this problem, use the handle declarator to specify a variable that the garbage collector is aware of and can update automatically.

Examples

This sample shows how to create an instance of a reference type on the managed heap. This sample also shows that you can initialize one handle with another, resulting in two references to same object on managed, garbage-collected heap. Notice that assigning nullptr to one handle does not mark the object for garbage collection.

// mcppv2_handle.cpp // compile with: /clr ref class MyClass { public: MyClass() : i(){} int i; void Test() { i++; System::Console::WriteLine(i); } }; int main() { MyClass ^ p_MyClass = gcnew MyClass; p_MyClass->Test(); MyClass ^ p_MyClass2; p_MyClass2 = p_MyClass; p_MyClass = nullptr; p_MyClass2->Test(); } 1 2

The following sample shows how to declare a handle to an object on the managed heap, where the type of object is a boxed value type. The sample also shows how to get the value type from the boxed object.

// mcppv2_handle_2.cpp // compile with: /clr using namespace System; void Test(Object^ o) { Int32^ i = dynamic_cast(o); if(i) Console::WriteLine(i); else Console::WriteLine("Not a boxed int"); } int main() { String^ str = "test"; Test(str); int n = 100; Test(n); } Not a boxed int 100

This sample shows that the common C++ idiom of using a void* pointer to point to an arbitrary object is replaced by Object^ , which can hold a handle to any reference class. It also shows that all types, such as arrays and delegates, can be converted to an object handle.

// mcppv2_handle_3.cpp // compile with: /clr using namespace System; using namespace System::Collections; public delegate void MyDel(); ref class MyClass { public: void Test() {} }; void Test(Object ^ x) { Console::WriteLine("Type is {0}", x->GetType()); } int main() { // handle to Object can hold any ref type Object ^ h_MyClass = gcnew MyClass; ArrayList ^ arr = gcnew ArrayList(); arr->Add(gcnew MyClass); h_MyClass = dynamic_cast(arr); Test(arr); Int32 ^ bi = 1; Test(bi); MyClass ^ h_MyClass2 = gcnew MyClass; MyDel^ DelInst = gcnew MyDel(h_MyClass2, &MyClass::Test); Test(DelInst); } Type is System.Collections.ArrayList Type is System.Int32 Type is MyDel

This sample shows that a handle can be dereferenced and that a member can be accessed via a dereferenced handle.

// mcppv2_handle_4.cpp // compile with: /clr using namespace System; value struct DataCollection { private: int Size; array^ x; public: DataCollection(int i) : Size(i) { x = gcnew array(Size); for (int i = 0 ; i < Size ; i++) x[i] = i.ToString(); } void f(int Item) { if (Item >= Size) { System::Console::WriteLine("Cannot access array element {0}, size is {1}", Item, Size); return; } else System::Console::WriteLine("Array value: {0}", x); } }; void f(DataCollection y, int Item) { y.f(Item); } int main() { DataCollection ^ a = gcnew DataCollection(10); f(*a, 7); // dereference a handle, return handle"s object (*a).f(11); // access member via dereferenced handle } Array value: 7 Cannot access array element 11, size is 10

This sample shows that a native reference (&) can’t bind to an int member of a managed type, as the int might be stored in the garbage collected heap, and native references don’t track object movement in the managed heap. The fix is to use a local variable, or to change & to % , making it a tracking reference.

В общих чертах, дескрипторы — это некие атрибуты объектов, для которых определено соответствующее поведение. При доступе к ним происходит получение, установка или удаление указанных атрибутов из словаря. Говоря простым языком, это особые ключевые слова, определяющие поведение объекта, его свойства или структуру. В статье будет рассмотрено несколько вариантов дескрипторов. Это позволит более точно понять их суть и предназначение.

HTML

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

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

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

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

Архитектура х86

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

• Смещение. Может сдвинуть процедуру кода.
• Селектор. Отражает своего рода метку, куда должна перейти процедура.
• Количество параметров.
• Права доступа.

Java

В Java EE имеется понятие дескриптора развёртывания. Он определяет то, каким образом будет развёрнут сервлет. По сути, это конфигурационный файл, содержащий настройки, свойства и требования к аппаратной части.

В веб-приложениях такой файл по правилам должен называться web.xml и располагаться в определённой папке.

Файловые дескрипторы

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

Операционная система Windows позволяет обратиться к дескриптору с помощью функции CreateFile. Его можно в дальнейшем использовать при работе с требуемым файлом.

В Unix системах для файлового дескриптора используется цифровые обозначения. 0 — стандартный ввод процесса терминала, 1 — его вывод, 2 — поток диагностики. Помимо числовых представлений можно использовать символические константы, определённые спецификацией.

Дескриптор окна

После того как в системе создаётся любое окно, ему присваивается определённый дескриптор. Типы данных применяемых в нем — HWND. Программисту, при создании приложения, нужно правильно использовать их для обращения к

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

Чтобы проверить, правильно ли прошла идентификация, стоит использовать функцию IsWindow.

Ошибка номер 1400

Данная проблема часто встречается в семействе операционных систем Windows. При её появлении вместе с ней может быть и краткое описание — недопустимый дескриптор окна. А может встречаться и такая формулировка - «Error_invalid_window_handle» или 0х578.

Как бороться и что значит неверный дескриптор? В зависимости от контекста объекта, нужно принимать разные меры.

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

запуск и сканирование ошибки с помощью утилиты проверки целостности системных файлов;

проверить компьютер на вирусы.

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

Ещё один надёжный способ быстро восстановить работоспособность системы — сделать её откат с помощью стандартных инструментов. После использования «Восстановления системы», она вернётся к последней действующей резервной копии, при условии что она была ранее создана.

Когда может возникнуть ошибка

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

Заключение

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

А также стало ясно, что это — неверный дескриптор. Как оказалось, это распространённая проблема в среде Windows, в большинстве случаев решаемая простыми манипуляциями.

ДЕСКРИПТОР ДЕСКРИПТОР (от латинского descriptor - описывающий), лексическая единица (слово, словосочетание) информационно-поискового языка, служит для описания основного смыслового содержания документа или формулировки запроса при поиске документа (информации) в информационно-поисковой системе. Дескриптор однозначно ставится в соответствие группе ключевых слов естественного языка, отобранных из текста, относящегося к определенной области знаний.

Современная энциклопедия . 2000 .

Синонимы :

Смотреть что такое "ДЕСКРИПТОР" в других словарях:

- (англ. Descriptor): Дескриптор HTML элемент языка разметки гипертекста HTML. В разговорной речи дескрипторы называют тегами. Дескриптор развертывания XML файлы, которые описывают, как развернуть модули. Файловый дескриптор число… … Википедия

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

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

Дескриптор - (от латинского descriptor описывающий), лексическая единица (слово, словосочетание) информационно поискового языка, служит для описания основного смыслового содержания документа или формулировки запроса при поиске документа (информации) в… … Иллюстрированный энциклопедический словарь

Ключевое слово, характеризующее блок информации. Словарь бизнес терминов. Академик.ру. 2001 … Словарь бизнес-терминов

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

Сущ., кол во синонимов: 5 описатель (4) описыватель (1) таг (2) … Словарь синонимов

- (от лат. descriptio описание) англ. descriptor; нем. Deskriptor. Лексическая единица (слово, словосочетание) информационно поискового языка, служащая для выражения основного смыслового содержания документов (текста). Antinazi. Энциклопедия… … Энциклопедия социологии

дескриптор - а, м. descripteur, нем. Deskriptor, англ. descriptor < describere описывать. лингв., инф. Стандартизированное слово, словосочетание инфрмационно поискового языка, служащее для описания основного смыслового содержания документа (текста),… … Исторический словарь галлицизмов русского языка

Дескриптор - единица языка информационно поисковой системы, соответствующая определенному ключевому или базовому понятию, включенному в тезаурус этой системы. Это термин со строго фиксированным значением, без синонимов. Из Д ов для каждого… … Экономико-математический словарь

Книги

• Економіка підприємства: формування компетентностей на основі тренінгів , Николай Афанасьев,Марина Боровик,Альбина Диоба. От издателя:Розглянуто практичну компоненту опанування економіки підприємства. Велику увагу приділено формуванню професійних компетностей відповідно до дескрипторів Національної рамки…