c++动态内存分配、把转置矩阵函数改造成转置矩阵类

函数版：

#include <iostream>
using namespace std;
 void swap(int &a,int &b)
{
	int temp;
	temp = a;
	a = b;
	b = temp;
}
int main()
{
	int **p;//指向指针的指针p，被它指向的对象还是一个指针
	p = new int*[3];//p指向的是指针数组，该数组的元素都是指针，指针名可看作p[0],p[1],p[2]
	cout << "请输入9个数：" << endl;
	for (int i=0; i < 3; i++)
	{
		p[i] = new int[3];//使每个指针都指向一个含3个元素的一维数组
	}
	for (int i = 0; i <3; i++)
		for (int j = 0; j < 3; j++)
	{
			cin >> p[i][j];
	}
	cout << "原数组" << endl;
	for (int i = 0; i < 3; i++)
		for (int j = 0; j < 3; j++)
		{
			cout << p[i][j]<<"\t";
			if (j == 2) { cout << endl; }
		}
	for (int i = 0; i < 3; i++)
		for (int j = 0; j < i; j++)//注意是j < i;不是j < 3;要不然又转置回来了
		{
			swap(p[i][j], p[j][i]);
		}
	cout << "转置数组后" << endl;
	for (int i = 0; i < 3; i++)
		for (int j = 0; j < 3; j++)
		{
			cout << p[i][j] << "\t";
			if (j == 2) { cout << endl; }
		}
	
	return 0;
}

请输入9个数：
1 2 3 4 5 6 7 8 9
原数组
1       2       3
4       5       6
7       8       9
转置数组后
1       4       7
2       5       8
3       6       9
请按任意键继续. . .

类版：功能能实现，但是delete部分有问题，会报错！

#include <iostream>
using namespace std;
class T {
public:
	T(int n = 2);
	~T();
	T(const T&v);
	void swap(int &a, int &b);
	void show();
	void transform();
	void input();
private:
	int **p;
	int size;
};

T::T(int n ) :p(new int*[n]), size(n)
{
	for (int i = 0; i < size; i++)
	{
		p[i] = new int[size];//使每个指针都指向一个含size个元素的一维数组
	}
	cout << "调用构造函数，动态创建指针数组" << endl;
}
T::~T()
{
	for (int i = 0; i < size; i++)
	{
		delete []p[i];
		cout << "调用析构函数，delete[] p["<<i<<"]" << endl;
	}
	//delete []p;//!!!!!!!!!!!为什么报错！
	cout << "调用析构函数，delete[] p" << endl;
	cout << "调用析构函数，delete动态创建指针指向的空间" << endl;
}
T::T(const T&v) :size(v.size), p(new int*[size])
{
	for (int i = 0; i < size; i++)
	{
		p[i] = new int[size];//使每个指针都指向一个含size个元素的一维数组
	}
	for (int i = 0; i < size; i++)
		for (int j = 0; j < size; j++)
		{
			p[i][j] = v.p[i][j];
		}
	cout << "调用复制函数，深拷贝" << endl;
}
void T::swap(int &a, int &b)
{
	int temp;
	temp = a;
	a = b;
	b = temp;
}
void T::show()
{
	for (int i = 0; i < size; i++)
		for (int j = 0; j < size; j++)
		{
			cout << p[i][j] << "\t";
			if (j == size - 1) { cout << endl; }
		}
}
void T::transform()
{
	for (int i = 0; i < size; i++)
		for (int j = 0; j < i; j++)//注意是j < i;不是j < size;要不然又转置回来了
		{
			swap(p[i][j], p[j][i]);
		}
}
void T::input()
{
	
	cout << "请输入矩阵："<<endl;
	for (int i = 0; i < size; i++)
		for (int j = 0; j <size; j++)
		{
			cin >> p[i][j];
		}
}
int main()
{   
	int n;
	cout << "请输入方阵维数：" << endl;
	cin >> n;
	T juz(n);
	juz.input();
	cout << "原矩阵" << endl;
	juz.show();
	juz.transform();
	cout << "转置后的矩阵" << endl;
	juz.show();
	cout << "测试复制构造函数深拷贝" << endl;
	T juz1 = juz;
	juz1.show();
	return 0;
}

转置3阶方阵：

请输入方阵维数：
3
调用构造函数，动态创建指针数组
请输入矩阵：
1 2 3 4 5 6 7 8 9
原矩阵
1       2       3
4       5       6
7       8       9
转置后的矩阵
1       4       7
2       5       8
3       6       9
测试复制构造函数深拷贝
调用复制函数，深拷贝
1       4       7
2       5       8
3       6       9
调用析构函数，delete[] p[0]
调用析构函数，delete[] p[1]
调用析构函数，delete[] p[2]
调用析构函数，delete[] p
调用析构函数，delete动态创建指针指向的空间
调用析构函数，delete[] p[0]
调用析构函数，delete[] p[1]
调用析构函数，delete[] p[2]
调用析构函数，delete[] p
调用析构函数，delete动态创建指针指向的空间
请按任意键继续. . .

转置2阶方阵：

请输入方阵维数：
4
调用构造函数，动态创建指针数组
请输入矩阵：
1 2 3 4 5 6 7 8 9 22 33 44 55 66 77 88
原矩阵
1       2       3       4
5       6       7       8
9       22      33      44
55      66      77      88
转置后的矩阵
1       5       9       55
2       6       22      66
3       7       33      77
4       8       44      88
测试复制构造函数深拷贝
调用复制函数，深拷贝
1       5       9       55
2       6       22      66
3       7       33      77
4       8       44      88
调用析构函数，delete[] p[0]
调用析构函数，delete[] p[1]
调用析构函数，delete[] p[2]
调用析构函数，delete[] p[3]
调用析构函数，delete[] p
调用析构函数，delete动态创建指针指向的空间
调用析构函数，delete[] p[0]
调用析构函数，delete[] p[1]
调用析构函数，delete[] p[2]
调用析构函数，delete[] p[3]
调用析构函数，delete[] p
调用析构函数，delete动态创建指针指向的空间
请按任意键继续. . .

转置5阶方阵：

请输入方阵维数：
5
调用构造函数，动态创建指针数组
请输入矩阵：
1 2 3 4 5 6 7 8 9 11 22 323 44 55 66 77 88 99 111 111 222 333 444 555 666
原矩阵
1       2       3       4       5
6       7       8       9       11
22      323     44      55      66
77      88      99      111     111
222     333     444     555     666
转置后的矩阵
1       6       22      77      222
2       7       323     88      333
3       8       44      99      444
4       9       55      111     555
5       11      66      111     666
测试复制构造函数深拷贝
调用复制函数，深拷贝
1       6       22      77      222
2       7       323     88      333
3       8       44      99      444
4       9       55      111     555
5       11      66      111     666
调用析构函数，delete[] p[0]
调用析构函数，delete[] p[1]
调用析构函数，delete[] p[2]
调用析构函数，delete[] p[3]
调用析构函数，delete[] p[4]
调用析构函数，delete[] p
调用析构函数，delete动态创建指针指向的空间
调用析构函数，delete[] p[0]
调用析构函数，delete[] p[1]
调用析构函数，delete[] p[2]
调用析构函数，delete[] p[3]
调用析构函数，delete[] p[4]
调用析构函数，delete[] p
调用析构函数，delete动态创建指针指向的空间

报错！！！！！！！！！！！！

---------------------------
Microsoft Visual C++ Runtime Library
---------------------------
Debug Assertion Failed!

Program: D:\VS2017程序\指针数组\Debug\指针数组与new.exe
File: minkernel\crts\ucrt\src\appcrt\heap\debug_heap.cpp
Line: 904

Expression: _CrtIsValidHeapPointer(block)

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

(Press Retry to debug the application)

---------------------------
中止(A)   重试(R)   忽略(I)   
---------------------------

问题代码

T::~T()
{
	for (int i = 0; i < size; i++)
	{
		delete []p[i];
		cout << "调用析构函数，delete[] p["<<i<<"]" << endl;
	}
	//delete []p;//!!!!!!!!!!!为什么报错！
	cout << "调用析构函数，delete[] p" << endl;
	cout << "调用析构函数，delete动态创建指针指向的空间" << endl;
}

哪的原因？