在 C 中有一个指向多个不同大小的 LUT 的数组

Question

我正在做一个程序，该程序使用两个堆栈对一个数字堆栈进行排序，用于学校项目，我想通过蛮力方法处理堆栈大小低于或等于 5 的情况，为此我有不同的结构，其中包含查找表，其中包含表示数字顺序的 int 数组数组（对于每个可能的顺序），以及包含相应操作序列的函数指针数组数组以对它们进行排序，并且每个结构对应于特定的数组大小（2、3、4、5）。并且为了避免一个巨大的if 森林，我想使用带有指向不同数据的指针的公共结构 (t_combi) 的 while 循环来访问它们，但显然它不起作用，我不知何故失去了我的全局数组的地址，因为当我比较订单时，我在第一次迭代时遇到了段错误（尝试使用 valgrind 访问未分配的数据）。

代码：

//  brute_force.h

#ifndef BRUTE_FORCE_H
# define BRUTE_FORCE_H

# include "resolver.h"

# define CNT_2 2
# define CNT_3 6
# define CNT_4 24
# define CNT_5 120

typedef struct s_mlx    *t_mlxptr;
typedef const char      *(*t_op)(t_stack *, t_stack *);

typedef struct  s_combi {
    int     cnt;
    int     **order;
    t_op    **op;
}   t_combi;

static const struct {
    int     cnt;
    int     order[CNT_2][2];
    t_op    op[CNT_2][2];
}   g_2combi = {
        .cnt = CNT_2,
        .order = {
            {0, 1},
            {1, 0}
        },
        .op = {
            {NULL},
            {sa, NULL}
        }
};

static const struct {
    int     cnt;
    int     order[CNT_3][3];
    t_op    op[CNT_3][3];
}   g_3combi = {
        .cnt = CNT_3,
        .order = {
            {0, 1, 2},
            {0, 2, 1},
            {1, 0, 2},
            ...
        },
        .op = {
            {NULL},
            {rra, sa, NULL},
            {sa, NULL},
            ...
        }
};

static const struct {
    int     cnt;
    int     order[CNT_4][4];
    t_op    op[CNT_4][7];
}   g_4combi = {
    .cnt = CNT_4,
    .order = {
        {0, 1, 2, 3},
        {0, 1, 3, 2},
        {0, 2, 1, 3},
        ...
    },
    .op = {
        {NULL},
        {pb, rra, sa, pa, NULL},
        {ra, sa, rra, NULL},
        ...
    }
};

static const struct {
    int     cnt;
    int     order[120][5];
    t_op    op[120][10];
}   g_5combi = {
    .cnt = CNT_5,
    .order = {
        {0, 1, 2, 3, 4},
        {0, 1, 2, 4, 3},
        {0, 1, 3, 2, 4},
        ...
    },
    .op = {
        {NULL},
        {rra, rra, sa, ra, ra, NULL},
        {pb, pb, sa, pa, pa, NULL},
        {pb, pb, rra, pa, pa, NULL},
        ...
    }
};

int brute_force(t_mlxptr mlx, t_stack *st[2], t_queue *instr);

#endif

// brute_force.c

#include <brute_force.h>
#include <resolver.h>

bool    same_order(const int *a, const int *b, size_t size)
{
    size_t  i = 0;

    while (++i < size)
    {
        if ((a[i - 1] < a[i] && b[i - 1] > b[i])
        || (a[i - 1] > a[i] && b[i - 1] < b[i]))
            return (false);
    }
    return (true);
}

void    apply_instructions(t_mlxptr mlx, t_stack *st[2], t_op *op, t_queue *instr)
{
    while (*op)
    {
        add_op(mlx, *op, st, instr); // function from resolver.h
        ++op;
    }
}

void    init_combi(t_combi combi[4])
{
    combi[0] = (t_combi) {
        .cnt = g_2combi.cnt,
        .order = (int**)g_2combi.order,
        .op = (t_op **)g_2combi.op
    };
    combi[1] = (t_combi) {
        .cnt = g_3combi.cnt,
        .order = (int**)g_3combi.order,
        .op = (t_op **)g_3combi.op
    };
    combi[2] = (t_combi) {
        .cnt = g_4combi.cnt,
        .order = (int**)g_4combi.order,
        .op = (t_op **)g_4combi.op
    };
    combi[3] = (t_combi) {
        .cnt = g_5combi.cnt,
        .order = (int**)g_5combi.order,
        .op = (t_op **)g_5combi.op
    };
}


int brute_force(t_mlxptr mlx, t_stack *st[2], t_queue *instr)
{
    const int *const    a_raw = stkcbegin(st[ST_A]); // pointer to a int array
    const size_t        size = stksize(st[ST_A]); // nbcount
    int                 i;

    t_combi             combi[4];
    
    init_combi(combi);
    if (stksorted(st[ST_A]))
        return (0);
    if (size > 5)
        return (1);
    i = -1;
    while (++i < combi[size - 2].cnt)
    {
        if (same_order(combi[size - 2].order[i], a_raw, size))
            apply_instructions(mlx, st, combi[size - 2].op[i], instr);
    }
    return (0);
}

Answer 1

主要问题是您将指向某种类型的数组的指针转换为指向某种类型的指针的指针。例如，在这段代码中：

void    init_combi(t_combi combi[4])
{
    combi[0] = (t_combi) {
        .cnt = g_2combi.cnt,
        .order = (int**)g_2combi.order,
        .op = (t_op **)g_2combi.op
    };
    /* ... */
}

g_2combi.order 是int 的二维数组：int [CNT_2][2]。在初始化器中，值被转换为指向其第一个元素的指针。元素的类型是int [2]（int的数组长度2），所以指向元素的指针的类型是int (*)[2]（int的数组长度2的指针）。但是，类型转换操作将其转换为指向不兼容类型int ** 的指针（指向int 的指针的指针）。 combi[0].order[0] 应该是 int * 类型，它与底层对象的类型不兼容：int [2]。

同样，g_2combi.op 是t_op 的二维数组：t_op [CNT_2][2]。在初始化器中，该值被转换为指向其第一个类型为t_op [2]（t_op 的数组长度为2）的元素的指针，因此该指针的类型为t_op (*)[2]（指向t_op 的数组长度为2 的指针） .类型转换操作将指针转换为t_op **（指向t_op 的指针）。 combi[0].op[0] 应该是 t_op * 类型，它与底层对象的类型不兼容：t_op [2]。

解决问题的一种方法是将所有变量g_2combi、g_3combi 等定义为同一类型t_combi。保持一切不变，compound literals 可用于初始化 g_2combi.order 等中的指针。例如：

typedef struct  s_combi {
    int     cnt;
    const int * const *order;
    const t_op * const *op;
} t_combi;

static const t_combi g_2combi = {
    .cnt = CNT_2,
    .order = (const int * const []){
        (const int []){0, 1},
        (const int []){1, 0}
    },
    .op = (const t_op * const []){
        (const t_op []){NULL},
        (const t_op []){sa, NULL}
    }
};

/* define g_3combi etc. in a similar way to the above. */

void    init_combi(t_combi combi[4])
{
    combi[0] = g_2combi;
    combi[1] = g_3combi;
    combi[2] = g_4combi;
    combi[3] = g_5combi;
}

（由于上面添加了constness，apply_instruction 函数的op 参数需要从t_op *op 更改为const t_op *op。）

Answer 2

一个大问题是您将指针隐藏在 typedef 后面。这样做的目的只有一个：混淆程序员和其他阅读代码的人。

例如 t_op **op; 没有 typedef 的扩展创建一个类型的函数指针

typedef const char      *(***t_op)(t_stack *, t_stack *);

正如您所希望的那样，这简直是疯了。您需要摆脱这些类型定义和不必要的多重间接层，然后才能执行其他任何操作。

函数指针的合理typedef 可能看起来像这样（它实际上是函数的 typedef）：

typedef char* t_op (t_stack*, t_stack*);

然后您将其用作t_op* op。

总体而言，您的程序方式太复杂了，对于听起来像是相当微不足道的任务而言。另一个例子，任何地方都不应该有任何演员表——所有这些都是为了隐藏错误。