C++11 什么是分割错误。如何处理

问题:

• • 一名学生报名参加研讨会，并希望参加最多的
    没有两个车间重叠的车间数量。你必须做这个
    以下：实施结构：
  • struct Workshop包含以下成员：研讨会的开始时间。研讨会的持续时间。研讨会的结束时间
  • struct Available_Workshop包含以下成员：整数（学生注册的研讨会数量）。安
    具有大小的车间阵列类型的阵列。执行功能：
  • 可用的工作坊*初始化（int start_time[]，int duration[]，int n）创建一个可用的工作坊对象，并 使用和参数中的元素初始化其元素 （两者都有尺寸）。这里，和是各自的开始时间和时间 讲习班的持续时间。此函数必须返回指向的指针 一个可用的对象
  • int CalculateMaxWorkshops（可用的_Workshops*ptr）返回学生可以参加的研讨会的最大数量，无重叠。
    只有在上一个研讨会之前，才能参加下一个研讨会
    末端。注意：未知大小（）的数组应声明为
    如下：数据类型*arrayName=新数据类型[n]
  初始化函数必须返回指向 可用对象。您的CalculateMaxWorkshops功能
  必须返回学生的最大非重叠研讨会数
  可以参加。
  样本输入

6
130558
161241
样本输出

四,

说明第一行表示车间的数量。下一行包含空格分隔的整数，其中整数 是车间的开始时间。下一行包含 以空格分隔的整数，其中整数是车间的 期间学生可以参加研讨会，也可以不参加 重叠，因此CalculateMaxWorkshops返回main（然后 打印到标准输出）

我的代码：

#include <iostream>

using namespace std;


class Workshop{
    public:
    int start_time{},duration{},end_time{};};

class Available_Workshops
{
    public:
     int n{};
    struct Workshop*arr=new struct Workshop[n];
    ~Available_Workshops()
    {
        delete [] arr;

    }
    void arr_sort();
    void arr_delete(int i);


};
////////////////////////////////////////////////////////////////////////////////////////////
Available_Workshops * initialize(int start_time[],int duration[],int n)
{
    Available_Workshops * x=new Available_Workshops{};
    x->n=n;
    for(int i=0;i<n;i++)
    {
     x->arr[i].start_time=start_time[i];
     x->arr[i].duration=duration[i];
     x->arr[i].end_time=start_time[i]+duration[i];
    }

    return x;

}
///////////////////////////////////////////////////////////////////////////////////////////
void Available_Workshops:: arr_delete(int i)
{

    n-=1;


    for(int j=i;j<n;j++)
    {
     arr[j]=arr[j+1];
    }


}
///////////////////////////////////////////////////////////////////////////////////////////
void Available_Workshops:: arr_sort()
{
for(int i=0;i<n;i++)
{
    for(int j=i+1;j<n;j++)
    {
        if(arr[i].start_time>arr[j].start_time)
            {
                struct Workshop temp=arr[i];
                arr[i]=arr[j];
                arr[j]=temp;
            }
    }
}


}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int CalculateMaxWorkshops(Available_Workshops * x)
{
    x->arr_sort();
    for(int i=0;i<x->n-1;i++)
    {
       for(int j=i+1;j<x->n;j++)
       {
           if(x->arr[i].end_time>x->arr[j].start_time)
           {
               if(x->arr[i].duration>=x->arr[j].duration)
                x->arr_delete(i);
               else x->arr_delete(j);
               j--;
           }
       }
    }
    int y=x->n;
    delete x;
   return y;

}

int main(int argc, char *argv[]) {
    int n; // number of workshops
    cin >> n;
    // create arrays of unknown size n
    int* start_time = new int[n];
    int* duration = new int[n];

    for(int i=0; i < n; i++){
        cin >> start_time[i];
    }
    for(int i = 0; i < n; i++){
        cin >> duration[i];
    }

    Available_Workshops * ptr;
    ptr = initialize(start_time,duration, n);

    cout << CalculateMaxWorkshops(ptr) << endl;
    return 0;
}

#包括
使用名称空间std；
班级工作坊{
公众：
int开始时间{}，持续时间{}，结束时间{}；}；
可参加的课程及工作坊
{
公众：
int n{}；
结构车间*arr=新结构车间[n]；
~u可用的工作坊（）
{
删除[]arr；
}
void arr_sort（）；
无效arr_删除（int i）；
};
////////////////////////////////////////////////////////////////////////////////////////////
可用的工作坊*初始化（整数开始时间[]，整数持续时间[]，整数n）
{
可用的车间*x=新的可用车间{}；
x->n=n；
对于（inti=0；iarr[i]。开始时间=开始时间[i]；
x->arr[i]。持续时间=持续时间[i]；
x->arr[i]。结束时间=开始时间[i]+持续时间[i]；
}
返回x；
}
///////////////////////////////////////////////////////////////////////////////////////////
无效可用工作坊：：arr\u delete（int i）
{
n-=1；
对于（int j=i；jarr[i]。结束时间>x->arr[j]。开始时间）
{
如果（x->arr[i]。持续时间>=x->arr[j]。持续时间）
x->arr_删除（i）；
else x->arr_delete（j）；
j--；
}
}
}
int y=x->n；
删除x；
返回y；
}
int main（int argc，char*argv[]）{
int n；//车间数量
cin>>n；
//创建大小未知的数组n
int*开始时间=新int[n]；
整数*持续时间=新整数[n]；
对于（int i=0；i>开始时间[i]；
}
对于（int i=0；i>持续时间[i]；
}
可用的工作坊*ptr；
ptr=初始化（开始时间，持续时间，n）；
cout您可以从类声明中看到bug：

class Available_Workshops
{
public:
    int n{};
    struct Workshop* arr = new struct Workshop[n];

    ~Available_Workshops()
    {
        delete[] arr;

    }
    void arr_sort();
    void arr_delete(int i);


};

成员
n
被显式初始化为0。然而，您的
initialize
函数将愉快地将更多元素填充到
arr
（一个零元素数组）中，并导致各种未定义的行为

你真的，真的想要一个适合你的类的构造函数，而不是试图内联初始化成员

Available_Workshops(int size) :
n(size)
{
    arr = new Workshop[n];
}

另一个与崩溃无关的问题是
arr\u delete
函数中的问题

for (int j = i; j < n; j++)
{
    arr[j] = arr[j + 1];
}

for（int j=i；j

在循环的最后一次迭代中，当
j==n-1
时，它将执行
arr[n-1]=arr[n]
。访问
arr[n]
是未定义的行为，因为数组中唯一有效的索引来自
[0..n-1]
第15行似乎可疑，可能引发异常。
~Available\u Workshops（）{delete[]arr；}