Debug error heap corruption detected after normal block

Динамический массив в языке C++ имеет два значения: массив переменного размера(т.е. способным к добавлению и удалению в нём элементов) и массив, который мы разместили в куче(heap). В данном случае вы используете второй вид динамического массива, который сам по себе не меняет своих размеров.

Когда мы хотим считать и записать элементы массива, то у нас стоит выбор какой использовать: статический или динамический(1 или 2). Если количество элементов фиксировано(т.е. мы изначально знаем), то под это отлично подойдёт обычный статический массив, а если же количество элементов вводится с клавиатуры, то мы используем динамический, т.к. по стандарту в языке C++ количество элементов в статическом массиве должно быть известно в момент компиляции, никак не исполнения.
В вашем случае, как я понял, количество элементов фиксировано и равно 10. Тогда и вовсе динамический массив никак не обязателен.

Распишу решение в 3-х видах: с использованием статического и динамического 1-го и 2-го вида.

Статический(неспособный к растягиванию массив, выделенный в stack):

int main()
{
    constexpr int ARR_SIZE = 10;
     arr[ARR_SIZE];
    for(int i = 0; i < ARR_SIZE; ++i)
        std::cin >> arr[i];

    //обрабатываем элементы массива
    ...
    return 0;
}

Динамический(неспособный к растягиванию массив в heap):

#include <iostream>
#include <vector>

int main()
{
    int numbersInArray;
    std::cout << "Enter number of elements: ";
    std::cin >> numbersInArray;
    double *arr = new double[numbersInArray];
    for(int i = 0; i < numbersInArray; ++i)
        cin >> arr[i];
    //обрабатываем элементы массива
    ...
    return 0;
}

Динамический(cпособный к растягиванию массив, внутри сам выделен в heap):

#include <iostream>
#include <vector>

int main()
{
    std::vector < double > arr;
    int numbersInArray;
    std::cout << "Enter number of elements: ";
    std::cin >> numbersInArray;
    for(int i = 0; i < numbersInArray; ++i)
    {
        double temp_variable;
        cin >> temp_variable;
        arr.push_back(temp_variable);
    }
    //обрабатываем элементы массива
    ...
    return 0;
}

Heap corruption at address.
HEAP[MyProg.exe]: Heap block at 0AC6A400 modified at 0AC6A6EC 
past requested size of 2e4

Итак, в чем состоят отличия и каким образом отлавливаются ошибки. Давайте я пример приведу, с примером удобнее.

class CBase 
{
public: 
 int BaseI;
 int BaseJ;
};
class CDerived : public CBase
{
public:
 int DerivedI;
};
int main()
{
 CBase *pBase = new CBase;//(1)
  pBase->BaseI = 3;
 pBase->BaseJ = 4;//(2) 
 delete pBase;//(3) 
 return 0;
}

Как будет выглядеть память в точке (1). (Чтобы вывести окно с памятью, выберите Debug->Windows->Memory->Memory1).

0x00984ED8  cd cd cd cd cd cd cd cd fd fd fd fd 00 00 00 00

У меня экземпляр класса CBase расположился по адресу 0x00984ED8. Оба int’а, а это восемь байт, заполнены значением 0xCD, Clean Memory. Это значение по умолчанию.
Дальше четыре байта 0XFD, Fence Memory, она же «no mans land». Это такой заборчик, которым обрамляется свежевыделенная память. Перед адресом 0x00984ED8 стоят точно такие же четыре байта.

Точка (2).

0x00984ED8  03 00 00 00 04 00 00 00 fd fd fd fd 00 00 00 00

Мы записали значения 3 и 4 и они идут одно за другим. Младший байт идет первым, потому что я работают с little endian платформой.

Точка (3)

0x00984ED8  dd dd dd dd dd dd dd dd dd dd dd dd 00 00 00 00

Память после удаления заполняется значениями 0xDD, Dead Memory. После вызова функции HeapFree() будет заполнена значениями 0xFEEEFEEE.

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

 CBase *pBase = new CBase;//(1)
  pBase->BaseI = 3;
 pBase->BaseJ = 4;//(2) 
 CDerived* pDerived = static_cast<CDerived*>(pBase);
 pDerived->DerivedI = 7;//(3)
 delete pBase;

Итак, мы стали приводить по иерархии с помощью static_cast’а, вместо dynamic_cast’а. Что в итоге получили. В точках (1) и (2) программа выглядит все также. В точке (3) мы полезли в чужую память и затерли забор.

03 00 00 00 04 00 00 00 07 00 00 00 00 00 00 00

После попытки вызвать delete pBase мы получим сообщение об ошибке, потому что забора нет, а это означает, что мы лазили в чужую память.

HEAP CORRUPTION DETECTED: after Normal block (#68) at 0x008D4ED8.
CRT detected that the application wrote to memory after end of heap buffer.

Еще различия между дебажной и релизной кучами приводят к тому, что программа начинает себя вести по-разному в дебаге и в релизе. Простой пример — дебажная «падает», релизная нет. Очень может быть, что «падение» — это не падение вовсе, а как раз сообщение о порче памяти. Почитайте повнимательнее, что там в окне написано.
Также народ жалуется, что дебажная версия работает сильно меденнее релизной. Причиной этого в том числе может быть дебажная куча. В интернетах пишут, что можно ее в дебаге отключить то ли с помощью переменной окружения _NO_DEBUG_HEAP, то ли NO_DEBUG_HEAP, в единицу ее надо выставить. Я пробовала ее отключить, куча осталась дебажной.

Ссылки по теме:
Win32 Debug CRT Heap Internals
Inside CRT: Debug Heap Management
Memory Management and the Debug Heap (MSDN)
Приведение типов в C++

Heap corruption detected

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

this is the full code ################################   strng3.h

#ifndef _STRNG2_H_
#define _STRNG2_H_

class String
{
private:
	char *str;
	int len;
public:
	String(const char *s);
	String();
	String(const String &st);
	~String();
	int length() const {return len;}

	String & operator=(const String &st);
	String & operator=(const char *s);

	String & operator+(const String &st);
	String & operator+(const char *s);

	friend ostream & operator<<(ostream &os,const String &st);
	friend istream & operator>>(istream &is,String &st);
	friend String & operator+(const char *s,String &st);
};

#endif


################################ strng3.cpp

#include <iostream>
#include <cstring>
using namespace std;
#include "strng3.h"

String::String()
{
	len=0;
	str=new char[1];
	str[0]='';

}

String::String(const char *s)
{
	len=strlen(s);
	str=new char[len+1];
	strcpy(str,s);
}

String::String(const String &st)
{
	len=st.len;
	str=new char[len+1];
	strcpy(str,st.str);
}

String::~String()
{
	delete [] str;               // <-------------------------------------- here
}

String & String::operator =(const char *s)
{
	delete [] str;
	len=strlen(s);
	str=new char[len+1];
	strcpy(str,s);
	return *this;
}

String & String::operator =(const String &st)
{
	if(this==&st)
		return *this;
	delete [] str;
	len=st.len;
	str=new char[len+1];
	strcpy(str,st.str);
	return *this;
}

String & String::operator +(const String &st)
{
	for(int i=0;i<=st.len;i++)
		*(str+len+i)=*(st.str+i);
	len=len+st.len;
	return *this;	
}

String & String::operator +(const char *s)
{
	int slen=strlen(s);
	char * temp=new char[slen+1];
	strcpy(temp,s);
	for(int i=0;i<slen;i++)
		*(str+len+i)=*(temp+i);
	delete [] temp;
	return *this;
}

String & operator+(const char *s,String &st)
{
	String temp(s);
	st=temp+st;                    //<---------------------- here
	return st;
}


ostream & operator<<(ostream &os,const String &st)
{
	os<<st.str;
	return os;
}

istream & operator>>(istream &is,String &st)
{
	char temp[80];
	is.get(temp,80);
	if(is)
		st=temp;
	while(is && is.get()!='n')
		continue;
	return is;
	
	/*
	char temp[20];
	is>>temp;
	char * ps=new char[strlen(temp)+1];
	strcpy(ps,temp);
	strcpy(st.str,ps);
	st.len=strlen(st.str);
	delete [] ps;
	return is;
	*/
}

#############################################

#include <iostream>
using namespace std;
#include "strng3.h"

int main()
{
	String s1("and I'm learnging c++");
	String s2="your name:";
	String s3;
	cout<<s2;
	cin>>s3;
	s2="my name is "+s3;            //<--------------- here
	cout<<s2<<".n";
	s2=s2+s1;
	cout<<s2<<"n";

	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

String & String::operator +(const String &st)
{
	char *temp=new char[len+st.len+1];
	strcpy(temp,str);
	for(int i = 0; i <= st.len; i++)
	{
		*(temp + len + i) = *(st.str + i);
	}
	len = len + st.len;
	delete [] str;
	str=new char[len+1];
	strcpy(str,temp);
	delete [] temp;
	return *this; 

}

String operator+(const char *s,String &st)
{
	String temp(s);
	return temp+st;
}

Topic archived. No new replies allowed.

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

HEAP[MAN2_GUI.exe]: Heap block at 0000000000395A00 modified at 000000000039626C past requested size of 85c
HEAP[MAN2_GUI.exe]: Invalid address specified to RtlValidateHeap( 0000000000350000, 0000000000395A10 )

Program: …_GUI-Desktop_Qt_5_8_0_MSVC2015_64bit-DebugdebugMAN2_GUI.exe
File: minkernelcrtsucrtsrcappcrtheapdebug_heap.cpp
Line: 888

Expression: _CrtIsValidHeapPointer(block)

For information on how your program can cause an assertion
failure, see the Visual C++ documentation on asserts.

Program: …_GUI-Desktop_Qt_5_8_0_MSVC2015_64bit-DebugdebugMAN2_GUI.exe

HEAP CORRUPTION DETECTED: after Normal block (#1903) at 0x0000000000395A40.
CRT detected that the application wrote to memory after end of heap buffer.

(Press Retry to debug the application)
HEAP[MAN2_GUI.exe]: Heap block at 0000000000395A00 modified at 000000000039626C past requested size of 85c

*.h

enum COMMAND {
        PING,
        ...
        ...
        BUFFER_OVERFLOW = 0xDF,
        WRONG_COMMAND = 0xEF,
    };
signals:
    void U(int ch, float v);
    void ManChannelDetected(int ch);

private:
    void CmdPing();
    void CmdNullFunction();
    typedef void (MyProtocol::*pFunc)();
    pFunc CmdArray[0xFF];

*.cpp
конструктор

for (int i = 0; i < 0xFF; ++i) {
    CmdArray[i] = &MyProtocol::CmdNullFunction;
}
CmdArray[PING] = &MyProtocol::CmdPing;
connect(this, &QSerialPort::readyRead, this, &MyProtocol::readyRead);

Cлот, использование.

void MyProtocol::readyRead()
{
     QMutexLocker locker(&readMutex);
     ...
    (this->*CmdArray[Data[4]])();
     ...
}

«Каллбак»

void MyProtocol::CmdPing()
{
    Channels.append((uint8_t)Data[5]);
    emit ManChannelDetected((uint8_t)Data[5]);
}

HEAP CORRUPTION DETECTED:after Normal block(#152)at 0x006613C0 CRT Detected

// Part-1 : --------------------------- sorting algorithms

void bubbleSort(double *x, int n)
{
// Implement the sorting function using the bubble sort algorithm.
double temp;
for (int j = 0;j < n;j++) {
for (int i = 0;i < n;i++) {
if (x[i] > x[i + 1]) {
temp = x[i];
x[i + 1] = x[i];
x[i + 1] = temp;
}
}
}
}void insertionSort(double *x, int n)
{
// Implement the sorting function using the insertion sort algorithm.

for (int i = 1;i < n;i++) {
double temp = x[i];
int j = 0;
for (j = i - 1;j >= 0 && x[j]>temp;j--) {
x[j + 1] = x[j];
}
x[j + 1] = temp;
}

}int compare_1(const void *a, const void *b) {
double *X = (double *)a;
double *Y = (double *)b;
if (*X > *Y) {
return 1;
}
else if (*X < *Y)
return -1;
return 0;

}

void part_1(int n)
{
srand((unsigned)time(NULL));  // set the seed of the random number generator

double *a = new double[n];  // create 3 arrays with identical contents
double *b = new double[n];
double *c = new double[n];

for (int i = 0; i < n; i++)
a[i] = b[i] = c[i] = rand() / 10000.0;

clock_t begin, end;
double elapsedTime;

cout << "Bubble sort: sorting an array of size " << n << endl;
begin = clock();
bubbleSort(a, n);
end = clock();

elapsedTime = (double)(end - begin) / CLOCKS_PER_SEC;
cout << "Elapsed time = " << elapsedTime << " seconds" << endl << endl;

for (int i = 0; i < n - 1; i++)
if (a[i] > a[i + 1])
{
cout << "Bubble sort : Incorrect resultsnn";
break;
}

cout << "Insertion sort: sorting an array of size " << n << endl;
begin = clock();
insertionSort(b, n);
end = clock();

elapsedTime = (double)(end - begin) / CLOCKS_PER_SEC;
cout << "Elapsed time = " << elapsedTime << " seconds" << endl << endl;

for (int i = 0; i < n - 1; i++)
if (b[i] > b[i + 1])
{
cout << "Insertion sort : Incorrect resultsnn";
break;
}

cout << "Write your statements to sort array c[] using qsort()n";
cout << "qsort: sorting an array of size " << n << endl;

begin = clock();

// #### write your statements to sort array c[] using qsort().
//      Define your own compare function.
qsort(c, n, sizeof(double), compare_1);

end = clock();

elapsedTime = (double)(end - begin) / CLOCKS_PER_SEC;
cout << "Elapsed time = " << elapsedTime << " seconds" << endl << endl;

for (int i = 0; i < n - 1; i++)
if (c[i] > c[i + 1])
{
cout << "qsort : Incorrect resultsnn";
break;
}
delete[] a;
delete[] b;
delete[] c;
}
int main()
{
part_1(50000);

system("pause");
return 0;
}

Решение

int array[5];

int n=4;
array[n+1] = 10; //array out of bound memory write operation

void bubbleSort(double *x, int n)
{
// Implement the sorting function using the bubble sort algorithm.
double temp;
for (int j = 0;j < n;j++) {
for (int i = 0;i < n;i++) {
if (x[i] > x[i + 1]) {
temp = x[i];
x[i + 1] = x[i]; // out of bound write when i=n-1.
x[i + 1] = temp;
}
}
}
}

Другие решения

void bubbleSort(double *x, int n)
{
// Implement the sorting function using the bubble sort algorithm.
double temp;
for (int j = 0; j < n; j++) {
for (int i = 0; i < n; i++) {
if (i + 1 >= n)
{ // index is out of range
cout << "Bummern";
exit(1);
}
if (x[i] > x[i + 1]) {
temp = x[i];
x[i + 1] = x[i];
x[i + 1] = temp;
}
}
}
}