Печать промежуточных значений

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

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

Листинг 21.6. Вывод значений в режиме отладки

1: // Листинг 21.6. Вывод значений в режиме отладки

2: #include < iostream.h>

3: #define DEBUG

5: #ifndef DEBUG

6: #define PRINT(x)

7: #else

8: #define PRINT(x) \

9: cout < < #x < < ": \t" < < x < < endl;

10: #endif

11:

12: enum bool { FALSE, TRUE }; 13:

14: int main()

15: {

16: int x = 5;

17: long у = 738981;

18: PRINT(x);

19: for (int i = 0; i < x; i++)

20: {

21: PRINT(i);

22: }

23:

24: PRINT (у);

25: PRINT(" Hi, " );

26: int *px = & x;

27: PRINT(px);

28: PRINT (*px);

29: return 0;

30: }

Результат:

x: 5

i: 0

i: 1

i: 2

i: 3

i: 4

у: 73898

" Hi.": Hi.

px: 0x2100

*px: 5

Анализ: Макрос PRINT(x) (строки 5—10) реализует вывод текущего значения переданного параметра. Обратите внимание, что сначала объекту cout передается сам параметр, взятый в кавычки, т.е., если вы передадите параметр x, объект cout примет " x".

Затем объект cout принимает заключенную в кавычки строку ": \t", которая обеспечивает печать двоеточия и табуляции. После этого объект cout принимает значение параметра (x), а объект endl выполняет переход на новую строку и очищает буфер.

Обратите внимание, что у вас вместо значения 0x2100 может быть выведено другое число.

Уровни отладки

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

Чтобы определить уровень отладки, достаточно после выражения #define DEBUG указать номер. Хотя число уровней может быть любым, обычная система должна иметь четыре уровня: HIGH (высокий), MEDIUM (средний), LOW (низкий) и NONE (никакой). В листинге 21.7 показано, как это можно сделать, на примере классов String и Animal из листинга 21.5.

Листинг 21.7. Уровни отладки

1: enum LEVEL { NONE, LOW, MEDIUM, HIGH };

2: const int FALSE = 0;

3: const int TRUE = 1;

4: typedef int bool;

6: #define DEBUGLEVEL HIGH

8: #include < iostream.h>

9: #include < string.h>

10:

11: #if DEBUGLEVEL < LOW // должен быть средний или высокий

12: #define ASSERT(x)

13: #else

14: #define ASSERT(x)

15: if (! (x))

16: {

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

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

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

20: }

21: #endif

22:

23: #if DEBUGLEVEL < MEDIUM

24: #define EVAL(x)

25: #else

26: #define EVAL(x)

27: cout < < #x < < ": \t" < < x < < andl;

28: #endif

29:

30: #if DEBUGLEVEL < HIGH

31: #define PRINT(x)

32: #else

33: #define PRINT(x)

34: cout < < x < < endl;

35: #endif

36:

37:

38: class String

39: {

40: public:

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

42: String();

43: String(const char *const);

44: String(const String & );

45: ~String();

46:

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

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

49:

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

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

52: const char > > GetString() const

53: { return itsString; }

54: bool Invariants() const;

55:

56: private:

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

58: char * itsString;

59: unsigned short itsLen;

60: };

61:

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

63: String:: String()

64: {

65: itsString = new char[1];

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

67: itsLen=0;

68: ASSERT(Invariants());

69: }

70:

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

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

73: // требуемого размера. Заполняется символом Null.

74: String:: String(int len)

75: {

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

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

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

79: itsLen=len;

80: ASSERT(Invariants());

81: }

82:

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

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

85: {

86: itsLen = strlen(cString);

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

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

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

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

91: ASSERT(Invariants());

92: }

93:

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

95: String:: String (const String & rhs)

96: {

97: itsLen=rhs.GetLen();

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

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

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

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

102: ASSERT(Invariants());

103: }

104:

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

106: String:: ^String ()

107: {

108: ASSERT(Invariants());

109: delete [] itsString;

110: itsLen = 0;

111: }

112:

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

114: // затем копирует строку и ее размер

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

116: {

117: ASSERT(Invariants());

118: if (this == & rhs)

119: return *this;

120: delete [] itsString;

121: itsLen=rhs.GetLen();

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

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

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

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

126: ASSERT(Invariants());

127: return *this;

128: }

129:

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

131: char & String:; operator[](int offset)

132: {

133: ASSERT(Invariants());

134: if (offset > itsLen)

135: {

136: ASSERT(Invariants());

137: return itsString[itsLen-1];

138: }

139: else

140: {

141: ASSERT(Invariants());

142: return itsString[offset];

143: }

144: }

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

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

147: {

148: ASSERT(Invariants());

149: char retVal;

150: if (offset > itsLen)

151: retVal = itsString[itsLen-1];

152: else

153: retVal = itsString[offset];

154: ASSERT(Invariants());

155: return retVal;

156: }

157:

158: bool String:: Invariants() const

159: {

160: PRINT(" (String Invariants Checked)" );

161: return ( (bool) (itsLen & & itsString) ||

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

163: }

164:

165: class Animal

166: {

167: public:

168: Anxmal(): itsAge(1), itsName(" John Q, Animal" )

169: { ASSERT(Invariants()); }

170:

171: Animal(int, const String& );

172: ~Animal(){ }

173:

174: int GetAge()

175: {

176: ASSERT(Invariants());

177: return itsAga;

178: }

179:

180: void SetAge(int Age)

181: {

182: ASSERT(Invariants());

183: itsAge = Age;

184: ASSERT(Inva riants());

185: }

186: String& GetName()

187: {

188: ASSERT(Invariants());

189: return itsName;

190: }

191:

192: void SetName(const String& name)

193: {

194: ASSERT(Invariants());

195: itsName = name;

196: ASSERT(Invariants());

197: }

198:

199: bool Invariants();

200: private:

201: int itsAge;

202: String itsName;

203: }

204:

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

206: itsAge(age),

207: itsName(name)

208: {

209: ASSERT(Invariants());

210: }

211:

212: bool Animal:: Invariants()

213: {

214: PRINT(" (Animal Invariants Checked)" );

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

216: }

217:

218: int main()

219: {

220: const int AGE = 5;

221: EVAL(AGE);

222: Animal sparky(AGE, " Sparky" );

223: cout < < " \n" < < sparky.GetName().GetStrin();

224: cout < < " is ";

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

226: sparky.SetAge(8);

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

228: cout < < " is ";

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

230: return 0;

231: }

Результат:

AGE: 5

(String Invariants Checked)

Sparky is (Animal Invariants Checked)

5 years old. (Animal Invariants Checked)

(Animal Invariants Checked)

Sparky is (Animal Invariants Checked)

8 years old. (String Invariants Checked)

(String Invariants Checked)

// run again with DEBUG = MEDIUM

AGE: 5

Sparky is 5 years old.

Sparky is 8 years old.

Анализ: В строках 11—21 макрос assert() определяется таким образом, чтобы вообще не создавался никакой код, если уровень отладки DEBUGLEVEL меньше, чем LOW (т.е. DEBUGLEVEL установлен равным значению NONE). Если же отладка разрешена, то и макрос assert() будет работать (строки 14—21). В строке 24 макрос EVAL отключается, если уровень отладки DEBUGLEVEL меньше, чем MEDIUM; иными словами, если уровень отладки DEBUGLEVEL установлен равным значению NONE или LOW, макрос EVAL не работает.

Наконец, в строках 30—35, макрофункция PRINT объявляется " бездействующей", если уровень отладки DEBUGLEVEL меньше, чем HIGH. Макрофункция PRINT используется только в том случае, если уровень отладки DEBUGLEVEL установлен равным значению HIGH, т.е. этот макрос можно удалить, установив уровень отладки DEBUGLEVEL равным значению MEDIUM, и при этом поддерживать использование макросов EVAL и assert().

Макрос PRINT используется внутри методов Invariants() для печати информативного сообщения. Макрос EVAL используется в строке 221, чтобы отобразить текущее значение целочисленной константы AGE.

Рекомендуется: Используйте ПРОПИСНЫЕ буквы для имен макросов. Это широко распространенное соглашение, поэтому его несоблюдение может ввести в заблуждение других программистов. Заключайте все аргументы макросов в круглые скобки.

Не рекомендуется: Не изменяйте и не присваивайте значения переменных в макросах отладки, поскольку это чревато появлением побочных эффектов.

Операции с битами данных

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

Для флагов можно использовать переменные типа Boolean, но если у вас много признаков и для вас важно экономить ресурсы компьютера, удобнее для установки флагов использовать отдельные биты значения в двоичном формате.

Каждый байт имеет восемь битов, поэтому четырехбайтовая переменная типа long может представлять 32 отдельных флага. Если значение бита равно 1, то говорят, что флаг установлен, а если 0 — то сброшен. Другими словами, чтобы установить флаг, нужно определенному биту переменной присвоить значение 1, а чтобы сбросить флаг — значение 0. Устанавливать и сбрасывать флаги можно, изменяя значения переменной типа long, но такой подход нерационален и может ввести в заблуждение.

Примечание: В приложении В содержится ценная дополнительная информация об операциях над двоичными и шестнадцатеричными числами.

В языке C++ предусмотрены побитовые операторы для работы с битами данных. Они схожи, но в то же время отличаются от логических операторов, поэтому многие начинающие программисты их путают. Побитовые операторы представлены в табл. 21.1.

Таблица 21.1. Побитовые операции

Оператор И (AND)

Для обозначения оператора побитового И (& ) используется одиночный амперсант, а оператор логического И обозначается двумя амперсантами. При выполнении операции побитового И с двумя битами результат равен 1, если оба бита равны 1, и 0, если хотя бы один бит (или оба сразу) равен 0.

Оператор ИЛИ (OR)

Вторым побитовым оператором является ИЛИ (|). И опять-таки для его обозначения используется одиночный символ вертикальной черты, в отличие от логического ИЛИ, обозначаемого двумя символами вертикальной черты. При выполнении операции побитового ИЛИ с двумя битами результат равен 1, если хотя бы один бит (или оба сразу) равен 1.

⇐ Предыдущая 76 77 78 79 808182 83 84 85 Следующая ⇒