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

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

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

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

См. примеры исправлений ниже. Рекомендуется инициализировать указатель на значение NULL при объявлении указателя.

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

#include <stdlib.h>

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

    if (prev == nullptr) 
      {
        pi = new int;
        if (pi == nullptr) return NULL;
      }
    *pi = j;                    
    /* Defect: Writing to uninitialized pointer */

    return pi;
}

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

Одной из возможных корректировок является присвоение адреса pi когда prev не является nullptr. Кроме того, можно инициализировать pi в качестве nullptr во время его декларирования.

#include <cstdlib>

int* assign_pointer(int* prev)
{
    int j = 42;
/*Fix: Initialize pointers by using nullptr during declaration*/
    int* pi = nullptr;

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

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

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

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

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

См. примеры исправлений ниже. Рекомендуется инициализировать переменную при объявлении.

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

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 функции или delete оператор.

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

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

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

#include <cstdlib>
int increment_content_of_address(int base_val, int shift)
   { 
    int j;
    int* pi = new int;
    if (pi == NULL) return 0;

    *pi = base_val;
    delete pi;

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

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

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

#include <cstdlib>

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

    *pi = base_val;

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

    /* Fix: The pointer is deallocated after its last use */
    delete pi;               
    return j;
}

Другой возможной поправкой является использование std::unique_ptr вместо необработанного указателя. Интеллектуальные указатели, такие как std::unique_ptr управляет собственными ресурсами. так как нет необходимости удалять смарт-указатели явным образом, доступ к ним после отмены назначения осуществляется непреднамеренно.

#include <cstdlib>
#include <memory>

int increment_content_of_address(int base_val, int shift)
{
    int j;
    /* Fix: A smart pointer is used*/
    std::unique_ptr<int>   pi(new int(3));
    if (pi == nullptr) return 0;

    *pi = base_val;

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

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

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

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

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

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

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,

auto createAdder(int amountToAdd) {
  int addThis = amountToAdd;
  auto adder = [&] (int initialAmount) {
      return (initialAmount + addThis);
  };
  return adder;
}
 
void func() {
  auto AddByTwo = createAdder(2);
  int res = AddByTwo(10);
}

В этом примере createAdder функция определяет лямбда-выражение adder который захватывает локальную переменную addThis по ссылке. Объем addThis ограничивается createAdder функция. Когда объект возвращен createAdder вызывается, ссылка на переменную addThis доступен за пределами его области действия. При обращении таким образом значение addThis не определен.

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

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

auto createAdder(int amountToAdd) {
  int addThis = amountToAdd;
  auto adder = [=] (int initialAmount) {
      return (initialAmount + addThis);
  };
  return adder;
}
 
void func() {
  auto AddByTwo = createAdder(2);
  int res = AddByTwo(10);
}

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

Для кода C++ при доступе к объекту с временным временем жизни возникает дефект только при записи в объект с временным временем жизни.

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

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

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

#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();
}