實現查找表

Question

我正在處理自定義數據結構，並且當前處於beta測試過程中：數據將存儲在數組中，並且此數組可以表示爲4D，2D & 1D數組。這三個數組是在一個union中聲明的，因爲它代表了相同的內存尋址。以下是聲明我的課：

SomeClass.h

#ifndef SomeClass_H 
#define SomeClass_H 

class SomeClass { 
public: 
    static const unsigned V1D_SIZE; // Single Or Linear Array Representation : Size 256 - 256 Elements 
    static const unsigned V2D_SIZE; // 2D Array [16][16]      : Size 16 - 256 Elements 
    static const unsigned V4D_SIZE; // 4D Array [4][4][4][4]     : Size 4 - 256 Elements 

    enum Index { 
     HEX_UNDER_FLOW = -0x01, 
     HEX_0 = 0x00, 
     HEX_1 = 0x01, 
     HEX_2 = 0x02, 
     HEX_3 = 0x03, 
     HEX_4 = 0x04, 
     HEX_5 = 0x05, 
     HEX_6 = 0x06, 
     HEX_7 = 0x07, 
     HEX_8 = 0x08, 
     HEX_9 = 0x09, 
     HEX_A = 0x0A, 
     HEX_B = 0x0B, 
     HEX_C = 0x0C, 
     HEX_D = 0x0D, 
     HEX_E = 0x0E, 
     HEX_F = 0x0F, 
     HEX_OVER_FLOW = 0x10 
    }; // Index 

    // Will Be Private After Testing. 
    union { 
     int m_p256[256]; 
     int m_p16[16][16]; 
     int m_p4[4][4][4][4]; 
    }; 

private: 
    struct CrossReference { 
     Index A; 
     Index B; 

     CrossReference() {} 
     CrossReference(const Index& A_, const Index& B_) : A(A_), B(B_) {} 
    } typedef CR; 


    // Current Not Used Only Here To Illustrate A Simple Representation - May Use Or Incorporate Later 
    struct Cubes { 
     unsigned box;  // 0 - 3 - w 
     unsigned slice; // 0 - 15 - z 
     unsigned row;  // 0 - 15 - y 
     unsigned coloumn; // 0 - 15 - x 
    } m_cubes; 


    CR m_cr[256]; 

public: 
    SomeClass(); 
    ~SomeClass(); 

    const CR& getIndexTable() const; 
    void displayIndexTable() const; 

private: 
    // Must Be Called In Constructor First! 
    void initializeCrossReference(); 

}; // SomeClass 

#endif // SomeClass 

我需要生成一個參考查找協調這一4D結構的值對執行其1D版本的表。

爲了說明索引遍歷可以參考這些圖片的視覺表示：

注：{X，Y，Z，W}此圖像不表示在存儲器中的實際四維陣列中：它只是一個可視化！在內存中，4D陣列將如下所示：array[box][slice][row][column]並且此圖像表示4D陣列內的1個框。

注意：此圖像是在頂部圖像中描述的所有4個框的2D視覺表示。兩幅圖像中的彩色文字都對應相應的索引。

第二個圖像是這個4D陣列數據結構的2D平面網格圖像表示。我們可以使用此圖像來生成此查找表的座標。

此圖片的每個季度代表1個框。左上方（開始）是方框0，右上方框1，左下方框2，右下方框3.每個方框可以按照每個方向相同的方式分解。左上（開始）切片0，右上切片1，左下切片2，右下切片3.然後，當在每個切片中工作時，遍歷是行 - 列和列 - 3，我們向下移動到下一行。因此，在完成一個切片後，我們必須根據當前切片索引跳轉我們的位置。盒子也一樣。

這裏有一對夫婦通過遍歷這個表來產生一組索引的座標16進制值的示例：

array[2][3][0][1] our [A,B] hex value would be [0x0C, 0x05] 
array[1][1][3][3] our [A,B] hex value would be [0x03, 0x0F] 

我在設計一個函數生成此查找表的過程。我在這裏手動完成了這項工作：

void SomeClass::initializeCrossReference() { 
    ////////////////////////////////// 
    // Upper Half Of Grid Structure // 
    ////////////////////////////////// 

    // Grid Coordinates // 
    // Linear Or 1D Array Representation - Mapped From type[16][16] which is a 
    // 2D Compressed Version of type[4][4][4][4] - 
    // NOTE: This does not represent 4D Space; it represents a cluster of 4 (3D Cubes). 
    // In the declaration of the class there are two multi deminsional arrays that 
    // are shared in memory through a nameless union. 

    //  ROW    COL   

    // BOX - 0 
    // Slice - 0 
    // Row - 0        // Column Coordinates 
    m_cr[0].A = HEX_0; m_cr[0].B = HEX_0; // col 0 
    m_cr[1].A = HEX_0; m_cr[1].B = HEX_1; // col 1 
    m_cr[2].A = HEX_0; m_cr[2].B = HEX_2; // col 2 
    m_cr[3].A = HEX_0; m_cr[3].B = HEX_3; // col 3 
    // Row - 1 
    m_cr[4].A = HEX_1; m_cr[4].B = HEX_0; 
    m_cr[5].A = HEX_1; m_cr[5].B = HEX_1; 
    m_cr[6].A = HEX_1; m_cr[6].B = HEX_2; 
    m_cr[7].A = HEX_1; m_cr[7].B = HEX_3; 
    // Row - 2 
    m_cr[8].A = HEX_2; m_cr[8].B = HEX_0; 
    m_cr[9].A = HEX_2; m_cr[9].B = HEX_1; 
    m_cr[10].A = HEX_2; m_cr[10].B = HEX_2; 
    m_cr[11].A = HEX_2; m_cr[11].B = HEX_3; 
    // Row - 3 
    m_cr[12].A = HEX_3; m_cr[12].B = HEX_0;  
    m_cr[13].A = HEX_3; m_cr[13].B = HEX_1; 
    m_cr[14].A = HEX_3; m_cr[14].B = HEX_2; 
    m_cr[15].A = HEX_3; m_cr[15].B = HEX_3; 

    // Slice - 1 
    // Row - 0 
    m_cr[16].A = HEX_0; m_cr[16].B = HEX_4; 
    m_cr[17].A = HEX_0; m_cr[17].B = HEX_5; 
    m_cr[18].A = HEX_0; m_cr[18].B = HEX_6;  
    m_cr[19].A = HEX_0; m_cr[19].B = HEX_7; 
    // Row - 1 
    m_cr[20].A = HEX_1; m_cr[20].B = HEX_4; 
    m_cr[21].A = HEX_1; m_cr[21].B = HEX_5; 
    m_cr[22].A = HEX_1; m_cr[22].B = HEX_6; 
    m_cr[23].A = HEX_1; m_cr[23].B = HEX_7; 
    // Row - 2; 
    m_cr[24].A = HEX_2; m_cr[24].B = HEX_4; 
    m_cr[25].A = HEX_2; m_cr[25].B = HEX_5; 
    m_cr[26].A = HEX_2; m_cr[26].B = HEX_6; 
    m_cr[27].A = HEX_2; m_cr[27].B = HEX_7; 
    // Row - 3 
    m_cr[28].A = HEX_3; m_cr[28].B = HEX_4; 
    m_cr[29].A = HEX_3; m_cr[29].B = HEX_5; 
    m_cr[30].A = HEX_3; m_cr[30].B = HEX_6; 
    m_cr[31].A = HEX_3; m_cr[31].B = HEX_7; 

    // Slice - 2 
    // Row - 0 
    m_cr[32].A = HEX_4; m_cr[32].B = HEX_0; 
    m_cr[33].A = HEX_4; m_cr[33].B = HEX_1; 
    m_cr[34].A = HEX_4; m_cr[34].B = HEX_2; 
    m_cr[35].A = HEX_4; m_cr[35].B = HEX_3; 
    // Row - 1; 
    m_cr[36].A = HEX_5; m_cr[36].B = HEX_0; 
    m_cr[37].A = HEX_5; m_cr[37].B = HEX_1; 
    m_cr[38].A = HEX_5; m_cr[38].B = HEX_2; 
    m_cr[39].A = HEX_5; m_cr[39].B = HEX_3; 
    // Row - 2; 
    m_cr[40].A = HEX_6; m_cr[40].B = HEX_0; 
    m_cr[41].A = HEX_6; m_cr[41].B = HEX_1; 
    m_cr[42].A = HEX_6; m_cr[42].B = HEX_2; 
    m_cr[43].A = HEX_6; m_cr[43].B = HEX_3; 
    // Row - 3 
    m_cr[44].A = HEX_7; m_cr[44].B = HEX_0; 
    m_cr[45].A = HEX_7; m_cr[45].B = HEX_1; 
    m_cr[46].A = HEX_7; m_cr[46].B = HEX_2; 
    m_cr[47].A = HEX_7; m_cr[47].B = HEX_3; 

    // Slice - 3 
    // Row - 0 
    m_cr[48].A = HEX_4; m_cr[48].B = HEX_4; 
    m_cr[49].A = HEX_4; m_cr[49].B = HEX_5; 
    m_cr[50].A = HEX_4; m_cr[50].B = HEX_6; 
    m_cr[51].A = HEX_4; m_cr[51].B = HEX_7; 
    // Row - 1 
    m_cr[52].A = HEX_5; m_cr[52].B = HEX_4; 
    m_cr[53].A = HEX_5; m_cr[53].B = HEX_5; 
    m_cr[54].A = HEX_5; m_cr[54].B = HEX_6; 
    m_cr[55].A = HEX_5; m_cr[55].B = HEX_7; 
    // Row - 2; 
    m_cr[56].A = HEX_6; m_cr[56].B = HEX_4; 
    m_cr[57].A = HEX_6; m_cr[57].B = HEX_5; 
    m_cr[58].A = HEX_6; m_cr[58].B = HEX_6; 
    m_cr[59].A = HEX_6; m_cr[59].B = HEX_7; 
    // Row - 3 
    m_cr[60].A = HEX_7; m_cr[60].B = HEX_4; 
    m_cr[61].A = HEX_7; m_cr[61].B = HEX_5; 
    m_cr[62].A = HEX_7; m_cr[62].B = HEX_6; 
    m_cr[63].A = HEX_7; m_cr[63].B = HEX_7; 

    // BOX - 1 
    // Slice - 0 
    // Row - 0 
    m_cr[64].A = HEX_0; m_cr[64].B = HEX_8; 
    m_cr[65].A = HEX_0; m_cr[65].B = HEX_9; 
    m_cr[66].A = HEX_0; m_cr[66].B = HEX_A; 
    m_cr[67].A = HEX_0; m_cr[67].B = HEX_B; 
    // Row - 1 
    m_cr[68].A = HEX_1; m_cr[68].B = HEX_8; 
    m_cr[69].A = HEX_1; m_cr[69].B = HEX_9; 
    m_cr[70].A = HEX_1; m_cr[70].B = HEX_A; 
    m_cr[71].A = HEX_1; m_cr[71].B = HEX_B; 
    // Row - 2 
    m_cr[72].A = HEX_2; m_cr[72].B = HEX_8; 
    m_cr[73].A = HEX_2; m_cr[73].B = HEX_9; 
    m_cr[74].A = HEX_2; m_cr[74].B = HEX_A; 
    m_cr[75].A = HEX_2; m_cr[75].B = HEX_B; 
    // Row - 3 
    m_cr[76].A = HEX_3; m_cr[76].B = HEX_8; 
    m_cr[77].A = HEX_3; m_cr[77].B = HEX_9; 
    m_cr[78].A = HEX_3; m_cr[78].B = HEX_A; 
    m_cr[79].A = HEX_3; m_cr[79].B = HEX_B; 

    // Slice - 1 
    // Row - 0 
    m_cr[80].A = HEX_0; m_cr[80].B = HEX_C; 
    m_cr[81].A = HEX_0; m_cr[81].B = HEX_D; 
    m_cr[82].A = HEX_0; m_cr[82].B = HEX_E; 
    m_cr[83].A = HEX_0; m_cr[83].B = HEX_F; 
    // Row - 1 
    m_cr[84].A = HEX_1; m_cr[84].B = HEX_C; 
    m_cr[85].A = HEX_1; m_cr[85].B = HEX_D; 
    m_cr[86].A = HEX_1; m_cr[86].B = HEX_E; 
    m_cr[87].A = HEX_1; m_cr[87].B = HEX_F; 
    // Row - 2 
    m_cr[88].A = HEX_2; m_cr[88].B = HEX_C; 
    m_cr[89].A = HEX_2; m_cr[89].B = HEX_D; 
    m_cr[90].A = HEX_2; m_cr[90].B = HEX_E; 
    m_cr[91].A = HEX_2; m_cr[91].B = HEX_F; 
    // Row - 3 
    m_cr[92].A = HEX_3; m_cr[92].B = HEX_C; 
    m_cr[93].A = HEX_3; m_cr[93].B = HEX_D; 
    m_cr[94].A = HEX_3; m_cr[94].B = HEX_E; 
    m_cr[95].A = HEX_3; m_cr[95].B = HEX_F; 

    // Slice - 2 
    // Row - 0 
    m_cr[96].A = HEX_4; m_cr[96].B = HEX_8; 
    m_cr[97].A = HEX_4; m_cr[97].B = HEX_9; 
    m_cr[98].A = HEX_4; m_cr[98].B = HEX_A; 
    m_cr[99].A = HEX_4; m_cr[99].B = HEX_B; 
    // Row - 1 
    m_cr[100].A = HEX_5; m_cr[100].B = HEX_8; 
    m_cr[101].A = HEX_5; m_cr[101].B = HEX_9; 
    m_cr[102].A = HEX_5; m_cr[102].B = HEX_A; 
    m_cr[103].A = HEX_5; m_cr[103].B = HEX_B; 
    // Row - 2 
    m_cr[104].A = HEX_6; m_cr[104].B = HEX_8; 
    m_cr[105].A = HEX_6; m_cr[105].B = HEX_9; 
    m_cr[106].A = HEX_6; m_cr[106].B = HEX_A; 
    m_cr[107].A = HEX_6; m_cr[107].B = HEX_B; 
    // Row - 3 
    m_cr[108].A = HEX_7; m_cr[108].B = HEX_8; 
    m_cr[109].A = HEX_7; m_cr[109].B = HEX_9; 
    m_cr[110].A = HEX_7; m_cr[110].B = HEX_A; 
    m_cr[111].A = HEX_7; m_cr[111].B = HEX_B; 

    // Slice - 3 
    // Row - 0 
    m_cr[112].A = HEX_4; m_cr[112].B = HEX_C; 
    m_cr[113].A = HEX_4; m_cr[113].B = HEX_D; 
    m_cr[114].A = HEX_4; m_cr[114].B = HEX_E; 
    m_cr[115].A = HEX_4; m_cr[115].B = HEX_F; 
    // Row - 1 
    m_cr[116].A = HEX_5; m_cr[116].B = HEX_C; 
    m_cr[117].A = HEX_5; m_cr[117].B = HEX_D; 
    m_cr[118].A = HEX_5; m_cr[118].B = HEX_E; 
    m_cr[119].A = HEX_5; m_cr[119].B = HEX_F; 
    // Row - 2 
    m_cr[120].A = HEX_6; m_cr[120].B = HEX_C; 
    m_cr[121].A = HEX_6; m_cr[121].B = HEX_D; 
    m_cr[122].A = HEX_6; m_cr[122].B = HEX_E; 
    m_cr[123].A = HEX_6; m_cr[123].B = HEX_F; 
    // Row - 3 
    m_cr[124].A = HEX_7; m_cr[124].B = HEX_C; 
    m_cr[125].A = HEX_7; m_cr[125].B = HEX_D; 
    m_cr[126].A = HEX_7; m_cr[126].B = HEX_E; 
    m_cr[127].A = HEX_7; m_cr[127].B = HEX_F; 

    ////////////////////////////////// 
    // Lower Half Of Grid Structure // 
    ////////////////////////////////// 

    // Box - 2 
    // Slice - 0 
    // Row - 0 
    m_cr[128].A = HEX_8; m_cr[128].B = HEX_0; // col 0 
    m_cr[129].A = HEX_8; m_cr[129].B = HEX_1; // col 1 
    m_cr[130].A = HEX_8; m_cr[130].B = HEX_2; // col 2 
    m_cr[131].A = HEX_8; m_cr[131].B = HEX_3; // col 3 
    // Row - 1 
    m_cr[132].A = HEX_9; m_cr[132].B = HEX_0; 
    m_cr[133].A = HEX_9; m_cr[133].B = HEX_1; 
    m_cr[134].A = HEX_9; m_cr[134].B = HEX_2; 
    m_cr[135].A = HEX_9; m_cr[135].B = HEX_3; 
    // Row - 2 
    m_cr[136].A = HEX_A; m_cr[136].B = HEX_0; 
    m_cr[137].A = HEX_A; m_cr[137].B = HEX_1; 
    m_cr[138].A = HEX_A; m_cr[138].B = HEX_2; 
    m_cr[139].A = HEX_A; m_cr[139].B = HEX_3; 
    // Row - 3 
    m_cr[140].A = HEX_B; m_cr[140].B = HEX_0; 
    m_cr[141].A = HEX_B; m_cr[141].B = HEX_1; 
    m_cr[142].A = HEX_B; m_cr[142].B = HEX_2; 
    m_cr[143].A = HEX_B; m_cr[143].B = HEX_3; 

    // Slice - 1 
    // Row - 0 
    m_cr[144].A = HEX_8; m_cr[144].B = HEX_4; 
    m_cr[145].A = HEX_8; m_cr[145].B = HEX_5; 
    m_cr[146].A = HEX_8; m_cr[146].B = HEX_6; 
    m_cr[147].A = HEX_8; m_cr[147].B = HEX_7; 
    // Row - 1 
    m_cr[148].A = HEX_9; m_cr[148].B = HEX_4; 
    m_cr[149].A = HEX_9; m_cr[149].B = HEX_5; 
    m_cr[150].A = HEX_9; m_cr[150].B = HEX_6; 
    m_cr[151].A = HEX_9; m_cr[151].B = HEX_7; 
    // Row - 2; 
    m_cr[152].A = HEX_A; m_cr[152].B = HEX_4; 
    m_cr[153].A = HEX_A; m_cr[153].B = HEX_5; 
    m_cr[154].A = HEX_A; m_cr[154].B = HEX_6; 
    m_cr[155].A = HEX_A; m_cr[155].B = HEX_7; 
    // Row - 3 
    m_cr[156].A = HEX_B; m_cr[156].B = HEX_4; 
    m_cr[157].A = HEX_B; m_cr[157].B = HEX_5; 
    m_cr[158].A = HEX_B; m_cr[158].B = HEX_6; 
    m_cr[159].A = HEX_B; m_cr[159].B = HEX_7; 

    // Slice - 2 
    // Row - 0 
    m_cr[160].A = HEX_C; m_cr[160].B = HEX_0; 
    m_cr[161].A = HEX_C; m_cr[161].B = HEX_1; 
    m_cr[162].A = HEX_C; m_cr[162].B = HEX_2; 
    m_cr[163].A = HEX_C; m_cr[163].B = HEX_3; 
    // Row - 1; 
    m_cr[164].A = HEX_D; m_cr[164].B = HEX_0; 
    m_cr[165].A = HEX_D; m_cr[165].B = HEX_1; 
    m_cr[166].A = HEX_D; m_cr[166].B = HEX_2; 
    m_cr[167].A = HEX_D; m_cr[167].B = HEX_3; 
    // Row - 2; 
    m_cr[168].A = HEX_E; m_cr[168].B = HEX_0; 
    m_cr[169].A = HEX_E; m_cr[169].B = HEX_1; 
    m_cr[170].A = HEX_E; m_cr[170].B = HEX_2; 
    m_cr[171].A = HEX_E; m_cr[171].B = HEX_3; 
    // Row - 3 
    m_cr[172].A = HEX_F; m_cr[172].B = HEX_0; 
    m_cr[173].A = HEX_F; m_cr[173].B = HEX_1; 
    m_cr[174].A = HEX_F; m_cr[174].B = HEX_2; 
    m_cr[175].A = HEX_F; m_cr[175].B = HEX_3; 

    // Slice - 3 
    // Row - 0 
    m_cr[176].A = HEX_C; m_cr[176].B = HEX_4; 
    m_cr[177].A = HEX_C; m_cr[177].B = HEX_5; 
    m_cr[178].A = HEX_C; m_cr[178].B = HEX_6; 
    m_cr[179].A = HEX_C; m_cr[179].B = HEX_7; 
    // Row - 1 
    m_cr[180].A = HEX_D; m_cr[180].B = HEX_4; 
    m_cr[181].A = HEX_D; m_cr[181].B = HEX_5; 
    m_cr[182].A = HEX_D; m_cr[182].B = HEX_6; 
    m_cr[183].A = HEX_D; m_cr[183].B = HEX_7; 
    // Row - 2; 
    m_cr[184].A = HEX_E; m_cr[184].B = HEX_4; 
    m_cr[185].A = HEX_E; m_cr[185].B = HEX_5; 
    m_cr[186].A = HEX_E; m_cr[186].B = HEX_6; 
    m_cr[187].A = HEX_E; m_cr[187].B = HEX_7; 
    // Row - 3 
    m_cr[188].A = HEX_F; m_cr[188].B = HEX_4; 
    m_cr[189].A = HEX_F; m_cr[189].B = HEX_5; 
    m_cr[190].A = HEX_F; m_cr[190].B = HEX_6; 
    m_cr[191].A = HEX_F; m_cr[191].B = HEX_7; 

    // BOX - 3 
    // Slice - 0 
    // Row - 0 
    m_cr[192].A = HEX_8; m_cr[192].B = HEX_8; 
    m_cr[193].A = HEX_8; m_cr[193].B = HEX_9; 
    m_cr[194].A = HEX_8; m_cr[194].B = HEX_A; 
    m_cr[195].A = HEX_8; m_cr[195].B = HEX_B; 
    // Row - 1 
    m_cr[196].A = HEX_9; m_cr[196].B = HEX_8; 
    m_cr[197].A = HEX_9; m_cr[197].B = HEX_9; 
    m_cr[198].A = HEX_9; m_cr[198].B = HEX_A; 
    m_cr[199].A = HEX_9; m_cr[199].B = HEX_B; 
    // Row - 2 
    m_cr[200].A = HEX_A; m_cr[200].B = HEX_8; 
    m_cr[201].A = HEX_A; m_cr[201].B = HEX_9; 
    m_cr[202].A = HEX_A; m_cr[202].B = HEX_A; 
    m_cr[203].A = HEX_A; m_cr[203].B = HEX_B; 
    // Row - 3 
    m_cr[204].A = HEX_B; m_cr[204].B = HEX_8; 
    m_cr[205].A = HEX_B; m_cr[205].B = HEX_9; 
    m_cr[206].A = HEX_B; m_cr[206].B = HEX_A; 
    m_cr[207].A = HEX_B; m_cr[207].B = HEX_B; 

    // Slice - 1 
    // Row - 0 
    m_cr[208].A = HEX_8; m_cr[208].B = HEX_C; 
    m_cr[209].A = HEX_8; m_cr[209].B = HEX_D; 
    m_cr[210].A = HEX_8; m_cr[210].B = HEX_E; 
    m_cr[211].A = HEX_8; m_cr[211].B = HEX_F; 
    // Row - 1 
    m_cr[212].A = HEX_9; m_cr[212].B = HEX_C; 
    m_cr[213].A = HEX_9; m_cr[213].B = HEX_D; 
    m_cr[214].A = HEX_9; m_cr[214].B = HEX_E; 
    m_cr[215].A = HEX_9; m_cr[215].B = HEX_F; 
    // Row - 2 
    m_cr[216].A = HEX_A; m_cr[216].B = HEX_C; 
    m_cr[217].A = HEX_A; m_cr[217].B = HEX_D; 
    m_cr[218].A = HEX_A; m_cr[218].B = HEX_E; 
    m_cr[219].A = HEX_A; m_cr[219].B = HEX_F; 
    // Row - 3 
    m_cr[220].A = HEX_B; m_cr[220].B = HEX_C; 
    m_cr[221].A = HEX_B; m_cr[221].B = HEX_D; 
    m_cr[222].A = HEX_B; m_cr[222].B = HEX_E; 
    m_cr[223].A = HEX_B; m_cr[223].B = HEX_F; 

    // Slice - 2 
    // Row - 0 
    m_cr[224].A = HEX_C; m_cr[224].B = HEX_8; 
    m_cr[225].A = HEX_C; m_cr[225].B = HEX_9; 
    m_cr[226].A = HEX_C; m_cr[226].B = HEX_A; 
    m_cr[227].A = HEX_C; m_cr[227].B = HEX_B; 
    // Row - 1 
    m_cr[228].A = HEX_D; m_cr[228].B = HEX_8; 
    m_cr[229].A = HEX_D; m_cr[229].B = HEX_9; 
    m_cr[230].A = HEX_D; m_cr[230].B = HEX_A; 
    m_cr[231].A = HEX_D; m_cr[231].B = HEX_B; 
    // Row - 2 
    m_cr[232].A = HEX_E; m_cr[232].B = HEX_8; 
    m_cr[233].A = HEX_E; m_cr[233].B = HEX_9; 
    m_cr[234].A = HEX_E; m_cr[234].B = HEX_A; 
    m_cr[235].A = HEX_E; m_cr[235].B = HEX_B; 
    // Row - 3 
    m_cr[236].A = HEX_F; m_cr[236].B = HEX_8; 
    m_cr[237].A = HEX_F; m_cr[237].B = HEX_9; 
    m_cr[238].A = HEX_F; m_cr[238].B = HEX_A; 
    m_cr[239].A = HEX_F; m_cr[239].B = HEX_B; 

    // Slice - 3 
    // Row - 0 
    m_cr[240].A = HEX_C; m_cr[240].B = HEX_C; 
    m_cr[241].A = HEX_C; m_cr[241].B = HEX_D; 
    m_cr[242].A = HEX_C; m_cr[242].B = HEX_E; 
    m_cr[243].A = HEX_C; m_cr[243].B = HEX_F; 
    // Row - 1 
    m_cr[244].A = HEX_D; m_cr[244].B = HEX_C; 
    m_cr[245].A = HEX_D; m_cr[245].B = HEX_D; 
    m_cr[246].A = HEX_D; m_cr[246].B = HEX_E; 
    m_cr[247].A = HEX_D; m_cr[247].B = HEX_F; 
    // Row - 2 
    m_cr[248].A = HEX_E; m_cr[248].B = HEX_C; 
    m_cr[249].A = HEX_E; m_cr[249].B = HEX_D; 
    m_cr[250].A = HEX_E; m_cr[250].B = HEX_E; 
    m_cr[251].A = HEX_E; m_cr[251].B = HEX_F; 
    // Row - 3 
    m_cr[252].A = HEX_F; m_cr[252].B = HEX_C; 
    m_cr[253].A = HEX_F; m_cr[253].B = HEX_D; 
    m_cr[254].A = HEX_F; m_cr[254].B = HEX_E; 
    m_cr[255].A = HEX_F; m_cr[255].B = HEX_F; 

} // initializeCrossReference 

正如你所看到的，這個函數很長，而且不是很可讀。我試圖找出一種方式來實現這個功能的優雅方式，這就是我卡住的地方。如何在少數幾行代碼中使用for循環/ s和幾個if語句（如果需要）來生成此模式？最後我想將這些[A，B]座標壓縮成一個無符號字符，就像[A，B] = [0x0C，0x08]一樣，它將被存儲爲0xC8而不是一對枚舉。

編輯 - 添加一個新的圖像，這應該有助於瞭解我如何生成我的座標對以及它們在我的查找陣列中的確切順序。

注：這個問題是我要接受崗位，併爲這裏的老問題Custom Data Structure: Implementing an algorithim to generate a lookup table [duplicate]現在是一個死了後，請參考這一個作爲是正確的。昨天晚上我試圖繼續編輯舊的瀏覽器時，我遇到了麻煩。我打算刪除它，但爲了歷史目的我會將其留在那裏，讓管理部門決定是否刪除它。

Answer 1

例如，像這樣：

for (int i = 0; i < 256; ++i) { 
    int cube = i/64; 
    int slice = (i % 64)/16; 
    int row = (i % 16)/4; 
    int col = i % 4; 
    m_cr[i].A = cube/2 * 8 + slice/2 * 4 + row; 
    m_cr[i].B = cube % 2 * 8 + slice % 2 * 4 + col; 
} 

Answer 2

盯着查找表幾分鐘（並且只查找表中的原始數據，我無法跟蹤圖形），我相信下面的示例會生成查找表。

正如我告訴過你in your first question，大部分問題是無關緊要的。如果你擺脫了問題的第一個3/4，那麼很快就會有人提出答案。有時候它確實有助於瞭解一些數據的含義，但在這裏它似乎更像是一種分心，而不是其他任何事情。

無論如何，首先要做的是擺脫enum。它沒有增加任何價值，只是礙事。只需使用自然的十六進制數字即可。話雖如此，它應該是微不足道的爲你使用自己的代碼適應這樣的：

#include <iostream> 

int main() 
{ 
    for (int n=0; n<256; ++n) 
    { 
     int a = ((((n >> 5) & 1) << 2) | (n & 0x80) >> 4) | ((n >> 2) & 3); 
     int b = (n & 3) | (((n >> 4) & 1) << 2) | 
      (((n >> 6) & 1) << 3); 

     std::cout << n << ": a=" << a << " b=" << b << std::endl; 
    } 
} 

我有一種揮之不去的感覺，這可哪怕是一點點更簡化，也許別人可以促進一個進步，但在任何情況下，在查找表中，對於A和B，其輸出似乎都與原始十六進制值相匹配。

Answer 3

首先將HEX_更改爲數組。然後，查看各個塊並將它們變成循環。由於您的.A和.B是互斥的，我們可能會分開處理它們。

這裏是一個「功能」，你可以用它來幫助初始化：

void InitializeA(CrossReference arr[]) 
{ 
    InitializeABlock(arr, 0x00, 0x00); 
    InitializeABlock(arr, 0x10, 0x00); 
    InitializeABlock(arr, 0x20, 0x04); 
    InitializeABlock(arr, 0x30, 0x04); 
    InitializeABlock(arr, 0x40, 0x00); 
    InitializeABlock(arr, 0x50, 0x00); 
    InitializeABlock(arr, 0x60, 0x04); 
    InitializeABlock(arr, 0x70, 0x04); 

    InitializeABlock(arr, 0x80, 0x08); 
    InitializeABlock(arr, 0x90, 0x08); 
    InitializeABlock(arr, 0xA0, 0x10); 
    InitializeABlock(arr, 0xB0, 0x10); 
    InitializeABlock(arr, 0xC0, 0x08); 
    InitializeABlock(arr, 0xD0, 0x08); 
    InitializeABlock(arr, 0xE0, 0x10); 
    InitializeABlock(arr, 0xF0, 0x10); 
} 

void InitializeABlock(CrossReference arr[], int idxStart, int hexStart) 
{ 
    for(int j = hexStart; j < hexStart + 4; j++) 
    { 
     int baseIdx = idxStart + 4 * (j - hexStart); 

     for(int i = 0; i < 4; i++) 
     { 
      arr[baseIdx + i].A = j; 
     } 
    } 
} 

對於B來說，實現非常相似：

void InitializeB(CrossReference arr[]) 
{ 
    InitializeBBlock(arr, 0x00, 0x00); 
    InitializeBBlock(arr, 0x10, 0x00); 
    InitializeBBlock(arr, 0x20, 0x04); 
    InitializeBBlock(arr, 0x30, 0x04); 
    InitializeBBlock(arr, 0x40, 0x00); 
    InitializeBBlock(arr, 0x50, 0x00); 
    InitializeBBlock(arr, 0x60, 0x04); 
    InitializeBBlock(arr, 0x70, 0x04); 

    InitializeBBlock(arr, 0x80, 0x08); 
    InitializeBBlock(arr, 0x90, 0x08); 
    InitializeBBlock(arr, 0xA0, 0x10); 
    InitializeBBlock(arr, 0xB0, 0x10); 
    InitializeBBlock(arr, 0xC0, 0x08); 
    InitializeBBlock(arr, 0xD0, 0x08); 
    InitializeBBlock(arr, 0xE0, 0x10); 
    InitializeBBlock(arr, 0xF0, 0x10); 
} 

void InitializeBBlock(CrossReference arr[], int idxStart, int hexStart) 
{ 
    for(int j = idxStart; j < idxStart + 4; j++) 
    { 
     int baseIdx = idxStart + 4 * (j - idxStart); 

     for(int i = 0; i < 4; i++) 
     { 
      arr[baseIdx + i].A = i + hexStart; 
     } 
    } 
} 

你當然可以，進一步壓縮這一點。 ）