Назад На главную Вперед

Таблица умножения на DELPHI

    Почему я начал с C++, потому, что решил оставить вкусненькое на потом. в том смысле, что теперь все то же мне хотелось бы проделать на Delphi.
    Да простят меня Си-шники: в вечном споре о преимуществах и недостатках СИ и Паскаля, а потом C++ и Delphi, я остаюсь приверженцем вторых.

    Итак приступим. Казалось бы,  чего проще создать программу вывода таблицы умножения на DELPHI?  Возьмем к примеру создание консольного приложения. Запустим DELPHI и выберем создание нового приложения, а конкретно CONSOLE APPLICATION.  Введем в предлагаемое место наш паскалевский код, запустим - работает. Вот вам и новая среда программирования.

program tumn;
{$APPTYPE CONSOLE}

Var
  A : Integer;
  I : Integer;

begin
  Writeln('Input first number');
  Readln(A);
    For I:=1 to 10 do
       Writeln(A,'x',I,'=',A*I);
       Readln;
end.
 

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

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

  Три щелчка мышью File-New-Application и наше знакомая заготовка к нашим услугам. Еще несколько манипуляций и программа готова. Из особенностей отметим установку своей иконки вместо стандартной в свойствах приложения.

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

// Таблица умножения на Delphi c использованием VCL:
// Visual Component Library
// Код программы получился компактным, но это все требует пояснения.
// Во первых Unit . То есть это модуль. Сам файл Delphy-проекта или,
// если хотите, главный файл нашего приложения совсем другой.
// Он имеет расширение DPR,
// создается  автоматически и ничего не сможет добавить
// к рассказу о конкретном устройстве нашей программы.
// За исключением того, что использует вышеназванный модуль,
// а также инициализирует наше приложение, создает окошко нашей программы
//  и запускает ее.
unit tab_um_del;

// А раз мы говорим о модуле, то как во всех стандартных модулях паскаля, он имеет два раздела.
// Раздел объявлений interface, и раздел реализации implementation.

// интерфейсный блок: всяческие объявления - заявления.
interface

// Во первых: дополнительные модули, которые могут потребоваться нашей программе
// Смотрите, как оказывается много всего требуется нашей малютке.
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls;

 //Объявление типов данных.
type
// Здесь начинаются основы объектного программирования
// Оновы терминологии не могут быть разъеснены в кратком комментарии
// TForm1 это потомок класса TForm
TForm1 = class(TForm)
// У нашего потомка есть определенные особенности.
// Это те элементы, которые наша форма - будушее окно использует.
// Вот они и описаны ниже: Метки, поля редактирования, кнопки.
Label1: TLabel;
Edit1: TEdit;
Button1: TButton;
Button2: TButton;
Memo1: TMemo;

// А также процедуры реакций на события происходящие
// с этими самыми элементами. В скобках - источник события:
// в нашем случае главный прародитель TObject.
procedure Button2Click(Sender: TObject);
procedure Button1Click(Sender: TObject);
// Если нашей форме нужны приватные (доступные только для нее) переменные,
// а также публичные (доступные всем), то они могут быть объявлены ниже.
private
{ Private declarations }
public
{ Public declarations }
// декларации для потомка класса форм заканчиваем
end;

// Объявляем переменную FORM1 - наше будущее окно,
// имеющую тип, указанный выше.
var
Form1: TForm1;

// Секция реализации. (Ну, хватит уже болтовни! )
implementation

//Конкретное описание нашего будущего окна, со всеми подробностями
// в виде заданных свойств хранится в файле формы.
// Вот ее то, или их, если она не одна, мы здесь и подключаем.
{$R *.dfm}

//Наконец непосредственно сам код программы. Его негусто.
// Реакция на нажатие второй кнопки.
// Как видим это application.Terminate
// Если сказать, что application это наше приложения,
// то все становится ясным. Раз терминэйт значит
// программе ничего хорошего ждать не приходится. Пора закругляться
// А в качестве параметра в процедуре используется какой-то Sender (Посыльный) его тип TObject.  
// Ну тут тоже все ясно: все команды исходят от главенствующего объекта.
procedure TForm1.Button2Click(Sender: TObject);
 begin
  Application.Terminate;
end;

// А это реакция на нажатие кнопки расчета
procedure TForm1.Button1Click(Sender: TObject);
 // Здесь происходит объявление локальных переменных.
Var
  I : Integer;
  iSomn : Integer;

begin

form1.Memo1.Clear;
 //Потом очищается поле вывода

 //Из поля ввода получаем первую цифру, если вы нечаянно ввели несколько
iSomn:= StrToInt(Copy(form1.Edit1.text,1,1));
 // Оставляем ее в поле ввода, чтобы не было никаких сомнений и
Edit1.Text:=IntToStr(iSomn);

 //  организуем цикл вывода нашей таблицы на экран в поле вывода Memo1.
For I:=1 to 10 do
  Memo1.Text:= Memo1.Text + Copy(form1.Edit1.text,1,1) +' x '+ IntToStr(I)+ ' = '+ IntToStr(iSomn*I)+ #13#10;
 //Попутно применяем преобразование типов для вывода чисел в текстовые поля

 // А здесь конец процедуре и конец нашему модулю.
end;
end.

- Как все замечательно получилось несколько минут и приложение для Windows создано. Посмотрим вот он наш экзешничек. Но, что это?  Его размер 391 килобайт?!  Это за простенькое окошечко - такая цена. Вот тебе и DELPHI.

 

 
 - Увы но это так.
    На больших серьезных программах такой объем не очень заметен, но для простеньких такие размеры являются серьезным недостатком, особенно если их приходится качать из Интернета по слабому каналу.
  Например программы на VB в этом отношении имеют то преимущество, что скажем для 5-й и 6-й версий в XP их библиотеки устанавливаются с операционной системой и их не приходится скачивать. А программа на DELPHI является самодостаточной, то есть при использовании стандартных компонентов для запуска ничего дополнительно не требуется.
 -   Неужели этот недостаток для DELPHI непреодолим?
 - Ну, во первых при теперешних скоростях сетей и объемах дисковой памяти, это не очень страшно. А во вторых, если для небольшой программки на Delphi критичным является ее объем, то эта проблема может быть решена несколькими способами. Давайте рассмотрим некоторые из них.

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

Теперь нам не потребуется наша форма, поэтому мы избавимся от нее выбрав пункты меню Project-Remove-Form1. А код будем заводить прямо в файл проекта DELPHI, удалив из него все лишнее.Project-View Source.

// Программа: таблица умножения на Delphi + API
// без ипользования VCL (библиотеки визуальных компонентов)

program DelphyAPI;

// Объявление дополнительных модулей
// Как видим ничего кроме...
Uses
Windows, messages;

// Иконка в заголовок окна: святое дело...
{$R nk.res}

// Объявление структуры окна и элементов нашей программы
// совершенно понятны из своих названий.
// Немного подробней об HWND. Как видно из аббревиатуры, в типе
// переменной присутствует H - handle (указатель) и WND - window (окно).
// То есть все что начинается с H - является указателем на область памяти,
// а фактически адресом объекта.
Var
// структура для регистрации нашего класса
wc: TWndClassEx;
// Указатели на главное окно и
// компоненты на нем размещенные
pWnd : HWND;
lText : HWND;
pButton1 : HWND;
pButton2 : HWND;
pTxt1 : HWND;
pTxt2 : HWND;
// Сообщения ОС
pMsg : TMsg;

// Чтобы не подключать могучие модули из-за
// двух простеньких функции пришлось сделать их
// из подручного материала

// Конвертирует целое в строку
function Int2Str(I: Longint): string;
var
S: string[11];
  begin
    Str(I, S);
    Result:= S;
end;

// И строку в целое тоже.
function Str2Int(s: string): Integer;
var
code: integer;
begin
   val(s, result, code);
end;

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

function WindowProc(wnd:HWND; Msg:Integer; wParam:wParam;
lParam:lParam):Lresult; stdcall;

// Локальные переменные для оконной функции.
Var
lpBuf: array[0..1024] of char;
sTum : String;
I : integer;
iSomn : integer;
sSomn : String;

//Начало ее работы
begin

//Если ничего ненепредвиденного не произойдет, то функция вернет 0
Result:=0;

// Выберем варианты обработки сообщений для нашего окна
case msg of

//Уничтожение окна
WM_DESTROY:
begin
  PostQuitMessage(0);
  exit;
end;

// События от элементов управления
WM_COMMAND:
begin
//Нажата кнопка
if lParam = pButton1 then
begin
// Получить из текстового поля ввода
// значение сомножителя
  GetWindowText(pTxt1, lpBuf, 2);
  sSomn:=lpBuf;
// Преобразовать его в число
  iSomn:=Str2Int(sSomn);

// Очистить исходную строку, если в ней больше одной цифры
  SetWindowText(pTxt1, lpBuf);

// Готовим нашу строку для вывода таблицы
  sTum:='';

// Фактически вся программа: это вот эти четыре строчки.
// Посмотрите, как здесь просто все организованно, это вам не ASSEMBLER.

// Формируем строку нашей таблицы перед выводом
  For I:=1 to 10 do
    sTum:= sTum + Int2Str(iSomn)+ ' x '+ Int2Str(I)+ ' = '+ Int2Str(iSomn*I)+ #13#10;

// В угоду Windows поместим нашу строку в символьный массив lpBuf
    lstrcpy(lpBuf, pchar(stum));
// И забросим его в наше текстовое окошечко.
    SetWindowText(pTxt2, lpBuf);

end; // Конец обработки нажатой кнопки
// Принудительная очистка окна вывода.
// Посмотрите, как просто все организовано.
  if lParam = pButton2 then
  SetWindowText(pTxt2, '');

end; // Конец обработки всех команд
end;
// Конец Case - обработки сообщений для нашего окна,
// Тех, которые мы хотели обработать.

// Обработка остальных сообщений поступивших для нашего окна.
  Result:=DefWindowProc(wnd,msg,wparam,lparam);

//Конец функции окна
end;

//Начало кода программы
begin


//Заполнение структуры и регистрация класса окна

wc.cbSize:=sizeof(wc);
wc.lpfnWndProc:= @WindowProc;
wc.cbClsExtra:=0;
wc.cbWndExtra:=0;
wc.hInstance:=HInstance;
wc.hIcon := LoadIcon (HInstance, 'MYICON');
wc.hCursor:=LoadCursor(0,IDC_ARROW);
wc.hbrBackground:=COLOR_BTNFACE+1;
wc.lpszMenuName:=nil;
wc.lpszClassName:='delphi_winapi';

RegisterClassEx(wc);

//Создание окна на основе зарегистрированного класса
  pWnd:=CreateWindowEx(WS_EX_APPWINDOW,
  'delphi_winapi', ' Таблица умножения',
  WS_OVERLAPPED or WS_SYSMENU,
  100, 100,
  250, 300,
  0, 0,
  Hinstance, nil);

// Создание надписи
lText:=CreateWindow('static', 'Введи сомножитель ',
SS_LEFT or WS_CHILD or WS_VISIBLE or WS_GROUP, 20, 15,
170, 20, pWnd, 0, hInstance, nil);

// Создание кнопки для расчета
pButton1:=CreateWindow('button', 'Расчет',
WS_CHILD or WS_VISIBLE or BS_DEFPUSHBUTTON, 150, 45,
70, 20, pWnd, 0, hInstance, nil);

// Создание кнопки для очистки
pButton2:=CreateWindow('button', 'Очистка',
WS_CHILD or WS_VISIBLE or BS_DEFPUSHBUTTON, 150, 75,
70, 20, pWnd, 0, hInstance, nil);

// Создание текстового окошка - ввод сомножителя
pTxt1:=CreateWindow('edit', '0',
WS_CHILD or WS_VISIBLE, 20, 45,
50, 20, pWnd, 0, hInstance, nil);

// Создание текстового окошка - вывод результата
pTxt2:=CreateWindow('edit', '',
ES_LEFT or ES_MULTILINE or WS_CHILD or WS_VISIBLE or WS_BORDER, 20, 85,
100, 180, pWnd, 0, hInstance, nil);

// Показать окно главное окно и прорисовать его
ShowWindow(pWnd, SW_SHOW);
UpdateWindow(pWnd);

// Цикл обработки сообщений
while GetMessage(pMsg,0,0,0) do

begin
   TranslateMessage(pMsg);
   DispatchMessage(pMsg);
end;

end.

// При кажущейся громоздкости вся программа
// стройно разложена по полочкам.
 

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

 

 - Увы но за разработку серьезной программы таким способом  возьмутся немногие. Все эти параметры структур, окон, сообщений очень сильно напрягают программиста. Чтобы сделать что то толковое потребуется вгрызаться в подробности не одного десятка API-функций. Но если программа не слишком объемна, и ее потребности не выходят за рамки стандартного ввода-вывода и простеньких расчетов, то можно этим запросто воспользоваться.
 - Но нельзя ли упростить создание этих окошек, кнопок, полей ввода и редактирования. Кто то мог бы уже  догадаться, как это можно сделать.
     Да это уже давно придумано. Существуют программы для создания ресурсов WINDOWS , в том числе и, так называемых диалоговых окон. То есть, как раз таких окон, где используются все тобою названные компоненты.
 - И этим можно легко воспользоваться?
 -  Да. Вот посмотри: этот файл создан при помощи программы разработки WINDOWS-ресурсов.

#include "\masm32\include\resource.h"

TABUM DIALOGEX MOVEABLE IMPURE LOADONCALL DISCARDABLE 10, 10, 160, 170, 0
STYLE DS_MODALFRAME | 0x0004 | DS_CENTER | WS_CAPTION | WS_SYSMENU | WS_VISIBLE | WS_POPUP
CAPTION " Таблица умножения"
FONT 8, "MS Sans Serif", 700, 0 /*FALSE*/
BEGIN
EDITTEXT 100, 10,26,20,16, ES_AUTOHSCROLL | ES_LEFT, , 0
EDITTEXT 101, 10,52,70,100, ES_AUTOHSCROLL | ES_LEFT | ES_MULTILINE | ES_WANTRETURN | WS_CHILD | WS_VISIBLE | WS_BORDER | WS_TABSTOP, 0
PUSHBUTTON "Расчет", 1000, 100,30,40,16, 0, , 0
PUSHBUTTON "Очистить", 1001, 100,60,40,16, 0, , 0
LTEXT "Введи первый сомножитель", 20,10,10,143,16, SS_LEFT, , 0
END

MYICON ICON "nk.ico"
 

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

// Таблица умножения на DELPHY без VCL с использованием
// API и диалогового окна, которое помещено
// в файл ресурса.
program tum_dlg;

// Используемые модули.
// Две функции преобразования строки в целое и наоборот
// помещены в отдельный модуль для компактности программы.
uses
Windows, messages, myfunc;

// Подключение файла ресурсов, в котором находится
// окно нашей программы. Оно было создано с помощью
// программы создания и редактирования ресурсов.
{$R dnk.res}

// Объявление констант
Const
dlgname = 'TABUM';
AppName = 'WinDLG';

// Функция, которая обрабатывает сообщения для нашего окна
// В качестве параметров: идентификатор окна и характеристики сообщения
function WindowProc(wnd:HWND; Msg:Integer; wParam:wParam;
lParam:lParam):Lresult; stdcall;

// Объявление локальных переменных функции
Var
lpBuf: array[0..1024] of char;
sTum : String;
I : integer;
iSomn : integer;
sSomn : String;

begin
   Result:=0;

// Реакция на сообщения операционной системы
case msg of

// Инициализация диалога: главного окна программы.
  WM_INITDIALOG:
    begin
//Помещаем в шапку программы значок MAINICON: куда ж без нее.
     SendMessage(wnd, WM_SETICON, ICON_BIG, LoadIcon(hInstance, 'MYICON'));
   end;

// События от элементов управления
WM_COMMAND:
begin
// Анализируется нижнее слово wParam для принятия решения
// о выполнении программой соответствующих действий
   case LoWord(wParam) of
// Идентификатор нажатия левой кнопки мыши на кнопке
// выполнения расчета
1000:
  begin
// Получить сомножитель из окна ввода
    GetWindowText(GetDlgItem(wnd, 100), lpBuf, 2);
// Перегнать массив символов в строку
    sSomn:=lpBuf;
// Конвертировать строку в число для вычислений
    iSomn:=Str2Int(sSomn);
// Очистить исходную строку, если в ней больше одной цифры
    SetWindowText(Getdlgitem(wnd, 100), lpBuf);
// Очистить строку вывода
   sTum:='';
// Организация цикла вычислений
    For I:=1 to 10 do
// Сформировать строку перед выводом
     sTum:= sTum + Int2Str(iSomn)+ ' x '+ Int2Str(I)+
     ' = '+ Int2Str(iSomn*I)+ #13#10;
// Конвертировав строку в pchar скопировать ее в буфер символов
    lstrcpy(lpBuf,pchar(sTum));
// Сформированную строку поместить в окно вывода результата
    SetWindowText(Getdlgitem(wnd, 101), lpBuf);
end;
// Отработка очистки окна вывода
1001: SetWindowText(Getdlgitem(wnd, 101), '');

end; // конец анализа Case LoWord
end; // конец анализа WM_Command

// В случае получения программой сообщения о ее закрытии
// послать сообщение о завершении работы программы
   WM_DESTROY, WM_CLOSE: PostQuitMessage(0);

end; //Конец Case анализа сообщений
end;

begin
// Назначить нашему окну, которое мы создали в файле ресурса
// программу обработки оконных сообщений
   DialogBox(hInstance, dlgname, 0, @WindowProc);

end.
 

    Как можно видеть: в случае определения параметров нашего главного окна в файле ресурсов, программа получилась очень компактной и логичной.  На мой взгляд, в случае необходимости создания  программы нетребовательной к ресурсам и скромной по объему генерация диалоговых окон при помощи специальных программ является самой удобной. При более близком знакомстве диалоговые окна легко создавать, даже с помощью  простого текстового редактора. Тем более структура файла ресурсов подробно документирована во множестве источников.
   Хотя по размеру программного кода 18 килобайт, отличия нет, то с точки зрения компактности и доступности код этой программы намного проще.
 - И все таки код и этой программы изобилует разными конструкциями, которые для понимания требуют дополнительной подготовки. Я имею в виду,  что нужно рассматривать еще что то, кроме DELPHI. Вручную вводить длинные и странные с точки зрения обычного Паскаля строки кода. Неужели нет средства совместить строгость и наглядность Паскаля с преимуществами визуального программирования и получать при этом не столь громоздкий программный файл.
 - Есть и такое решение. Одного хорошего человека эта проблема так сильно волновала, что он взял и разработал: сначала систему KOL (Key Objects Library), а затем  MCK (Mirror Classes Kit). Я не буду рассказывать много об этих вещах, поясню общими словами. Библиотека KOL - это набор процедур и функций, использование которых дает возможность резко сократить объем получаемой программы при сохранении ее полной функциональности. А  MCK дает возможность использовать при разработке программ привычный набор визуальных компонентов в виде кнопок, окошек, списков и так далее. Конечно же две этих составляющих работают в паре и размер кода программы получается на порядок меньше обычного.
     Чего долго болтать, вот код модуля программы.

// Программа: таблица умножения с использованием KOL и MCK
// Не пугайтесь от обилия параметров условной компиляции
// Никто не заставит вас все это прописывать вручную.
// Если вы правильно установите KOL и MCK, то все остальное
// они проделают за вас сами. И создание программы выльется в
// привычную работу с визуальными компонентами и
// кодирование на Object Pascal.
{ KOL MCK } // Do not remove this line!
{$DEFINE KOL_MCK}

// Известное объявление о том, что это модуль
unit Unit1;

// Открытие интерфейсной секции.
interface

// Подключение дополнительных модулей
{$IFDEF KOL_MCK}
uses Windows, Messages, ShellAPI, KOL {$IFNDEF KOL_MCK}, mirror, Classes, Controls, mckControls, mckObjs, Graphics,
mckCtrls {$ENDIF};
{$ELSE}
{$I uses.inc}
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs;
{$ENDIF}

// Объявление типов данных
type
{$IFDEF KOL_MCK}
{$I MCKfakeClasses.inc}
{$IFDEF KOLCLASSES} TForm1 = class; PForm1 = TForm1; {$ELSE OBJECTS} PForm1 = ^TForm1; {$ENDIF CLASSES/OBJECTS}
{$IFDEF KOLCLASSES}{$I TForm1.inc}{$ELSE} TForm1 = object(TObj) {$ENDIF}
Form: PControl;
{$ELSE not_KOL_MCK}
TForm1 = class(TForm)
{$ENDIF KOL_MCK}
FIRSTKOL: TKOLProject;
KOLForm1: TKOLForm;
Label1: TKOLLabel;
EditBox1: TKOLEditBox;
Button1: TKOLButton;
Button2: TKOLButton;
Memo1: TKOLMemo;
procedure Button1Click(Sender: PObj);
procedure Button2Click(Sender: PObj);
procedure KOLForm1Show(Sender: PObj);
private
{ Private declarations }
public
{ Public declarations }
end;

// Объявление переменных
var
Form1 {$IFDEF KOL_MCK} : PForm1 {$ELSE} : TForm1 {$ENDIF} ;

// Очевидно, что этой процедурой
// инициализируется наша форма-окно программы.

{$IFDEF KOL_MCK}
procedure NewForm1( var Result: PForm1; AParent: PControl );
{$ENDIF}

// Секция реализации
implementation

{$IFNDEF KOL_MCK} {$R *.DFM} {$ENDIF}

{$IFDEF KOL_MCK}
{$I Unit1_1.inc}
{$ENDIF}

// Переменные секции реализации
Var
somn, I, pr : Integer;

// Реализация реакции на кнопку расчета
procedure TForm1.Button1Click(Sender: PObj);
begin

// Очистим поле вывода
Memo1.Text:='';

// Прочитаем значение сомножителя из поля ввода
Somn:= Str2Int(Copy(EditBox1.text,1,1));

//Вернем в поле ввода одну цифру
EditBox1.Text:=Int2Str(Somn);

// Цикл организации вывода таблицы на экран
For i:=1 to 10 do
Begin
   pr:=somn*I;
   Memo1.text:= Memo1.text + Int2Str(Somn)+ ' x ' + Int2Str(i) +
  ' = ' + Int2Str(pr) + #13#10;
end;
end;

// Реакция на кнопку закрытия программы.
procedure TForm1.Button2Click(Sender: PObj);
begin
   Form.Close;
end;

// Иконочку в заголовочек программы: мелочь, а приятно.
procedure TForm1.KOLForm1Show(Sender: PObj);
begin
   form.Icon := LoadIcon (HInstance, 'MYICON');
end;

// Конец программе.
end.
 

 - Итак, что мы имеем? Чуть больше 28-и килобайт. Ну, что ж неплохо, но до чистой DELPHI-API, конечно не дотягивает.  
    Если вы решите использовать KOL и MCK, то приготовьтесь к некоторым особенностям в их применении. Их установка при прочтении инструкции не вызывает проблем.  Создание формы на их основе, хоть и имеет свои правила, тоже не обременительно.  Главные преимущества: привычные визуальные компоненты  при создании программы и очень скромный размер конечного продукта.  Из неприятных неожиданностей: замена некоторых привычных процедур и  функций Паскаля своими.  Правда, файл помощи позволяет быстро освоиться с этими заменами.

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

- Я не понял, почему ты этого не хочешь, неужели слабо!!!

- Ну, что ж, учти, за последствия я не отвечаю!

Продолжение следует...

  Назад На главную Вперед  

Другая информатика. (C) Публикация на draginf.ru. При использовании материалов ссылка на сайт обязательна.