Плохой режим доступа к файлу или состояние происходят, когда вы используете функции в fopen или open группа с недопустимыми или несовместимыми режимами доступа к файлу, флагами создания файла или состоянием файла отмечает в качестве аргументов. Например, для open функция, примеры допустимых:

Дефект может произойти в следующих ситуациях.

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

Смотрите примеры мер ниже.

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

#include <stdio.h>

void func(void) {
    FILE *file = fopen("data.txt", "rw");
    if(file!=NULL) {
        fputs("new data",file);
        fclose(file);
    }
}

В этом примере, режим доступа rw недопустимо. Поскольку r указывает, что вы открываете файл для чтения и w указывает, что вы создаете новый файл для записи, эти два режима доступа несовместимы.

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

#include <stdio.h>

void func(void) {
    FILE *file = fopen("data.txt", "w");
    if(file!=NULL) {
        fputs("new data",file);
        fclose(file);
    }
}

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

Этот дефект применяется, только если кодовый язык для проекта является C.

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

Избегайте броска между двумя указателями функции с несоответствием в аргументе или возвратите типы.

Смотрите примеры мер ниже.

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

#include <stdio.h>
#include <math.h>
#include <stdio.h>
#define PI 3.142
 
double Calculate_Sum(int (*fptr)(double))
{
    double  sum = 0.0;
    double  y;
	  
    for (int i = 0;  i <= 100;  i++)
    {
        y = (*fptr)(i*PI/100);
        sum += y;
    }
    return sum / 100;
}
 
int main(void)
{
    double  (*fp)(double);      
    double  sum;
 
    fp = sin;
    sum = Calculate_Sum(fp); 
    /* Defect: fp implicitly cast to int(*) (double) */

    printf("sum(sin): %f\n", sum);
    return 0;
}

Указатель функции fp объявляется как double (*)(double). Однако мимоходом это, чтобы функционировать Calculate_Sumfp неявно брошен к int (*)(double).

Одна возможная коррекция должна проверять что указатель функции в определение Calculate_Sum имеет тот же аргумент, и возвратите тип как fp. Этот шаг убеждается тот fp неявно не брошен к различному аргументу, или возвратите тип.

#include <stdio.h>
#include <math.h>
#include <stdio.h>
# define PI 3.142
 
/*Fix: fptr has same argument and return type everywhere*/
double Calculate_Sum(double (*fptr)(double)) 
{
    double  sum = 0.0;
    double y;
	    
    for (int i = 0;  i <= 100;  i++)
    {
        y = (*fptr)(i*PI/100);
        sum += y;
    }
    return sum / 100;
}
 
int main(void)
{
    double  (*fp)(double);      
    double  sum;
 
    
    fp = sin;
    sum = Calculate_Sum(fp);
    printf("sum(sin): %f\n", sum);
 
    return 0;
}

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

Например, аргументы к этим функциям могут быть недопустимыми следующими способами.

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

Смотрите примеры мер ниже.

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

#include <string.h>
#include <stdlib.h>

enum {
    SIZE10 = 10,
    SIZE20 = 20
};

int func() {
    char* s = NULL;
    return strnlen(s, SIZE20);
}

В этом примере, NULL указатель передается как strnlen аргумент вместо NULL- отключенная строка.

Перед рабочим анализом кода задайте компилятор GNU. Смотрите Compiler (-compiler).

Передайте NULL- отключенная строка в качестве первого аргумента strnlen.

#include <string.h>
#include <stdlib.h>

enum {
    SIZE10 = 10,
    SIZE20 = 20
};

int func() {
    char* s = "";
    return strnlen(s, SIZE20);
}

Неподдерживаемые сложные аргументы происходят, когда эти функции вызваны с complex аргумент:

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

Постарайтесь не вызывать предыдущие функции с complex входной параметр. Чтобы выполнить предыдущие математические операции на комплексном числе, задайте альтернативные функции та поддержка complex аргументы.

#include <complex.h>
#include <tgmath.h>
typedef double complex cDouble;
cDouble Noncompliant (void)
{
    cDouble Z = 2.0 + 4.0 * I;
    cDouble result = log2 (Z); //Noncompliant
    return trunc(result);//Noncompliant
}

В этом примере, функциональном Noncompliant вычисляет основу два логарифма комплексного числа, обрезает результат и возвращает его. Функции log2 и trunc не поддерживайте сложный аргумент. Polyspace^® отмечает эти операции.

Одна возможная коррекция должна задать альтернативные функции та поддержка комплексные числа. Например, в то время как log2 не поддерживает complex числа, функциональный log делает. Задайте функциональный complexLog2 это использует log вычислить основу два логарифма комплексного числа. Точно так же trunc не поддерживает complex числа и математическое правило для усечения комплексного числа не четко определены. Задайте функциональный complexTrunc это обрезает комплексное число путем усечения его действительных и мнимых частей отдельно.

#include <complex.h>
#include <tgmath.h>
typedef double complex cDouble;

cDouble complexLog2(cDouble z) {
    return log (z) / log (2);  // Compliant
}

cDouble complexTrunc(cDouble z){
	return trunc(creal(z)) + I*trunc(cimag(z));  //Compliant
}
 
cDouble Compliant (void)
{
    cDouble Z = 2.0 + 4.0 * I;
    cDouble result = complexLog2 (Z); //Compliant
    return complexTrunc(result);//Compliant
}

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

При выведении прототипа функции от вызова до такой функции Polyspace делает эти предположения:

Средство проверки не отмечает эту проблему в Polyspace по умолчанию как Вы Анализ кода. Смотрите Средства проверки, Деактивированные в Polyspace, когда Вы Кодируете Анализ По умолчанию (Polyspace Bug Finder Access).

Согласно стандарту C, несоответствие объявления функции может привести к неопределенному поведению даже при том, что такой код может скомпилировать успешно создание только предупреждения во время компиляции. Поскольку код с этой проблемой может скомпилировать успешно, несоответствия объявления функции могут привести к неожиданным результатам, которые затрудняют, чтобы диагностировать.

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

// file1.c
void foo(int iVar){
	//...
}
void bar(float fVar1, float fVar2){
	//...
}
void bar2(float fVar1){
	//...
}
void fubar(const char* str,...){
	//...
}
void foo2(char cVar){
	//...
}
void call_variadic(){
	fubar("String");
}

//file2.c
void bar2(float);
void foo2(int);
void call_funcs(){
	int iTemp;
	float fTemp;
	foo();//Noncompliant
	bar(fTemp,fTemp);//Noncompliant
	fubar("String"); //Noncompliant	
	bar2(iTemp);//Compliant
	foo2(iTemp); //Noncompliant
}

В этом примере, функции foo, foo2панель, bar2, и fubar заданы в файле file1.c. Эти функции затем вызваны в файле file2.c.

Фиксация для этого дефекта должна объявить полные прототипы для вызванных функций во всех модулях компиляции. Это - лучшая практика объединить объявления прототипа функции в заголовочном файле, и затем включать его в файлы, где функции вызваны. В этом случае решите отмеченные вопросы включением такого заголовочного файла prototype.h в file2.c. Если правильный прототип объявляется, вызов foo() в file2.c вызывает отказ компиляции, потому что компилятор не может разрешить несоответствие между вызовом и заявленным прототипом. Вызовите foo с int разрешить отказ компиляции.

// file1.c
void foo(int iVar){
	//...
}
void bar(float fVar1, float fVar2){
	//...
}
void bar2(float fVar1){
	//...
}
void fubar(const char* str,...){
	//...
}
void foo2(char cVar){
	//...
}
void call_variadic(){
	fubar("String");
}

//prototypes.h
void foo(int iVar);
void bar(float fVar1, float fVar2);
void fubar(const char* str,...);
void bar2(float);
void foo2(char);
void call_variadic(void);
void call_funcs(void);

//file2.c
#include"prototype.h"
void call_funcs(){
	int iTemp;
	float fTemp;
	//foo(); This call results in compile failure
	foo(iTemp);//Compliant
	bar(fTemp,fTemp);//Compliant
	fubar("String"); //Compliant	
	bar2(iTemp);//Compliant
	foo2('a'); //Compliant
}