Question

这是我到目前为止所拥有的：

    typedef const float Chord[6];

    static Chord progressionOne[] = {
        {5.0f / 6.0f, 1.0, 1.25, 5.0f / 3.0f, 2.0, 2.5},         // i
        {5.0f / 6.0f, 2.0f / 3.0f, 1.0, 4.0f / 3.0f, 5.0f / 3.0f, 2.0}, // VI
        {0.75, 1.0, 1.25, 1.5, 2.0, 2.5},                       // III
        {1.125, 1.5, 1.875, 2.25, 3.0, 3.75}                      // VII
    };

    static Chord progressionTwo[] = {
        progressionOne + 1, //VI
        progressionOne + 3, //VII
        progressionOne + 0, // i
        progressionOne + 0,
    };

这似乎是我可以通过几轮按摩我的符号，绕着星号和调整typedef得到的最接近的。我想要的是，在上下文中有希望清楚，重新排列progressionTwo的行，产生progressionTwo。我不介意数据重复或毛茸茸的表示法 - 我只想DRY足以避免两次输入实际值。

......我真的需要四处阅读标准：/

Answer 1

如果你真的希望这些是简单的数组，你可以简单地为和弦创建#define宏（预处理器定义），并使进度引用这些和弦：

typedef const float Chord[6];

#define CHORD_I { 5.0f / 6.0f, 1.0, 1.25, 5.0f / 3.0f, 2.0, 2.5 }
#define CHORD_VI { 5.0f / 6.0f, 2.0f / 3.0f, 1.0, 4.0f / 3.0f, 5.0f / 3.0f, 2.0 }
#define CHORD_III { 0.75, 1.0, 1.25, 1.5, 2.0, 2.5 }
#define CHORD_VII { 1.125, 1.5, 1.875, 2.25, 3.0, 3.75 }

const Chord progressionOne[] = {
    CHORD_I,
    CHORD_VI,
    CHORD_III,
    CHORD_VII,
};

const Chord progressionTwo[] = {
    CHORD_VI,
    CHORD_VII,
    CHORD_I,
    CHORD_I,
};

但是，预处理器定义很麻烦。

如果你将Chord变成一个成熟的类，你可以用同样的方式将它们定义为本地或静态变量，但具有更多的类型安全性和更大的灵活性。然后，您可以在定义progressionOne所需的方式时引用progressionTwo（至少可以使用本地人。对于全局变量，您可能遇到"static order initialization fiasco"）

将静态2D数组的行分配给另一行

1 个答案: