Project 3.exe中的0x7A12FF80（ucrtbased.dll）引发异常：0xC0000005：访问冲突读取位置0x00000000

问题描述 投票：0回答：1

我已经尝试运行此代码。在运行此程序之前，不存在任何警告或错误，但是一旦执行，我就会抛出异常，并且该异常会使程序无法编译。这是我的代码，错误在主题行中。 CDA文件被用作头文件来创建循环动态数组，该数组将在Heaps.cpp中进行操作。 heaps.cpp用于创建二进制堆，该二进制堆将用于创建二项式堆，但是该代码尚未开发。 

#include <iostream>
using namespace std;

template <class T>
class CDA
{
private:
	int rear;
	int size;
	int capacity;
	T* circArray;
	int front;
	bool ordered;
	T placeHolder;

public:
	CDA();
	CDA(int s);
	~CDA();
	int Front();
	T Data(int n);
	T& operator[](int i);
	void AddEnd(T v);
	void AddFront(T v);
	void DelEnd();
	void DelFront();
	int Length();
	int Capacity();
	int Clear();
	bool Ordered();
	int SetOrdered();
	int S01(int n);
	T Select(int k);
	void InsertionSort();
	void QuickSort();
	void QuickSort1(int low, int high);
	void CountingSort(int m);
	int Search(T e);
	void reSize();
	void Shrink();
	int BinarySearch(int left, int right, T e);
	int QSortPartition(int low, int high);
	void Swap(int* x, int* y);
	int QSelPartition(int front, int rear);
	T QuickSelect(int front, int rear, int k);
	CDA<T>& operator=(const CDA& a);
	CDA(const CDA& old);
	int Median(int low, int high);
};

template <class T>
CDA<T>::CDA()
{
	capacity = 1;
	circArray = new T[capacity];
	size = 0;
	rear = size - 1;
	front = -1;
	ordered = false;
	placeHolder = 0;
}

template <class T>
CDA<T>::CDA(int s)
{
	size = s;
	capacity = s;
	circArray = new T[capacity];
	front = 0;
	rear = size - 1;
	ordered = false;
}

template <class T>
CDA<T>::CDA(const CDA& a)
{
	size = a.size;
	capacity = a.capacity;
	circArray = new T[a.capacity];
	front = a.front;
	rear = a.size - 1;
	ordered = a.ordered;
	for (int i = a.front; i < a.front + (a.size); i++)
	{
		circArray[i % capacity] = a.circArray[i % capacity];
	}
}

template <class T>
CDA<T>::~CDA()
{
	delete[]circArray;
}


template <class T>
T& CDA<T>::operator[](int i)
{
	if (i > capacity)
	{
		cout << "Array index is out of bounds; exiting." << endl;
		placeHolder = i;
		cout << endl;

		return placeHolder;
		exit(0);
	}
	else
	{
		return circArray[(front + i) % capacity];
	}
}


template <class T>
void CDA<T>::AddEnd(T v)
{
	size++;
	if (front == -1)
	{
		circArray[0] = v;
		front++;
		rear++;
		return;
	}

	if (size > capacity)
	{
		reSize();
	}

	else if (front == -1)
	{
		front = 0;
		rear = size - 1;
	}

	else
	{
		rear = (rear + 1) % capacity;
	}
	circArray[rear] = v;

}

template <class T>
void CDA<T>::AddFront(T v)
{
	size++;
	if (size > capacity)
	{
		reSize();
	}

	if (front == -1) //means the array is empty
	{
		front = 0;
		rear = capacity % size;
	}

	else if (front == 0) //means something is in spot 0
	{
		front = capacity - 1; //puts front at the end and places the input there
	}

	else //go until it is back at zero
	{
		front--;
	}
	circArray[front] = v;

}


template <class T>
void CDA<T>::DelEnd()
{
	size--;
	if (size <= capacity / 4)
	{
		Shrink();
	}

	else if (rear == front)
	{
		front = -1;
		rear = -1;
	}

	else
	{
		rear--;
	}
}

template <class T>
void CDA<T>::DelFront()
{

	size--;
	double shrMeasure;
	shrMeasure = capacity / 4.0;
	if (size <= shrMeasure) // make an empty and shrink function
	{
		Shrink();
	}

	/*
	else if (front == rear)
	{
		if (front == 0)
			front = size - 1;

		else
		front++;
	}
	*/
	else
	{
		if (front == size) //brings it full circle 
		{
			front = 0;
		}

		else
		{
			front++;
		}
	}
	if (front > capacity)
		front = front % capacity;
}

template <class T>
int CDA<T>::Length()
{
	return size;
}

template <class T>
int CDA<T>::Capacity()
{
	return capacity;
}

template <class T>
int CDA<T>::Clear()
{
	~CDA();
	size = 1;
	circArray[size] = NULL;

}

template <class T>
bool CDA<T>::Ordered()
{
	return ordered;
}

template <class T>
int CDA<T>::SetOrdered()
{

	for (int i = 1; i < size - 1; i++)
	{
		if (circArray[(i - 1)] > circArray[i])
		{
			ordered = false;
			return -1;
		}
	}
	ordered = true;
	return 1;

}

template <class T>
T CDA<T>::Select(int k)
{
	if (ordered == true)
	{
		return circArray[(front + k - 1) % capacity];
	}
	else
		QuickSelect(front, front + (size - 1), k);
}

template <class T>
int CDA<T>::QSelPartition(int left, int right)
{
	int pivot = circArray[right % capacity];
	int x = left - 1;

	//Swap(&circArray[pivIndex], &circArray[right]);

	for (int i = left; i <= right - 1; i++)
	{
		if (circArray[i % capacity] <= pivot)
		{
			x++;
			Swap(&circArray[x % capacity], &circArray[i % capacity]);
		}
	}
	Swap(&circArray[(x + 1) % capacity], &circArray[right % capacity]);

	return (x + 1);
}

template <class T>
T CDA<T>::QuickSelect(int left, int right, int k)
{
	if (k > 0 && k <= (right - left) + 1)
	{
		int index = QSelPartition(left, right);

		if (index - 1 == k - 1)
			return circArray[index % capacity];

		else if (index - 1 > k - 1)
			return QuickSelect(left, index - 1, k);

		else
			return QuickSelect(index - 1, right, k - index + left - 1);
	}
	return -1;
}

template <class T>
void CDA<T>::InsertionSort() //must be utilized in quicksort
{
	for (int i = front + 1; i < (front + size); i++)
	{
		int val = circArray[i % capacity];
		int inc = (i - 1) % capacity;

		while (inc >= 0 && circArray[inc] > val)
		{
			circArray[(inc + 1) % capacity] = circArray[inc];
			inc--;

			if (inc == -1)
			{
				inc = capacity - 1;
			}
		}
		circArray[(inc + 1) % capacity] = val;
	}
	ordered = true;
}

template <class T>
void CDA<T>::QuickSort() // change to other quicksort before leaving the ferg 
{
	QuickSort1(front, front + (size - 1));
}

template <class T>
void CDA<T>::QuickSort1(int low, int high)
{
	while (low < high)
	{
		if (high - low < 900)
		{
			InsertionSort();
			break;
		}
		else
		{
			int pivot = QSortPartition(low, high);

			if (pivot - low < high - pivot)
			{
				QuickSort1(low, pivot--);
				low = pivot + 1;
			}
			else
			{
				QuickSort1(pivot++, high);
				high = pivot - 1;

			}
		}
	}

}

template <class T>
int CDA<T>::QSortPartition(int low, int high)
{
	int pivot = circArray[Median(low, high) % capacity];
	Swap(&circArray[(Median(low, high)) % capacity], &circArray[(high) % capacity]);

	int index = low % capacity;

	for (int i = low; i < high; i++)
	{
		if (circArray[i % capacity] <= pivot)
		{
			T t = circArray[i % capacity];
			circArray[i % capacity] = circArray[index % capacity];
			circArray[index % capacity] = t;
			index++;
		}
	}
	Swap(&circArray[index % capacity], &circArray[high % capacity]);

	return index;
}

template <class T>
int CDA<T>::Median(int low, int high)
{
	T left, mid, right;
	left = circArray[low % capacity];
	mid = circArray[((low + high) / 2) % capacity];
	right = circArray[high % high];

	if (left < right && left > mid)
		return low % capacity;
	if (left < mid && left > right)
		return low % capacity;
	if (right < left && right > mid)
		return high % capacity;
	if (right < mid && right > left)
		return high % capacity;
	if (mid < left && mid > right)
		return ((low + high) / 2 % capacity);
	if (mid < right && mid > left)
		return ((low + high) / 2 % capacity);
}

template <class T>
void CDA<T>::Swap(int* x, int* y)
{
	int temp = *x;
	*x = *y;
	*y = temp;
}

template <class T>
void CDA<T>::CountingSort(int m)  ////NEED TO FIX THIS 
{
	int* OP = new int[size];
	int* Counter = new int[m + 1];

	for (int i = front; i <= rear; i++)
	{
		cout << "CircArray[" << i << "] is " << circArray[i] << endl;
	}
	for (int i = 0; i <= m; i++)
	{
		Counter[i] = 0;
	}
	for (int i = front; i < front + (size); i++)
	{
		Counter[circArray[i % capacity]]++;
	}
	for (int i = 1; i <= m; i++)
	{
		Counter[i] += Counter[i - 1];
	}

	for (int i = rear - 1; i > 0; i--)
	{
		OP[Counter[circArray[i]] - 1] = circArray[i];
		cout << "Circular array at " << i << " is " << circArray[i] << endl;
		Counter[circArray[i]] -= 1;
		if (i == front % capacity)
			break;

		if (i == 0)
			i = capacity;

	}

	for (int i = 0; i < size; i++)
		circArray[i] = OP[i];

	ordered = true;
	front = 0;
}



template <class T>
int CDA<T>::Search(T e)
{
	if (ordered == true) //binary search of item e
	{
		return BinarySearch(front, front + (size - 1), e);
	}

	else if (ordered == false)
	{
		for (int i = 0; i < size - 1; i++)
		{
			if (circArray[i] == e)
				return i;
		}
	}

	return -1;
}

template <class T>
int CDA<T>::BinarySearch(int left, int right, T e)
{
	while (left <= right)
	{
		int mid = (left + right) / 2;
		int value = circArray[mid % capacity];
		if (value == e)
			return (mid - front) % capacity;

		else if (value < e)
			return BinarySearch(mid + 1, right, e);

		else if (value > e)
			return BinarySearch(left, mid - 1, e);

	}

	return -1;

}


template <class T>
void CDA<T>::reSize()
{
	capacity = capacity * 2;
	T *nArray = new T[capacity];
	for (int i = 0; i < size - 1; i++)
	{
		int l = (front + i) % (size-1);
		nArray[i] = circArray[l];
	}
	//delete[]circArray;
	circArray = nArray;
	front = 0;
	rear = (size - 1);
}


template <class T>
void CDA<T>::Shrink()
{
	int tFront = front;
	capacity = capacity / 2;
	T* bArr = new T[capacity];
	int index = 0;
	while (front <= rear)
	{
		bArr[index] = circArray[(front + index) % capacity];
		index++;
	}
	T* circArray = bArr;
	front = 0;
	rear = (size - 1);
}

template <class T>
CDA<T>& CDA<T>::operator=(const CDA<T>& a)
{
	if (this != &a)
	{
		delete[]circArray;
		size = a.size;
		capacity = a.capacity;
		circArray = new T[a.capacity];
		front = a.front;
		rear = a.size - 1;
		ordered = a.ordered;
		for (int i = a.front; i < a.front + (a.size); i++)
		{
			circArray[i % capacity] = a.circArray[i % capacity];
		}
	}
	return *this;
}

template <class T>
int CDA<T>::Front()
{
	return front;
}

template <class T>
T CDA<T>::Data(int n)
{
	return circArray[n];
}

#include <iostream>
#include "CDA-1.cpp"
using namespace std;

template<class keytype, class valuetype>
class Heap
{
private:
	CDA<keytype>* K;
	CDA<valuetype>* V;
	int size;

public: 
	Heap()
	{
		this->K = new CDA<keytype>();
		this->V = new CDA<valuetype>();
		size = 0;
	}

	Heap(keytype k[], valuetype v[], int s)
	{
		//allocate two different arrays for each type
		//fill those arrays concurrently using insert
		//sort concurrently using heapafy recursively
		this->K = new CDA<keytype>(s);
		this->V = new CDA<valuetype>(s);
		this->size = s;
		for (int i = 0; i < s; i++)
		{
			insert(k[i], v[i]);
		}
		heapify(s, K->Front());
	}

	void heapify(int s, int i)
	{
		//Errors for evans to fix:	swap the n's with s. 
									//Fix the left and right variable logic. Hepaify smallest not small at the bottom. 
									//Also we need to pass V[] in a parameter so we can edit it in this. 

		//How to better swap V with K and not just K.
		int smallest = i; 
		int left = 2*i +(-i+1);  
		int right = 2*i + (-i+2);
		
		keytype kl = K->Data(left);
		keytype kr = K->Data(right);
		keytype ks = K->Data(smallest);
	   	if (left < s && kl < ks) //FIX 
			smallest = left;

		if (right < s && kr < ks) //FIX
			smallest = right;

		if (smallest != i)
		{
			swap(K[i], K[smallest]);
			swap(V[i], V[smallest]); //FIX

			heapify(s, smallest);
		}
	}

	~Heap() {
		return;
	}

	//items should be inserted using bottom up heap building method
	void insert(keytype k, valuetype v)
	{
		K->AddEnd(k);
		V->AddEnd(v);
		
		heapify(size, K->Front());
	}


	keytype peekKey()
	{
		int f = K->Front();
		return K->Data(f);
	}

	valuetype peekValue()
	{
		int f = V->front();
		return V->Data(f);
	}

	keytype extractMin()
	{
		keytype temp = K->Data(K->Front());
		K->DelFront();
		V->DelFront();
		heapify(size, K->Front());
		return temp;
	}

	void printKey()
	{
		ActualPrintKey(K->Front());
	}

	void ActualPrintKey(int n)
	{
		keytype rt = K->Data(n);
		if (rt != size)
		{
			cout << K->Data(rt) << " ";
			ActualPrintKey((2 * n) + (-n + 1));
			ActualPrintKey((2 * n) + (-n + 2)); 
		}
	}
};

/*
template <class keytype, class valuetype>
class BHeap
{
	BHeap();

	BHeap(keytype k[], valuetype v[], int s);

	~BHeap();

	keytype peekKey();

	valuetype peekValue();

	keytype extractMin();

	//items should be inserted using repeated insertion
	void insert(keytype k, valuetype v);

	void merge(BHeap<keytype, valuetype>& H2);

	void printKey(); 
};
*/

#include <iostream>
#include "Heaps.cpp"

using namespace std;

int main() {
	
	string K[10] = { "A", "B", "C", "D", "E", "F", "G", "H", "I", "K" };
	int V[10] = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };

	Heap<string, int> T1, T2(K, V, 10);
	cout << T2.peekKey() << endl;
	cout << endl;
	system("pause");

	return 0;
}
access-violation
1个回答
0
投票

通常，“访问冲突读取位置”表示您正在尝试向不属于您的应用程序的进程读取虚拟的内存地址空间，并且操作系统保护机制正在启动以保护其余已加载的应用程序和资源从您的应用程序访问（读取或写入）“内存泄漏漏洞”。如果我在您家，请检查代码以及所有变量和数组，如果它们在使用前已正确初始化。需要考虑的另一件事是操作系统和应用程序所需的权限（Windows以Administrator / GNU / Linux sudo身份运行）。

欢呼声

最新问题
© www.soinside.com 2019 - 2024. All rights reserved.