* Насчет работы с файлами. А не легче(и лучше) для открытия и сохранения файлов использовать диалоги?
Dark Storn

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

Но, безусловно, диалоги открытия/сохранения очень удобны и обязательно должны присутствовать в программе, где есть работа с файлами. Эти диалоги - невизуальные компоненты, они расположены на вкладке Dialogs. Диалог выбора файла для открытия называется OpenDialog, диалог выбора файла для сохранения - SaveDialog. Разместите их на форме, добавьте кнопку и поле надписи и в ее обработчике запишите так:

OpenDialog1.Execute;

Запустите программу, нажмите на кнопку, и появится стандартное окно выбора файла.

Полный путь к файлу хранится в свойстве FileName этого объекта. А метод Execute - на самом деле логическая функция, которая возвращает true, если пользователь нажал Ok, и false, если нажал Cancel в диалоге выбора.

  if OpenDialog1.Execute then
     begin
     // обрабатываем файл, если нажата ОК

     Label1.Caption := OpenDialog1.FileName;
     AssignFile(MyFile, OpenDialog1.FileName);
     ...
     end;

В свойстве Title можно указать название диалога (в его шапке будет показываться). В свойстве Filter - шаблон выбора файлов.

Например, мы хотим открывать только файлы с расширениями *.txt и *.pas. Тогда в Filter надо такую конструкцию записать:

  OpenDialog1.Filter := ' Текстовые файлы|*.TXT|Файлы Паскаля|*.PAS ' ;
  if OpenDialog1.Execute then ...

Строка в Filter состоит из пар название-файлов | шаблон отбора, тоже разделенных в свою очередь символом | . То есть в выпадающем списке в диалоге покажутся две строки "Текстовые файлы" и "Файлы Паскаля", а отбираться будут соответственно все файлы с расширениями .txt или .pas. Свойство FilterIndex задает номер маски файлов, начиная с единицы:

  OpenDialog1.Filter := ' Текстовые файлы|*.TXT|Файлы Паскаля|*.PAS ' ;
  OpenDialog1.FilterIndex := 2; // по умолчанию покажутся файлы
  Паскаля

Что такое интелектуальная обработка и символ DecimalSeparotor;

Интелектуальная обработка - это обработка чего-то (или кого-то :) с помощью интеллекта. Естественного или искусственного.

DecimalSeparotor (Separator, видимо) - десятичный разделитель.

Образно готовим блюдо нужно какое то вещество то мы не идем в магазин покупаем и смешиваем а просто берем на полке указав что оно там лежит. Тоесть таким образом можно взять кусок исходного кода любой програмы и вставить в свою.Правильно ли я понял?
Олег

Во-первых, пожелаем Олегу скорейшего нахождения новой интересной работы, более тесно связанной с программированием! Он также передает благодарность Тане:

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

Напоминаю, по вопросам базового курса к Тане (она также принимает пожелания по улучшению сайта) или Лене.

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

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

Практически все проекты, распространяющиеся свободно и в исходных текстах (как Линукс например, и десятки тысяч прикладных программ для нее, от системных утилит и браузеров до графических редакторов и игр типа Цивилизации или Варлордов), распространяются, как принято говорить, под лицензиями. Есть и так называемые public domain-системы, "общенародное достояние", вот с ними можно что угодно делать. Но как правило открытый софт выпускается под конкретными лицензиями, которые требуют хотя бы упоминания автора исходных текстов. Или например требуют, чтобы все основанные на них программы также обязательно были сводобными.

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

Можно конечно спросить "а кто узнает?". Но это уже вопрос личной порядочности :) Кроме того, достаточно большие вкрапления чужого кода обычно выявить все же можно (по наличию характерного скомпилированного двоичного кода), да и, как показывает практика, все равно почти всегда проще написать самому, чем брать чужое. Но вот для знакомства с правильными программами и правильным кодом - очень полезно!

Продолжают приходить письма от доброжелателей ("с камушком за пазухой и с пикой за спиной и с одной на всех извилиной" (с) Тальков). Я уже писал, что о моей рассылке заботиться не надо :) лучше заботьтесь о своих собственных проблемах. И в моей рассылке я буду писать все, что хочу, и советоваться ни с кем не буду. Захочу - напишу, что Бейсик - это язык ассемблера и что класс - это экземпляр объекта. Если кому-то это не нравится, тот может шевелить большим пальцем на левой ноге :) В качестве альтернативы могу предложить попробовать открыть свою рассылку и там демонстрировать свое владение Дельфи или Си. Все в равных условиях.

Разница между стратегическим (все мелочи нафиг) и тактическим мышлением, которое видит лишь мелкие нюансы, - в задавании вопроса "а почему?", "а может, в будущем?". Чем мельче личность, тем более мелкие вещи она замечает :) Пропуская при этом крупные. Уровень вопроса отражает уровень сознания, его задающего :)

Кроме того, что, у нас в рассылке нет позитивных моментов? Нечему порадоваться, ничего позитивного не видно? Только мелкие описки заслуживают внимания? Только 1% негатива замечается, а 99% позитива? По письму можно сразу сказать, что за человек его пишет и кто он по жизни.

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

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

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

Перед тем, как писать письмо, ну спросите себя - "Что улучшится в моей собственной жизни, если я напишу? Удовлетворю свое чувство тщеславия, или комплекс неполноценности потешу?".

Не факт еще, кстати, что удовлетворите :) Я вам так просто его удовлетворить не дам :) Придется потрудиться все равно.

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

Вот типичное письмо - от Алексея.

У меня к Вам возникло несколько вопросов по поводу последнего выпуска Вашей рассылки. Я пишу на C++, поэтому вопросы касаются только раздела посвященного ему.

У меня, вообще-то, раздела, специально посвященного ему, нету.

1. Ну зачем вводить людей в заблуждение словами «Специальный тип данных "файл" в Си для хранения идентификатора называется FILE (на самом деле обычный int). Но после него еще звездочку надо указать.»
Во-первых ели бы это даже и был обычный int, то перед ним не надо было бы ставить «звездочку»
Во-вторых это указатель на файловую переменную. УКАЗАТЕЛЬ, а не целочисленная переменная и не специальный тип.

На знаю, ели вы, Алексей, или не ели обычный int, и какой он на вкус, и зачем перед ним надо (или не надо) ставить звездочку. Я говорю о том, что "после" надо ставить, а не "перед". Понимаете разницу между "перед" и "после"?

Вот несколько цитат из книг авторов, авторитет которых не подлежит сомнению:
"Программа, использующая эту функцию, должна включать во время компиляции системный файл stdio.h, в котором определен новый тип данных - FILE"
"Реализация файлового ввода-вывода скрыта в типе данных FILE*"
"Определение типа данных FILE"
итд.

Далее, говоря про тип данных, я упоминал именно FILE. FILE - воспользуюсь вашим способом акцентирования внимания - это НЕ это "указатель на файловую переменную". Указатель на файловую переменную - это FILE* , со звездочкой именно после, и именно так, как я написал.

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

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

2. На сколько я понял в рассылке речь идет не только о чистом C, но и о C++, так почему вы даете людям информацию о работе с файлами только в стиле чистого C?

Вот именно потому, что в рассылке речь идет не только о C++, но и о чистом C, как вы правильно поняли, я и даю людям (кстати, не только людям, еще и хомячкам, которые умеют за компьютером работать) информацию о работе с файлами только в стиле чистого C.
А что, кстати, есть грязный С? И как его отчистить до чистого С?

3. Зачем все выворачивать на изнанку? Сначала Вы предлагаете преобразовать строку в целочисленную переменную (задание 41), а только потом писать ее в файл. Что, кто-то отменял функцию fscanf() со спецификатором %d, о которой Вы даже не упомянули, или функцию fprintf(), для чтения данных из файла? По-моему нет…

А по-моему, Алексей, это вы как раз опять все выворачиваете "на изнанку". Если вы потрудитесь внимательно прочесть текст задания, то, возможно, обнаружите, что там сказано:

"Каждое значение - строка файла представляет собой случайное число от 100 до 999, только в виде строки (IntToStr() используем перед записью числа в файл)."

Число представить в виде строки! А не наоборот. Откуда вы взяли, что я предлагаю "преобразовать строку в целочисленную переменную" перед записью в файл? Ну откуда?

Да и насчет fscanf() и fprintf() вы тоже все перепутали.

"fprintf(), для чтения данных из файла" - нет, неверно! fprintf() - для записи данных в файл. Здесь разницу понимаете, между записью и чтением из файла?

4. Зачем для всего это еще и BCB или VC использовать?. Я понимаю, если бы стояла задача создать консольное приложение, а так бред получается, как например в задании 40. Зачем в этом случае использовать функции из stdio.h, когда можно использовать WinAPI?

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

Отвечу пока просто - для более тесного знакомства с "BCB или VC".

Насчет того, что "можно использовать WinAPI" - кто ж спорит, конечно можно. А можно и на ассемблере, можно и свою операционную систему написать и ее возможностями пользоваться. Это уж личный выбор каждого. Мне нравится stdio.h, а если кому-то нравится что-то другое, могу только порадовваться, что кто-то любит арбуз, а кто-то свиной хрящик.

5. Да, кстати, stdio.h – это не библиотека, а заголовочный файл, содержащий прототипы функций (но не сами функции). Библиотеки имеют расширение lib.

Уели, уели! Ничего не могу сказать, действительно, stdio.h – это не библиотека, а заголовочный файл. Если быть формалистом, конечно, и вычитать слова про заголовочные файлы в правильных книжках. Хотя в немалом числе и правильных книжек можно найти определения типа "подключение библиотеки stdio.h", "Стандартная библиотека ввода-вывода stdio.h" итд. Жаргон такой, просто. Который как правило только школьные учителя не понимают.

Уж если кому-то так хочется продемонстрировать свои познания - как минимум укажите точные источники ваших знаний, откуда вы узнали. Потрудитесь, иначе будете выглядеть глупо. А в ходе такого поиска, скорее всего, понимание придет, и потребность доказывать мне, что "и я тоже знаю программирование!" отпадет :)

Я не формалист. Более того, я категорчный противник любой формальности. Еще раз повторю, это моя рассылка, и если я сочту нужным, то буду писать, что stdio.h - это библиотека, WinAPi - оболочка линукса, и даже такие жуткие вещи, что fprintf() нужна для чтения данных :)

А наблюдателям останется только большой палец на левой ноге для шевеления.

В бессильной злобе :)))))

Коллеги! Ну уж берите ответственность, за то, что пишите. А то потом бросаются мне письма строчить - да я не то имел в виду, да я хотел сказать другое, да я просто описался, чтож такого...

То есть себе вы позволяете описываться, а другим нет?

Таких писем мне приходит много. Я из них особую подборку сделаю и назову как-нибудь типа "Потуги мирян" :) (с) не мой).

Это все очень серьезно на самом деле :)))

Идите и делайте; вы всегда успеете оправдаться позже.
(c) Грейс Хоппер, легендарная программистка, придумавшая в 40-х годах идеи бибиотеки подпрограмм, концепцию компилятора и еще кучу полезных вещей.

И вот, кстати, только что пришло письмо от Андрея, который уже немного более аргументированно :) обосновал плюсы и минусы чистого С :) и C++. Спасибо, Андрей, ваше письмо я обязательно опубликую уже как замечательный пример того, "а как надо правильно" :) Пример конструктивного подхода.

Объектное программирование

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

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

Объект, прежде всего, объединяет в пределах одного смыслового понятия как данные, так и методы их обработки. Он также способен реагировать на события и сам такие события может генерировать.

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

В нем есть свойство Enabled, фактически переменная логического типа. А есть свойство Items - вложенный другой объект, массив элементов.

Есть у списка всевозможные методы (подпрограммы), например Clear, который очищает внутренне содержимое. Это не данное, а программный код. А есть события, на которые он может реагировать (например, выбор элемента списка мышкой, OnClick).

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

Можно считать в принципе любой элемент данных в программе объектом. Так, переменная

x: Integer

как бы хранит в себе объект-число. Есть такие языки программирования (SmallTalk например), в которых любое число - объект со своими методами. Например, записанное в x число-объект 10 может быть преобразовано в число обращением к его методу ToString:

10.ToString

Integer в данном случае - это тип данных переменной x, но на самом деле программист может создавать свои собственные типы данных, представляющие самые разные объекты. Это удобно, так как проще всего в программе создавать и затем использовать сущности и понятия, приближенные к реальной жизни. Если надо смоделировать взаимодействие хомячков, то каждого из них неплохо представить в виде объекта, у которого будет набор полей -значений (текущие координаты, скорость, запас здоровья :), и методы (НапастьНа(), Убегать(), Кушать(), Размножаться() :) итп).

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

Здесь аналогия с переменными x и y целого типа - они одинаковы по внутренней структуре (обе хранят значения целого типа), а отличаются только значениями.

Поэтому очень удобно описать наших хомяков в виде переменных (например, массива хомяков :), с помощью некоторого универсального описания структуры этих переменных. Фактически, с помощью нового, программистом определенного, типа данных Хомяк.

Тогда мы сможем делать такие записи:

var Хомяк1, Хомяк2: Хомяк;

А потом:

Хомяк1.Скорость := 9.8;
Хомяк1.НапастьНа( Хомяк2.Координаты );

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

Наш новый тип данных (например, Хомяк), описывающий структуру конкретных объектов (конкретных экземпляров хомяков в программе) называется КЛАСС.

Класс - это фактически другое название типа данных. Мы некоторым способом определяем класс - новый тип данных, пользовательский, и затем создаем переменные этого нового типа. Только класс в дополнение к данным позволяет задавать и методы (код программный).

Компоненты, которые мы с панели инструментов ставим на форму, описаны в недрах Дельфи в виде классов. А будучи размещены на форме, они превращаются в конкретные объекты - реализацию этих классов в конкретной программе.

В записи

var МойХомяк: СуперХомяк;

СуперХомяк - это название класса (тип данных), своего рода описание (проектная документация на здание). А переменная МойХомяк - это конкретный, реально существующий объект програмы (построенные по документации дома), имеющий тип СуперХомяк.

В таком случае принято говорить, что объект - это экземпляр класса.

Запомните эту вечную фразу! :)

Конкретный объект хомяк Вася в аквариуме на окне - это экземпляр класса Хомяк.

Конкретный объект Label1 в программе расчета суммы калорий - это экземпляр класса Label.

Только на самом деле правильно записывается не Label (это название компонента с панели инструментов), а TLabel. В Борланде перед названием класса ставится буква T (Type, тип данных), в Microsoft принято ставить букву C (Class), CLabel например.

И что из этого, можно спросить?

Если посмотреть на код любой программы с формой, то там явно будет виден раздел, в начале, где создается специальный пользовательский класс TForm1 (тип СуперХомяк :), а затем объявляется переменная этого типа -

var Form1: TForm1;

Form1 (как Хомяк1 :) - объект, экземпляр класса TForm1.

Класс TForm1 задается такой формой записи:

type TForm1 = class(TForm)
...
end;

Здесь определяется новый тип данных TForm1, который можно использовать в принципе наравне с типами Integer или String. Пока зазубривать это не надо, просто принцип поймите.

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

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

Например, надо считать число нажатий на некоторую кнопку, а при каждом нажатии показывать в поле-надписи случайное число, лежащее в пределе от 1 до текущего числа нажатий.

Можно описать где-то в программе, в начале, отдельную переменную-счетчик

var N: Integer;

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

В целом это может выглядеть так - следом например за описанием переменной-формы:

  var
    Form1: TForm1;

  // разместим декларацию нашей переменной
  var N: Integer;

  ...

Затем в обработчике события создания формы запишем в N начальное значение:

  procedure TForm1.FormCreate(Sender: TObject);
  begin
  N := 0;
  end;

А в обработчике нажатия на кнопку - увеличение:

  procedure TForm1.Button1Click(Sender: TObject);
  begin
  N := N + 1;
  end;

Функцию же Dice, допустим, по некоторым причинам (например, желанию заказчика) нам надо написать без параметра, а с явной привязкой к значению переменной N (это плохой стиль программирования! берем его только для наглядности):

  function Dice: Integer;
  begin
  if N <= 1
     then Result := 1
     else Result := random(N)+1
  end;

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

  var N: Integer;
  ...
  function Dice: Integer;
  begin

Вот так нельзя:

  function Dice: Integer;
  begin
  if N <= 1
     then Result := 1
     else Result := random(N)+1
  end;

  var N: Integer;

Компилятор укажет на ошибку - в строке

  if N <= 1

так как он анализирует исходный текст от начала к концу, и упоминание N встретил, а ее описание - еще нет. Это, впрочем, особенность компилятора Паскаля, а вот в Си по-моему выдается только предупреждение - система, ожидает, что описание N может встретиться в каком-нибудь другом модуле программы (до многомодульности мы скоро доберемся).

Правильно конечно ее так записать:

  function Dice(N: Integer): Integer;
  begin
  if N <= 1
     then Result := 1
     else Result := random(N)+1
  end;

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

В этом нам помогут объекты. Нашу переменную N, да и любые другие, мы можем поместить внутрь класса TForm1, наряду с кнопками, полями вывода итд. В тексте описания TForm1

  type
    TForm1 = class(TForm)
      Button1: TButton;
      procedure FormCreate(Sender: TObject);
      procedure Button1Click(Sender: TObject);
    private
      { private declarations }
    public
      { public declarations }
    end;

больше всего нас интересует раздел, начинающийся со слова public. Классы устроены таким образом, что одни содержащиеся внутри них свойства и методы могут быть доступны во внешней программе (говорят, видимы), а другие - скрыты. Так, в классе СуперХомяк может быть свойство "Мозга" , однако из внешней программы оно недоступно (видимость свойств определяет программист). А вот свойство "Скорость" видимо всем. Поэтому можно записать

Хомяк1.Скорость := 9.8;

но нельзя записать

Хомяк1.Мозга := 0;

хотя свойство Мозга у объекта Хомяк1 имеется.

А зачем это надо? Дело в том, что свойство Мозга может активно использоваться при каких-то внутренних вычислениях. Например, если мы создаем метод "ИдтиКСамочке" в классе СуперХомяк, то внутри этого метода может активно обрабатываться значение свойства "Мозга" (а может, и не может :). Но только внутри собственых! методов класса СуперХомяк эта Мозга будет видна. Извне добраться до Мозга не выйдет.

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

Сначала полагается в этом разделе указывать данные (описания внутренних переменных фактически - они еще называются члены класса :), а затем - методы.

Переменные внутри класса также декларируются, как и с помощью var, только само слово var не указывается. Вот так мы добавим в класс TForm1 новое поле N:

  ...
    public
      { public declarations }

      N : Integer;

    end;

Далее нам надо добавить метод Dice. Однако в описание класса добавляются только так называемые заголовки подпрограмм (прототипы функций :), а сама их реализация располагается в другом месте. То есть в нашем случае достаточно только записать первую строчку с заголовком функции Dice:

  ...
    public
      { public declarations }

      N : Integer;

     function Dice: Integer;
    end;

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

Зачем сделано такое разделение? Представьте, что над суперсекретным проектом создания Боевого Робота-Хомяка работает большой коллектив. И раскрывать каждому программисту или кодировщику полный текст всего проекта, как-то не очень желательно. Вот тут и поможет понятие разделов интерфейса и реализации. Раздел интерфейса доступен каждому разработчику - он видит доступные поля и методы каждого класса. А вот раздел реализации можно легко скрыть (попозже мы рассмотрим, как это делать), и как конкретно реализована та или иная функция, посмотреть постороннему не удастся. Однако на его работу это никак не влияет - описание назначения функций есть, бери и пользуйся.

Как записать реализацию метода Dice? Переместимся в любое место файла после ключевого слова Implementation (между другими реализациями), и запишем эту функцию полностью:

  function Dice: Integer;
  begin
  if N <= 1
     then Result := 1
     else Result := random(N)+1
  end;

Только дополнительно нам необходимо явно указать, что это не автономная функция (для работы которой, соответственно, понадобилась бы глобальная переменная N ), а метод класса TForm1. Записывается это указанием перед названием функции Dice префикса - названия класса, которому этот метод принадлежит, и точки:

  function TForm1.Dice: Integer;
  begin
  if N <= 1
     then Result := 1
     else Result := random(N)+1
  end;

При этом N в теле функции будет трактоваться прежде всего как собственное поле класса TForm1, и дополнительно глобальную переменную определять не надо.

Теперь из любого обработчика формы Form1 мы можем свободно обращаться к ее новому методу Dice (где он определен в коде, выше или ниже данного обработчика, уже неважно - компилятор знает по наличию заголовка в описании класса, что такой метод есть).

  procedure TForm1.Button1Click(Sender: TObject);
  begin
  Label1.Caption := IntToStr( Dice );
  end;

Кстати, посмотрите на заголовок этого обработчика - это тоже, как теперь понятно, обычное описание метода класса TForm1. Его параметр Sender - стандартный в Дельфи, он определяет объект, который послал данное сообщение (этот параметр почти всегда игнорируется :). Тип этого объекта - TObject, один из универсальных классов Дельфи, задающих понятие объекта.

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

В Си++ такая информация - описание класса - включается в так называемые упомянутые выше всуе :) заголовочные файлы. Они реализуют концепцию интерфейсного раздела Дельфи, только описание классов в Си++ выделено в отдельный файл с расширением .h. А в файле .cpp - реализация классов. Кстати, поддержка классов есть только в С++. В чистом С :) классов нету.

Откроем этот файл - Unit1.h. Для этого в начале файла Unit1.cpp можно найти команду подключения этого файла -

#include "Unit1.h"

достаточно навести на слова Unit1.h курсор и нажать Ctrl+F6 (Borland C++Builder). Вот такое там будет описание класса TForm1:

  class TForm1 : public TForm
  {
  __published: // IDE-managed Components
          TButton *Button1;
          void __fastcall Button1Click(TObject *Sender);
  private: // User declarations
  public: // User declarations
          __fastcall TForm1(TComponent* Owner);
  };

Здесь тоже виден раздел public. Вот в него и занесем наше поле N и описание функции Dice:

  ...
  public: // User declarations
          __fastcall TForm1(TComponent* Owner);

          int N;
          int Dice();

  };

Теперь вернемся в файл реализации и запишем там функцию Dice:

  int Dice()
  {
   if( N <= 1 ) return 1;
   else return random(N)+1;
  }

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

  int TForm1::Dice()
  {
   if( N <= 1 ) return 1;
   else return random(N)+1;
  }

Ну и обработчик нажатия:

  void __fastcall TForm1::Button1Click(TObject *Sender)
  {
   Label1->Caption = IntToStr( Dice() );
  }

На подборку ответов на задания опять места не хватило - в следующий раз.

Школа программирования с нуля
Все предыдущие выпуски базового курса тут:
http://russianenterprisesolutions.com/sbo/