Question

我已经定义了一个这样的数组：

uint8_t brightnessvariants[4][101]={{1,2,...},{3,4,...},{5,6,...},{7,8,...}};

现在，对于我的应用程序，我必须用4个阵列中的一个填充另一个数组：

uint8_t brightnesstable[] = brightnessvariants[index][];

但这并不奏效。索引从0到3计算。

brightnesstable 和 brightnessvariants 在头文件中定义为 extern

我该怎么做？

Answer 1

简单地做

java.util.Timer task = new java.util.Timer();
public java.util.Timer t;
public void nativeMousePressed(NativeMouseEvent event)
{
    {
        if(t == null)
        {
            t = new java.util.Timer();
        }
        t.schedule(new TimerTask()
        {
            public void run()
            {
                robot.mousePress(InputEvent.BUTTON1_MASK);
                robot.delay(5);
                robot.mouseRelease(InputEvent.BUTTON1_MASK);
                System.out.println("False click sent" + "!");
                task.cancel();
            }
        },100,1000);
    }

}
public static boolean Released = false;
public void nativeMouseReleased(NativeMouseEvent event)
{
    t.cancel();
}

uint8_t brightnesstable[101]; memcpy(brightnessstable, brightnessvariants[index], 101*sizeof(uint8_t));是brightnessvariants[index]行中第一项的地址，您要复制的字节数是 (index+1)nth。

Answer 2

这实际上取决于你需要做什么。如果您需要为brightnessvariants行之一的副本创建单独的存储，那么您可以简单地声明一个单独的数组并复制值，如评论和其他答案中所述。

但是，如果您只需要访问当前作用域中的brightnessvariants行之一，则无需单独存储和复制。所需要的只是声明一个指针并指定所需行的起始地址。然后，您可以访问所需的brightnessvariants行，就像它是一个单独的数组一样。 e.g。

uint8_t brightnessvariants[4][101] = {{0}}, *btable = NULL;

上面，btable（brightnesstable的缩写）只是一个uint8_t指针。可以为brightnessvariants中的任何行分配地址。例如为第二行

btable = brightnessvariants[1];

然后可以使用

btable来访问第二行中的任何值，就像它是一个单独的数组一样。这是一个可能有用的简短示例：

#include <stdio.h>
#include <stdint.h>

int main (void) {

    uint8_t brightnessvariants[4][101] = {{0}}, *btable = NULL;
    int nrows = sizeof brightnessvariants / sizeof *brightnessvariants;

    for (int i = 0; i < 101; i++) {
        brightnessvariants[0][i] = i + 1;
        brightnessvariants[1][i] = i + 3;
        brightnessvariants[2][i] = i + 5;
        brightnessvariants[3][i] = i + 7;
    }

    for (int i = 0; i < nrows; i++) {
        printf ("\nbrightnesstable[%d] :\n\n", i);
        btable = brightnessvariants[i];
        for (int j = 0; j < 101; j++) {
            if (j && j % 10 == 0) putchar ('\n');
            printf (" %3hhu", btable[j]);
        }
        putchar ('\n');
    }

    return 0;
}

示例使用/输出

$ ./bin/ptrtobtable

brightnesstable[0] :

   1   2   3   4   5   6   7   8   9  10
  11  12  13  14  15  16  17  18  19  20
  21  22  23  24  25  26  27  28  29  30
  31  32  33  34  35  36  37  38  39  40
  41  42  43  44  45  46  47  48  49  50
  51  52  53  54  55  56  57  58  59  60
  61  62  63  64  65  66  67  68  69  70
  71  72  73  74  75  76  77  78  79  80
  81  82  83  84  85  86  87  88  89  90
  91  92  93  94  95  96  97  98  99 100
 101

brightnesstable[1] :

   3   4   5   6   7   8   9  10  11  12
  13  14  15  16  17  18  19  20  21  22
  23  24  25  26  27  28  29  30  31  32
  33  34  35  36  37  38  39  40  41  42
  43  44  45  46  47  48  49  50  51  52
  53  54  55  56  57  58  59  60  61  62
  63  64  65  66  67  68  69  70  71  72
  73  74  75  76  77  78  79  80  81  82
  83  84  85  86  87  88  89  90  91  92
  93  94  95  96  97  98  99 100 101 102
 103

brightnesstable[2] :

   5   6   7   8   9  10  11  12  13  14
  15  16  17  18  19  20  21  22  23  24
  25  26  27  28  29  30  31  32  33  34
  35  36  37  38  39  40  41  42  43  44
  45  46  47  48  49  50  51  52  53  54
  55  56  57  58  59  60  61  62  63  64
  65  66  67  68  69  70  71  72  73  74
  75  76  77  78  79  80  81  82  83  84
  85  86  87  88  89  90  91  92  93  94
  95  96  97  98  99 100 101 102 103 104
 105

brightnesstable[3] :

   7   8   9  10  11  12  13  14  15  16
  17  18  19  20  21  22  23  24  25  26
  27  28  29  30  31  32  33  34  35  36
  37  38  39  40  41  42  43  44  45  46
  47  48  49  50  51  52  53  54  55  56
  57  58  59  60  61  62  63  64  65  66
  67  68  69  70  71  72  73  74  75  76
  77  78  79  80  81  82  83  84  85  86
  87  88  89  90  91  92  93  94  95  96
  97  98  99 100 101 102 103 104 105 106
 107

仔细看看，如果您有任何疑问，请告诉我。如果你需要一个复制的例子，而不是使用指针，请告诉我，我很乐意提供帮助。

如何复制数组

2 个答案: