Главная
Регистрация
Вход
Суббота
16.12.2017
23:22
Приветствую Вас, Гость | RSS

Меню сайта

Категории раздела
1. Основы работы в среде C++ Builder.Основы языка Си++ [9]
2. Операторы ветвления и операторы передачи управления [4]
3. Операторы цикла и операторы передачи управления [5]
4. Одномерные массивы [3]
5. Многомерные массивы [3]
6. Указатели.Динамическое распределение памяти [6]
7. Отладка программы [3]
8. Функции [8]
9. Строки [5]
10. Функция Main [2]
11. Типы данных,определяемые пользователем [5]
12. Потоки ввода/вывода [7]
13. Основы объектно-ориентированного программирования [5]
Приложения [11]

Форма входа


Наш опрос
Оцените мой сайт
Всего ответов: 388

Пользователи

Онлайн всего: 2
Гостей: 2
Пользователей: 0

 Каталог статей 
Главная » Статьи » Лекции по C++ » 13. Основы объектно-ориентированного программирования

PDA-версия страницы

4. Статические функции и элементы данных

Статические функции и элементы данных

До настоящего момента каждый создаваемый вами объект имел свой собственный набор элементов данных. В зависимости от назначения вашего приложения могут быть ситуации, когда объекты одного и того же класса должны совместно использовать один или несколько элементов данных. Например, предположим, что вы пишете программу платежей, которая отслеживает рабочее время для 1000 служащих. Для определения налоговой ставки программа должна знать условия, в которых работает каждый служащий. Пусть для этого используется переменная класса state_of_work. Однако, если все служащие работают в одинаковых условиях, ваша программа могла бы совместно использовать этот элемент данных для всех объектов типа employee. Таким образом, ваша программа уменьшает необходимое количество памяти, выбрасывая 999 копий одинаковой информации. Для совместного использования элемента класса вы должны объявить этот элемент как static (статический).
• C++ позволяет иметь объекты одного и того же типа, которые совместно используют один или несколько элементов данных класса.
• Если ваша программа присваивает значение совместно используемому элементу данных, то все объекты этого класса сразу же получают доступ к этому новому значению.
• Для создания совместно используемого элемента данных класса вы должны предварять имя элемента ключевым словом static.
• После того как программа объявила элемент класса как static, она должна объявить глобальную переменную (вне определения класса), которая соответствует этому совместно используемому элементу класса.
• Ваши программы могут использовать ключевое слово static, чтобы сделать метод класса вызываемым в то время, как программа, возможно, еще не объявила каких-либо объектов данного класса.

Cовместное использование элемента данных

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

public :
static int shared_value;

или

private :
static int shared_value;
После объявления класса вы должны объявить элемент как глобальную переменную вне класса, как показано ниже:
int   class_name: :shared_value;

Рассмотрим пример:

//---------------------------------------------------------------------------
#pragma hdrstop
#include <iostream.h>
#include <conio.h>

class T
{
 public:
static int ObCount;
T(){ObCount++;}
~T(){ObCount--;}
//…….
 private:
int x;

};
int T::ObCount = 0;
#pragma argsused
int main()
{const int N=5;
T *pOb[N];
for (int i=0; i<N; i++)
pOb[i] = new T;
cout <<"\n Sozdano "<< T::ObCount<< "  object classa T";
for (int i=0; i<N-2; i++)
delete  pOb[i];
cout <<"\n Ostalos "<< T::ObCount<< "  object classa T";
getch();
return 0;
}

При выполнении программа выводит на экран:
Sozdano 5  object classa Т.
Ostalos 2  object classa T.
В этом примере статический элемент данных ObCount объявлен в разделе public, изменяется с помощью конструктора и деструктора и ведет учет созданных объектов.
Следующая программа определяет класс book_series, совместно использующий элемент page_count, который объявлен в разделе private и является одинаковым для всех объектов (книг) класса (серии). Если программа изменяет значение этого элемента в одном объекте, изменение сразу же проявляется во всех объектах класса. Доступ к элементу page_count возможен только с помощью функции-элемента void set_pages ( int ).

#include < iostrearn.h>
# include <string.h>

class book_series
{
  public:
     book_series(char *, char *, float);
     void show_book(void) ;
     void set_pages ( int ) ;
  private :
     static int page_count;
     char title [64];
     char author [64];
     float price;
};

int  book_series::page_count;
void book_series::set_pages ( int pages)
{
page_count   =  pages;
}

book_series::book_series(char *title, char "author, float price)
{
strcpy(book_series::title, title);
strcpy(book_series::author, author);
book_series::price = price;
}
void book_series::show_book(void)
{
cout « "Заголовок: " « title « endl;
cout « "Автор: " « author « endl;
cout « "Цена: " « price « endl;
cout « "Страницы: " « page_count « endl;
}
void main(void)
{
book_series programming( "Учимся программировать на C++", "Jamsa", 22.95);
book_series word( "Учимся работать с Word для Windows", "Wyatt", 19.95);
word.set_pages(256);
programming.show_book();
word.show_book();
cout « endl « "Изменение page_count " « endl;
programming.set_pages(512);
programming.show_book();
word.show_book();
}

Как видите, класс объявляет page_count как static int. Сразу же за определением класса программа объявляет элемент page_count как глобальную переменную. Когда программа изменяет элемент page_count, изменение сразу же проявляется во всех объектах класса book_series: programming и word.

Использование элементов данных с атрибутами public static, если объекты не существуют.

При объявлении элемента класса как static этот элемент совместно используется всеми объектами данного класса. Однако возможны ситуации, когда программа еще не создала объект, но ей необходимо использовать элемент. Для использования элемента ваша программа должна объявить его как public и static. Например, следующая программа использует элемент page_count из класса book_series, даже если объекты этого класса не существуют:

#include <iostream.h>
#include <string.h>
class book_series
{
 public:
    static int page_count;
 private:
    char title[64];
    char author[64];
     float price;
}
int book_series::page_count;

void main(void)
{
book_series::page_count = 256;
cout « "Текущее значение page_count равно " « book_series::page_count « endl;
}

В данном случае, поскольку класс определяет элемент класса page_count как public, программа может обратиться к этому элементу класса, даже если объекты класса book_series не существуют.
Таким образом, статические элементы данных применяются для хранения данных, общих для всех объектов класса, например, количества объектов или ссылки на разделяемый всеми объектами ресурс. Ниже перечислены особенности статических элементов данных:
•  Эти элементы данных существуют для всех объектов класса в единст-венном экземпляре, то есть не дублируются.
•  Память под статический элемент данных выделяется один раз при его инициализации независимо от числа созданных объектов (и даже при их отсутствии) и инициализируется с помощью операции доступа к области действия(определение должно быть записано вне функций):

class A
{
public:
static int count;          // Объявление в классе
………..
};

int A::count;       // Определение в глобальной области, по умолчанию инициализируется нулем
int A::count = 10;       //Пример инициализации значением 10
•  Статические элементы данных доступны как через имя класса, так и через имя объекта:
А  *а, b;

cout « A:: count;
cout « a->count;
cout « b. count;

Здесь будет выведено одно и то же
•  На статические элементы данных распространяется действие спецификаторов доступа, поэтому статические элементы данных, описанные как private, нельзя изменить с помощью операции доступа к области действия, как описано выше. Это можно сделать только с помощью функций-элементов (статических функций-элементов (см. далее) ).
•  Память, занимаемая статическим элементом данных, не учитывается при определении размера объекта с помощью операции sizeof.

Использование статических функций-элементов

Предыдущая программа иллюстрировала использование статических элементов данных. Подобным образом C++ позволяет вам определить статические функции-элементы (методы). Если вы создаете статический метод, ваша программа может вызывать такой метод, даже если объекты не были созданы. Например, если класс содержит метод, который может быть использован для данных вне класса, вы могли бы сделать этот метод статическим. Поставьте перед его прототипом ключевое слово static и объявите этот метод как public:


//………………………
public:
static void clear_screen(void);
//………………………

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

menu::clear_screen();

Ниже приведен класс menu, который использует функцию clear_screen() для очистки экрана дисплея. Поскольку этот метод объявлен как статический, программа может использовать его, даже если объекты типа menu не существуют. Следующая программа использует метод clear_screen для очистки экрана дисплея:

#include <iostream.h>
#include <conio.h>
class menu
{
 public:
static void clear_screen(void);
// Здесь могут быть другие методы
 private:
int number_of_menu_options;
};
void menu::clear_screen(void)
{
clrscr();
}
void main(void)
{
menu::clear_screen();
}

Так как программа объявляет элемент clear_screen как статический, она может использовать эту функцию для очистки экрана, даже если объекты типа menu не существуют. Функция clear_screen использует функцию clrscr() для очистки экрана.
Статические методы предназначены для обращения к статическим полям класса. Они могут обращаться непосредственно только к статическим полям и вызывать только другие статические методы класса, потому что им не передается скрытый указатель this ( см. ниже ). Обращение к статическим методам производится так же, как к статическим полям – либо через имя класса, либо, если хотя бы один объект класса уже создан, через имя объекта.

class A
{
static int count; // Поле count - скрытое
public:
static void inc_count(){ count++; }
};
A::int count;     // Определение в глобальной области статического элемента данных
……………………….
void f(){
А а;
// a.count++           выполнить нельзя, поле count скрытое
a.inc_count();       // Изменение поля с помощью статического метода:
// или
A::inc_count();

Статические методы не могут быть:
константными (const);
виртуальными (virtual).

Указатель this

Каждый объект содержит свой экземпляр полей класса. Методы класса находятся в памяти в единственном экземпляре и используются всеми объектами совместно, поэтому необходимо обеспечить работу методов с полями именно того объекта, для которого они были вызваны. Это обеспечивается передачей в функцию скрытого параметра this, в котором хранится константный указатель на вызвавший функцию объект. Указатель this неявно используется внутри метода для ссылок на элементы вызвавшего объекта. В явном виде этот указатель применяется в основном для возвращения из метода указателя (return this;) или ссылки (return *this;) на вызвавший объект. Он широко используется при перегрузке операторов.

Категория: 13. Основы объектно-ориентированного программирования | Добавил: Admin (10.09.2011)
Просмотров: 9933 | Рейтинг: 0.0/0
Всего комментариев: 0
Добавлять комментарии могут только зарегистрированные пользователи.
[ Регистрация | Вход ]

Помочь сайту!
рублей WMR
WebMoney на кошелек R407507742179

Закладки

Поиск по сайту

Друзья сайта

Ссылки

Разное
Система Orphus

Copyright H-L-L.RU © 2017
Сделать бесплатный сайт с uCoz