C中的分段故障问题（堆芯转储） #包括 #包括 结构arrayADT{ int*A； 整数大小； 整数长度； int*B； int arr3； }; struct arrayADT*MergeArray（struct arrayADT*arr1，struct arrayADT*arr2）{//我们在堆中创建，因为我们需要能够在主函数中使用这些 struct arrayADT*arr3=（struct arrayADT*）malloc（（sizeof（struct arrayADT））； int i，j，k； i=j=k=0； 而（ilength&&jlength）{ 如果（arr1->A[i]A[j]）{ arr3->A[k]=arr1->A[i]； k++； i++； } 否则{ arr3->A[k]=arr2->A[j]； k++； j++； } } 对于（；ilength；i++）{ arr3->A[k]=arr1->A[i]； k++； } 对于（；j长度；j++）{ arr3->A[k]=arr2->A[j]； k++； } arr3->length=arr1->length+arr2->length； arr3->长度=10； } void main（）{ 结构arrayADT arr； printf（“输入数组的大小”）； scanf（“%d”和&arr.size）； arr.A=（struct arrayADT*）malloc（arr.size*sizeof（int））； arr.length=0； int n； printf（“输入数组中的元素数”）； scanf（“%d”和“&n”）； printf（“输入元素”）； 对于（int i=0；i值[数组->长度++]=x； } }

我想用堆内存合并这些数组，但我遇到了分段错误。我对使用指针的C编程是新手，我在这里被打动了，如果我在你的帮助下通过了这个障碍，那将非常有帮助。 我不知道我的错误在哪里，如果有人也指定了这一点，我会很有帮助，这样我将来可以避免这些错误。

---

PS：我使用的是minGW编译器。

一般来说，您的代码没有组织。存在几种未定义行为的情况，例如，您没有正确扫描第二个数组。分段错误的最可能原因是：

#include <stdio.h>
#include <stdlib.h>

struct arrayADT {

  int *A;
  int size;
  int length;
  int *B;
  int arr3;
};
struct arrayADT * MergeArray(struct arrayADT *arr1, struct arrayADT *arr2) {    //we create thus in heap cuz we need to be able to use these in main function
  
  struct arrayADT *arr3 = (struct arrayADT *)malloc((sizeof(struct arrayADT)));

  int i, j, k;
  i = j = k = 0;

  while(i < arr1->length && j < arr1->length ) {
    if(arr1->A[i] < arr2->A[j]) {
      arr3->A[k] = arr1->A[i];
      k++;
      i++;
    }

    else {
      arr3->A[k] = arr2->A[j];
      k++;
      j++;
    }
  }

  for(; i<arr1->length ; i++) {
    arr3->A[k] = arr1->A[i];
    k++;
  }

  for(; j < arr2->length ; j++) {
    arr3->A[k] = arr2->A[j];
    k++;
  }

  arr3->length = arr1->length + arr2->length;
  arr3->length = 10;
  
  
}
void main() {

  struct arrayADT arr;
  printf("Enter the size of an array");
  scanf("%d", &arr.size);

  arr.A = (struct arrayADT *)malloc(arr.size * sizeof(int));

  arr.length = 0;
  int n;
  printf("enter the number of elements in an array");
  scanf("%d", &n);
  printf("enter the elements");
  for(int i = 0; i < n; i++) {
    scanf("%d", &arr.A[i]);
  }
  arr.length = n;
  display(arr);
  printf("Enter second array");
  
  int j;
  struct arrayADT *B = (struct arrayADT *)malloc((sizeof(struct arrayADT)));
  for(j = 0; j < arr.length; j++) {
    scanf("%d", &B[j]);
  }
  struct arrayADT *arr3 = (struct arrayADT *)malloc(sizeof(struct arrayADT));
  arr3 = MergeArray(&arr, &B);
  display(*arr3);

这将为您提供一个未初始化的内存块。

arr3

的长度和大小可以是任意值，其数据字段

A

未指向有效内存。访问它可能会崩溃

您的代码中有三个数组。您一步一步地构造每个数组，并对每个数组进行不同的处理。这很容易导致错误。让我们更系统地讨论这个问题

让我们为固定大小的数组创建一个结构类型：最大大小必须在创建时给定，并且不能更改。数组的实际长度可以是从0到最大大小的任何值

struct arrayADT *arr3 = (struct arrayADT *)malloc((sizeof(struct arrayADT)));

此函数最多为

size

整数创建一个空数组。如果分配内存，我们以后必须取消分配，因此让我们编写一个相应的析构函数，它将清除资源：

Array *array_create(int size)
{
    Array *array = calloc(1, sizeof(*array));
    
    array->size = size;
    array->value = calloc(size, sizeof(*array->value));
    
    return array;
}

销毁阵列后，它将无法再使用，就像对其调用

free（）

后的内存一样

数组一开始是空的，因此，如果有空间，让我们编写一个函数在其末尾添加元素：

void array_destroy(Array *array)
{
    if (array) {
        free(array->value);
        free(array);
    }
}

void数组\u push（数组*数组，int x）
{
如果（数组->长度<数组->大小）{
数组->值[数组->长度++]=x；
}
}

以及打印它的功能：

void array_push(Array *array, int x)
{
    if (array->length < array->size) {
        array->value[array->length++] = x;
    }
}

void数组\u打印（常量数组*数组）
{
printf（“[”）；
对于（int i=0；ilength；i++）{
如果（i）printf（“，”）；
printf（“%d”，数组->值[i]）；
}
printf（“]\n”）；
}

现在您可以这样创建阵列：

void array_print(const Array *array)
{
    printf("[");
    
    for (int i = 0; i < array->length; i++) {
        if (i) printf(", ");
        printf("%d", array->value[i]);
    }
    
    printf("]\n");
}

Array*a=Array\u create（10）；
对于（int i=0；isize；i++）{
阵列推力（a，i）；
}
阵列打印（a）；
阵列（a）；

合并函数也会更简单。下面是一个完整的示例。（但它使用生成的数组，而不是用户键入的数组。）

#包括
#包括
typedef结构数组；
结构数组{
int*值；
整数长度；
整数大小；
};
数组*数组_创建（整数大小）
{
Array*Array=calloc（1，sizeof（*Array））；
数组->大小=大小；
数组->值=calloc（大小、大小（*数组->值））；
返回数组；
}
无效数组\u销毁（数组*数组）
{
if（数组）{
自由（数组->值）；
自由（数组）；
}
}
无效数组\u推送（数组*数组，整数x）
{
如果（数组->长度<数组->大小）{
数组->值[数组->长度++]=x；
}
}
无效数组\u打印（常量数组*数组）
{
printf（“[”）；
对于（int i=0；ilength；i++）{
如果（i）printf（“，”）；
printf（“%d”，数组->值[i]）；
}
printf（“]\n”）；
}
数组*合并（数组*a，数组*b）
{
Array*res=Array\u create（a->length+b->length）；
int i=0；
int j=0；
而（ilength&&jlength）{
如果（a->值[i]值[j]）{
数组_push（res，a->value[i++]）；
}否则{
数组_push（res，b->value[j++]）；
}
}
while（ilength）{
数组_push（res，a->value[i++]）；
}
而（j长度）{
数组_push（res，b->value[j++]）；
}
返回res；
}
内部主（空）
{
数组*a=数组_创建（10）；
数组*b=数组_创建（6）；
数组*c；
对于（int i=0；isize；i++）{
阵列推送（a，1+3*i）；
}
对于（inti=0；isize；i++）{
阵列推送（b，4+2*i）；
}
阵列打印（a）；
阵列打印（b）；
c=合并（a，b）；
数组_打印（c）；
阵列（a）；
阵列(b),；
阵列销毁（c）；
返回0；
}

如果你已经读过了，下面是一些真相：

• 组织你的代码。这同样适用于代码布局，就像编写小的、普遍适用的函数，而不是“手工”完成所有事情一样。（上面的数组类型有点牵强：它使用函数，但获取数据仍然是通过访问struct字段来完成的。你甚至可以更改

  void array_print(const Array *array)
  {
      printf("[");
      
      for (int i = 0; i < array->length; i++) {
          if (i) printf(", ");
          printf("%d", array->value[i]);
      }
      
      printf("]\n");
  }
  

  Array *a = array_create(10);
  
  for (int i = 0; i < a->size; i++) {
      array_push(a, i);
  }
  
  array_print(a);
  array_destroy(a);
  

  #include <stdio.h>
  #include <stdlib.h>
  
  typedef struct Array Array;
  
  struct Array {
    int *value;
    int length;
    int size;
  };
  
  Array *array_create(int size)
  {
      Array *array = calloc(1, sizeof(*array));
      
      array->size = size;
      array->value = calloc(size, sizeof(*array->value));
      
      return array;
  }
  
  void array_destroy(Array *array)
  {
      if (array) {
          free(array->value);
          free(array);
      }
  }
  
  void array_push(Array *array, int x)
  {
      if (array->length < array->size) {
          array->value[array->length++] = x;
      }
  }
  
  void array_print(const Array *array)
  {
      printf("[");
      
      for (int i = 0; i < array->length; i++) {
          if (i) printf(", ");
          printf("%d", array->value[i]);
      }
      
      printf("]\n");
  }
  
  Array *merge(Array *a, Array *b)
  {
      Array *res = array_create(a->length + b->length);
  
      int i = 0;
      int j = 0;
  
      while(i < a->length && j < b->length) {
          if(a->value[i] < b->value[j]) {
              array_push(res, a->value[i++]);
          } else {
              array_push(res, b->value[j++]);
          }
      }
  
      while(i < a->length) {
          array_push(res, a->value[i++]);
      }
  
      while(j < b->length) {
          array_push(res, b->value[j++]);
      }
      
      return res;
  }
  
  int main(void)
  {
      Array *a = array_create(10);
      Array *b = array_create(6);
      Array *c;
      
      for (int i = 0; i < a->size; i++) {
          array_push(a, 1 + 3 * i);
      }
      
      for (int i = 0; i < b->size; i++) {
          array_push(b, 4 + 2 * i);
      }
      
      array_print(a);
      array_print(b);
      
      c = merge(a, b);
  
      array_print(c);
      
      array_destroy(a);
      array_destroy(b);
      array_destroy(c);
  
      return 0;
  }