C中的跳转表数组

Question

我正在尝试优化对我制作的一些跳转表的访问，它们如下：

int (*const usart_ctrl_table[USART_READ_WRITE_CLEAR])() =
{zg_usartCtrlRead, zg_usartCtrlWrite, zg_usartCtrlClr};
int (*const usart_frame_table[USART_READ_WRITE_CLEAR])() =
{zg_usartFrameRead, zg_usartFrameWrite, zg_usartFrameClr};
int (*const usart_trig_ctrl_table[USART_READ_WRITE_CLEAR])() =
{zg_usartTrigctrlRead, zg_usartTrigctrlWrite, zg_usartTrigctrlClr};

如您所见，这些功能用于在硬件级别访问usart外围设备，并按读/写/清除的顺序排列在表中。

我试图做的是有另一个跳转表的跳转表，这样我可以在启动时初始化所有usart的寄存器，也可以在以后根据需要简单地更改一个寄存器。

即

<datatype> (*usart_peripheral_table[<number of jump tables>])() = 
{usart_ctrl_table, usart_frame_table, usart_trig_ctrl_table};

通过这种方式，我可以将该表暴露给我的中间件层，这将有助于在不断变化的HAL中维护标准，而且我还可以使用define来索引该表，即

fn_ptr = usart_peripheral_table[CTRL_TABLE]
fn_ptr[WRITE](bitmask);
fn_ptr[READ](buffer);

正如你可能已经猜到的，我正在努力弄清楚如何构建这个表。我想这是两件事之一：

1. 另一个简单的指针数组，因为即使是跳转表本身也只是一个指针数组。因此，我的初始化将是：

   const int* (*usart_peripheral_table[<number of jump tables])() = 
   {usart_ctrl_table, usart_frame_table, usart_trig_ctrl_table};
   

但是这似乎不起作用。然后我想：

2. 指向指针的指针数组。所以我尝试了各种组合：

   const int**(*usart_perip...
   
   const int**(usart_perip...
   
   const int** (*usart_peripheral_table[<number of jump tables])() = 
   {&usart_ctrl_table, &usart_frame_table[0], usart_trig_ctrl_table};
   

似乎什么都不起作用。在将该变量分配给指针到指针数组之前，是否需要将较低跳转表的地址存储在另一个指针中？即

int* fn_ptr = usart_ctrl_table;

<dataytype>(*const usart_periph[<number>])() = {fn_ptr};

提前感谢，如有任何帮助，我们将不胜感激。

MM25

编辑：

const int** (*const peripheral_table[1])() =
{&usart_ctrl_table[0]};

const int** (*const peripheral_table[1])() =
{usart_ctrl_table};

上面两个都给出了错误"从不适应的指针类型初始化"，就像我尝试过的所有其他组合一样

Answer 1

您可能会发现，为函数指针定义typedef会使代码更易于阅读和维护(尽管我也看到有人建议不要这样做(：

#include <stdio.h>
#include <stdlib.h>
#define UART_RWC 3U
typedef int (*uart_ctl_func)(void);
int uart_read(void)
{
printf("Read.n");
fflush(stdout);
return 0;
}
int uart_write(void)
{
printf("Write.n");
fflush(stdout);
return(0);
}
int uart_clear(void)
{
printf("Clear.n");
fflush(stdout);
return 0;
}
uart_ctl_func uart_ctl_jump_table[][UART_RWC] = {
{ uart_read, uart_write, uart_clear },
{ uart_read, uart_write, uart_clear }
};
int main(void)
{
uart_ctl_jump_table[0][1](); // Write.
uart_ctl_jump_table[1][0](); // Read.
uart_ctl_jump_table[1][2](); // Clear.
return EXIT_SUCCESS;
}

下一步可能是将跳转表设为struct，以便最终编写Uart_ctl_table.frame.read()，或者至少为常量定义一个enum。

#include <stdio.h>
#include <stdlib.h>
#define UART_RWC 3U
typedef int (*uart_ctl_func)(void);
int uart_read(void)
{
printf("Read.n");
fflush(stdout);
return 0;
}
int uart_write(void)
{
printf("Write.n");
fflush(stdout);
return(0);
}
int uart_clear(void)
{
printf("Clear.n");
fflush(stdout);
return 0;
}
typedef struct {
uart_ctl_func read;
uart_ctl_func write;
uart_ctl_func clear;
} uart_ctl_set_t;
typedef struct {
uart_ctl_set_t ctrl;
uart_ctl_set_t frame;
uart_ctl_set_t trig;
} uart_ctl_table_t;
const uart_ctl_table_t uart_ctl_table = {
.ctrl = { uart_read, uart_write, uart_clear },
.frame = { uart_read, uart_write, uart_clear },
.trig = { uart_read, uart_write, uart_clear }
};
int main(void)
{
uart_ctl_table.ctrl.write(); // Write.
uart_ctl_table.frame.read(); // Read.
uart_ctl_table.trig.clear(); // Clear.
return EXIT_SUCCESS;
}

Answer 2

只需添加一个*，就像定义数组时添加[]一样。

int zg_usartCtrlRead();
int zg_usartCtrlWrite();
int zg_usartCtrlClr();
int zg_usartFrameRead();
int zg_usartFrameWrite();
int zg_usartFrameClr();
int zg_usartTrigctrlRead();
int zg_usartTrigctrlWrite();
int zg_usartTrigctrlClr();
int (*const usart_ctrl_table[])() =
{zg_usartCtrlRead, zg_usartCtrlWrite, zg_usartCtrlClr};
int (*const usart_frame_table[])() =
{zg_usartFrameRead, zg_usartFrameWrite, zg_usartFrameClr};
int (*const usart_trig_ctrl_table[])() =
{zg_usartTrigctrlRead, zg_usartTrigctrlWrite, zg_usartTrigctrlClr};
int (* const * const usart_peripheral_table[])() = 
{usart_ctrl_table, usart_frame_table, usart_trig_ctrl_table};

用法：

usart_peripheral_table[1][2](5, 1, 3, 5, 6);

顺便说一句，函数声明()上的空参数列表表示参数的数量和类型未指定。如果不希望任何参数传递给函数，请执行(void)。

此：

const int* (*usart_peripheral_table[<number of jump tables])();

函数指针的数组，该数组接受未指定数量的参数，并返回指向常量整数的指针。

此：

const int** (*usart_peripheral_table[<number of jump tables])() 

函数指针的数组，该数组接受未指定数量的参数，并返回指向常量整数指针的指针。

你也可以使用2D阵列：

int (* const usart_peripheral_table_2d[][3])() = {
{
zg_usartCtrlRead, zg_usartCtrlWrite, zg_usartCtrlClr, 
}, {
zg_usartFrameRead, zg_usartFrameWrite, zg_usartFrameClr,
}, {
zg_usartTrigctrlRead, zg_usartTrigctrlWrite, zg_usartTrigctrlClr,
},
};

但是，您可能想要编写访问器函数，该函数将返回指向函数数组的指针。再简单不过了！

#include <stddef.h>
int (*usart_ctrl_table_get(size_t idx))() {
return usart_ctrl_table[idx];
}
int (*usart_frame_table_get(size_t idx))() {
return usart_frame_table[idx];
}
int (*usart_trig_ctrl_table_get(size_t idx))() {
return usart_trig_ctrl_table[idx];
}
int (* const (* const usart_peripheral_table_indirect[])(size_t))() = {
usart_ctrl_table_get, 
usart_frame_table_get,
usart_trig_ctrl_table_get,
};

使用示例：

int main() {
usart_peripheral_table_indirect[2](1)();
}