Тебе ещё не надоело в чатах девкам кариес заговаривать:)? Может хватит целами ночами сканировать порты всего инета? И самое главное, не надоело ли тебе использовать чужое вооружение. Не пора ли научится создавать своё?

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

Сегодня я постараюсь объяснить все основы кодинга, а потом мы перейдём к реальным делам. А всё реальное, мы будем творить с помощью двух крутейших сред программирования: Delphi (под Windows) и Kylix (под Linux) от фирмы Борман (Borland).

Почему я выбрал именно их? Да потому что они визуальные и в их среде мне не надо будет выдумывать велосипед. Оболочку будущей проги я создаю за пять минут, и моя работа превращается в творчество, а на VC++ я трачу до 60% времени на написания кода оформления и 40% на сом кодинг. Когда мне говорят, что настоящий программер должен писать всё руками, то на этот вопрос я отвечаю коротко: тогда пиши в машинных кодах, это ещё круче. Я ничего не имею против языка С++ (он действительно гениален), его знать надо и я использую вставки на нём. Но реализация языка С++ от M$ не просто хромает, это калека от рождения, а сам MFC никогда не сможет стать визуальным. Тут нужно полное обрезание начиная с Била :).

А главное - всем моим заказчикам абсолютно параллельно, какой язык я использую. Им нужно, чтобы прога была готова быстро и качественно. А это возможно только на Delphi. Прога создаётся в 10 раз быстрее и отлаживать надо в 100 раз меньший код. Остальное за меня отладил дядя Борман.

Всё, что я буду сейчас говорить одинаково касается как Kylix так и Delphi 5.0 (потому что они практически одинаковы), но показывать буду на примере второго. На рисунке 1 ты можешь увидеть оболочку Delphi 5. Она немного непривычна, но очень удобна. Как видишь, здесь четыре окна:

1. Форма - на ней ты визуально устанавливаешь компоненты.

2. Окно редактора кода - здесь ты будешь заниматься кодингом.

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

4. Объектный инспектор - здесь ты можешь изменять свойства компонентов.

Рисунок 1. Оболочка Delphi 5.

Все компоненты устанавливаются на форму простым перетаскиванием. Выбери на палитре компонентов что твоей душе угодно и щёлкни потом на форме. Этот компонент удобно расположится на месте твоего щелчка и будет слушать дальнейших твоих приказаний. А в это время, из-за леса из-за гор, в объектном инспекторе появляются все доступные свойства компонента. Давай поставим кнопку Button на закладке Standard палитры компонентов. Её основные свойства выглядят так:

Caption - заголовок кнопки

Cursor - тип курсора, при наведении на кнопку

Default - использовать по умолчанию если юзер нажал Enter в окне

Enabled - доступность. Если этот параметр равен false, то кнопка отображается серым цветом

Font - шрифт текста на кнопке

Hint - подсказка, показываемая при наведении на кнопку

TabOrder - порядковый номер компонента. При перемещении между компонентами с помощью Tab используется указанный здесь порядок

TabStop - Можно ли переходить на кнопку с помощью клавиши Tab

Left, Right, Height, Width - левая, правая позиция кнопки и высота и ширина

Visible – видимость

Это основные свойства, которые присутствуют практически во всех компонентах Delphi. Помимо свойств, у любого компонента есть методы и события. Методы - это действия, которые может выполнять компонент. События - реакция на происходящие действия в компоненте. В объектном инспекторе тебе доступны свойства на закладке Properties и события на закладке Events.

Перейди на закладку Events. Здесь перечислены основные события от выделенного тобой компонента (рисунок 2).

Рисунок 2. События.

Посмотрим на события кнопки:

OnClick - это событие происходит после нажатия на кнопку.

OnEnter - когда кнопка получила фокус

OnExit - когда фокус пропал

OnKeyPress - когда нажата какая-нибудь клавиша

OnMouseDown - когда надавили на кнопку мышкой

OnMouseMove - когда мышка ездиет над компонентом

OnMouseUp - когда мышку отпустили

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

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

И теперь мы и подошли к реальному кодингу.

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

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

2. Всё, что заключено в фигурные кавычки { и } тоже комментарий. Так можно заключить в комментарий сколько угодно строк.

Пример:

//Это комментарий. 
Это уже не комментарий

{Это снова комментарий
И это то же
И это }

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

==== Начало модуля ===

unit Unit1;//Имя модуля

interface

uses //После этого слова идёт перечисления подключённых модулей.
  Windows, Messages, SysUtils, StdCtrls;

//В этих модулях находится описание разных методов и процедур, 
//которые мы можем использовать

type//После этого идёт объявление типов

TForm1 = class(TForm) //Начало описания нового объекта TForm1
//Здесь описываются компоненты и события
  Button1: TButton;//Эта наша кнопка:
  procedure Button1Click(Sender: TObject);//Это собитие от кнопки
private
{Здесь можно описывать переменные и методы. 
доступные только для TForm1}
public
{Здесь можно описывать переменные и методы
доступные везде}
end;

var//Объявление глобальных переменных
 Form1: TForm1;//это описана переменная Form1 типа объекта TForm1

implementation

{$R *.DFM}

{Далее идёт процедура, которую создал Delphi для обработки
события OnClick, когда мы дважды щёлкнули по событию в 
объектном инспекторе.}
procedure TForm1.Button1Click(Sender: TObject);//Имя процедуры
begin//Начало процедуры
//Здесь можно писать свой код
end;//Конец процедуры

end.//Конец модуля. После end и точки, никакой код больше не воспринимается.
==== Конец модуля ===

Практически все строчки заканчиваются знаком ";". Этот знак показывает конец оператора. Он ставится только после операторов и никогда не используется после ключевых слов uses, type, begin, implementation, private, public и т.д.

Самое сложное - разобраться с объявлениями типов. Весь код который ты пишешь должен относится к какому-нибудь типу. Их мы описываем после ключевого слова type. Строка TForm1 = class(TForm) говорит о том, что мы создаём новый объект TForm1, который будет происходить от объекта TForm. А это значит, что TForm1 будет обладать всеми возможностями TForm , и плюс то, что мы захотим. TForm - это объект-форма. Все окна в Delphi относятся к этому классу.

Что же такое "объект"? Говоря научно - это совокупность свойств, методов и событий. То есть любой компонент Delphi – это объект, потому что у него есть всё это. Объекты могут наследовать всё своё содержимое. Например, наш объект TForm1 наследует всё содержимое у TForm и добавляет только одну кнопку и (пока пустой) обработчик события для неё. Это очень удобно. Тебе не надо писать каждый раз один и тот же код. Ты можешь создать объект форма+кнопка и использовать его где угодно. Можно выводить новые объекты из TForm1 и они будут обладать всеми свойствами TForm1 плюс свойства и методы TForm (например TForm2 = class(TForm1)).

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

Давай ещё познакомимся с типами переменных. Объявление переменных всегда происходит после слова VAR. Существует три основных типа: строки (string), числа (integer) и булевы (boolean) операторы. Для тех, кто в школе вместо информатики гонял девок по коридору:), сообщаю, что булев оператор это переменная, которая может принимать только два значения true или false (0 или 1). Существуют и другие разновидности этих трёх типов, но это основные, с которыми мы будем работать.

Объявление простой переменной:

var
 i:Integer;

Это я объявил переменную i типа целое число. Теперь я могу присваивать ей значение: i:=1 или производить с ней любую математическую операцию. Двоеточие плюс равно читается как присвоить значение, т.е. я присваиваю переменной i число 1. Теперь I у меня равна единице.

В самом начале Delphi создаёт только одну глобальную переменную Form1 типа объекта TForm1, но зато это переменная сложного типа. Глобальные переменные можно использовать не только в этом модуле, но и в любом другом, если подключить его, добавив имя в раздел USES.

Итак, ты можешь использовать объект TForm1 через переменную From1. Для доступа к свойствам объекта TForm1 нужно написать Form1.свойство (имя переменной, точка, свойство). Например, доступ к кнопке формы будет происходить так Form1.Button1 (это грубо говоря). Button1 - это тоже объект и у него есть свойства. Когда ты выделяешь кнопку на форме, то ты видишь её свойства в объектном инспекторе. Чтобы получить доступ к её свойству (например Caption) нужно написать Form1.Button1.Caption := "Название кнопки". Всё что заключено в двойные кавычки, Delphi воспринимает, как строки.

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

procedure Exampl;
var
 i:Integer;//Объявление локальной переменной
begin//Начало процедуры
 i:=10;//Присваиваю переменной значение
end;//Конец процедуры

Эта процедура называется Exampl. Для использования процедуры нужно написать в любом участке кода «Exampl;».

Если процедура является методом какого-то объекта, то нужно написать в имени процедуры, "Имя Объекта.Имя процедуры":

procedure Form1.Examp2;
begin
 Exampl; //Вызываем процедуру Exampl написанную ранее.
end;

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

function Exampl:Integer;
var
 i:Integer;//Объявление локальной переменной
begin
 i:=10;//Присваиваю переменной значение
 Result:=i; // Возвращаю значение i
end;

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

function Exampl(index:Integer):Integer;
begin
// Возвращаю переданное значение
// index делённое на 2
 Result:=index/2;
end;

Здесь мы передаём в функцию Exampl одну переменную - index типа число integer. Для вызова этой функции можно использовать x:=Exampl(10);. Этим мы присваиваем переменной «х» результат работы функции Exampl(10). Если у тебя нет проблем с математикой, то ты уже должен высчитать, что в "х" должно попасть число 5.

На этом всё. Больше я не буду забивать тебе голову теорией. Я постарался дать тебе максимум инфы. Если ты что-то не понял, то не отчаивайся. Со следующего раза мы приступим к реальным делам и на практике всё само к тебе придёт. Если не придёт, то я затолкну молотком.

Лично я, долгое время использовал в кодинге некоторые приёмы ничего не понимая в происходящем. Но со временем всё само пришло. Только на практике можно со всем разобраться.

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

До встречи!!!