С помощью указателя на объект

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

Инициализация

Полное или квалифицированное имя функции

2.

// в теле класса присутствует прототип функции

// определение функции после определения класса

struct book1 { char title[256];

void show_title ();

};

void book1::show_title()

{ cout << title; }

<тип возв. рез.> < имя класса >::

<имя функции> (спецификация формальных параметров)

{ тело принадлежащей классу функции}

:: - операция принадлежности функции классу

Имя book1::show_title (имя класса:: имя функции) - полное или квалифицированное имя функции – члена класса

Класс, как и структура, описывает тип, шаблон для будущих объявление переменных, память при объявлении класса не выделяется.

Класс – это тип, который служит для определения переменных класса - объектов класса.

Определение объекта (экземпляра) класса:

Создание объектов или экземпляров класса осуществляется также как создание структурных переменных.

Создание экземпляра по имени – статическое выделение памяти:

<имя класса ><имя объекта>;

book tip1, tip2, tips[ 5 ], * ptr =&tip1, &name = tip2;

// объявлены объекты tip1 и tip2,

// объявлен массив из пяти объектов с именем tips,

//объявлен указатель на объект ptr, инициированный адресом первого объекта

// объявлена ссылка на объект tip2

// (все - класса book)

Создание экземпляра с помощью указателя и динамического выделения памяти:

<имя класса >*<имя указателя на объект > = new (<имя класса >)

book * pb = new (book);

book1 tip3 ={“Язык С++”}; - // объявление объекта класса book1 с

// инициализацией

Можно сразу объявлять объекты при объявлении класса, поместив имя объекта (или имена объектов) после закрывающей фигурной скобки.

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

Как только объект определен, можно обращаться к его компонентам

Используя имя объекта:

1) С помощью квалифицированных имен:

<имя объекта>. <имя класса>:: <имя компонента>

<имя объекта>. <имя класса>:: <вызов компонентной функции >

2) С помощью уточненного имени:

< имя объекта>. <имя компонента>

Можно присваивать значения, вводить, выводить элементы объектов.

cin>>tip1.title;

strcpy (tip1.title, “Турбо Паскаль”);

cin >> tips[3].author; cout<<tips[3].price;

Вызов компонентной функции, используя уточненное имя:

<имя объекта >. <вызов компонентной функции>

Компонентная функция объекта обрабатывает данные того же объекта!

tip3. show_title () - такой вызов приведет к печати – Язык С++

3) Обращение с помощью указателя на объект класса и операции косвенного

выбора элемента (‘->’):

<указатель на объект класса> -> <имя компонента>

book X1, X2, X3, * ptr = & X3;

// объявлено три объекта класса book и указатель на объект класса, //инициированный адресом третьего объекта

strcpy(ptr ->title, “ Turbo Pascal”);// даст значения элементу объекта X3

cin >> pb->title; // ввод данных в динамический участок памяти

Вызов компонентной функции, с использованием указателя:

указатель на объект класса -> вызов компонентной функции

ptr -> show_title(); // выведет “ Turbo Pascal”

pb ->show_title();

Объявление функции вне и внутри тела класса

При объявлении функции вне класса, внутри тела класса помещается только прототип или описание функции - заголовок функции с указанием типов формальных параметров, оканчивающийся знаком ‘; ‘.

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

Например класс имеет три метода (функции), определенных вне класса и сто экземпляров (объектов) класса, то в программе присутствуют 100 экземпляров данных, но коды только трех функций.

Данные тиражируются при создании объектов.

Компонентные функции не тиражируются.

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

Вместо команд передачи управления единственному экземпляру тела функции компилятор в каждое место вызова функции помещает команды кода операторов тела функции.

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

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

inline int ff (void) {... } //- обычная функция

class Men { char * name;

…

void setName (char*); // -функция- член класса

…

};

inline void Men:: setName (char*n)

{ name = n;}

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

Ограничения и запреты для подставляемых функций (включая и компонентные):

1) встраиваемая функция слишком велика;

2) встраиваемая функция рекурсивная;

3) обращение к встраиваемой функции размещено до ее определения;

4) встраиваемая функция используется более одного раза в выражении;

5) встраиваемая функция содержит операторы for, while, do, switch, goto.

Статический компонент класса

Каждый объект одного и того же класса имеет собственную копию данных класса.

Т.е. данные класса тиражируются при каждом создании объекта.

Иногда возникает необходимость объявить данные общие для всех объектов данного класса.

Например:

- если нужен счетчик объектов данного класса,

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

-может понадобиться указатель на последний элемент списка и. т. д.

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

Такой элемент должен быть определен в классе как статический.

Он должен быть определен со спецификатором static (выделяется память при его определении и сохраняется до окончания действия программы)

Статический элемент класса не дублируется при создании новых объектов класса.

Каждый статический элемент существует в единственном экземпляре и память на него выделяется при его инициализации.

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

<тип компонента > <имя класса>:: <имя компонента> <инициализатор>

Обращение к статическому компоненту:

Обращение к статическому компоненту класса возможно до определения первого объекта класса по квалификационному имени

<имя класса>:: <имя компонента>

После объявления объектов можно также обращаться как к обычному компоненту класса:

<имя объекта>. <имя класса>::<имя компонента>

<имя объекта>. <имя компонента>

При этом любые изменения (в любом объекте) статического элемента – становятся общими для всех объектов данного класса.