Последние записи

made in programmersforum 7

Интенсив по Python: Работа с API и фреймворками 24-26 ИЮНЯ 2022. Знаете Python, но хотите расширить свои навыки?
Slurm подготовили для вас особенный продукт! Оставить заявку по ссылке - https://slurm.club/3MeqNEk

Online-курс Java с оплатой после трудоустройства. Каждый выпускник получает предложение о работе
И зарплату на 30% выше ожидаемой, подробнее на сайте академии, ссылка - ttps://clck.ru/fCrQw

8th
Ноя

ДЕШИФРАТОР

Дешифратор, устройство для расшифровки (декодирования) сообщения и перевода содержащейся в нём информации на язык (в код) воспринимающей системы. В общем случае Д. имеет n входов и m выходов. Поступающая на входы Д. информация преобразуется — дешифрируется, — и на соответствующем выходе (группе выходов) выделяется сигнал, указывающий признак (или содержание) входной информации. Любому сигналу или комбинации сигналов на входах Д. соответствует определённый сигнал или комбинация сигналов на выходах Д. Это соответствие задаётся структурой Д. при его проектировании. Д. применяют в различных устройствах обработки и передачи информации: в телемеханике, в вычислительной технике (декодирующие устройства, преобразователи представления величин), в радиотехнике и измерительной технике (детекторы, демодуляторы), в системах телефонной и телеграфной связи. Назначение предопределяет структуру, число входов и выходов Д., форму и последовательность входных и выходных сигналов.

Д. в телемеханике расшифровывают сообщения (их коды) по структурам принимаемых сигналов. Структура сигналов создаётся приданием импульсам, образующим сигналы, различных качеств — признаков. Такими признаками являются полярность, частота и порядок следования, количество, длительность и амплитуда импульсов, группировка импульсов различного качества и т.д. (см. Кодирование в телемеханике). Если, например, Д. используется в системе телеуправления, то Д. автоматически анализирует структуру принимаемых сигналов в соответствии с программой, заложенной в конструкции самого Д.; сигналы с его выходов подаются на входы исполнительных механизмов управляемых объектов. Избирательность — основное свойство Д.; она обеспечивает защиту входных цепей воспринимающих систем от посторонних сигналов, которые могут оказать ложное воздействие на систему.

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

Лит.: Тутевич В. Н., Основы телемеханики, М. — Л., 1967.

Вернуться к оглавлению — Термины 20 века

Programming articles
Создание сайтов на шаблонах
Множество вариантов работы с графикой на канве
Шифруем файл с помощью другого файла
Перехват API функций — Основы
Как сделать действительно хороший сайт
Создание почтового клиента в Delphi 7
Применение паскаля для
решения геометрических задач
Управление windows с помощью Delphi
Создание wap сайта
Операционная система unix, термины и понятия
SQL враг или друг
Возникновение и первая редакция ОС UNIX
Оптимизация проекта в Delphi
Ресурсы, зачем нужны ресурсы
Термины программистов 20 века
Советы по созданию собственного сайта с нуля
Шифруем файл с помощью пароля
Фракталы – геометрия природы
Crypt – Delphi программа для шифрования
Рассылка, зачем она нужна и как ее организовать?
Учебник по C++ для начинающих программистов
Уроки для изучения ассемблера
Загадочный тип PCHAR
Средства по созданию сайтов
Операторы преобразования
классов is и as
Borland Developer studio 2006. Всё в одном
Создание базы данных в Delphi, без сторонних БД
Software engineering articles

Добавлено в Советы, Статьи. Дата Ноябрь 8th, 2011

8th

УРОК 26. НАСЛЕДОВАНИЕ

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

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

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

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

В дополнение к общим (public) (доступным всем) и частным (private) (доступным методам класса) элементам C++ предоставляет защищенные (protected) элементы, которые доступны базовому и производному классам.

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

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

ПРОСТОЕ НАСЛЕДОВАНИЕ

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

class employee { public: employee(char *, char *, float); void show_employee(void); private: char name[64]; char position[64]; float salary; };

Далее предположим, что вашей программе требуется класс manager, который добавляет следующие элементы данных в класс employee:

float annual_bonus; char company_car[64]; int stock_options;

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

Производный класс //——> class manager : public employee { <——-// Базовый класс // Здесь определяются элементы };

Ключевое слово public, которое предваряет имя класса employee, указывает, что общие (public) элементы класса employee также являются общими и в классе manager. Например, следующие операторы порождают класс manager.

class manager : public employee { public: manager(char *, char *, char *, float, float, int); void show_manager(void); private: float annual_bonus; char company_car[64]; int stock_options; };

Когда вы порождаете класс из базового класса, частные элементы базового класса доступны производному классу только через интерфейсные функции базового класса. Таким образом, производный класс не может напрямую обратиться к частным элементам базового класса, используя оператор точку. Следующая программа MGR_EMP.CPP иллюстрирует использованиенаследования в C++ , создавая класс manager из базового класса employee:

#include <iostream.h> #include <string.h> class employee { public: employee(char *, char *, float); void show_employee(void); private: char name [ 64 ]; char position[64]; float salary; }; employee::employee(char *name, char *position,float salary) { strcpy(employee::name, name); strcpy(employee::position, position); employee::salary = salary; } void employee::show_employee(void) { cout << «Имя: » << name << endl; cout << «Должность: » << position << endl; cout << «Оклад: $» << salary << endl; } class manager : public employee { public: manager(char *, char *, char *, float, float, int); void show_manager(void); private: float annual_bonus; char company_car[64]; int stock_options; }; manager::manager(char *name, char *position, char *company_car, float salary, float bonus, int stock_options) :employee(name, position, salary) { strcpy(manager::company_car, company_car) ; manager::annual_bonus = bonus ; manager::stock_options = stock_options; } void manager::show_manager(void) { show_employee(); cout << «Машина фирмы: » << company_car << endl; cout << «Ежегодная премия: $» << annual_bonus << endl; cout << «Фондовый опцион: » << stock_options << endl; } void main(void) { employee worker(«Джон Дой», «Программист», 35000); manager boss(«Джейн Дой», «Вице-президент «, «Lexus», 50000.0, 5000, 1000); worker.show_employee() ; boss.show_manager(); }

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

manager::manager(char *name, char *position, char *company_car, float salary, float bonus, int stock_options) : employee(name, position, salary) //————————————— Конструктор базового класса { strcpy(manager::company_car, company_car); manager::annual_bonus = bonus; manager::stock_options = stock_options; }

Также обратите внимание, что функция show_manager вызывает функцию show_employee, которая является элементом класса employee. Поскольку класс manager является производным класса employee, класс manager может обращаться к общим элементам класса employee, как если бы все эти элементы были определены внутри класса manager,

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

Второй пример

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

class book { public: book (char *, char *, int); void show_book(void); private: char title[64]; char author[б 4]; int pages; };

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

char catalog[64]; int checked_out; // 1, если проверена, иначе О

Ваша программа может использовать наследование, чтобы породить класс library _card из класса book, как показано ниже:

class library_card : public book { public: library_card(char *, char *, int, char *, int); void show_card(void); private: char catalog[64] ; int checked_out; };

Следующая программа BOOKCARD.CPP порождает класс library_card из клacca book:

#include <iostream.h> #include <string.h> class book { public: book(char *, char *, int); void show_book(void); private: char title [64]; char author[64]; int pages; }; book::book(char •title, char *author, int pages) { strcpy(book::title, title); strcpy(book::author, author); book::pages = pages; } void book::show_book(void) { cout << «Название: » << title << endl; cout << «Автор: » << author << endl; cout << «Страниц: » << pages << endl; } class library_card : public book { public: library_card(char *, char *, int, char *, int); void show_card(void) ; private: char catalog[64]; int checked_out; }; library_card::library_card(char *title, char *author, int pages, char *catalog, int checked_out) : book(title, author, pages) { strcpy(library_card::catalog, catalog) ; library_card::checked_out = checked_out; } void 1ibrary_card::show_card(void) { show_book() ; cout << «Каталог: » << catalog << endl; if (checked_out) cout << «Статус: проверена» << endl; else cout << «Статус: свободна» << endl; } void main(void) { library_card card( «Учимся программировать на языке C++», «Jamsa», 272, «101СРР», 1); card.show_card(); }

Как и ранее, обратите внимание, что конструктор library _card вызывает конструктор класса book для инициализации элементов класса book. Кроме того, обратите внимание на использование функции-элемента show_book класса book внутри функции show_card. Поскольку класс library_card наследует методы класса book, функция show_card может вызвать этот метод (show_book) без помощи оператора точки, как если бы этот метод был методом класса library _card.

ЧТО ТАКОЕ ЗАЩИЩЕННЫЕ ЭЛЕМЕНТЫ

При изучении определений базовых классов вы можете встретить элементы, объявленные как public, private и protected (общие, частные и защищенные). Как вы знаете, производный класс может обращаться к общим элементам базового класса, как будто они определены в производном классе. С другой стороны, производный класс не может обращаться к частным элементам базового класса напрямую. Вместо этого для обращения к таким элементам производный класс должен использовать интерфейсные функции. Защищенные элементы базового класса занимают промежуточное положение между частными и общими. Если элемент является защищенным, объекты производного класса могут обращаться к нему, как будто он является общим. Для оставшейся части вашей программы защищенные элементы являются как бы частными. Единственный способ, с помощью которого ваши программы могут обращаться к защищенным элементам, состоит в использовании интерфейсных функций. Следующее определение класса book использует метку protected, чтобы позволить классам, производным от класса book, обращаться к элементам title, author и pages напрямую, используя оператор точку:

class book { public: book(char *, char *, int) ; void show_book(void) ; protected: char title [64]; char author[64]; int pages; };

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

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

РАЗРЕШЕНИЕ КОНФЛИКТА ИМЕН

Если вы порождаете один класс из другого, возможны ситуации, когда имя элемента класса в производном классе является таким же, как имя элемента в базовом классе. Если возник такой конфликт, C++ всегда использует элементы производного класса внутри функций производного класса. Например, предположим, что классы book и library_card используют элемент price. В случае класса book элемент price соответствует продажной цене книги, например $22.95. В случае класса library’_card price может включать библиотечную скидку, например $18.50. Если в вашем исходном тексте не указано явно (с помощью оператора глобального разрешения), функции класса library_card будут использовать элементы производного класса {library_card). Если же функциям класса library_card необходимо обращаться к элементу price базового класса {book), они должны использовать имя класса book и оператор разрешения, например book::price. Предположим, что функции show_card необходимо вывести обе цены. Тогда она должна использовать следующие операторы:

cout << «Библиотечная цена: $» << price << endl; cout << «Продажная цена: $» << book::price << endl;

ЧТО ВАМ НЕОБХОДИМО ЗНАТЬ

Из этого урока вы узнали, что наследование в C++ позволяет вам строить /порождать) новый класс из существующего класса. Строя таким способом один класс из другого, вы уменьшаете объем программирования, что, в свою очередь, экономит ваше время. Из урока 27 вы узнаете, что C++ позволяет вам порождать класс из двух или нескольких базовых классов. Использование нескольких базовых классов для порождения класса представляет собой множественное наследование. До изучения урока 27 убедитесь, что освоили следующие основные концепции:

Наследование представляет собой способность производить новый класс из существующего базового класса.
Производный класс — это новый класс, а базовый класс — существующий класс.
Когда вы порождаете один класс из другого (базового класса), производный класс наследует элементы базового класса.
Для порождения класса из базового начинайте определение производного класса ключевым словом class, за которым следует имя класса, двоеточие и имя базового класса, например class dalmatian: dog.
Когда вы порождаете класс из базового класса, производный класс может обращаться к общим элементам базового класса, как будто эти элементы определены внутри самого производного класса. Для доступа к частным данным базового класса производный класс должен использовать интерфейсные функции базового класса.
Внутри конструктора производного класса ваша программа должна вызвать конструктор базового класса, указывая двоеточие, имя конструктора базового класса и соответствующие параметры сразу же после заголовка конструктора производного класса.
Чтобы обеспечить производным классам прямой доступ к определенным элементам базового класса, в то же время защищая эти элементы от оставшейся части программы, C++ обеспечивает защищенные {protected) элементы класса. Производный класс может обращаться к защищенным элементам базового класса, как будто они являются общими. Однако для оставшейся части программы защищенные элементы эквивалентны частным.
Если в производном и базовом классе есть элементы с одинаковым именем, то внутри функций производного класса C++ будет использовать элементы производного класса. Если функциям производного класса необходимо обратиться к элементу базового класса, вы должны использовать оператор глобального разрешения, например base class:: member.

Предыдущий урок | Следующий урок

Programming articles Создание сайтов на шаблонах Множество вариантов работы с графикой на канве Шифруем файл с помощью другого файла Перехват API функций — Основы Как сделать действительно хороший сайт Создание почтового клиента в Delphi 7 Применение паскаля для решения геометрических задач Управление windows с помощью Delphi Создание wap сайта Операционная система unix, термины и понятия SQL враг или друг Возникновение и первая редакция ОС UNIX Оптимизация проекта в Delphi Ресурсы, зачем нужны ресурсы Термины программистов 20 века Советы по созданию собственного сайта с нуля Шифруем файл с помощью пароля Фракталы – геометрия природы Crypt – Delphi программа для шифрования Рассылка, зачем она нужна и как ее организовать? Учебник по C++ для начинающих программистов Уроки для изучения ассемблера Загадочный тип PCHAR Средства по созданию сайтов Операторы преобразования классов is и as Borland Developer studio 2006. Всё в одном Создание базы данных в Delphi, без сторонних БД Software engineering articles

Добавлено в c/c++. Дата Ноябрь 8th, 2011

8th

Dynamic

Позволяет методу класса быть перекрытым в классах-потомках

Function|Procedure declaration; Dynamic;

Описание:

Директива Dynamic позволяет методу класса быть перекрытым (замененным) одноименным методом в классе-потомке.

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

Например, вы можете позволить базовому классу рисовать на канве белым цветом, а классу-наследнику вместо этого — рисовать картинку на канве. Таким образом, директива Dynamic позволяет коду быть расширенным и обогащенным.

За директивой Dynamic может следовать директива Abstract. Она изменяет эффект директивы Dynamic. Это означает, что текущий класс не должен реализовывать это метод — это только «заглушка» для напоминания и уверенности в том, что классы-наследники реализуют его.

Пример кода:

// Full Unit code.
// ————————————————————
// You must store this code in a unit called Unit1 with a form
// called Form1 that has an OnCreate event called FormCreate.

unit Unit1;

interface

uses
Forms, Dialogs, Classes, Controls, StdCtrls, SysUtils;

type
// Define a base TPolygon class :
// This class is a traingle if 3 sides, square if 4 sides …
TPolygon = class
private
sideCount : Integer; // How many sides?
sideLength : Integer; // How long each side?
shapeArea : Double; // Area of the polygon
protected
procedure setArea; Dynamic; Abstract; // Must be implemented in child
property count : Integer read sideCount;
property length : Integer read sideLength;
property area : Double read shapeArea;
constructor Create(sides, length : Integer);
end;

// Define triangle and square descendents
TTriangle = class(TPolygon)
protected
procedure setArea; override; // Override the abstract method
end;

TSquare = class(TPolygon)
protected
procedure setArea; override; // Override the abstract method
end;

// Define the form class used by this unit
TForm1 = class(TForm)
procedure FormCreate(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;

var
Form1: TForm1;

implementation
{$R *.dfm} // Include form definitions

// Create the TPolygon object
constructor TPolygon.Create(sides, length : Integer);
begin
// Save the number and length of the sides
sideCount := sides;
sideLength := length;

// Set the area using the abstract setArea method :
// This call will be satisfied only by a subclass
setArea;
end;

// Implement the abstract setArea parent method for the triangle
procedure TTriangle.setArea;
begin
// Calculate and save the area of the square
shapeArea := (sideLength * sideLength) / 2;
end;

// Implement the abstract setArea parent method for the square
procedure TSquare.setArea;
begin
// Calculate and save the area of the square
shapeArea := sideLength * sideLength;
end;

// Main line code
procedure TForm1.FormCreate(Sender: TObject);
var
triangle : TTriangle;
square : TSquare;
begin
// Create a triangle and a square
triangle := TTriangle.Create(3, 10);
square := TSquare.Create(4, 10);

// Show the areas of our polygons:
ShowMessageFmt(‘Triangle area = %f’,[triangle.area]);
ShowMessageFmt(‘Square area = %f’,[square.area]);
end;

end.

Результат выполнения:

Triangle area = 50.0
Square area = 100.0

Добавлено в Советы, Статьи. Дата Ноябрь 8th, 2011

8th

STRINGGRID ЗАКРАШИВАТЬ ЯЧЕЙКИ ТАБЛИЦЫ, ВЫБРАННЫМ ПОЛЬЗОВАТЕЛЕМ

Создать приложение, позволяющее:
1) устанавливать количество столбцов и строк квадратной таблицы StringGrid равными числу, вводимому пользователем;
2) закрашивать ячейки таблицы, расположенные на главной диагонали и ниже цветом, выбранным пользователем.

Решение

скачать исходник

Добавлено в Delphi. Дата Ноябрь 8th, 2011

8th

ЗАПОЛНЕНИЕ ОДНОМЕРНОГО МАССИВА; ВЫВОД ОДНОМЕРНОГО МАССИВА НА ЭКРАН; ПОИСК СУММЫ ЧЕТНЫХ ЭЛЕМЕНТОВ ОДНОМЕРНОГО МАССИВА

Составить текст программы, которая:
1) реализовывает в виде подпрограмм:
— заполнение одномерного массива;
— вывод одномерного массива на экран;
— поиск суммы четных элементов одномерного массива.
2) вычисляет y=|t|+|r|+|z|, где t, r, z — сумма четных элементов одномерных массивов А, В, С соответственно.

Решение

скачать пример

Добавлено в Pascal. Дата Ноябрь 8th, 2011

8th

2. ПРИМЕРЫ ПОСТРОЕНИЯ ФРАКТАЛЬНЫХ МНОЖЕСТВ. КЛАССИФИКАЦИЯ ФРАКТАЛОВ.

Однако существуют ли в математике множества, которые имеют фрактальную размерность? Да, такие множества были открыты в XIX и XX веках. В 1883 г. немецкий математик Георг Кантор (1845-1918) построил множество, носящее его имя (множество Кантора). Построение множества Кантора осуществляется следующим образом: Единичный отрезок разбивается на 3 равные части. Средняя часть выбрасывается. Оставшиеся 2 части снова разбиваются, каждая на 3 равные части, и средние их части выбрасываются. Получившиеся отрезки снова разбиваются, каждый на 3 равные части, и средние части выбрасываются и т. д. В пределе получается множество Кантора.

Спрашивается, чему равна фрактальная размерность множества Кантора? Применим для ее вычисления формулу (*). Чтобы подсчитать по формуле (*), нужно определить e и N(e). На первом этапе построения множества Кантора отрезок единичной длины можно покрыть одним отрезком длиной в, т.е. e = 1 и N(e) = 1.

В 1904 г. немецкий математик Хельга фон Кох построила кривую, которая в настоящее время носит ее имя (кривая Кох). Построение начинается с единичного отрезка прямой. Единичный отрезок прямой делится на 3 равные части. Средняя часть удаляется, а на месте средней части строится равносторонний треугольник. В итоге получается ломаная линия, состоящая из 4 отрезков, каждый из которых равен 1/3 .

Далее, каждый из 4 отрезков снова делится на 3 равные части, на отрезках, расположенных в середине, строятся равносторонние треугольники, и средние части отрезков удаляются. Эта процедура повторяется еще и еще раз. В итоге линия становится очень изрезанной. Если этот процесс повторять бесконечно долго (т. е. перейти к пределу), то получаем непрерывную, нигде не дифференцируемую кривую, и эта непрерывная кривая имеет ненулевую «площадь». Чтобы в этом убедиться, подсчитаем фрактальную размерность кривой Кох. На первом этапе мы имеем один отрезок длиной 1, который можно покрыть одним отрезком длиной, равной 1, т. е. e. = 1 и N(e) = 1. На втором этапе мы имеем 4 отрезка, каждый длиной, равной 1/3 поэтому для покрытия этих отрезков нужны 4 отрезка длиной 1/3 т. е. e=1/3 и N(e)=4.

Таким образом, мы впервые сталкиваемся с фрактальным множеством. Привычная (или топологическая) размерность канторовой пыли равна 0, а вот фрактальная, оказывается, нулю не равна — она строго больше; это и есть, по определению Мандельброта, свойство фрактала.

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

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

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

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

Мандельброт исследовал преобразование комплексной плоскости, заданное элементарной формулой: Z?Z2+C. Впрочем, преобразование, исследованное Мандельбротом, можно представить просто как преобразование плоскости. Мандельброт рассматривал траектории точек, которые получаются при этом преобразовании, и изучал зависимость получающейся картины от параметра С. Казалось бы, ничего интересного ожидать не приходилось: настолько простым казалось преобразование. Фиксируя параметр С, Мандельброт попытался установить те области на плоскости, выходя из которых, точки не «убегают» на бесконечность, а образованная при итерационном процессе последовательность остается в ограниченной окрестности. Оказалось, что значения таких параметров С образуют связное множество с удивительно причудливой границей, и форма основной части множества повторяется и повторяется в разных масштабах. Это множество и было названо множеством Мандельброта.

Мандельброт опубликовал исследование найденного им множества в конце 1980 года. Математики Р. Брукс и Дж. Мателски выпустили свою работу с сообщением об этом множестве в 1978 году. Поначалу Брукс и Мателски не придавали особого значения своей находке, однако впоследствии заявили, что являются, по меньшей мере, соавторами открытия. Дж. Хаббард сообщил, что наблюдал множество Мандельброта на дисплее своего компьютера в 1976 году. Кроме того, Хаббард, Мателски и Брукс предложили считать истинным открывателем множества французского математика Пьера Фату, описавшего его еще в 1906 году. Однако во всех этих случаях приходится говорить даже не о корнях фрактальной геометрии, а лишь о ее зернах — причем еще не проросших; ибо «авторы» не смогли оценить и понять смысл того, что они нашли. Сталкивавшиеся с множеством Мандельброта ученые считали свои находки частным случаем, почти случайностью, и не увидели совершенно новой области знаний и исследований. Не было озарения, не было выхода за конкретную проблему. Поэтому первооткрывателем множества Мандельброта мы, без сомнения, можем считать самого Б. Мандельброта. Здесь стоит обратить внимание на любопытный факт: Хаббард именно наблюдал множество Мандельброта; не вычислил, не построил — а видел его. Точно так же, как увидел его и Мандельброт. Видели они одно и то же. Это настолько похоже на открытия в естественных науках, что можно утверждать: фракталы были открыты экспериментально. В отличие от своих коллег, Мандельброт почти знал, что он ищет, — но совершенно не знал, что именно он найдет. Когда в своих воспоминаниях Мандельброт говорит о новеньком компьютере Vax, с которым ему посчастливилось работать, о плохих дисплеях и принтере со слабым разрешением, не позволившим ему сразу видеть свое множество, он говорит о них так же, как физик об экспериментальной установке, создание и применение которой привело к открытию.

<<< Предыдущая страница

Следующая страница >>>

обсудить на форуме

Добавлено в Советы, Статьи. Дата Ноябрь 8th, 2011

8th

Constructor

Определяет метод, используемый для создания объекта из класса

type Class declaration
…
Constructor Name; {Overload;}
…
end;
type Class declaration
…
Constructor Name(Arguments); {Overload;}
…
end;

Описание:

Ключевое слово Constructor определяет процедуру-конструктор Name для класса.

При создании объекта вы вызываете метод-конструктор класса, не объекта:

имяОбъекта := имяКласса.Create(параметры);

Обычно конструктор называют Create, но ограничений на имя нет. Разумней будет оставить это имя.

Объект может быть сконструирован с аргументами или без них (см. пример).

Конструкторы могут быть объявлены в секциях public или published определения класса.

Вы можете создать несколько конструкторов, но в этом случае опубликовать в секции Published можно только один из них. В случае нескольких конструкторов, после каждого из них должна стоять директива Overload, как того требует Delphi.

При реализации процедуры-конструктора, обычно называемого Create, у вас должно войти в привычку вызов конструктора предка, например

constructor Create;
inherited; >
…

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

Пример кода:

unit Unit1;

interface

uses
Forms, Dialogs, Classes, Controls, StdCtrls;

type
// Define a parent class, base on TObject by default
TFruit = class
public
name : string;
Constructor Create; overload; // This constructor uses defaults
Constructor Create(name : string); overload;
end;

// Define a descendant types
TApple = class(TFruit)
public
diameter : Integer;
published
Constructor Create(name : string; diameter : Integer);
end;

// The class for the form used by this unit
TForm1 = class(TForm)
procedure FormCreate(Sender: TObject);
end;

var
Form1: TForm1;

implementation
{$R *.dfm} // Include form definitions

// Create a fruit object — parameterless version
constructor TFruit.Create;
begin
// Execute the parent (TObject) constructor first
inherited; // Call the parent Create method

// Now set a default fruit name
self.name := ‘Fruit’;
end;

// Create a fruit object — parameterised version
constructor TFruit.Create(name: string);
begin
// Cannot execute the parent constructor — parms differ

// And save the fruit name
self.name := name;
end;

// Create an apple object
constructor TApple.Create(name: string; diameter : Integer);
begin
// Execute the parent (TFruit) constructor first
inherited Create(name); // Call the parent method

// Now save the passed apple diameter
self.diameter := diameter;
end;

// Main line code
procedure TForm1.FormCreate(Sender: TObject);
var
fruit : TFruit;
banana : TFruit;
apple : TApple;

begin
// Create 3 different fruit objects
fruit := TFruit.Create;
banana := TFruit.Create(‘Banana’);
apple := TApple.Create(‘Pink Lady’, 12);

// See which of our objects are fruits
if fruit Is TFruit then ShowMessage(fruit.name +’ is a fruit’);
if banana Is TFruit then ShowMessage(banana.name +’ is a fruit’);
if apple Is TFruit then ShowMessage(apple.name +’ is a fruit’);

// See which objects are apples
if fruit Is TApple then ShowMessage(fruit.name +’ is an apple’);
if banana Is TApple then ShowMessage(banana.name +’ is an apple’);
if apple Is TApple then ShowMessage(apple.name +’ is an apple’);
end;
end.

Результат выполнения:

Fruit is a fruit
Banana is a fruit
Pink Lady is a fruit
Pink Lady is an apple

Добавлено в Советы, Статьи. Дата Ноябрь 8th, 2011

8th

ВВОДИТЬ С КЛАВИАТУРЫ СВЕДЕНИЯ О ПОЛЕТАХ АВИАКОМПАНИИ: ТИП САМОЛЕТА, ПУНКТ НАЗНАЧЕНИЯ, ДАТА ВЫЛЕТА, ПРОДОЛЖИТЕЛЬНОСТЬ ПОЛЕТА

Составить текст программы, позволяющий:
1) вводить с клавиатуры сведения о полетах авиакомпании «С ветерком»: тип самолета, пункт назначения, дата вылета, продолжительность полета (в минутах) и фамилия командира экипажа;
2) выводить на экран строки созданного текстового файла, в которых тип самолета совпадает с N;
3) формировать текстовый файл otbor.txt, записывая в него строки исходного файла airplane.txt, удовлетворяющие условию: продолжительность полета превышает W минут.

Решение

скачать пример

Добавлено в Pascal. Дата Ноябрь 8th, 2011

8th

ДОБАВИТЬ ЗАПИСИ В ТЕКСТОВЫЙ ФАЙЛ BILET.TXT О БИЛЕТАХ, КУПЛЕННЫХ НА ПОЕЗД

Создать приложение, позволяющее:
1) добавлять записи в текстовый файл bilet.txt о билетах, купленных на поезд. Каждая строка должна файла должна содержать: ФИО пассажира, номер вагона, тип вагона, номер места, стоимость билета;
2) просматривать содержимое всего файла в Мемо1;
3) отображать в Мемо2 информацию о пассажирах, купивших билеты в купейный/ плацкартный/ спальный вагон ( в зависимости от выбранной радиокнопки);
4) отображать в Мемо3 информацию о пассажирах, купивших билеты в вагон Z, номера мест с Р по К.
Просмотр записей производить на форме 2.

Решение

скачать исходник

Добавлено в Delphi, Советы, Статьи. Дата Ноябрь 8th, 2011

8th

ASSEMBLER&WIN32. КУРС МОЛОДОГО БОЙЦА. УРОК 2.

Память системы

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

Немного истории.
Теперь о памяти. В ДОС и в windows 3.Х память была сегментной. Вся память делилась на сегменты по 64 КВ., и адрес (именно адрес, а не смещение) задавалась, форматом сегмент: офсет. Сегмент задаёт порядковый номер сегмента, а офсет задаёт смещение чего-либо в этом сегменте.

Память
Сегмент 1 (64kb)	Сегмент 2 (64kb)	Сегмент 3 (64kb)	Сегмент 4 (64kb)	и так далее

Учтите, что это объяснение для 16-разрядных программ, о 32-разрядных я расскажу позже, (но не пропускайте эту часть, важно понять, что такое 32-разрядность).
Таблица выше иллюстрирует общую память, разделенную на сегменты по 64kb. Здесь максимум 65536 сегментов. Теперь возьмите один из сегментов:

Сегмент 1(64kb)
Смещение 1	Смещение 2	Смещение 3	Смещение 4	Смещение 5	и так далее

Вы спросите, зачем нужна эта сегментность. Всему есть разумное объяснение. Дело в том в том, что ДОС 16 битный. И регистры 16 битные. С помощью 16 бит можно адресовать только 65536 байт памяти и 65536 сегментов.

Например:
0030:4012 (всё шестнадцатиричное)
Это означает: сегмент 30, смещение 4012. Чтобы узнать, что находится в том адресе, вы сначала переходите на сегмент 30, а затем в сегменте смещаетесь на 4012. В предыдущих уроках мы узнали о сегментных и указательных регистрах. Например, сегментные регистры:
CS — Сегмент кода
DS — Сегмент данных
SS — Сегмент стека
ES — Дополнительный сегмент
FS — Универсальный сегмент
GS — Универсальный сегмент
Названия говорят о их функциях: сегмент кода (CS) содержит номер секции, где вылнен текущий код. Сегмент данных для получения данных из текущего сегмента. На стек указывает сегмент стека (SS) (подробнее о стеке я раскажу позже), ES, FS, GS — универсальные регистры и могут использоваться для любого сегмента (не в win32).

Теперь о Win32

В 16-разрядном программировании, сегменты необходимы. К счастью, эта проблема решена в 32-разрядном Windows (95 и выше). Вы все еще имеете сегменты, но вам не нужно заботиться о них, потому, что они уже не 64kb (как в 16-разрядном), а 4 Гб. Windows вероятно даже «повиснет», если вы попытаетесь изменить один из сегментных регистров. Это называеся плоской моделью памяти (flat). Здесь есть только смещения и они теперь 32-разрядные (в диапазоне от 0 до 4,294,967,295). Каждая ячейка в памяти указывается смещением. Это действительно одно из лучших преимуществ 32-разрядного программирования над 16-разрядным. Так что теперь вы можете забыть о сегментных регистрах и сосредоточиться на других регистрах.Общая схема памяти в Win32Но 4ГБ может и не быть на машине, поэтому эта память называется виртуальной. Мало того, каждый процесс выполняется в своём виртуальном адресном пространстве. А это значит, что никакой другой процесс не сможет получить доступ к вашей памяти. Для этого существуют специальные API функции, но для их использования нужно иметь специальные привилегии в системе. Память 0-0000FFFF не используется и служит для выявления нулевых указателей, значит, если вы укажете адрес 0000С567, то он будет считаться нулевым, удобно, не правда ли? Любая попытка обратится к этой памяти приводит к ошибке. Память выше 80000000 одна для всех процессов. В этой памяти находится код нулевого кольца, структуры ядра, код планировщика задач, код драйверов, диспетчер ввода вывода, таблица прерываний и т.д. Любая попытка обратиться к памяти ядра приводит к ошибке и к немедленному завершению приложения. Память в диапазоне 00001000-7FFFFFFF доступна для 3 кольца, т.е. для вашего приложения. С ней вы, что хотите то и делаете, в неё также грузятся Дллки.

Выделение памяти.
Если вам даётся 2ГБ памяти, то это не означает, что вы можете обратиться к любому участку памяти. Для того чтобы получить доступ к некоторому участку памяти надо сначала её зарезервировать. Грубо говоря, перед резервированием памяти, резервируемого участка памяти просто не существует (я не оговорился её просто не существует), вы как бы его создаёте и задаёте ему атрибуты доступа (полный доступ, только чтение, только запись, нет доступа). Минимальный размер выделяемой памяти — страница, равна 1000 байтам (для тех, кто не привык к шестнадцатеричной записи, это 4096 байт — 4КБ). Даже если вы захотите выделить 5 байт, то всё равно выделится 4КБ. Такой метод распределения памяти называется гранулярность. Думаю, вы не столкнётесь с тем, что вам надо будет выделять память, лично мне это ни разу не пригодилось. Это нужно при работе с файлами для того, что бы в эту память читать файл.

Вернуться к оглавлению.

Обсудить на форуме