Question

昨天我在C上进行了一次测试，在那里我没有弄清楚最后一个问题：

我们得到了两个类型的数组的两个数组：包含相等连续元素的数组（例如：{“stack”，“heap”，“heap”}）和没有连续元素相等的数组（例如： {1,2,3,4,5,6,7,8,9}）。

然后我们被要求找到一个返回1或0的函数，如果给定的数组包含双精度数。所以这个函数必须同时使用整数数组和char *数组。

这就是我今天提出的问题（但是它会不断给出错误的答案，然后在比较字符串时出现崩溃或分段错误）

编辑：正确的代码（感谢@BLUEPIXY！）

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

int contains_dup(void *array, size_t size, size_t sizeoftype, int (*cmp)(const void*, const void*)){
    //array != NULL, size != 0
    char *obj = array;
    size_t i;
    for(i = 0; i < size-1; ++i){
        if(cmp(obj + sizeoftype * i, obj + sizeoftype * (i+1)))
            return 1;
    }

    return 0;
}

int eqi(const void *a, const void *b){
    int x = *(const int *)a;
    int y = *(const int *)b;
    return x == y;
}
int eqs(const void *a, const void *b){
    return strcmp(a, b) == 0;
}

#define TEST(name, cmp)\
do{\
    int test;\
    puts(#name ":");\
    test = contains_dup(name, sizeof(name)/sizeof(*name), sizeof(*name), cmp);\
    test ? puts("doubles? Yes\n") : puts("doubles? No\n");\
}while(0)\
/**/

int main(void){
int ints_yes[] = {0,1,2,2,2,3,4,4,5};
int ints_no[]  = {0,1,2,3,4,5,6,7,8};
char *strings_yes[]={"heap","stack","stack","overflow"};
char *strings_no[] ={"heap","stack","heap","stack","overflow"};

puts("test:");
TEST(ints_yes, eqi);
TEST(ints_no, eqi);
TEST(strings_yes, eqs);
TEST(strings_no, eqs);
return 0;
}

错误的旧代码：

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

int array_contains_doubles(void ** array, int size, int sizeoftype){
 int i;
 char **out =(char**) malloc(size * sizeof(char*));

 for(i=0;i<size;i++){            //trying to convert the array of ints to an 
    out[i] = array+i*sizeoftype; //array of char * eg: {1,2} ->{"1","2"}
//  *out[i] +='a';
    printf("%c\n",*out[i]);

 }
 out[i]= NULL;

 while(*(out+1)!=NULL){ 
    if(strcmp(*out,*(out++))==0){ //<- where i get the segmentation error
            return 1;
    }

 }

 return 0;

 }


int main(void){
  int i;
  int ints_yes[] = {0,1,2,2,2,3,4,4,5};
  int ints_no[]={0,1,2,3,4,5,6,7,8};
  char * strings_yes[]={"heap","stack","stack","overflow"};
  char * strings_no[]={"heap","stack","heap","stack","overflow"};

  int test = array_contains_doubles((void **) ints_no, 
  sizeof(ints_no)/sizeof(ints_no[0]), sizeof(int));

  (test) ? (printf("doubles? Yes")) : (printf("doubles? No"));

}

对于任何拼写错误，很抱歉，英语不是我的母语。

Answer 1

你的老师可能会钓到什么，是为了你实现一个＆＃34;仿函数＆＃34;类似于传递给bsearch的函数指针（研究这个函数）。有点像这样：

typedef int comp_func_t (const void*, const void*);

bool equal (const void* obj1, const void* obj2, comp_func_t* comp)
{
  return comp(obj1, obj2)==0;
}

您可以使用指向要比较的对象的指针从应用程序中调用equal，无论它们是什么类型的对象。函数指针指定应如何比较此类型的对象。然后，您可以为每种类型实现比较函数：

int comp_int (const void* obj1, const void* obj2)
{
  int a = *(const int*)obj1;
  int b = *(const int*)obj2;

  if(a < b)
  {
    return -1;
  }
  else if(a > b)
  {
    return 1;
  }
  else // a == b
  {
    return 0;
  }
}

int comp_str (const void* obj1, const void* obj2)
{
  ...
}

典型用途可能是：

int x;
int y;
...
if(equal(&x, &y, comp_int))
{
  ...
}

现在这只比较了两个对象，所以你必须通过1）对数组进行排序以及2）为排序数组中的每两个相邻项调用它来扩展数组，以找出是否存在相等。

以上是旧的，事实上的标准＆＃34;在C语言中实现特定于类型的行为的方法。在该语言的较新版本中，通过_Generic关键字可以获得更优雅的方法，但这可能不会在初学者级别的类中解决。

C：检查数组是否包含相等的连续元素

1 个答案: