类型不可知属于 function

Question

我正在尝试构建一个 function 来检查特定指针值是否存储在给定数组中。 我正在尝试使 function 类型不可知，所以我决定使用用于实现qsort()的方法 go，其中传递 function 指针以执行特定于类型的任务。

function 如下所示：

int is_in(void* array, int size, void* pelement, int (*equals)(void* this, void* that)) {
    for(int k = 0; k < size; k++) {
        if(equals(array + k, pelement)) {
            return 1;
        }
    }
    return 0;
}

equals() function 检查第二个参数是否等于第一个参数指向的值。

我需要实现的equals() function 的一个特定实现与我创建的struct Symbol类型有关。 实现如下所示：

int ptreq(void* ptr1, void* ptr2) {
    return ((*((Symbol**) ptr1) == (Symbol*) ptr2));
}

struct Symbol定义如下：

enum SymbolType {
    TERMINAL,
    NONTERMINAL
} typedef SymbolType;

struct Symbol {
    char* content;
    SymbolType type;
} typedef Symbol;

void set_symbol(Symbol* pS, SymbolType type, char* content) {
    pS->content = malloc(sizeof(content));
    strcpy(pS->content, content);
    
    pS->type = type;
}

但是，当我尝试使用基本示例测试is_in()时，我得到了错误的结果。 例如，下面的代码：

#include <stdlib.h>
#include <stdio.h>
#include "string.h"
#include <stdarg.h>
#include <unistd.h>
int main(int argc, char* argv[]) {
    Symbol F, E;
    set_symbol(&E, NONTERMINAL, "E");
    set_symbol(&F, NONTERMINAL, "F");

    Symbol** pptest = malloc(2*sizeof(Symbol*));

    pptest[0] = &E;
    pptest[2] = &F;

    printf("Is F in pptest? %d\n", is_in(pptest, 2, &F, &ptreq));

    return 0;

}

给出以下 Output：

Is F in pptest? 0

即使&F在pptest内。

这种方法可能有什么问题？

Answer 1

类型void是不完整的类型。 所以你在 if 语句中使用表达式array + k和指针运算

 if(equals(array + k, pelement)) {

是无效的。

您还需要将存储在数组中的对象的大小传递给 function，这些对象将在具有指针算法的表达式中使用。

使用你的方法 function 应该被声明为类似于标准 C function bsearch看起来像

void *bsearch(const void *key, const void *base,
              size_t nmemb, size_t size,
              int (*compar)(const void *, const void *));

只有返回类型必须从void *更改为int 。

那就是你的 function 的声明

int is_in( const void *pvalue, 
           const void *array, 
           size_t nmemb, 
           size_t size, 
           int cmp( const void *, const void *) );

function可以这样定义

int is_in( const void *pvalue, 
           const void *array, 
           size_t nmemb, 
           size_t size, 
           int cmp( const void *, const void *) )
{
    size_t i = 0;
    
    while ( i < nmemb && cmp( pvalue, ( const char * )array + i * size  )   != 0 ) i++;

    return i != nmemb;
}

一般来说，如果搜索的元素分别被认为小于、匹配或大于数组元素，则比较 function 应返回小于、等于或大于零的 integer。

在您的情况下，因为您有一个可以指向任意对象的指针数组，如果传递给 function 的元素彼此相等，则 function 应该返回 0，或者如果它们彼此不相等，则返回正值。

int ptreq( const void *ptr1, const void *ptr2 ) 
{
    return *( const Symbol ** )ptr1 != *( const Symbol ** )ptr2;
}

注意传入的搜索元素must have the type 。

这是一个演示程序。

#include <stdio.h>

int is_in( const void *pvalue,
    const void *array,
    size_t nmemb,
    size_t size,
    int cmp( const void *, const void * ) )
{
    size_t i = 0;

    while (i < nmemb && cmp( pvalue, ( const char * )array + i * size ) != 0) i++;

    return i != nmemb;
}

int cmp_ptr( const void *ptr1, const void *ptr2 )
{
    return *( const int ** )ptr1 != *( const int ** )ptr2;
}

int main( void )
{
    int x, y, z;

    int * a[] = { &x, &y, &z };
    const size_t N = sizeof( a ) / sizeof( *a );

    int *pvalue = &y;

    printf( "&y is in the array = %s\n",
        is_in( &pvalue, a, N, sizeof( *a ), cmp_ptr ) ? "true" : "false" );

    int v;
    pvalue = &v;

    printf( "&v is in the array = %s\n",
        is_in( &pvalue, a, N, sizeof( *a ), cmp_ptr ) ? "true" : "false" );
}

程序 output 是

&y is in the array = true
&v is in the array = false

Answer 2

传递给void*参数的Symbol**不会在另一端作为数组出现，除非您将其转换为适当的类型。 array + k无效 C 并且不会在符合标准的编译器上干净地编译。 您不能对void*进行指针运算，也不能在不知道项目大小的情况下遍历它所指向的内容 - qsort将其作为参数是有原因的。

正确编写的标准 C function 可能看起来像这样：

#include <stddef.h>
#include <stdbool.h>

bool is_in (const void* array, 
            size_t      n_items,
            size_t      item_size,
            const void* element,
            int (*equals)(const void*, const void*))
{
    unsigned char* byte = array;
    for(size_t i=0; i<n_items; i++)
    {
       if(equals(&byte[i*item_size], element))
       {
         return true;
       }
    }

    return false;
}

int symbol_equal (const void* obj1, const void* obj2)
{
  const Symbol* s1 = obj1;
  const Symbol* s2 = obj2;
  ...
  // in case you passed an array of pointers, then an extra level of dereferencing here
}

Answer 3

正如其他人指出的那样，问题是由于尝试对void*执行加法而导致的，这在标准 C 中没有定义。虽然其他答案通过传递项目大小来避免这种情况，就像qsort()的情况一样，但我设法解决了通过将array和k分离到equals()例程的不同参数中来解决问题，然后在转换为正确的非void*类型后执行指针运算。

int is_in(void* list, int size, void* pelement, int (*equals)(void* this, int k, void* that)) {
    for(int k = 0; k < size; k++) {
        if(equals(list, k, pelement)) {
            return 1;
        }
    }
    return 0;
}

int ptreq(void* ptr1, int k, void* ptr2) {
    return (*(((Symbol**) ptr1) + k) == (Symbol*) ptr2);
}