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

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

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

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

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

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

#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 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 функционируйте или 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 относится к. Поэтому dereferencingpi после 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 функция. Дефект не применяется к статическим, локальным переменным.

Локальные переменные выделяются адрес на стеке. Если осциллограф локальной переменной заканчивается, этот адрес доступен для повторного использования. Используя этот адрес, чтобы получить доступ к значению локальной переменной вне переменной 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,

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 isundefined.

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

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

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

Объект 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();
}