День 14-й. Специальные классы и функции

 

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

• Что такое статические переменные-члены и функции-члены

• Как используются статические переменные-члены и функции-члены

• Как создавать и применять указатели на функции и на функции-члены

• Как работать с массивами указателей на функции

Статические переменные-члены

 

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

Однако иногда возникает необходимость контроля за накоплением данных программой. Может потребоваться информация о том, сколько всего было создано объектов определенного класса и сколько их существует в данный момент. Статические переменные-члены совместно используются всеми объектами класса. Они являются чем вроде "золотой серединки" между глобальными данными, доступными всем частям программы, и данными членов, доступными, как правило, только одному объекту.

Можно полагать, что статические члены принадлежат классу, а не объекту. Если данные обычных членов доступны одному объекту, то статические члены могут использоваться всем классом. В листинге 14.1 объявляется объект Cat со статическим членом HowManyCats. Эта переменная учитывает количество созданных объектов Cat, что реализуется приращением статической переменной HowManyCats при вызове конструктора или отрицательным приращением при вызове деструктора.

Листинг 14.1. Статические переменные-члены

1: //Листинг 14.1. Статические переменные-члены

2:

3: #include <iostream.h>

4:

5: class Cat

6: {

7: public:

8: Cat(int age):itsAge(age){ HowManyCats++; }

9: virtual ~Cat() { HowManyCats--; }

10: virtual int 6etAge() { return itsAge; }

11: virtual void SetAge(int age) { itsAge = age; }

12: static int HowManyCats;

13:

14: private:

15: int itsAge;

16:

17: };

18:

19: int Cat::HowManyCats = 0;

20:

21: int main()

22: {

23: const int MaxCats = 5;

24: int i; Cat *CatHouse[MaxCats];

25: for (i = 0; i<MaxCats; i++)

26: CatHouse[i] = new Cat(i);

27:

28: for (i = 0; i<MaxCats; i++)

29: {

30: cout << "There are ";

31: cout << Cat::HowManyCats;

32: cout << " cats left!\n";

33: cout << "Deleting the one which is ";

34: cout << CatHouse[i]->GetAge();

35: cout << " yea.rs old\n";

36: delete CatHouse[i];

37: CatHouse[i] = 0;

38: }

39: return 0;

40: }

 

Результат:

There are 5 cats left!

Deleting the one which is 0 years old

There are 4 cats left!

Deleting the one which is 1 years old

There are 3 cats left!

Deleting the one which is 2 years old

There are 2 cats left!

Deleting the one which is 3 years old

There are 1 cats left!

Deleting the one which is 4 years old

 

Анализ: Обычный класс Cat объявляется в строках 5—17. С помощью ключевого слова static в строке 12 объявляется статическая переменная-член

HowManyCats типа int.

Объявление статической переменной HowManyCats само по себе не определяет никакого целочисленного значения, т.е. в памяти компьютера не резервируется область для данной переменной при ее объявлении, поскольку, по сути, она не является переменной-членом конкретного объекта Cat. Определение и инициализация переменной HowManyCats происходит в строке 19.

Не забывайте отдельно определять статическую переменную-член класса (весьма распространенная ошибка среди начинающих программистов). В противном случае редактор связей во время компиляции программы выдаст следующее сообщение об ошибке:

undefined symbol Cat::HowManyCats

Обратите внимание, что для обычной переменной-члена itsAge не требуется отдельное определение, поскольку обычные переменные-члены определяются автоматически каждый раз при создании объекта Cat, как, например, в строке 26.

Конструктор объекта Cat, объявленный в строке 8, увеличивает значение статической переменной-члена на единицу. Деструктор, объявленный в строке 9, уменьшает это значение на 1. Таким образом, в любой момент времени переменная HowManyCats отражает текущее количество созданных объектов класса Cat.

В строках программы 21—40 создается пять объектов Cat, указатели на которые заносятся в массив. Это сопровождается пятью вызовами конструктора класса Cat, в результате чего пять раз происходит приращение на единицу переменной HowManyCats, начиная с исходного значения 0.

Затем в программе цикл for последовательно удаляет все объекты Cat из массива, предварительно выводя на экран текущее значение переменной HowManyCats. Вывод начинается со значения 5 (ведь было создано пять объектов) и с каждым циклом уменьшается.

Обратите внимание: переменная HowManyCats объявлена как public и может вызываться из функции main(). Однако нет веских причин объявлять эту переменную-член таким образом. Если предполагается обращаться к статической переменной только через объекты класса Cat, предпочтительней сделать ее закрытой вместе с другими переменными-членами и создать открытый метод доступа. С другой стороны, если необходимо получать прямой доступ к данным без использования объекта Cat, то можно либо оставить ее открытой, как показано в листинге 14.2, либо создать статическую функцию-член. Реализация последнего варианта рассматривается далее в этой главе.

Листинг 14.2. Доступ к статическим членам без использования объектов

1: // Листинг 14.2. Статические переменные-члены

2:

3: #include <iostream.h>

4:

5: class Cat

6: {

7: public:

8: Cat(int age):itsAge(age) { HowManyCats++; }

9: virtual ~Cat() { HowManyCats--; }

10: virtual int GetAge() { return itsAge; }

11: virtual void SetAge(int age) {itsAge = age;}

12: static int HowManyCats;

13:

14: private:

15: int itsAge;

16:

17: };

18:

19: int Cat::HowManyCats = 0;

20:

21: voidTelepathicFunction();

22:

23: int main()

24: {

25: const int MaxCats = 5; int i;

26: Cat *CatHouse[MaxCats];

27: for (i = 0; i<MaxCats; i++)

28: {

29: CatHouse[i] = new Cat(i);

30: TelepathicFunction();

31: }

32:

33: for (i = 0; i<MaxCats; i++)

34: {

35: delete CatHouse[i];

36: TelepathicFunction();

37: }

38: return 0;

39: }

40:

41: void TelepathicFunction()

42: {

43: cout << "There are ";

44: cout << Cat::HowManyCats << " cats alive!\n";

45: }

 

Результат:

There are 1 cats alive!

There are 2 cats alive!

There are 3 cats alive!

There are 4 cats alive!

There are 5 cats alive!

There are 4 cats alive!

There are 3 cats alive!

There are 2 cats alive!

There are 1 cats alive!

There are 0 cats alive!

 

Анализ: Листинг 14.2 аналогичен листингу 14.1, однако включает новую функцию TelepahicFunction().Она не создает объект СаГ и даже не использует тегов качестве параметра, однако может получить доступ к переменной-члену HowManyCats. Не лишним будет еще раз напомнить, что эта переменная-член относится не к какому-либо определенному объекту, а ко всему классу в целом. Поэтому если она объявлена как public, то может использоваться любой функцией программы.

Если статическая переменная-член будет объявлена как закрытая, то доступ к ней можно получить с помощью функции-члена. Но для этого необходимо наличие хотя бы одного объекта данного класса. Именно такой подход реализован в листинге 14.3. Затем мы перейдем к изучению статических функций-членов.

Листинг 14.3. Доступ к статическим членам с помощью обычных функций-членов

1: //Листинг 14.3. Закрытые статические переменные-члены

2:

3: #include <iostream.h>

4:

5: class Cat

6: {

7: public:

8: Cat(int age):itsAge(age){ HowManyCats++; }

9: virtual ~Cat() { HowManyCats--; }

10: virtual int GetAge() { return itsAge; }

11: virtual void SetAge(int age) { itsAge = age; }

12: virtual int GetHowMany() { return HowManyCats; }

13:

14:

15: private:

16: int itsAge;

17: static int HowManyCats;

18: };

19:

20: int Cat::HowManyCats = 0;

21:

22: int main()

23: {

24: const int MaxCats = 5; int i;

25: Cat *CatHouse[MaxCats];

26: for (i = 0; i<MaxCats; i++)

27: CatHouse[i] = new Cat(i);

28:

29: for (i = 0; i<MaxCats; i++)

30: {

31: cout << "There are ";

32: cout << CatHouse[i]->GetHowMany();

33: cout << " cats left!\n";

34: cout << "Deleting the one which is ";

35: cout << CatHouse[i]->GetAge()+2;

36: cout << " years old\n";

37: delete CatHouse[i];

38: CatHouse[i] = 0;

39: }

40: return 0;

41: }

 

Результат:

There are 5 cats left!

Deleting the one which is 2 years old

There are 4 cats left!

Deleting the one which is 3 years old

There are 3 cats left!

Deleting the one which is 4 years old

There are 2 cats left!

Deleting the one which is 5 years old

There are 1 cats left!

Deleting the one which is 6 years old

 

Анализ: В строке 17 статическая переменная-член HowManyCats объявлена как private. Поэтому теперь доступ к ней закрыт для функций, не являющихся членами класса, например для функции TelepathicFunction из предыдущего листинга.

Хотя переменная HowManyCats является статической, она все же находится в области видимости класса. Поэтому любая функция класса, например GetHoqMany(), может получить доступ к ней так же, как к любой обычной переменной-члену. Однако для вызова GetHowMany() функция должна иметь объект, через который осуществляется вызов.

 

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

 

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

 

Статические функции-члены

 

Статические функции-члены подобны статическим переменным-членам: они не принадлежат одному объекту, а находятся в области видимости всего класса. Именно поэтому их можно вызывать даже в тех случаях, когда не было создано ни одного объекта класса, как показано в листинге 14.4.

Листинг 14.4. Статические функции-члены

1: // Листинг 14.4. Статические функции-члены

2:

3: #include <iostream.h>

4:

5: class Cat

6: {

7: public:

8: Cat(int age):itsAge(age){ HowManyCats++; }

9: virtual ~Cat() { HowManyCats--; }

10: virtual int GetAge() { return itsAge; }

11: virtual void SetAge(int age) { itsAge = age; }

12: static int GetHowMany() { return HowManyCats; }

13: private:

14: int itsAge;

15: static int HowManyCats;

16: };

17:

18: int Cat::HowManyCats = 0;

19:

20: void TelepathicFunction();

21:

22: int main()

23: {

24: const int MaxCats = 5;

25: Cat *CatHouse[MaxCats]; int i;

26: for (i = 0; i<MaxCats; i++)

27: {

28: CatHouse[i] = new Cat(i);

29: TelepathicFunction();

30: }

31:

32: for (i = 0; i<MaxCats; i++),

33: {

34: delete CatHouse[i];

35: TelepathicFunction();

36: }

37: return 0;

38: }

39:

40: void TelepathicFunction()

41: {

42: cout << "There are " << Cat::GetHowMany() << " cats alive!\n";

43: }

 

Результат:

There are 1 cats alive!

There are 2 cats alive!

There are 3 cats alive!

There are 4 cats alive!

There are 5 cats alive!

There are 4 cats alive!

There are 3 cats alive!

There are 2 cats alive!

There are 1 cats alive!

There are 0 cats alive!

 

Анализ: В строке 15 в объявлении класса Cat создается закрытая статическая переменная-член HowManyCats. В строке 12 объявляется открытая статическая функция-член GetHowMany().

Так как функция GetHowMany() открыта, доступ к ней может получить любая другая функция, а при объявлении ее статической отпадает необходимость в существовании объекта типа Cat. Именно поэтому функция TelepathicFunction() в строке 42 может получить доступ к GetHowMany(), не имея доступа к объекту Cat. Конечно же, к функции GetHowMany() можно было обратиться из блока main() так же, как к обычным методам объектов Cat.

 

Примечание: Статические функции-члены не содержат указателя this. Поэтому они не могут объявляться со спецификатором const. Кроме того, поскольку функции-члены получают доступ к переменным-членам с помощью указателя this, статические функции-члены не могут использовать обычные нестатические переменные-члены!

 

Статические функции-члены

Доступ к статическим функциям-членам можно получить, либо вызывая их из объектов класса как обычные функции-члены, либо вызывая их без объектов, явно указав в этом случае имя класса. Пример:

class Cat

{

public:

static int GetHowMany() { return HowManyCats; }

private:

static int HowManyCats;

}

int Cat::HowManyCats = 0;

int main()

{

int howMany;

Cat theCat; // определение обьекта

howMany = theCat.GetHowMany(); // доступ через объект

howMany = Cat::GetHowMany(); // доступ без объекта

}

 

Указатели на функции

 

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

Единственная важная деталь для определения указателя на функцию — знание типа объекта, на который ссылается указатель. Указатель типа int обязательно связан с целочисленной переменной. Аналогичным образом указатель на функцию может вызывать только функции с заданными сигнатурой и типом возврата.

В объявлении

long (*funoPtr) (int);

создается указатель на функцию funcPtr (обратите внимание на символ * перед именем указателя), которая принимает целочисленный параметр и возвращает значение типа long. Круглые скобки вокруг (*funcPtr) обязательны, поскольку скобки вокруг (int) имеют больший приоритет по сравнению с оператором косвенного обращения (*). Если убрать первые скобки, то это выражение будет объявлять функцию funcPtr, принимающую целочисленный параметр и возвращающую указатель на значение типа long. (Вспомните, что все пробелы в C++ игнорируются,) Рассмотрим два следующих объявления:

long * Function (int); long (*funcPtr) (int);

В первой строке Function() — это функция, принимающая целочисленный параметр и возвращающая указатель на переменную типа long. Во втором примере funcPtr — это указатель на функцию, принимающую целочисленный параметр и возвращающую переменную типа long.

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

Листинг 14.5. Указатели на функцию

1: // Листинг 14.5. Использование указателей на функции

2:

3: #include <iostream.h>

4:

5: void Square (int&,int&);

6: void Cube (int&, int&);

7: void Swap (int&, int &);

8: void GetVals(int&, int&);

9: void PrintVals(int, int);

10:

11: int main()

12: {

13: void (* pFunc) (int &, int &);

14: bool fQuit = false;

15:

16: int val0ne=1, valTwo=2;

17: int choice;

18: while (fQuit == false)

19: {

20: cout << "(0)Quit (1)Change Values (2)Square (3)Cube (4)Swap";

21: cin >> choice;

22: switch (choice)

23: {

24: case 1: pFunc = GetVals; break;

25: case 2: pFunc = Square; break;

26: case 3: pFunc = Cube; break;

27: case 4: pFunc = Swap; break;

28: default: fQuit = true; break;

29: }

30:

31: if (fQuit)

32: break;

33:

34: PrintVals(valOne, valTwo);

35: pFunc(valOne, valTwo);

36: PrintVals(valOne, valTwo);

37: }

38: return 0;

39: }

40:

41: void PrintVals(int x, int y)

42: {

43: cout << "x: " << x << " y: " << y << endl;

44: }

45:

46: void Square (int & rX, int & rY)

47: {

48: rX *= rX;

49: rY *= rY;

50: }

51:

52: void Cube (int & rX, int & rY)

53: {

54: int tmp;

55:

56: tmp = rX;

57: rX *= rX;

58: rX = rX * tmp;

59:

60: tmp = rY;

61: rY *= rY;

62: rY = rY * tmp;

63: }

64:

65: void Swap(int & rX, int & rY)

66: {

67: int temp;

68: temp = rX;

69: rX = rY;

70: rY = temp;

71: }

72:

73: void GetVals (int & rValOne, int & rValTwo)

74: {

75: cout << "New value for ValOne: ";

76: cin >> rValOne;

77: cout << "New value for ValTwo: ";

78: cin >> rValTwo;

79: }

 

Результат:

(0)0uit (1)Change Values (2)Square (3)Cube (4)Swap: 1

x: 1 у: 2

New value for ValOne: 2

New value for ValTwo: 3

x: 2 y: 3

(0)Quit (1)Change Values (2)Square (3)Cube (4)Swap: 3

x: 2 y: 3

x: 8 y: 27

(0)Qult (1)Change Values (2)Square (3)Cube (4)Swap: 2

x: 8 y: 27

x: 64 y: 729

(0)Quit (1)Change Values (2)Square (3)Cube (4)Swap: 4

x: 64 y: 729

x: 729 y: 64

(0)Quit (1)Change Values (2)Square (3)Cube (4)Swap: 0

 

Анализ: В строках 5—8 объявляются четыре функции с одинаковыми типами возврата и сигнатурами. Все эти функции возвращают void и принимают ссылки на значения типа int.

В строке 13 переменная pFunc объявлена как указатель на функцию, принимающую две ссылки на int и возвращающую void. Этот указатель может ссылаться на каждую из упоминавшихся ранее функций. Пользователю предлагается выбрать функцию, после чего она связывается с указателем pFunc. В строках 34—36 выводятся текущие значения двух целочисленных переменных, вызывается текущая функция и выводятся результаты вычислений.

 

Указатели на функции

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

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

long(*pFuncOne) (int,int);

long SomeFunction (int,int);

pFuncOne = SomeFunction;

pFuncOne (5,7);