用递归实现两矩阵相乘，这里为什么跳不出递归函数呢？

Question

为什么递归的时候跳不出递归函数呢？

vector类：

#define OVERFLOW -2               //数据溢出时的标识符
#define OK 1                      //正确运行时的标识符
#define ERROR 0                   //运行异常时的标识符
#define DEFAULT_CAPACITY 100      //顺序表的默认容量

template <typename ElemType>
class Vector
{
	private:
		int length;     //顺序表的初始长度
		int capacity;   //顺序表的最大存储容量
		ElemType *elem; //用于存储顺序表元素数组的指针
		
		void expand()   //如果顺序表大小大于初始化大小,重新分配空间
		{
			if(length<capacity)
				return;
			if(capacity<DEFAULT_CAPACITY)
				capacity=DEFAULT_CAPACITY;
			ElemType *oldElem=elem;
			elem=new ElemType[capacity<<=1];
			for(int i=0;i<length;i++)
				elem[i]=oldElem[i];
			delete[] oldElem;
		}

	public:
		int size() const { return length; }	    //返回规模大小
		bool empty() const { return !length; }	//判断是否为空
		
    	Vector(int c=DEFAULT_CAPACITY):capacity(c)        //构造函数用于初始化顺序表，在之后所有数据结构都有定义
		{
        	elem=new ElemType[capacity];
        	length=0;
    	}
    
	    ~Vector() { delete[] elem; }         //析构函数用于删除顺序表后释放空间，在之后所有数据结构都有定义	

	
	    ElemType &operator[](int r) const { return elem[r]; }         //重载下标运算符，使其可像数组一样简单访问
     
    	void insert(int r,ElemType const &e)        //在指定位置插入元素e
    	{
        	expand();
        	for(int i=length;i>r;i--) elem[i]=elem[i-1];
        	elem[r]=e;
        	length++;
    	}

	    void insert(ElemType const &e) { insert(length, e); }     //默认在最后插入元素e

    	ElemType get_elem(int i)           //定位指定位置元素，如果有则返回该元素
	    {
        	if (!elem||i>length||i<1)
            	return ERROR; //检查查找位置是否错误
        	return elem[i-1];
    	}
   
    	int locate_elem(ElemType e)      //定位指定元素，如果有返回第一个匹配的元素的位置
	    {
        if (!elem)
			return ERROR;
        for(int i=0;i<length;i++)
            if(e==elem[i])
				return i+1;
        return ERROR;
    	}

	    ElemType remove(int i)       //删除指定位置的元素
    	{
        	ElemType e=elem[i];
        	for(int j=i;j<length;j++)      //强删除元素后的所有元素前移一位
            	elem[j]=elem[j+1];
        	--length;
        	return e;
    	}
    	
    	void reverse()
    	{
    		int i;
			int t=length-1;
			for(i=0;i<length/2;i++)
			{
				elem[i]=elem[i]+elem[t-i];
				elem[t-i]=elem[i]-elem[t-i];
				elem[i]=elem[i]-elem[t-i];
			}
    	}
};

递归程序段：

#include"Vector.h"
#include<iostream>
#include<stdlib.h> 
#include<iomanip>
using namespace std;
//用顺序表进行储存，在输出时通过换行以矩阵的形式输出 
//递归时出现了问题，采用了递归但是不能跳出递归的函数，直接结束了整个的运行，导致不能得到结果 

void CreateMatrix(Vector<int> &matrix,int m, int n)
{
	int e;
	for(int i=0;i<m;i++)
	{
		for(int j=0;j<n;j++)
		{
			cout<<"请输入第"<<i+1<<"行第"<<j+1<<"列的值：" ;
			cin>>e;
			matrix.insert(e);
		}
	}
}

void PrintMatrix(Vector<int> &matrix,int m,int n)
{
	cout<<"两矩阵相乘后的结果为："<<endl; 
	for(int i=0;i<m;i++)
	{
		for(int j=0;j<n;j++)
			cout<<setiosflags(ios::right)<<setw(5)<<matrix[i*n+j];  //控制每个数的长度并按矩阵形式输出 
		cout<<endl;
	}
}

void PrintVector(Vector<int> &L){	//打印顺序表中元素
    cout << "顺序表一共" << L.size() << "个元素:\n";
    for (int i = 0; i < L.size(); i++) cout << L[i] << ' ';
    cout << endl;
}

void MultiplyMatix(Vector<int> &A,Vector<int> &B,Vector<int> &C,int n,int q) 
{
	int e,sum=0;
	Vector<int> D;  //B的替身，实现下面删除D（B）的列后出了函数顺序表B仍不变 
	D=B;
	for(int j=0;j<n;j++)  //A的第一行乘以D的第一列 
	{
		e=A[j]*D[j*q];
		sum=sum+e;
	}
	C.insert(sum);

	for(int i=n-1;i>=0;i--)  
		D.remove(i*q);    //将D矩阵的第一列删除 
	q--;
	
	if(q>0)   //如果D的列数大于0，进行递归 
		MultiplyMatix(A,D,C,n,q);  //递归使 A的第一行乘以B剩下的列 

}

int main()
{
	int m,n,p,q;
	Vector<int> A,B,C;
	cout<<"矩阵A"<<endl;
	cout<<"请输入矩阵的行数：";
	cin>>m;
	cout<<"请输入矩阵的列数：";
	cin>>n;	
	CreateMatrix(A,m,n);
	
	cout<<"矩阵B"<<endl;
	cout<<"请输入矩阵的行数：";
	cin>>p;
	cout<<"请输入矩阵的列数：";
	cin>>q;	
	CreateMatrix(B,p,q);
	
	if(n!=p)
		cout<<"两矩阵不能相乘！"<<endl; 
	else
	{
		while(m>0)     
		{
			MultiplyMatix(A,B,C,n,q);   //递归+循环：A的第一行被删除之后第二行当做第一行再重复以上操作 
			for(int i=0;i<n;i++)    //在A的第一行完成相乘后将A的第一行删除 
				A.remove(i);	
			m--;       //A的行数减1 	
		}
		PrintMatrix(C,m,q);
	}
	
	system("pause");
	return 0;
}