Описание

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

Риск

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

Фиксация

Фиксация зависит от первопричины дефекта. Например, вы присвоили адрес указателю, но присвоение недостижимо.

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

Смотрите примеры мер ниже. Это - хорошая практика, чтобы инициализировать указатель на NULL при объявлении указателя.

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

Пример - Неинициализированная ошибка указателя

#include <stdlib.h>

int* assign_pointer(int* prev)
{
    int j = 42;
    int* pi;

    if (prev == NULL) 
      {
        pi = (int*)malloc(sizeof(int));
        if (pi == NULL) return NULL;
      }

    *pi = j;                    
    /* Defect: Writing to uninitialized pointer */

    return pi;
}

Если prev не является NULL, указатель, pi не присвоен адрес. Однако pi разыменовывается на каждом выполнении пути, независимо от того, является ли prev NULL или нет.

Исправление — инициализирует указатель на каждом пути к выполнению

Одно возможное исправление должно присвоить адрес pi, когда prev не является NULL.

#include <stdlib.h>

int* assign_pointer(int* prev)
{
    int j = 42;
    int* pi;

    if (prev == NULL) 
       {
        pi = (int*)malloc(sizeof(int));
        if (pi == NULL) return NULL;
       } 
    /* Fix: Initialize pi in branches of if statement  */
    else 
        pi = prev;              
    

    *pi = j;

    return pi;
}

Описание

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

Риск

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

Фиксация

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

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

Смотрите примеры мер ниже. Это - хорошая практика, чтобы инициализировать переменную в объявлении.

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

Пример - Неинициализированная переменная погрешность

int get_sensor_value(void)
{
    extern int getsensor(void);
    int command;
    int val;

    command = getsensor();
    if (command == 2) 
      {
        val = getsensor();
      }

    return val;              
    /* Defect: val does not have a value if command is not 2 */
}

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

Исправление — инициализирует во время объявления

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

int get_sensor_value(void)
{
    extern int getsensor(void);
    int command;
    /* Fix: Initialize val */
    int val=0;

    command = getsensor();
    if (command == 2) 
      {
        val = getsensor();
      }

    return val;              
 }

val присвоен начальное значение 0. Когда command не равен 2, функциональный get_sensor_value возвращает это значение.

Описание

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

Риск

Когда указатель является выделенной динамической памятью с malloc, calloc или realloc, это указывает на ячейку памяти на куче. Когда вы используете функцию free на этом указателе, связанный блок памяти освобожден для перераспределения. Попытка получить доступ к этому блоку памяти может привести к непредсказуемому поведению или даже отказу сегментации.

Фиксация

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

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

Пример - использование ранее освобожденной ошибки указателя

#include <stdlib.h>
#include <stdio.h>
 int increment_content_of_address(int base_val, int shift)
   { 
    int j;
    int* pi = (int*)malloc(sizeof(int));
    if (pi == NULL) return 0;

    *pi = base_val;
    free(pi);

    j = *pi + shift;
    /* Defect: Reading a freed pointer */
 
    return j;
   }

Оператор free выпускает блок памяти, к которой относится pi. Поэтому dereferencingpi после оператора free не допустим.

Исправление — свободный указатель после использования

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

#include <stdlib.h>

int increment_content_of_address(int base_val, int shift)
{
    int j;
    int* pi = (int*)malloc(sizeof(int));
    if (pi == NULL) return 0;

    *pi = base_val;

    j = *pi + shift;
    *pi = 0;

    /* Fix: The pointer is freed after its last use */
    free(pi);               
    return j;
}

Описание

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

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

Риск

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

Если указатель на локальную переменную оставляет осциллограф переменной, Polyspace^® Bug Finder™ подсвечивает дефект. Дефект появляется, даже если вы не используете адрес, сохраненный в указателе. Для удобного в сопровождении кода это - хорошая практика, чтобы не позволить указателю оставлять переменную scope. Даже если вы не используете адрес в указателе теперь, кто-то еще использующий вашу функцию может использовать адрес, вызывая неопределенное поведение.

Фиксация

Не позволяйте указателю или ссылке на локальную переменную оставлять переменную scope.

Пример - указатель на локальную переменную, возвращенную в функцию

void func2(int *ptr) {
    *ptr = 0;
}

int* func1(void) {
    int ret = 0;
    return &ret ;
}
void main(void) {
    int* ptr = func1() ;
    func2(ptr) ;
}

В этом примере func1 возвращает указатель на локальную переменную ret.

В main ptr указывает на адрес локальной переменной. Когда к ptr получают доступ в func2, доступ недопустим, потому что осциллограф ret ограничивается func1,

Описание

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

Для Кода С++ объект Accessing с временным временем жизни повышает дефект только, когда вы пишете в объект с временным временем жизни.

Если временный пожизненный объект возвращен адресом, никакой дефект не повышен.

Риск

Изменение объектов с временным временем жизни является неопределенным поведением и может вызвать аварийное завершение программы и проблемы мобильности.

Фиксация

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

Пример - изменение временного пожизненного объекта, возвращенного вызовом функции

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

#define SIZE6 6

struct S_Array
{
    int t;
    int a[SIZE6];
};

struct S_Array func_temp(void);

/* func_temp() returns a struct value containing
* an array with a temporary lifetime.
*/
int func(void) {
 
/*Writing to temporary lifetime object is
 undefined behavior
 */
    return ++(func_temp().a[0]); 
}

void main(void) {
    (void)func();
}

В этом примере func_temp() возвращает значением структуру с участником массивов a. У этого участника есть временное время жизни. Постепенное увеличение его является неопределенным поведением.

Исправление — присвоение возвращенное значение к локальной переменной перед записью

Одно возможное исправление должно присвоить возврат вызова func_temp() к локальной переменной. Содержимое временного объекта, a копируется в переменную, которую можно безопасно постепенно увеличить.

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

#define SIZE6 6

struct S_Array
{
    int t;
    int a[SIZE6];
};

struct S_Array func_temp(void);

int func(void) {

/* Assign object returned by function call to 
 *local variable
 */
    struct S_Array s = func_temp(); 

/* Local variable can safely be
 *incremented
 */
    ++(s.a[0]);                                           
    return s.a[0];
}

void main(void) {
    (void)func();
}