ТОП 10:

Тип данных “класс”. Объекты и классы.



Тип данных “класс”. Объекты и классы.

Класс — это такая абстракция множества предметов реального мира, что

1. Предметы в этом множестве - объекты имеют одни и те же характеристики

2. Все объекты подчинены и согласованы с одним и тем же набором правил и линий поведений

Классы и объекты, понятие экземпляра класса, понятие членов класса

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

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

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

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

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

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

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

Виды классов

§ Базовый (родительский) класс

§ Производный класс (наследник, потомок)

§ Абстрактный класс

§ Интерфейс

Классы в языке Object Pascal (среда Delphi)

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

TMyClass = class(TObject) private {Описанные в этой секции элементы не доступны извне (за пределами класса, но доступны в пределах модуля).} {Здесь обычно находятся поля класса.} protected {Описанные в этой секции элементы доступны только классу и всем его потомкам.} public {Описанные в этой секции элементы доступны всем.} published {Описанные в этой секции элементы доступны всем и отображаются в Object Inspector'e.} end;

§ TMyClass — имя класса;

§ class — ключевое слово, начинающее определение класса;

§ TObject — класс-предок, если есть наследование;

§ private, protected, public, published — ключевые слова, обозначающие секции областей доступа.

Методы класса

Метод представляет собой подпрограмму (процедуру или функцию), предназначенную для обработки полей.

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

Метод, объявленный в классе, может вызываться различными способами, что зависит от вида этого метода. Вид метода определяется модификатором, который указывается в описании класса после заголовка метода и отделяется от заголовка точкой с запятой: virtual (виртуальный метод); dynamic (динамический метод) и др.

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

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


· Статические – все методы по умолчанию. При переопределении метода в классе – наследнике то отменятся родительский метод для всех объектов этого класса.

· Виртуальный и динамический методы не имеют ничего общего с методами с такими же именами в классах – наследниках. Очень часто применяется полиморфизм – когда создается виртуальный метод для объектов базового класса. При объявлении таких методов добавляются ключевые слова dynamic или virtual, которые завершают объявление метода. Для перегрузки метода ставим слово override.

· Если виртуальный или динамический метод не определен в объявленном классе, то такой метод называют Абстрактный. Такой метод будет перегружен в классах – наследниках. Из этого следует, что в том классе, где он перегружен, можно его вызывать. Ключевое слово – abstract. Перегрузка метода – overload, а для виртуального метода – добавляется слово reintroduce.

Свойства класса и поля. Отличие свойства класса от полей записи.

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

Согласно принятому обозначению в Delphi имена полей должно начинаться с буквы F (Field – поле), а имена классов с буквы T.

Изменение значений полей обычно выполняется с помощью методов и свойств объекта.

Свойства реализуют механизм доступа к полям. Каждому свойству соответствует поле, содержащее значение свойства, и два метода, обеспечивающих доступ к этому полю.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Delphi

В Delphi, в отличие от C++, для объявления конструктора служит ключевое слово constructor. Имя конструктора может быть любым, но рекомендуется называть конструктор Create.

Пример

TClassWithConstructor = class public constructor Create; end;

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

Деструктор в Delphi

Для объявления деструктора в Delphi используется ключевое слово destructor. Имя деструктора может быть любым, но рекомендуется всегда называть деструктор Destroy.

TClassWithDestructor = class destructor Destroy; override; end;

В Delphi все классы являются потомками, по крайней мере, класса TObject, поэтому, для корректного освобождения памяти, необходимо перекрывать деструктор, используя директиву override.

В Delphi прямой вызов деструктора используется редко. Вместо него используют метод Free.

MyObject.Free;

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

 

Простое наследование

Класс, от которого произошло наследование, называется базовым или родительским (англ. base class). Классы, которые произошли от базового, называются потомками,наследниками или производными классами (англ. derived class).

В некоторых языках используются абстрактные классы. Абстрактный класс — это класс, содержащий хотя бы один абстрактный метод, он описан в программе, имеет поля,методы и не может использоваться для непосредственного создания объекта. То есть от абстрактного класса можно только наследовать. Объекты создаются только на основе производных классов, наследованных от абстрактного. Например, абстрактным классом может быть базовый класс «сотрудник вуза», от которого наследуются классы «аспирант», «профессор» и т. д. Так как производные классы имеют общие поля и функции (например, поле «год рождения»), то эти члены класса могут быть описаны в базовом классе. В программе создаются объекты на основе классов «аспирант», «профессор», но нет смысла создавать объект на основе класса «сотрудник вуза».

Множественное наследование

Основная статья: Множественное наследование

При множественном наследовании у класса может быть более одного предка. В этом случае класс наследует методы всех предков. Достоинства такого подхода в большей гибкости. Множественное наследование реализовано в C++. Из других языков, предоставляющих эту возможность, можно отметить Python и Эйфель. Множественное наследование поддерживается в языке UML.

Множественное наследование — потенциальный источник ошибок, которые могут возникнуть из-за наличия одинаковых имен методов в предках. В языках, которые позиционируются как наследники C++ (Java, C# и др.), от множественного наследования было решено отказаться в пользу интерфейсов. Практически всегда можно обойтись без использования данного механизма. Однако, если такая необходимость все-таки возникла, то, для разрешения конфликтов использования наследованных методов с одинаковыми именами, возможно, например, применить операцию расширения видимости — «::» — для вызова конкретного метода конкретного родителя.

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

Большинство современных объектно-ориентированных языков программирования (C#, Java, Delphi и др.) поддерживают возможность одновременно наследоваться от класса-предка и реализовать методы нескольких интерфейсов одним и тем же классом. Этот механизм позволяет во многом заменить множественное наследование — методы интерфейсов необходимо переопределять явно, что исключает ошибки при наследовании функциональности одинаковых методов различных классов-предков.

 

Delphi (Object Pascal)

Для использования механизма наследования в Delphi необходимо в объявлении класса справа от слова class указать класс предок:

Предок:

TAncestor = classprivateprotectedpublic // Виртуальная процедура procedure VirtualProcedure; virtual; abstract; procedure StaticProcedure;end;

Наследник:

TDescendant = class(TAncestor)privateprotectedpublic // Перекрытие виртуальной процедуры procedure VirtualProcedure; override; procedure StaticProcedure;end;

Абсолютно все классы в Delphi являются потомками класса TObject. Если класс-предок не указан, то подразумевается, что новый класс является прямым потомком классаTObject.

Множественное наследование в Delphi частично поддерживается за счёт использования классов-помощников (Сlass Helpers).

 

 

Определение инкапсуляции.

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

§ Пользователь может взаимодействовать с объектом только через этот интерфейс. Реализуется с помощью ключевого слова: public.

§ Пользователь не может использовать закрытые данные и методы. Реализуется с помощью ключевых слов: private, protected, internal.

Инкапсуляция — один из четырёх важнейших механизмов объектно-ориентированного программирования (наряду с абстракцией, полиморфизмом и наследованием).

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

§ предельная локализация изменений при необходимости таких изменений,

§ прогнозируемость изменений (какие изменения в коде надо сделать для заданного изменения функциональности) и прогнозируемость последствий изменений.

 

Delphi

В Delphi для создания скрытых полей или методов их достаточно объявить в секции private.

TMyClass = class private FMyField: Integer; procedure SetMyField(const Value: Integer); function GetMyField: Integer; protected public property MyField: Integer read GetMyField write SetMyField; end;

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

 

Определение полиморфизма.

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

Язык программирования поддерживает полиморфизм, если классы с одинаковой спецификацией могут иметь различную реализацию — например, реализация класса может быть изменена в процессе наследования[1].

Кратко смысл полиморфизма можно выразить фразой: «Один интерфейс, множество реализаций».

Полиморфизм — один из четырёх важнейших механизмов объектно-ориентированного программирования (наряду с абстракцией, инкапсуляцией и наследованием).

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

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

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

Примеры

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

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

Классы

Для поддержки ООП в язык Delphi введены объектные типы данных, с помощью которых одновременно описываются данные и операции над ними. Объектные типы данных называют классами, а их экземпляры — объектами.

Классы объектов определяются в секции type глобального блока. Описание класса начинается с ключевого слова class и заканчивается ключевым словом end. По форме объявления классы похожи на обычные записи, но помимо полей данных могут содержать объявления пользовательских процедур и функций. Такие процедуры и функции обобщенно называют методами, они предназначены для выполнения над объектами различных операций. Приведем пример объявления класса, который предназначен для чтения текстового файла в формате "delimited text" (файл в таком формате представляет собой последовательность строк; каждая строка состоит из значений, которые отделены друг от друга символом-разделителем):

type TDelimitedReader = class // Поля FileVar: TextFile; Items: array of string; Delimiter: Char; // Методы procedure PutItem(Index: Integer; const Item: string); procedure SetActive(const AActive: Boolean); function ParseLine(const Line: string): Integer; function NextLine: Boolean; function GetEndOfFile: Boolean; end;

Класс содержит поля (FileVar, Items, Delimiter) и методы (PutItem, SetActive, ParseLine, NextLine, GetEndOfFile). Заголовки методов, (всегда) следующие за списком полей, играют роль упреждающих (forward) описаний. Программный код методов пишется отдельно от определения класса и будет приведен позже.

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

Класс содержит несколько полей:

  • FileVar — файловая переменная, необходимая для доступа к файлу;
  • Delimiter — символ, который служит разделителем элементов;
  • Items — массив элементов, полученных разбором последней считанной строки;

Класс также содержит ряд методов (процедур и функций):

  • PutItem — помещает элемент в массив Items по индексу Index; если индекс превышает верхнюю границу массива, то размер массива автоматически увеличивается;
  • SetActive — открывает или закрывает файл, из которого производится чтение строк;
  • ParseLine — осуществляет разбор строки: выделяет элементы из строки и помещает их в массив Items; возвращает количество выделенных элементов;
  • NextLine — считывает очередную строку из файла и с помощью метода ParseLine осуществляет ее разбор; в случае успешного чтения очередной строки функция возвращает значение True, а иначе — значение False (достигнут конец файла);
  • GetEndOfFile — возвращает булевское значение, показывающее, достигнут ли конец файла.

Обратите внимание, что приведенное выше описание является ничем иным, как декларацией интерфейса для работы с объектами класса TDelimitedReader. Реализация методов PutItem, SetActive, ParseLine, NextLine и GetEndOfFile на данный момент отсутствует, однако для создания и использования экземпляров класса она пока и не нужна.

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

StringGrid.

Компонент StringGrid находится на странице Additionalпалитры компонентов. Там находятся "дополнительные" компоненты, но StringGrid Delphi, на мой взгляд, достоин большего уважения, лично я разместил бы его на странице Standart! StringGrid - компонент для отображения различных данных в табличной форме. Как следует из названия, ячейки компонента StringGrid Delphi могут содержать данные, имеющие тип String, а также отображать графику.  

Таблица StringGrid состоит из выделенных серым FixedCols и FixedRows - зафиксированных ячеек-заголовков, и обычных, белых ячеек. Содержимое Fixed ячеек недоступно редактированию, и меняется только программно. За возможность редактирования обычных ячеек отвечает одно из значений свойства Options.

Итак, компонент StringGrid имеет возможность адресации каждой отдельной ячейки по номеру столбца и строки. Содержимое ячейки (i, j), где где i - номер столбца, j - номер строки, имеет вид

StringGrid1.Cells[i, j]

и доступно как для чтения, так и для записи. Здесь, как и всегда, номера столбцов ( i ) и строк ( j ) отсчитываются от 0.

Выделенная ячейка таблицы имеет

номер столбца: StringGrid1.Col
номер строки: StringGrid1.Row

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

S:=StringGrid1.Cells[StringGrid1.Col, StringGrid1.Row];

Не правда ли, написание такой строки - утомительный процесс. Поэтому пользуйтесь оператором присоединения with:

with StringGrid1 do
S:=Cells[Col, Row];


А лучше сразу задать в свойстве Name имя покороче, например SG.

За многие свойства компонента Delphi StringGrid отвечает свойство Options. В Инспекторе Объектов Options - это раскрывающийся список, представляющий собой элементы данногомножества. Если значение элемента равно True, то он присутствует в множестве, если False - то нет.

 

 
Свойство Значение
goFixedVertLine Наличие вертикальных разделительных линий между "фиксированными" ячейками
goFixedHorzLine Наличие горизонтальных разделительных линий между "фиксированными" ячейками
goVertLine Наличие вертикальных разделительных линий между "обычными" ячейками
goHorzLine Наличие горизонтальных разделительных линий между "обычными" ячейками
goRangeSelect Возможность выделить диапазон ячеек
goDrawFocusSelected Закрашивание ячейки с фокусом ввода
goRowSizing Возможность менять высоту строк мышкой
goColSizing Возможность менять ширину столбцов мышкой
goRowMoving Возможность менять номер строки, то есть перемещать её, мышкой
goColMoving Возможность менять номер столбца, то есть перемещать его, мышкой
goEditing Возможность редактировать содержимое ячейки с клавиатуры
goTabs При значении True фокус смещается на следующую ячейку в таблице,False - на следующий компонент
goRowSelect Выделяется вся строка с "фокусированной" ячейкой
goAlwaysShowEditor При значении True содержимое ячейки при получении фокуса сразу доступно редактированию, False - сначала необходимо щёлкнуть по ней мышкой, либо нажать Enter или F2 (прим.: не действует приgoRowSelect=True)
goThumbTracking При значении True перемещение "бегунка" прокрутки мышкой вызывает немедленное перемещение ячеек,False - ячейки перемещаются только при отпускании "бегунка"


Как следует из таблицы, за возможность редактировать содержимое ячеек с клавиатуры отвечает элемент goEditing свойства-множества Options. В Инспекторе Объектов установите его значение вTrue. Чтобы управлять этой возможностью программно, нужно включить или исключить из множества данный элемент:

StringGrid1.Options:=StringGrid1.Options+[goEditing]; //Включаем редактирование, другие элементы не трогаем

StringGrid1.Options:=StringGrid1.Options-[goEditing]; //Выключаем редактирование, другие элементы не трогаем

StringGrid1.Options:=[goEditing, goFixedVertLine, goFixedHorzLine, goVertLine, goHorzLine, goRowSelect]; //Задаём список необходимых элементов

Если элементы заданы списком, это аналогично присвоению в Инспекторе Объектов этим элементам значения True, остальным - False.

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

Количество строк в Delphi StringGrid равно StringGrid1.RowCount.
Количество столбцов в Delphi StringGrid равно StringGrid1.ColCount.

Если ячейки не помещаются в таблице, появляются полосы прокрутки. При прокручивании

 

StringGrid1.LeftCol Номер столбца, видимого самым левым
StringGrid1.TopRow Номер строки, видимой самой верхней
StringGrid1.VisibleColCount Количество столбцов, видимых в рамках таблицы
StringGrid1.VisibleRowCount Количество строк, видимых в рамках таблицы


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

 

DefaultRowHeight - высота строк по умолчанию
DefaultColWidth - ширина столбцов по умолчанию


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

 

RowHeights[i] - массив, содержащий высоты строк с номером i
ColWidths[i] - массив, содержащий ширины столбцов с номером i


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

Отдельно требуется осветить вопрос очистки содержимого таблицы StringGrid. Так как таблицаStringGrid, в отличие от, например, компонента Memo, не имеет метода для очистки содержимого сразу всех ячеек, то для удаления внесённых в таблицу ранее данных приходится очищать каждую ячейку отдельно. Делается это двумя вложенными циклами for, пробегающими по столбцам и строкам:

var i, j: Integer;
begin
with StringGRid1 do
for i:=1 to RowCount-1 do //Заголовки строк не трогаем
for j:=1 to ColCount-1 do //Заголовки столбцов не трогаем
Cells[j, i]:='';
end;

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

StringGrid1.Cols[i].Clear; //Очищается столбец с номером i
StringGrid1.Rows[i].Clear; //Очищается строка с номером i

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

var i, j: Integer;
begin
with StringGRid1 do
for i:=1 to RowCount-1 do //Заголовки столбцов не трогаем - цикл от 1
begin
Rows[i].Clear;
Cells[0, i]:="Заголовок строки i";
end;
end;

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

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

Работа с графическими свойствами компонента StringGrid происходит в обработчике OnDrawCell. По событию OnDrawCell происходит перерисовка таблицы, и следовательно, код в обработчике этого события будет управлять выводом на холст таблицы необходимой графики. Переменные этого обработчика помогут определить и прямоугольник, в котором будет происходить вывод графики:

procedure TForm1.StringGrid1DrawCell(Sender: TObject; ACol, ARow: Integer;
Rect: TRect; State: TGridDrawState);
begin
//ACol - индекс столбца
//ARow - индекс строки
//Rect - прямоугольник вывода, заданный ячейкой (ACol, ARow)
end;

Для начала давайте выведем в ячейку (1, 1) компонента StringbGrid какой-нибудь рисунок. Вывести рисунок в ячейку компонента StringGrid проще всего, предварительно загрузив его в компонент Image:

Image1.Picture.LoadFromFile('Имя_файла');

Загрузить рисунок в компонент Image можно, конечно, уже на этапе проектирования, в Инспекторе Объектов, вызвав графический редактор нажатием кнопочки в свойстве Picture.

Затем нужно определить размеры загруженного рисунка:

W:=Image1.Picture.Width;
H:=Image1.Picture.Height;

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

StringGrid1.ColWidths[1]:=Round(W/10);
StringGrid1.RowHeight[1]:=Round(H/10);

Все эти манипуляции делаем предварительно, в обработчике OnCreate Формы, например. Ну и, наконец, в обработчике OnDrawCell выводим рисунок:

procedure TForm1.StringGrid1DrawCell(Sender: TObject; ACol, ARow: Integer;
Rect: TRect; State: TGridDrawState);
begin
if ACol*ARow=1 then //Условие ACol*ARow=1 тождественно (ACol=1)and(ARow=1)
StringGrid1.Canvas.StretchDraw(Rect, Image1.Picture.Graphic);
end;

Таким образом, при перерисовке таблица просматривает все ячейки и, встретив комбинацию ACol=1 и ARow=1, выводит в эту ячейку рисунок.

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

procedure TForm1.StringGrid1DrawCell(Sender: TObject; ACol, ARow: Integer;
Rect: TRect; State: TGridDrawState);
var X: Real;
begin
with StringGrid1 do
begin
try
X:=StrToFloat(Cells[ACol, ARow]);
if X>0 then Canvas.Brush.Color:=clGreen;
if X<0 then Canvas.Brush.Color:=clRed;
if X=0 then Canvas.Brush.Color:=clBlue;
except
end;
Canvas.FillRect(Rect); //Текст тоже будет закрашен, его нужно перерисовать:
Canvas.TextOut(Rect.Left+2, Rect.Top+2, Cells[ACol, ARow]);
end;
end;

Осталось рассмотреть возможности компонента StringGrid по выводу текста в ячейку таблицы в несколько строк. Если строки для вывода уже подготовлены, достаточно просто выводить строки со сдвигом по вертикали на высоту строки. Высота ячейки таблицы должна позволять вывод нескольких строк текста. Например, заголовок первого столбца:

//В обработчике OnCreate Формы подготавливаем высоту строки:
StringGrid1.RowHeight[0]:=(StringGrid1.Canvas.TexHeight('A')+2)*N; //N - количество строк
//теперь в обработчике OnDrawCell выводим текст:
if (ACol=1) and (ARow=0) then
begin
Canvas.TextOut(Rect.Left+2, Rect.Top+2, 'Многострочный заголовок');
Canvas.TextOut(Rect.Left+2, Canvas.TextHeight('A')+Rect.Top+2, 'Вторая строка');
Canvas.TextOut(Rect.Left+2, Canvas.TextHeight('A')*2+Rect.Top+2, 'Третья строка');
end;

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

     

17. Процедуры работы с памятью. Приведите примеры.







Последнее изменение этой страницы: 2016-04-08; Нарушение авторского права страницы

infopedia.su Все материалы представленные на сайте исключительно с целью ознакомления читателями и не преследуют коммерческих целей или нарушение авторских прав. Обратная связь - 3.226.245.48 (0.031 с.)