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

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

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

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

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

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

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

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

int* Initialize(void)
{
 int arr[10];
 int *ptr=arr;

 for (int i=0; i<=9;i++)
   {
    ptr++;
    *ptr=i;
    /* Defect: ptr out of bounds for i=9 */
   }

 return(arr);
}

ptr присвоен адрес arr это указывает на блок памяти размера 10*sizeof(int). В for- цикл, ptr постепенно увеличивается 10 раз. В последней итерации цикла, ptr точки вне блока памяти, присвоенного ему. Поэтому это не может быть разыменовано.

Одна возможная коррекция должна инвертировать порядок шага и разыменовать ptr.

int* Initialize(void)
{
 int arr[10];
 int *ptr=arr;

 for (int i=0; i<=9;i++)
     {
      /* Fix: Dereference pointer before increment */
      *ptr=i;
      ptr++;
     }

 return(arr);
}

После последнего шага, даже при том, что ptr точки вне блока памяти, присвоенного ему, это не разыменовывается больше.

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

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

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

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

int* bug_taintedmemoryallocsize(void) {
    size_t size;
    scanf("%zu", &size);
    int* p = (int*)malloc(size);
    return p;
}

В этом примере, malloc выделяет size объем памяти для указателя pразмер прибывает от пользователя программы, и ее значение не проверяется. Если размер больше, чем объем памяти, вы имеете в наличии, ваша программа могла бы отказать.

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

#include "stdlib.h"

enum {
    SIZE10  =  10,
    SIZE100 = 100,
    SIZE128 = 128
};

int* corrected_taintedmemoryallocsize(int size) {
    int* p = NULL;
          /* Fix: Check entry range before use */
    if (size>0 && size<SIZE128) {
        p = (int*)malloc((unsigned int)size);
    }
    return p;
}

Неправильно введите используемый в sizeof во время выделения памяти, происходит, когда вы используете указатель в качестве аргумента sizeof оператор вместо того, чтобы использовать объект, на который указывает указатель при выделении памяти для указателя динамически. Например, этот вопрос поднят, если вы используете malloc (sizeof (type*)) вместо malloc (sizeof (type)) при инициализации type* указатель.

Независимо от какой type обозначает, выражение sizeof (type*) всегда возвращает размер указателя на вашей платформе в байтах. Если вы непреднамеренно используете sizeof (type*) вместо sizeof (type) в вашем malloc оператор, выделенный блок памяти может быть меньшим, чем, в чем вы нуждаетесь. Эта ошибка может вызвать дефекты, такие как переполнение буфера.

Считайте структуру structType, который содержит 10 int переменные. Если вы инициализируете structType* указатель при помощи malloc(sizeof(structType*)) на 32-битной платформе указатель присвоен блок памяти четырех байтов. Этот блок памяти недостаточен для structType структура, которая требует, по крайней мере, 10 * sizeof(int) байты. Поскольку необходимый размер очень больше фактического выделенного размера, с помощью structType* вместо structType в качестве аргумента sizeof результаты в переполнении.

При выделении блоков памяти для указателей используйте sizeof (type) вместо sizeof (type*). В качестве альтернативы избегайте использования malloc или подобные команды выделения памяти, которые требуют, чтобы вы задали размер блока памяти, который будет выделен. Используйте new оператор, чтобы выделить память, не задавая размер и delete оператор, чтобы освободить память.

#include <stdlib.h>
class USER{
	long uid;
	long euid;
	int number;
	int address;
	int value;
};


void Noncompliant(void) {
	USER* user_list;
	user_list = (USER*)malloc(sizeof(USER*) * 5);
	/*...*/
	free(user_list);

}

В этом примере память динамически выделяется для массива user_list который содержит пять объектов класса USER. Этот массив требует по крайней мере 50 байтов памяти, потому что каждый элемент массива требует по крайней мере 10 байтов памяти. В malloc оператор, USER* используется в качестве аргумента для sizeof оператор вместо USER, возможно, непреднамеренно. В результате размер выделенного блока памяти может составить 20 байтов, который очень меньше необходимой памяти. Эта ошибка может привести к переполнению буфера.

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

#include <stdlib.h>
class USER{
	long uid;
	long euid;
	int number;
	int address;
	int value;
};

void Compliant(void) {
	USER* user_list;
	user_list = (USER*)malloc(sizeof(USER) * 5);
	/*...*/
	free(user_list);

}

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

#include <stdlib.h>
class USER{
	long uid;
	long euid;
	int number;
	int address;
	int value;
};

void Compliant(void) {
	USER* user_list = new USER[5];
	//...
	delete(user_list);
}