VC++ во время выполнения debug вылазит сообшение Unhandled exception и выполнение заканчивается
ошибка возникает при оканчание выполнения процедуры Init.

#include "stdafx.h"

#include <stdio.h>
#include<iostream>
#include<vector>
#include"MyMath.h"
using namespace std;


const int num=4;
typedef float typ;
typedef vector<double> MasD;
void main()
{
    CSpline dsa;
    MasD f;
    MasD e;
    for(int i=0;i<100;i++)
    {
        f.push_back(i);
        e.push_back(i);
    }
    dsa.Init(f,e);
}

//Mymath.h

#define MY_MATH_HHH

#include <vector>
#include "MyType.h"
void MethodProgon(int n,const MasD2& mas,MasD& rez);
class CSpline
{
private:
    MasD a,b,c,d;
    MasD x,y;
    int num;
    int qy;
    bool initial;
public:
    void Init(const MasD& x,const MasD& y);
    void ReturnSplineCoef(MasD& a,MasD& b,MasD& c,MasD& d);
    void ReturnExtrDate(MasD& x,MasD& y);
    double Mean(double x);
    CSpline();
};
double IntegRect(double x0,double xN,tFun fun,double precision);
double IntegRect(double x0,double xN,CSpline& fun,double precision);
#endif

//MyMath.cpp

#include "MyMath.h"
#include "iostream.h"
#include <math.h>

void MethodProgon(int n,const MasD2& mas,MasD& rez)
{

    std::vector<double> A(n-1),B(n-1),C(n-1);
    A[0]=-mas[0][1]/mas[0][0];
    B[0]=mas[0][n]/mas[0][0];
    for(int i=1;i<(n-1);i++)
    {
        double e=0.0;
        e=mas[i][i-1]*A[i-1]+mas[i][i];
        A[i]=-mas[i][i+1]/e;
        B[i]=(mas[i][n]-mas[i][i-1]*B[i-1])/e;
    }
    rez[n-1]=(mas[n-1][n]-mas[n-1][n-2]*B[n-2])/(mas[n-1][n-1]+mas[n-1][n-2]*A[n-2]);
    for(int i=n-2;i>=0;i--)
    {
        rez[i]=A[i]*rez[i+1]+B[i];
    }
}

CSpline::CSpline()
{
    initial=false;
}

void CSpline::Init(const MasD &x0,const MasD &y0)
{
    if(initial==true)
    {
        x.clear();
        y.clear();
        a.clear();
        b.clear();
        c.clear();
        d.clear();
    }
    initial=true;

    num=x0.size();
    for(int i=0;i<num;i++)
    {
        y.push_back(y0[i]);
        x.push_back(x0[i]);
        c.push_back(0);
        if(i!=(num-1))
        {
            a.push_back(y0[i]);
            b.push_back(0);
            d.push_back(0);
        }
    }
    MasD h(num-1);
    for(int i=0;i<num-1;i++)h[i]=x[i+1]-x[i];
    c[0]=0;
    c[num-1]=0;
    MasD2 mas(num-2);
    InitMasD2(mas,num-1,0);
    for(int i=0;i<num-2;i++)
    {
        if(i>0)mas[i][i-1]=h[i];
        mas[i][i]=2*(h[i]+h[i+1]);
        if(i<num-3)mas[i][i+1]=h[i+1];
        mas[i][num-2]=3*((y[i+2]-y[i+1])/h[i+1]-(y[i+1]-y[i])/h[i]);
    }
    MasD rezC(num-2);
    MethodProgon(num-2,mas,rezC);
    for(int i=1;i<num-1;i++)c[i]=rezC[i];
    for(int i=0;i<num-1;i++)
    {
        d[i]=(c[i+1]-c[i])/3/h[i];
        b[i]=(y[i+1]-y[i])/h[i]-h[i]*(c[i+1]+2*c[i])/3;
    }
}

double CSpline::Mean(double x0)
{
    double mean;
    for(int i=0;i<num-1;i++)
    {
        if((x0>=x[i])&&(x0<=x[i+1]))
        {
            mean=a[i]+b[i]*(x0-x[i])+c[i]*(x0-x[i])*(x0-x[i])
                +d[i]*(x0-x[i])*(x0-x[i])*(x0-x[i]);
            return mean;
        }
    }
    return 0;
}

void CSpline::ReturnSplineCoef(MasD& a0,MasD& b0,MasD& c0,MasD& d0)
{
    for(int i=0;i<a.size();i++)
    {
        a0.push_back(a[i]);
        b0.push_back(b[i]);
        c0.push_back(c[i]);
        d0.push_back(d[i]);
    }
}

void CSpline::ReturnExtrDate(MasD& x0,MasD& y0)
{
    for(int i=0;i<x.size();i++)
    {
        x0.push_back(x[i]);
        y0.push_back(y[i]);
    }
}


double IntegRect(double x0,double xN,tFun fun,double precision)
{
    double I,I0;
    I=(xN-x0)*fun((xN+x0)/2);
    int n=1;
    do
    {
        I0=I;
        I=0;
        n*=2;
        double deltaX=(xN-x0)/n;
        for(int i=0;i<n;i++)
        {
            I+=deltaX*fun(x0+deltaX/2+deltaX*i);
        }
    }
    while(fabs(I-I0)>precision);
    return I;
}


double IntegRect(double x0,double xN,CSpline& fun,double precision)
{
    double I,I0;
    I=(xN-x0)*fun.Mean((xN+x0)/2);
    int n=1;
    do
    {
        I0=I;
        I=0;
        n*=2;
        double deltaX=(xN-x0)/n;
        for(int i=0;i<n;i++)
        {
            I+=deltaX*fun.Mean(x0+deltaX/2+deltaX*i);
        }
    }
    while(fabs(I-I0)>precision);
    return I;
}

MyType.h

#ifndef MY_TYPE_HHH
#define MY_TYPE_HHH

#include<vector>
typedef std::vector<double> MasD;
typedef std::vector<MasD> MasD2;
typedef std::vector<MasD2> MasD3;
typedef double(*tFun)(double);
void InitMasD2(MasD2& mas1,int num,double mean);
//-----------------------------------------------------------------------------
class ExInitMasD2_ErroeSize{};
#endif

MyType.cpp

#include "MyType.h"


void InitMasD2(MasD2& mas1,int num,double mean)
{
    if ((mas1.size()<1)||(num<1))throw ExInitMasD2_ErroeSize();
    for(int i=0;i<(mas1.size());i++)
    {
        mas1[i].resize(num-1);
        for(int j=0;j<(num);j++) mas1[i][j]=mean;
    };
}