Оладка программы с помощью assert()

⇐ ПредыдущаяСтр 80 из 85Следующая ⇒

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

При этом от частого использования макроса assert() вы не несете никаких убытков, поскольку он автоматически удаляется из программы, если не будет определена лексема DEBUG. Более того, присутствие макроса assert() также обеспечивает хорошее внутреннее документирование программы, поскольку наделяет в коде важные моменты, на которые следует обратить внимание в случае модернизации программы.

Макрос assert() вместо исключений

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

Важно понимать, что при передаче программы заказчикам макросы assert() в коде будут удалены. Поэтому если с ошибками выполнения программы удавалось справляться только благодаря макросу assert(), то у заказчика эта программа просто не будет работать.

Распространенной ошибкой является использование макроса assert() для тестирования возвращаемого значения при выполнении операции выделения памяти:

Animal *pCat = new Cat:

Assert(pCat); // неправильное использование макроса pCat-> SomeFunction();

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

new терпит крах и программа возвращает NULL (пустой указатель). Однако макроса assert() больше нет в коде, и некому сообщить пользователю о том, что указатель ссылается на NULL. Поэтому, как только дойдет очередь до выражения pCat-> SomeFunction(), программа дает сбой.

Возвращение значения NULL при выделения памяти — это не ошибка программирования, а исключительная ситуация. Чтобы программа смогла с честью выйти из этой ситуации, необходимо использовать исключение. Помните, что макрос assert() полностью удаляется из программы, если лексема DEBUG не определена. (Исключения были подробно описаны на занятии 20.)

Побочные эффекты

Нередко случается так, что ошибка проявляется только после удаления экземпляров макроса assert(). Почти всегда это происходит из-за того, что программа попадает в зависимость от побочных эффектов, вызванных выполнением макроса assert() или другими частями кода, используемыми только для отладки. Например, если записать

ASSERT (x = 5)

при том, что имелась в виду проверка x == 5, вы тем самым создадите чрезвычайно противную ошибку.

Предположим, что как раз до выполнения макроса assert() вызывалась функция, которая установила переменную x равной 0. Используя данный макрос, вы полагали, что выполняете проверку равенства переменной x значению 5. На самом же деле вы устанавливаете значение x равным 5. Тем не менее эта ложная проверка возвращает значение TRUE, поскольку выражение x = 5 не только устанавливает переменную x равной 5, но одновременно и возвращает значение 5, а так как 5 не равно нулю, то это значение расценивается как истинное.

Во время отладки программы макрос assert() не выполняет проверку равенства переменной x значению 5, а присваивает ей это значение, поэтому программа работает прекрасно. Вы готовы передать ее заказчику и отключаете отладку. Теперь макрос assert() удаляется из кода и переменная x не устанавливается равной 5. Но поскольку в результате ошибки в функции переменная x устанавливается равной 0, программа дает сбой.

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

Инварианты класса

Для многих классов существует ряд условий, которые всегда должны выполняться при завершении работы с функцией-членом класса. Эти обязательные условия выполнения класса называются инвариантами класса. Например, обязательными могут быть следующие условия: объект CIRCLE никогда не должен иметь нулевой радиус или объект ANIMAL всегда должен иметь возраст больше нуля и меньше 100.

Может быть весьма полезным объявление метода Invariants(), который возвращает значение TRUE только в том случае, если каждое из этих условий является истинным. Затем можно вставить макрос ASSERT(Invariants()) в начале и в конце каждого метода класса. В качестве исключения следует помнить, что метод Invariants() не возвращает TRUE до вызова конструктора и после выполнения деструктора. Использование метода Invariants() для обычного класса показано в листинге 21.5.

Листинг 21.5. Использование метода lnvariаnts ()

1: #define DEBUG

2: #define SHOW_INVARIANTS

3: #include < iostream.h>

4: #include < string.h>

6: #ifndef DEBUG

7: #define ASSERT(x)

8: #else

9: #define ASSERT(x)

10: if (! (x))

11: {

12: cout < < " ERROR!! Assert " < < #x < < " failed\n";

13: cout < < " on line " < < __LINE__ < < " \n";

14: cout < < " in file " < < FILE < < " \n";

15: }

16: #endif

17:

18:

19: const int FALSE = 0;

20: const int TRUE = 1;

21: typedef int bool;

22:

23:

24: class String

25: {

26: public:

27: // конструкторы

28: String();

29: String(const char *const);

30: String(const String & );

31: ~String();

32:

33: char & operator[](int offset);

34: char operator[](int offset) const;

35:

36: String & operator= (const String & );

37: int GetLen()const { return itsLen; }

38: const char * GetString() const { return itsString; }

39: bool Invariants() const;

40:

41: private:

42: String (int); // закрытый конструктор

43: char * itsString;

44: // беззнаковая целочисленная переменная itsLen;

45: int itsLen

46: };

47:

48: // стандартный конструктор создает строку нулевой длины

49: String:: String()

50: {

51: itsString = new char[1];

52: itsString[0] = '\0';

53: itsLen=0;

54: ASSERT(Invariants());

55: }

56:

57: // закрытый (вспомогательный) конструктор, используется

58: // методами класса только для создания новой строки

59: // требуемого размера, При этом вставляется концевой нулевой символ.\

60: String:: String(int len)

61: {

62: itsString = new char[len+1];

63: for (int i = 0; i< =len; i++)

64: itsString[i] = '\0';

65: itsLen=len;

66: ASSERT(Invariants());

67: }

68:

69: // Преобразует массив символов к типу String

70: String:: String(const char * const cString)

71: {

72: itsLen = strlen(cString);

73: itsString = new char[itsLen+1];

74: for (int i = 0; i< itsLen; i++)

75: itsString[i] = cString[i];

76: itsString[itsLen] ='\0';

77: ASSERT(Invariants());

78: }

79:

80: // конструктор-копировщик

81: String:: String (const String & rhs)

82: {

83: itsLen=rhs.GetLen();

84: itsString = new char[itsLen+1];

85: for (int i = 0; i< itsLen; i++)

86: itsString[i] = rhs[i];

87: itsString[itsLen] = '\0';

88: ASSERT(Invariants());

89: }

90:

91: // деструктор, освобождает выделенную память

92: String:: ~String ()

93: {

94: ASSERT(Invariants());

95: delete [] itsString;

96: itsLen = 0;

97: }

96:

99: // оператор выполняет сравнение, освобождает занятую

100: // память, а затем копирует строку и ее размер

101: String& String:: operator=(const String & rhs)

102: {

103: ASSERT(Invariants());

104: if (this == & rhs)

105: return *this;

106: delete [] itsString;

107: itsLen=rhs, GetLen();

108: itsString = new char[itsLen+1];

109: for (int i = 0; i< itsLen; i++)

110: itsString[i] = rhs[i];

111: itsString[itsLen] = '\0';

112: ASSERT(Invariants());

113: return *this;

114: }

115:

116: // неконстантный оператор индексирования

117: char & String:: operator[](int offset)

118: {

119: ASSERT(Invariants());

120: if (offset > itsLen)

121: {

122: ASSERT(Invariants());

123: return itsString[itsLen-1];

124: }

125: else

126: {

127: ASSERT(Invariants());

128: return itsString[offset];

129: }

130: }

131: // константный оператор индексирования

132: char String:: operator[](int offset) const

133: {

134: ASSERT(Invariants());

135: char retVal;

136: if (offset > itsLen)

137: retVal = itsString[itsLen-1];

138: else

139: retVal = itsString[offset];

140: ASSERT(Invariants());

141: return retVal;

142: }

143: bool String:: Invariants() const

144: {

145: #ifdef SHOW_INVARIANTS

146: cout < < " Invariants Tested";

147: #endif

148: return ( (itsLen & & itsString) ||

149: (! itsLen & & ! itsString) );

150: }

151: class Animal

152: {

153: public:

154: Animal(): itsAge(1), itsName(" John Q. Animal" )

155: { ASSERT(Invariants()); }

156: Animal(int, const String& );

157: ~Animal(){ }

158: int GetAge() { ASSERT(Invariants()); return itsAge; }

159: void SetAge(int Age)

160: {

161: ASSERT(Invariants());

162: itsAge = Age;

163: ASSERT(Invariants());

164: }

165: String& GetName()

166: {

167: ASSERT(Invariants());

168: return itsName;

169: }

170: void SetName(const String& name)

171: {

172: ASSERT(Invariants());

173: itsName = name;

174: ASSERT(Invariants());

175: }

176: bool Invariants();

177: private:

178: int itsAge;

179: String itsName;

180: };

181:

182: Animal:: Animal(int age, const String& name):

183: itsAge(age),

184: itsName(name)

185: {

186: ASSERT(Invariants());

187: }

188:

189: bool Animal:: Invariants()

190: {

191: #ifdef SHOW_INVARIANTS

192: cout < < " Invariants Tested";

193: #endif

194: return (itsAge > 0 & & itsName.GetLen());

195: }

196:

197: int main()

198: {

199: Animal sparky(5, " Sparky" );

200: cout < < " \n" < < sparky.GetName().GetString() < < " is ";

201: cout < < sparky.GetAge() < < " years old. ";

202: sparky.SetAge(8):

203: cout < < " \n" < < sparky.GetName(). GetString() < < " is ";

204: cout < < sparky.GetAge() < < " years old. ";

205: return 0;

206: }

Результат:

String OK String OK String OK String OK String OK String OK String OK

String OK String OK Animal OK String OK Animal OK

Sparky is Animal OK 5 years old. Animal OK Animal OK

Animal OK Sparky is Animal OK 8 years old. String OK

Анализ: В строках 9—15 определяется макрос assert(). Если лексема DEBUG определена и макрос assert() возвратит в результате операции сравнения значение FALSE, будет выведено сообщение об ошибке.

В строке 39 объявляется функция-член Invariants() класса String, а ее определение занимает строки 143—150. Конструктор объявляется в строках 49—55, а в строке 54, после того как объект полностью построен, вызывается функция-член Invariants(), чтобы подтвердить правомочность этой конструкции.

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

В строке 176 класс Animal объявляет собственный метод Invariants(), выполняемый в строках 189—195. Обратите внимание на строки 155, 158, 161 и 163: подставляемые функции также могут вызывать метод Invariants().

⇐ Предыдущая 75 76 77 78 798081 82 83 84 Следующая ⇒