Значения атрибутов, используемые в DTD по умолчанию

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

Например, рассмотрим элемент EXAMPLE с атрибутом "notation", который по умолчанию принимает значение "decimal". Фрагмент DTD может выглядеть следующим образом:

<!ATTLIST EXAMPLE notation (decimal,octal) "decimal">

Если таблица стилей содержит правила

EXAMPLE[notation=decimal] { /*... установки по умолчанию...*/ }EXAMPLE[notation=octal] { /*... прочие установки...*/ }

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

EXAMPLE { /*... установки, используемые по умолчанию...*/ }

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

Селекторы классов

В таблицах стилей, используемых с HTML-документами, при сопоставлении атрибуту "class" разработчики могут использовать точку (".") как альтернативу условному обозначению "~=". Таким образом, два выражения HTML "DIV.value" и "DIV[class~=value]" имеют одинаковый смысл. Значение атрибута должно находиться непосредственно после точки (".").

Например, для всех элементов с class~="pastoral" информацию о стиле можно определить следующим образом:

*.pastoral { color: green } /* все элементы с class~=pastoral */

или просто

.pastoral { color: green } /* все элементы с class~=pastoral */

Следующее правило назначает стиль только элементу H1 с class~="pastoral":

H1.pastoral { color: green } /* элемент H1 с class~=pastoral */

Благодаря этим правилам в следующем примере при первом появлении элементы H1 не будут отображаться зеленым цветом, а при втором появлении будут:

<H1>Не зеленый цвет</H1><H1 class="pastoral">Настоящий зеленый цвет</H1>

Для сопоставления подмножеству значений атрибута "class" перед каждым из них, записанных в произвольном порядке, должна следует поставить точку (".").

Например, следующее правило сопоставляется любому элементу P, атрибуту "class" которого в качестве значения назначен список разделенных пробелами значений, включающий слова "pastoral" и "marine":

 P.pastoral.marine { color: green }

Это правило сопоставляется, если, например, class="pastoral blue aqua marine" и не сопоставляется, если class="pastoral blue".

Примечание. В языке CSS атрибут "class" наделен большими описательными возможностями, позволяющими разработчикам создавать свои собственные "языки написания документов" с использованием элементов, с которыми не связана никакая информация о представлении (например, элементы DIV и SPAN в HTML) и назначать информацию о стиле посредством атрибута "class". Разработчикам следует избегать использования таких возможностей на практике, т.к. структурные элементы языка документа в основном имеют общепринятые значения, а определяемые разработчиком классы чаще всего их не имеют.

ID-селекторы

Язык документа может содержать атрибуты типа ID. Их отличие от других атрибутов заключается в том, что любые два из них обязательно имеют различные значения. Независимо от языка документа атрибут ID может использоваться для уникальной идентификации элементов. В HTML-документах все атрибуты ID обозначаются "id", а в XML-документах атрибуты ID могут обозначаться по-другому, но для них справедливо то же самое ограничение.

Атрибут ID языка документа позволяет разработчикам назначать идентификатор одному экземпляру элемента в дереве документа. В CSS ID-селекторы сопоставляются экземпляру элемента в зависимости от его идентификатора. В CSS ID-селектор содержит символ "#", непосредственно за которым следует значение атрибута ID.

Следующий ID-селектор сопоставляется элементу H1, значение атрибута ID которого равно "chapter1":

H1#chapter1 { text-align: center }

В следующем примере правило стиля сопоставляется элементу, у которого значение атрибута ID равно "z98y". Т.е. это правило будет сопоставляться элементу P:

<HEAD> <TITLE>Match P</TITLE> <STYLE type="text/css"> *#z98y { letter-spacing: 0.3em } </STYLE></HEAD><BODY> <P id=z98y>Разреженный текст</P></BODY>

Однако в следующем примере это правило стиля будет сопоставляться только элементу H1, значение атрибута ID которого равно "z98y". В этом примере данное правило не сопоставляется элементу P:

<HEAD> <TITLE>Match H1 only</TITLE> <STYLE type="text/css"> H1#z98y { letter-spacing: 0.5em } </STYLE></HEAD><BODY> <P id=z98y>Разреженный текст</P></BODY>

ID-селекторы имеют более высокий приоритет, чем селекторы атрибутов. Например, в HTML-документе, в терминах каскадаселектор #p123 более специфичен, чем [ID=p123].

Примечание. В XML 1.0 [XML10] информация о том, в каком атрибуте содержатся ID элементов, располагается в DTD. Во время синтаксического анализа XML-документа агенты пользователей не всегда просматривают DTD и поэтому не всегда могут иметь информацию об идентификаторе элемента. Если разработчик таблицы стилей знает или предполагает, что подобное может случиться, то он должен использовать обычные селекторы атрибутов вместо ID-селекторов: [name=p371] вместо #p371 . Порядок каскадирования обычных селекторов атрибутов отличается от порядка каскадирования ID-селекторов. Возможно, при этом понадобится добавить в объявления приоритет "!important": [name=p371] {color: red! important} . Естественно, что элементы в документах XML 1.0, не использующих DTD, вообще не имеют атрибута ID.

28.     Модификаторы

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

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

К целочисленным типам относятся типы, представленные следующими именами основных типов:

charshortintlong

Имена целочисленных типов могут использоваться в сочетании с парой модификаторов типа:

signedunsigned

Эти модификаторы изменяют формат представления данных, но не влияют на размеры выделяемых областей памяти.

Модификатор типа signed указывает, что переменная может принимать как положительные, так и отрицательные значения. Возможно, что при этом самый левый бит области памяти, выделяемой для хранения значения, используется для представления знака. Если этот бит установлен в 0, то значение переменной считается положительным. Если бит установлен в 1, то значение переменной считается отрицательным.

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

В ряде случаев модификаторы типа можно рассматривать как имена основных типов.

Здесь также многое определяется конкретной реализацией. В версиях Borland C++ данные типов, обозначаемых как signed, short и int в памяти занимают одно и то же количество байтов.

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

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

Тип данных	Байты	Биты	Min	Max
signed char	1	8	- 128	127
unsigned char	1	8	0	255
signed short	2	16	-32768	32767
enum	2	16	-32768	32767
unsigned short	2	16	0	65535
signed int	2	16	-32768	32767
unsigned int	2	16	0	65535
signed long	4	32	-2147483648	2147483647
unsigned long	4	32	0	4294967295

К плавающим типам относятся три типа, представленные следующими именами типов, модификаторов и их сочетаний:

floatdoublelong double

Как и ранее, модификатор типа входит в число имён основных типов.

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

297.72.977*10**22.977E2

и ещё один пример…

0.0023552.355*10**-32.355E-3

В научной нотации слева от символа E записывается мантисса, справа - значение экспоненты, которая всегда равняется показателю степени 10.

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

Ниже представлены основные характеристики типов данных с плавающей точкой (опять же для Borland C++ 4.5):

Тип данных	Байты	Биты	Min	Max
float	4	32	3.4E-38	3.4E+38
double	8	64	1.7E-308	1.7E+308
long double	10	80	3.4E-4932	3.4E+4932

Подведём итог.

Имена типов данных и их сочетания с модификаторами типов используются для представления данных различных размеров в знаковом и беззнаковом представлении:

charsigned charunsigned char shortsigned shortunsigned short signedunsigned short intsigned short intunsigned short int intsigned intunsigned int longsigned longunsigned long long intsigned long intunsigned long int

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

А вот сочетания имён типов и модификаторов для представления чисел с плавающей точкой:

floatdoublelong double

Вот и всё об основных типах. Помимо основных типов в C++ существуют специальные языковые средства, которые позволяют из элементов основных типов создавать новые, так называемые производные типы.

29. Конструкторы

В объектно-ориентированном программировании конструктор класса (от англ. constructor, иногда сокращают ctor) — специальный блок инструкций, вызываемый при создании объекта.

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

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

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

Назначение конструктора

Одна из ключевых особенностей ООП — инкапсуляция: внутренние поля объекта напрямую недоступны, и пользователь может работать с объектом только как с единым целым, через открытые (public) методы. Каждый метод, в идеале, должен быть устроен так, чтобы объект, находящийся в «допустимом» состоянии (то есть когда выполняется инвариант класса), после вызова метода также оказался в допустимом состоянии. И первая задача конструктора — перевести поля объекта в такое состояние.

Вторая задача — упростить пользование объектом. Объект — не «вещь в себе», ему часто приходится требовать какую-то информацию от других объектов: например, объект File, создаваясь, должен получить имя файла. Это можно сделать и через метод:

File file; file.open("in.txt", File::omRead);

Но удобнее открытие файла сделать в конструкторе:^[1]

File file("in.txt", File::omRead);

Виды конструкторов

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

· конструктор по умолчанию — конструктор, не принимающий аргументов;

· конструктор копирования — конструктор, принимающий в качестве аргумента объект того же класса (или ссылку из него);

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

class Complex{ public: // Конструктор по умолчанию   // (в данном случае является также и конструктором преобразования) Complex(double i_re = 0, double i_im = 0): re(i_re), im(i_im) {}   // Конструктор копирования Complex(const Complex &obj) { re = obj.re; im = obj.im; } private: double re, im;};

Конструктор по умолчанию

Основная статья: Конструктор по умолчанию

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

Конструктор копирования

Основная статья: Конструктор копирования

Конструктор, аргументом которого является ссылка на объект того же класса. Применяется в C++ для передачи объектов в функции по значению.

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

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

Конструктор преобразования

Конструктор, принимающий один аргумент. Задаёт преобразование типа своего аргумента в тип конструктора. Такое преобразование типа неявно применяется только если оно уникально.

Виртуальный конструктор

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

«Виртуальными конструкторами» называют похожий, но другой механизм, присутствующий в некоторых языках — например, он есть в Delphi, но нет в C++ и Java. Этот механизм позволяет создать объект любого заранее неизвестного класса при двух условиях:

· этот класс является потомком некоего наперёд заданного класса (в данном примере это класс TVehicle);

· на всём пути наследования от базового класса к создаваемому цепочка переопределения не обрывалась. При переопределении виртуального метода синтаксис Delphi требует ключевое слово overload, чтобы старая и новая функции с разными сигнатурами могли сосуществовать, override для переопределения функции либо reintroduce для задания новой функции с тем же именем — последнее недопустимо.

type TVehicle = class constructor Create; virtual; end;   TAutomobile = class (TVehicle) constructor Create; override; end;   TMotorcycle = class (TVehicle) constructor Create; override; end;   TMoped = class (TMotorcycle) // обрываем цепочку переопределения - заводим новый Create constructor Create(x: integer); reintroduce; end;

В языке вводится так называемый классовый тип (метакласс). Этот тип в качестве значения может принимать название любого класса, производного от TVehicle.

type CVehicle = class of TVehicle;

Такой механизм позволяет создавать объекты любого заранее неизвестного класса, производного от TVehicle.

var cv: CVehicle; v: TVehicle; cv:= TAutomobile;v:= cv.Create;

Заметьте, что код

cv:= TMoped;v:= cv.Create;

является некорректным — директива reintroduce разорвала цепочку переопределения виртуального метода, и в действительности будет вызван конструктор TMotorcycle.Create (а значит, будет создан мотоцикл, а не мопед!)

См. также Фабрика (шаблон проектирования)

Синтаксис

С++

Имя конструктора должно совпадать с именем класса. Допускается использовать несколько конструкторов с одинаковым именем, но различными параметрами.

Пример

class ClassWithConstructor { public: /* Инициализация внутреннего объекта с помощью конструктора */ ClassWithConstructor(float parameter): object(parameter) {} /* вызов конструктора AnotherClass(float); */ private: AnotherClass object;};

 

30. Конструктор по умолчанию (англ. default constructor), в объектно-ориентированных языках программирования — конструктор, который может быть вызван без аргументов.

В C++ и Java если нет явным образом опредёленных конструкторов в классе, то компилятор использует конструктор по умолчанию, опредёленный неявным способом, который аналогичен «чистому»^{[ уточнить ]} конструктору по умолчанию. Поэтому, класс не гарантирует наличия конструктора по умолчанию (то есть когда программист явным образом определяет только конструктор, который не по умолчанию). Некоторые программисты явным образом задают конструктор по умолчанию по привычке, чтобы не забыть в дальнейшем, но это не обязательно. В C++ только массивы имеют конструкторы по умолчанию, которые создают каждый элемент при помощи конструктора по умолчанию для их типа.

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

Пример Конструктора по умолчания

class Default Сonstructor {   int a = 10;   public int getInt() { return a; } } class Main {    public static void main(String[] args) {      Default Сonstructor Dc = new Default Сonstructor(); //Конструктор по умолчанию System.out.println(Dc.getInt());   } }

31. Деструкторы

Дестру́ктор — специальный метод класса, служащий для деинициализации объекта (например освобождения памяти).

Деструктор в С++

#include <iostream> using namespace std;     class NameOfClass {   private:        int a;   public:        NameOfClass(int m);        ~NameOfClass(); };     NameOfClass::~NameOfClass() {   cout << this->a << endl; }     NameOfClass::NameOfClass(int m) {   a = m; }

~NameOfClass() — деструктор, имеет имя ~NameOfClass, не имеет входных параметров.
В данном случае при уничтожении объекта выводит в консоль параметр a.

Виртуальный деструктор

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

Пусть (на C++) есть тип Father и порождённый от него тип Son:

class Father{public: Father() {} ~Father() {} }; class Son: public Father{public: int* buffer; Son(): Father() { buffer = new int[1024]; } ~Son() { delete[] buffer; }};

Нижеприведённый код является некорректным и приводит к утечке памяти.

Father* object = new Son(); // вызывается Son()delete object; // вызывается ~Father()!!

 

30-31-35. КОНСТРУКТОР И ДЕСТРУКТОР

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

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

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