Обработка ошибок

Виды ошибок

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

Ошибки компиляции пропустим:пока все они не исправлены, программа не готова, и запустить ее нельзя. Здесь мы будем рассматривать только ошибки, происходящие во время выполнения программы.

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

Теоретически возможно написать программу без таких ошибок. Во многом язык Си++ помогает предотвратить ошибки во время выполнения программы,осуществляя строгий контроль на стадии компиляции. Вообще, чем строже контроль на стадии компиляции, тем меньше ошибок остается при выполнении программы.

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

1. Контроль типов. Случаи использования недопустимых операций и смешения несовместимых типов будут обнаружены компилятором.
2. Обязательное объявление имен до их использования. Невозможно вызвать функцию с неверным числом аргументов. При изменении определения переменной или функции легко обнаружить все места, где она используется.
3. Ограничение видимости имен, контексты имен. Уменьшается возможность конфликтов имен, неправильного переопределения имен.

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

Несмотря на все эти положительные качества языка, остается "простор" для написания ошибочных программ. По мере рассмотрения свойств языка, мы стараемся давать рекомендации, какие возможности использовать, чтобы уменьшить вероятность ошибки.

Лучше исходить из того, что идеальных программ не существует, это помогает разрабатывать более надежные программы. Самое главное – обеспечить контроль данных, а для этого необходимо проверять в программе все, что может содержать ошибку. Если в программе предполагается какое-то условие, желательно проверить его, хотя бы в начальной версии программы, до того, как можно будет на опыте убедиться, что это условие действительно выполняется. Важно также проверять указатели, передаваемые в качестве аргументов, на равенство нулю; проверять, не выходят ли индексы за границы массива и т.п.

Ну и решающими качествами, позволяющими уменьшить количество ошибок, являются внимательность, аккуратность и опыт.

Второй вид ошибок – "предусмотренные", запланированные ошибки. Если разрабатывается программа диалога с пользователем, такая программа обязана адекватно реагировать и обрабатывать неправильные нажатия клавиш. Программа чтения текста должна учитывать возможные синтаксические ошибки. Программа передачи данных по телефонной линии должна обрабатывать помехи и возможные сбои при передаче. Такие ошибки – это, вообще говоря, не ошибки с точки зрения программы, а плановые ситуации, которые она обрабатывает.

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

Именно обработка двух последних видов ошибок и рассматривается в последующих разделах. Граница между ними довольно условна. Например, для большинства программ сбой диска – исключительная ситуация, но для операционной системы сбой диска должен быть предусмотрен и должен обрабатываться. Скорее два типа можно разграничить по тому, какая реакция программы должна быть предусмотрена. Если после плановых ошибок программа должна продолжать работать, то после исключительных ситуаций надо лишь сохранить уже вычисленные данные и завершить программу.

Возвращаемое значение как признак ошибки

Простейший способ сообщения об ошибках предполагает использование возвращаемого значения функции или метода. Функция сохранения объекта в базе данных может возвращать логическое значение: true в случае успешного сохранения, false – в случае ошибки.

class Database
{
public:
	bool SaveObject(const Object& obj);
};

Соответственно, вызов метода должен выглядеть так:

if (database.SaveObject(my_obj) == false ){
	//обработка ошибки
}

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

int main()
{
   if (fun1()==false )  //обработка ошибки
   return 1;
}
bool
fun1()
{
	if (fun2()==false )
		return false ;
	return true ;
}
bool
fun2()
{
	if (database.SaveObject(obj)==false )
		return false ;
	return true ;
}

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

Иногда невозможно вернуть признак ошибки в качестве возвращаемого значения. Примером является конструктор объекта, который не может вернуть значение. Как же сообщить о том, что во время инициализации объекта что-то было не так?

Распространенным решением является дополнительный атрибут объекта – флаг, отражающий состояние объекта. Предположим, конструктор класса Database должен соединиться с сервером базы данных.

class Database
{
public :
  Database(const char *serverName);
	...
  bool Ok(void) const {return okFlag;};
private :
  bool okFlag;
};
Database::Database(const char*serverName)
{
  if (connect(serverName)==true )
    okFlag =true ;
  else
    okFlag =false ;
}
int main()
{
  Database database("db-server");
  if (!database.Ok()){
    cerr <<"Ошибка соединения с базой данных"<<endl;
  return 0;
  }
  return 1;
}

Лучше вместо метода Ok, возвращающего значение флага okFlag, переопределить операцию ! (отрицание).

class Database
{
public :
   bool operator !()const {return !okFlag;};
};

Тогда проверка успешности соединения с базой данных будет выглядеть так:

if (!database){
  cerr <<"Ошибка соединения с базой 
                          данных"<<endl;
}

Следует отметить, что лучше избегать такого построения классов, при котором возможны ошибки в конструкторе. Из конструктора можно выделить соединение с сервером базы данных в отдельный метод Open:

class Database
{
public :
	Database();
	bool Open(const char*serverName);
}

и тогда отпадает необходимость в операции ! или методе Ok().

Использование возвращаемого значения в качестве признака ошибки – метод почти универсальный. Он применяется, прежде всего, для обработки запланированных ошибочных ситуаций. Этот метод имеет ряд недостатков. Во-первых, приходится передавать признак ошибки через вложенные вызовы функций. Во-вторых, возникают неудобства, если метод или функция уже возвращают значение, и приходится либо модифицировать интерфейс, либо придумывать специальное " ошибочное " значение. В-третьих, логика программы оказывается запутанной из-за сплошных условных операторов if с проверкой на ошибочное значение.