Джесс Либерти - Освой самостоятельно С++ за 21 день.

• Название: Освой самостоятельно С++ за 21 день.
• Автор: Джесс Либерти
• Жанр: Программирование

В книге широко представлены возможности новейшей версии программного продукта Microsoft Visual C++. Подробно описаны средства и подходы программирования современных профессиональных приложений. Материалы книги дополнены многочисленными демонстрационными программами, в процессе разработки которых максимально используются возможности программных инструментов Microsoft Visual Studio. Особое внимание уделено новинкам версии 6.0 и новейшим технологиям объектно-ориентированного программирования, включая использование библиотеки MFC и шаблонов классов, а также создание связанных списков. Отдельное занятие посвящено вопросам объектно-ориентированного анализа и проектирования приложений. Подробно рассмотрены все средства и подходы конструирования собственных пользовательских классов.

Книга рассчитана на широкий круг читателей, интересующихся современными проблемами программирования.

---

38:             break;

39:

40:          case 4:

41:             PrintVals(valOne, valTwo);

42:             Swap(valOne, valTwo);

43:             PrintVals(valOne, valTwo);

44:             break;

45:

46:          default:

47:             fOuit = true;

48:             break;

49:       }

50:

51:       if (fQuit)

52:          break;

53:    }

54:    return 0;

55: }

56:

57: void PrintVals(int x, int y)

58: {

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

60: }

61:

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

63: {

64:    rX *= rX;

65:    rY *= rY;

66: }

67:

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

69: {

70:    int tmp;

71:

72:    tmp = rX;

73:    rX *= rX;

74:    rX = rX * tmp;

75:

76:    tmp = rY;

77:    rY *= rY;

78:    rY = rY * tmp;

79: }

80:

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

82: {

83:    int temp;

84:    temp = rX;

85:    rX = rY;

86:    rY = temp;

87: }

88:

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

90: {

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

92:    cin >> rValOne;

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

94:    cin >> rValTwo;

95: }

Результат:

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

х. 1 у. 2

New value for ValOne: 2

New value for ValTwo: 3

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

x: 2 y: 3

x: 8 y: 27

(0)Quit (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

Анализ: Функции работают так же, как и в листинге 14.5. Информация, выводимая программой на экран, также не изменилась. Но размер программы увеличился с 22 до 46 строк. Причина в том, что вызов функции PrintVals() приходится повторять для каждого блока с оператором case.

Заманчивым может показаться вариант размещения функции PrintVals() вверху и внизу цикла while, а не в каждом блоке с оператором case. Но тогда функция PrintVals() будет вызываться даже в случае выхода из цикла, чего быть не должно.

Упрощенный вариант вызова функции

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

pFunc(x);

или

(*pFunc) (x);

Оба выражения приведут к одному и тому же результату. Хотя первое выражение ко- роче, второе придает программе больше гибкости.

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

Массивы указателей на функции

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

Листинг 14.7. Использование массива указателей на функции

1: // Листинг 14.7. Пример использования массива указателей на функции

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:    int valOne=1, valTwo=2;

14:    int choice, i;

15:    const MaxArray = 5;

16:    void (*pFuncArray[MaxArray])(int&, int&);

17:

18:    for (i=0;i<MaxArray;i++)

19:    {

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

21:       cin >> choice;

22:       switch (choice)

23:       {

24:          case 1:pFuncArray[i] = GetVals; break;

25:          case 2:pFuncArray[i] = Square; break;

26:          case 3:pFuncArray[i] = Cube; break;

27:          case 4:pFuncArray[i] = Swap; break;

28:          default:pFuncArray[i] = 0;

29:       }

30:    }

31:

32:    for (i=0;i<MaxArray; i++)

33:    {

34:       if ( pFuncArray[i] == 0 )

35:          continue;

36:       pFuncArray[i](valOne,valTwo);

37:       PrintVals(valOne,valTwo);

38:    }

39:    return 0;

40: }

41:

42: void PrintVals(int x, int у)

43: {

44:    cout << "x: " << x << " у: " << у << endl;

45: }

46:

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

48: {

49:    rX *= rX;

50:    rY *= rY;

51: }

52:

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

54: {

55:    int tmp;

56:

57:    tmp = rX;

58:    rX *= rX;

59:    rX = rX * tmp;

60:

61:    tmp = rY;

62:    rY *= rY;

63:    rY = rY * tmp;

64: }

65:

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

67: {

68:    int temp;

69:    temp = rX;

70:    rX = rY;

71:    rY = temp;

72: }

73:

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

75: {

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

77:    cin >> rValOne;

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

79:    cin >> rValTwo;

80: }

Результат:

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

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

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

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

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

New Value for ValOne: 2

New Value for ValTwo: 3

x: 2 y: 3

x: 4 y: 9

x: 64 y: 729

x: 729 y: 64

x: 531441 y:4096

Анализ: Как и в предыдущем листинге, для экономии места не были показаны выполнения объявленных функций, поскольку сами функции остались теми же, что и в листинге 14.5. В строке 16 объявляется массив pFuncArray, содержащий пять указателей на функции, которые возвращают void и принимают две ссылки на значения типа int.

В строках 18-30 пользователю предлагается установить последовательность вызова функций. Каждый член массива связывается с соответствующей функцией. Последовательный вызов функции осуществляется в строках 32-38, причем после каждого вызова на экран сразу выводится результат.

Передача указателей на функции в другие функции

Указатели на функции (или массивы указателей) могут передаваться в другие функции для вызова в них с помощью указателя нужной функции.

Листинг 14.5 можно усовершенствовать, передав указатель на выбранную функцию другой функции (кроме main()), которая выведет исходные значения на печать, вызовет функцию и вновь напечатает измененные значения. Именно такой подход применен в листинге 14.8.

Листинг 14.8. Передана указателя на функцию другой функции

1: // Листинг 14.8. Передача указателя на функцию другой функции

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(void (*)(int&, int&),int&, int&);

10:

11: int main()

12: {

13:    int val0ne=1, valTwo=2;

14:    int choice;

15:    bool fQuit = false;

16:

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

18:

19:    while (fQuit == false)

20:    {

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

22:       cin >> choice;

23:       switch (choice)

24:       {

25:          case 1:pFunc = GetVals; break;

26:          case 2:pFunc = Square; break;

27:          case 3:pFunc = Cube; break;

28:          case 4:pFunc = Swap; break;

29:          default:fQuit = true; break;

30:       }

31:       if (fQuit == true)

32:       break;

33:       PrintVals ( pFunc, valOne, valTwo);

34:    }

35:

36:    return 0;

37: }

38:

39: void PrintVals( void (*pFunc)(int&, int&),int& x, int& у)

40: {

41:    cout << "x: " << x << " у: " << у << endl;

42:    pFunc(x,у);

43:    cout << "x: " << x << " у: " << у << 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)Quit (1)Change Values (2)Square (3)Cube (4)Swap: 1

x: 1 у: 2

New value for Val0ne: 2

New value for ValTwo: 3

x: 2 у: 3

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