C 初始化指向二维数组的指针，然后将其与另一个数组链接

这很有效：

byte (*bufferedPacket)[nbPrioLP][lePrioLP] = &outBuffPacketPrio;

但我需要这样做：

byte **bufferedPacket = NULL; // wrong way

if ( _cmd == "prio" ) (*bufferedPacket)[nbPrioLP][lePrioLP] = &outBuffPacketPRIO; 
else (*bufferedPacket)[nbLP][leLP] = &outBuffPacket;

doByteBuffer("regular", 229, "add"); // add byte in the buffer

byte doByteBuffer(String _prio, byte _byte, String _action) {
  static byte posAddBytePrio, posAddPacketPrio, posTakePacketPrio, posAddByteReg, posAddPacketReg, posTakePacketReg;
  static unsigned long timePrio, timeReg;
  if ( _prio == "prio" ) return doBuffer( _action, _prio, &outBuffPacketPrio[0][0], &timePrio, &posTakePacketPrio, nbPrioLP, &posAddPacketPrio, lePrioLP, &posAddBytePrio, _byte );
  if ( _prio == "regular" ) return doBuffer( _action, _prio, &outBuffPacket[0][0], &timeReg, &posTakePacketReg, nbLP, &posAddPacketReg, leLP, &posAddByteReg, _byte );
}

byte doBuffer(String _action, String _prio, byte *_buffer, unsigned long *_time, byte *_posTakePacket, byte _nb, byte *_posAddPacket, byte _len, byte *_posAddByte, byte _byte) {
  boolean cond1, cond2, cond3;
  // init
  if ( *_posAddPacket >= _nb ) *_posAddPacket = 0; // cycle counting
  if ( *_posTakePacket >= _nb ) *_posTakePacket = 0; // cycle counting
  // packet overflow
  if ( (_action == "add") || (_action == "end") || (_action == "ack") ) {
    cond1 = ( *_posTakePacket == *_posAddPacket );
    if ( ( (*_posTakePacket) + 1 ) >= _nb ) cond2 = ( _buffer[0 * _len + 0] != 0 ); // _buffer[0][0]
    else cond2 = ( _buffer[ ((*_posTakePacket)+1)*_len + 0 ] != 0 ); // _buffer[posTakePacket+1][0]
    if ( cond1 && cond2 ) {
....

这是在一个函数中，我想用不同大小的数组初始化缓冲区

我应该如何初始化指针

谢谢

编辑

---

此代码位于函数内部。此函数用于管理数据包缓冲区。我有两种类型的数据包：8字节和30字节长。为了优化RAM，数据包的数量不同（10和19个数据包）

这两个缓冲区（arrays exputffpacketprio、exputffpacket）是来自主循环的全局变量。该函数具有静态变量，用于记住要清空/填充缓冲区的数据包的位置

在函数内部，我尝试指向2个缓冲区，以避免编写2个相同的函数，只使用不同的缓冲区（exputffpacketprio，exputffpacket）

---

我这样调用函数：

byte **bufferedPacket = NULL; // wrong way

if ( _cmd == "prio" ) (*bufferedPacket)[nbPrioLP][lePrioLP] = &outBuffPacketPRIO; 
else (*bufferedPacket)[nbLP][leLP] = &outBuffPacket;

doByteBuffer("regular", 229, "add"); // add byte in the buffer

byte doByteBuffer(String _prio, byte _byte, String _action) {
  static byte posAddBytePrio, posAddPacketPrio, posTakePacketPrio, posAddByteReg, posAddPacketReg, posTakePacketReg;
  static unsigned long timePrio, timeReg;
  if ( _prio == "prio" ) return doBuffer( _action, _prio, &outBuffPacketPrio[0][0], &timePrio, &posTakePacketPrio, nbPrioLP, &posAddPacketPrio, lePrioLP, &posAddBytePrio, _byte );
  if ( _prio == "regular" ) return doBuffer( _action, _prio, &outBuffPacket[0][0], &timeReg, &posTakePacketReg, nbLP, &posAddPacketReg, leLP, &posAddByteReg, _byte );
}

byte doBuffer(String _action, String _prio, byte *_buffer, unsigned long *_time, byte *_posTakePacket, byte _nb, byte *_posAddPacket, byte _len, byte *_posAddByte, byte _byte) {
  boolean cond1, cond2, cond3;
  // init
  if ( *_posAddPacket >= _nb ) *_posAddPacket = 0; // cycle counting
  if ( *_posTakePacket >= _nb ) *_posTakePacket = 0; // cycle counting
  // packet overflow
  if ( (_action == "add") || (_action == "end") || (_action == "ack") ) {
    cond1 = ( *_posTakePacket == *_posAddPacket );
    if ( ( (*_posTakePacket) + 1 ) >= _nb ) cond2 = ( _buffer[0 * _len + 0] != 0 ); // _buffer[0][0]
    else cond2 = ( _buffer[ ((*_posTakePacket)+1)*_len + 0 ] != 0 ); // _buffer[posTakePacket+1][0]
    if ( cond1 && cond2 ) {
....

编辑2

我有这个功能

byte doByteBuffer(String _prio, byte _byte, String _action) {
  static byte posAddBytePrio, posAddPacketPrio, posTakePacketPrio, posAddByteReg, posAddPacketReg, posTakePacketReg;
  static unsigned long timePrio, timeReg;
  if ( _prio == "prio" ) return doBuffer( _action, _prio, &(outBuffPacketPrio[nbPrioLP][0]), &timePrio, &posTakePacketPrio, nbPrioLP, &posAddPacketPrio, lePrioLP, &posAddBytePrio, _byte );
  if ( _prio == "regular" ) return doBuffer( _action, _prio, &(outBuffPacket[nbLP][0]), &timeReg, &posTakePacketReg, nbLP, &posAddPacketReg, leLP, &posAddByteReg, _byte );
}

把这个叫做：

byte doBuffer(String _action, String _prio, byte *_buffer, unsigned long *_time, byte *_posTakePacket, byte _nb, byte *_posAddPacket, byte _len, byte *_posAddByte, byte _byte) {
  boolean cond1, cond2, cond3;
  // init
  if ( *_posAddPacket >= _nb ) *_posAddPacket = 0; // cycle counting
  if ( *_posTakePacket >= _nb ) *_posTakePacket = 0; // cycle counting
  // packet overflow
  if ( (_action == "add") || (_action == "end") || (_action == "ack") ) {
    cond1 = ( *_posTakePacket == *_posAddPacket );
    if ( (*_posTakePacket+1) >= _nb ) cond2 = ( *_buffer[0][0] != 0 ); // WRONG WAY
...
}

我在该函数的最后一行得到此错误：

SCD_XBee.ino: In function 'byte doBuffer(String, String, byte*, long unsigned int*, byte*, byte, byte*, byte, byte*, byte)':
SCD_XBee:25: error: invalid types 'unsigned char[int]' for array subscript

你知道我做错了什么吗？

这难道不意味着bufferedPacket是指向二维字节数组的指针吗？你只是把它分配给一个已经分配了正确大小的对象？那么，为什么需要函数呢

好的，您将字节放入一个或另一个数组中。你基本上只是做：

if ( strncmp( _cmd, "prio", 4 ) )
{
    doAddByte( &(outBuffPacketPRIO[nbPrioLP][0]), lePrioLP, _byte );
    nbPrioLP++;
}
else
{
    doAddByte( &(outBuffPacket[nbLP][0]), leLP, _byte );
    nbLP++;
}

void doAddByte( byte* buffer, int buflen, byte _b )
{
    // buffer is now the pointer to the packet you want to add
    // and buflen is the max size of the packet
    buffer[3] = _b;
}

---

谢谢你，琼斯，你给了我这个主意。然后我看到了这一点：“有时你需要编写一个函数来接受一个二维数组，其中的宽度在运行时之前是未知的。在这种情况下，你可以传递一个指向[0][0]元素的指针，也可以传递两个维度，然后使用指针算术来获得正确的元素，例如：x[I*width+j]。”

我是这样解决的：

byte **bufferedPacket = NULL; // wrong way

if ( _cmd == "prio" ) (*bufferedPacket)[nbPrioLP][lePrioLP] = &outBuffPacketPRIO; 
else (*bufferedPacket)[nbLP][leLP] = &outBuffPacket;

doByteBuffer("regular", 229, "add"); // add byte in the buffer

byte doByteBuffer(String _prio, byte _byte, String _action) {
  static byte posAddBytePrio, posAddPacketPrio, posTakePacketPrio, posAddByteReg, posAddPacketReg, posTakePacketReg;
  static unsigned long timePrio, timeReg;
  if ( _prio == "prio" ) return doBuffer( _action, _prio, &outBuffPacketPrio[0][0], &timePrio, &posTakePacketPrio, nbPrioLP, &posAddPacketPrio, lePrioLP, &posAddBytePrio, _byte );
  if ( _prio == "regular" ) return doBuffer( _action, _prio, &outBuffPacket[0][0], &timeReg, &posTakePacketReg, nbLP, &posAddPacketReg, leLP, &posAddByteReg, _byte );
}

byte doBuffer(String _action, String _prio, byte *_buffer, unsigned long *_time, byte *_posTakePacket, byte _nb, byte *_posAddPacket, byte _len, byte *_posAddByte, byte _byte) {
  boolean cond1, cond2, cond3;
  // init
  if ( *_posAddPacket >= _nb ) *_posAddPacket = 0; // cycle counting
  if ( *_posTakePacket >= _nb ) *_posTakePacket = 0; // cycle counting
  // packet overflow
  if ( (_action == "add") || (_action == "end") || (_action == "ack") ) {
    cond1 = ( *_posTakePacket == *_posAddPacket );
    if ( ( (*_posTakePacket) + 1 ) >= _nb ) cond2 = ( _buffer[0 * _len + 0] != 0 ); // _buffer[0][0]
    else cond2 = ( _buffer[ ((*_posTakePacket)+1)*_len + 0 ] != 0 ); // _buffer[posTakePacket+1][0]
    if ( cond1 && cond2 ) {
....

---

只需一个FIY，

==

应用于字符串，它不会检查字符串的内容，而是检查它们是否指向内存中的同一位置。此代码位于函数内部。此函数用于管理数据包缓冲区。我有两种类型的数据包：8字节和30字节长。为了优化RAM，存储的最大数据包数不同（10和19个数据包）。这两个缓冲区（arrays exputffpacketprio、exputffpacket）是来自主循环的全局变量。该函数具有静态变量，用于记住要清空/填充缓冲区的数据包的位置。在函数内部，我试图指向2个缓冲区，以避免用不同的缓冲区（exputffpacketprio，exputffpacket）编写2个相同的函数；（等式：在缓冲区中添加字节）根据您的建议，我得到以下错误：SCD_XBee:20：错误：无法将赋值中的“byte（）[10][8]”转换为“byte*”，SCD_XBee:30：错误：无法转换“byte（）[19][30]'to'byte*'在赋值SCD_XBee:54:错误：无效的'unary*'类型参数SCD_XBee:55:错误：无效的'unary*'类型参数您似乎使它比需要的更复杂。是您的全局缓冲区“byte-exputffpacket[19][30]”的声明吗？是的，这是我的全局声明。好的，我已经将答案更改为您真正想要做的。