Я продолжаю знакомить тебя с основами С++. Здесь тебе предстоит познакомится с самыми азами этого языка: переменные, классы, конструкторы и деструкторы. Мы будем только знакомится, т.е. никакого примера не будет. Зато новой информации хоть отбавляй.

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

В С++ объявление классов происходит в специальных файлах с расширением ".h". Такие файлы я называю "заголовочными". Реализация классов происходит в файлах ".cpp". Рассмотрим простейший пример заголовочного файла, назовём его "Examp.h":

//класс CExampClass
class CExampClass
 {
  protected:
    int MyVariable;
  public:
    CExampClass();
    virtual  ~CExampClass();
    int GetVariable();
 };

Первая строка "//Класс CExampClass" - это комментарии. Если ты уже знаком с Delphi, то наверно знаешь, что всё, что стоит после двух косых чёрточек // - это комментарий. Точно так же и в С++, вся строка после // - это комментарий. Если ты хочешь выделить несколько строк в виде комментария, то все строки нужно округлить в /* и */. Например:

Это не комментарий /* это уже пошёл комментарий

Это всё ещё комментарий

*/ А это уже нет

Следующая строка "class CExampClass" - это объявление нового класса (объекта). CExampClass - имя класса.

Кавычки { и } заменяют соответственно begin и end из Delphi и означают начало и конец текста. В нашем примере мы объявляем класс и после этого указываем кавычкой { начало объявления этого класса. После того, как мы описали всё что нужно, закрываем кавычку }.

Далее идёт ключевое слово protected. Существует три таких ключевых слова private, protected и public. Всё, что объявлено после private относится только к этому объекту. Ни один другой объект не может обратиться к объявленным здесь переменным и функциям. Всё, что объявлено после protected доступно только этому и порождённым объектам. Всё, что описано после public доступно всем. Такая же терминология принята в Delphi и в Java.

Итак, я объявил одну protected переменную MyVariable типа int (целое число). В отличии от Delphi, объявление переменных происходит в виде: "Тип" пробел "Имя". Мы сразу познакомимся с несколькими типами:

• char - символ 1 байт (0..255)
• short - знаковое число 2 байта (0..65535)
• int - двухбайтовой знаковое число 2 байта (0..65535)
• long - четырёхбайтовой знаковое число 4 байта (0..4294967295)
• unsigned short - однобайтовой беззнаковое число 2 байта (0..65535)
• unsigned int - двухбайтовой беззнаковое число 2 байта (0..65535)
• unsigned long - четырёхбайтовой беззнаковое число 4 байта (0..4294967295)
• float - число с плавающей точкой 4 байта
• float - число с плавающей точкой 8 байта

Далее идёт объявление public переменных. Первой у меня объявлена процедура CExampClass(). Это конструктор. Как я это узнал? Конструктор - процедура с именем как у класса. Класс у меня называется CExampClass, значит конструктор будет зваться CExampClass.

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

Далее я объявляю деструктор (virtual ~CExampClass();). Деструктор - процедура с именем как у класса, но со знаком ~ впереди. Это простая процедура, которая автоматически вызывается, когда уничтожается класс. В ней удобно очищать и освобождать выделенную память.

Далее идёт объявление функции "int GetVariable();". Функция объявляется как:

Тип_Возвращаемого_Значения    Имя_Функции(список передаваемых переменных).

Имя моей функции GetVariable. Возвращаемое значение int, а передаваемых значений нет. Если функция не должна возвращать значения, то надо написать void. Например void GetVariable(); . Но в моём случае возвращаемое значение будет.

Теперь посмотрим на реализацию этого класса. Назовём этот файл Examp.cpp:

#include "Examp.h" // Подключение модуля

CExampClass::CExampClass 
 {                  //Начало процедуры
  MyVariable=1;
 }                  //Конец процедуры

CExampClass::~CExampClass
 {
 }

int CExampClass::GetVariable();
 {
  return MyVariable;
 }

Первая строка - подключение модуля (заголовочного файла) Examp.h, в котором объявлен наш класс.

Далее идёт конструктор CExampClass::CExampClass. Слева от :: стоит имя класса, а справа - имя процедуры. Внутри процедуры я присваиваю переменной MyVariable единицу.

Деструктор у меня пустой, потому что я ничего не создавал и ничего уничтожать не надо.

В функции GetVariable() я написал одну строку: return MyVariable. Она означает, что надо вернуть значение MyVariable. Теперь если ты напишешь ещё одну процедуру и вставишь там i=GetVariable(), то в переменной i будет значение, которое хранится в переменной MyVariable.

Всё. Первое знакомство закончено.