Целочисленное деление на ноль происходит, когда знаменателем операции деления или операции по модулю может быть целое число с нулевым значением.

Деление на ноль может привести к сбою программы.

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

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

res = num/den;

res = div(num, den);

См. примеры исправлений ниже.

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

int fraction(int num)
{
    int denom = 0;
    int result = 0;

    result = num/denom;

    return result;
}

Ошибка деления на ноль возникает при num/denom потому что denom равно нулю.

int fraction(int num)
{
    int denom = 0;
    int result = 0;

    if (denom != 0)
        result = num/denom;

    return result;
}

Перед делением добавьте тест, чтобы проверить, равен ли знаменатель нулю, проверяя перед делением. Если denom всегда равно нулю, эта коррекция может привести к дефекту мертвого кода в результатах Polyspace ®.

Одной из возможных корректировок является изменение значения знаменателя таким образом, чтобы denom не равно нулю.

int fraction(int num)
{
    int denom = 2;
    int result = 0;

    result = num/denom;

    return result;
}

int mod_arr(int input)
{
    int arr[5];
    for(int i = 0; i < 5; i++)
    {
        arr[i] = input % i;
    }

    return arr[0]+arr[1]+arr[2]+arr[3]+arr[4];
}

В этом примере Polyspace помечает операцию по модулю как деление на ноль. Поскольку по модулю по своей сути является операцией деления, делитель (правый аргумент) не может быть нулевым. Операция по модулю использует for индекс цикла в качестве делителя. Тем не менее, for цикл начинается с нуля, который не может быть итератором.

Одной из возможных корректировок является проверка делителя перед операцией по модулю. В этом примере см., если индекс i равен нулю перед операцией по модулю.

int mod_arr(int input)
{
    int arr[5];
    for(int i = 0; i < 5; i++)
    {
        if(i != 0)
        {
             arr[i] = input % i;
        }
        else
        {
             arr[i] = input;
        }
    }

    return arr[0]+arr[1]+arr[2]+arr[3]+arr[4];
}

Другой возможной поправкой является изменение делителя на ненулевое целое число. В этом примере добавьте один к индексу перед % во избежание деления на ноль.

int mod_arr(int input)
{
    int arr[5];
    for(int i = 0; i < 5; i++)
    {
         arr[i] = input % (i+1);
    }

    return arr[0]+arr[1]+arr[2]+arr[3]+arr[4];
}

Операнд запятнанного деления обнаруживает операции деления, где один или оба целочисленных операнда получены из небезопасного источника.

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

Перед выполнением деления проверьте значения операндов. Проверка знаменателей 0 или -1и числители минимального целого значения.

#include<stdio.h>
extern void print_int(int);

int taintedintdivision(void) {
    int num, den;
	scanf("%lf %lf",&num, &den);
	int r =  num/den; 
    print_int(r);
    return r;
}

В этом примере функция делит две переменные аргумента, затем печатает и возвращает результат. Значения аргументов неизвестны и могут вызвать деление на ноль или целочисленное переполнение.

Одной из возможных корректировок является проверка значений числителя и знаменателя перед выполнением деления.

#include<stdio.h>
#include <limits.h> 
extern void print_int(int);

int taintedintdivision(void) {
	int num, den;
	scanf("%lf %lf",&num, &den);
	int r = 0;
	if (den!=0 && !(num=INT_MIN && den==-1)){
		r =  num/den; 	
	}
	print_int(r);
	return r;
}

Запятнанный по модулю операнд проверяет операнды остатка % операции. Bug Finder помечает операции по модулю с одним или несколькими запятнанными операндами.

Эти риски могут быть использованы злоумышленниками для получения доступа к вашей программе или цели в целом.

Перед выполнением операции по модулю проверьте значения операндов. Проверьте второй операнд на значения 0 и -1. Проверьте оба операнда на наличие отрицательных значений.

#include<stdio.h>
extern void print_int(int);

int taintedintmod(void) {
	int userden;
	scanf("%d",&userden);
    int rem =  128%userden; 
    print_int(rem);
    return rem;
}

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

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

#include<stdio.h>
extern void print_int(int);

int taintedintmod(void) {
	int userden;
	scanf("%d",&userden);
	int rem = 0;
    if (userden > 0) { 
        rem = 128 % userden; 
    }
    print_int(rem);
    return rem;
}