瞭解C++代碼'新'和指針

Question

這可能很簡單，但我很難理解它。

代碼的摘錄，我想了解：

SomeStruct ***namestruct = new SomeStruct **[intVariable]; 
      //Three level pointer and... two level pointer? 
           //or product and pointer? 

for(int i=0; i < intVariable; i++) 
    namestruct[i] = new SomeStruct *[2]; //creates the same structure time 2? 

for(int i=0; i < intVariable; i++) { // just initialization of a 
    namestruct[i][0] = NULL;   // matrix like structure? 
    namestruct[i][1] = NULL; 
} 

代碼工作，但我需要理解爲什麼程序員做了什麼，它的完成。

如何從通過函數作爲地址傳遞的結構的另一個實例分配地址？例如：

void function(SomeStruct **othername); 

int main() 
{ 
    SomeStruct *othername; 
    function(&othername); 
    return 0; 
} 

void function(SomeStruct **othername) 
{ 
    SomeStruct ***namestruct = new SomeStruct **[intVariable]; 
    for(int i=0; i < intVariable; i++) 
    namestruct[i] = new SomeStruct *[2]; 

    for(int i=0; i < intVariable; i++) { 
    namestruct[i][0] = NULL; 
    namestruct[i][1] = NULL; 
    } 

    // This is what I want to do 
    ... 
    namestruct[x][0] = &othername[i]; // Error cannot convert SomeStruct** 
             // to SomeStruct* in assignment 
    ... 
} 

感謝您的幫助！問題出現在代碼本身以及將otherstruct的地址分配給namestruct的方法中。

Answer 1

我會作一個假設，其實這是你的問題：

我如何分配來自另一個結構體 的地址通過函數作爲地址傳遞？

簡短的回答：

namestruct[x][0] = othername[i]; //if othername is SomeStruct** 

龍答：

SomeStruct ***namestruct = new SomeStruct **[intVariable]; 
// namestruct is a three level pointer, that means you will need three levels 
// of dereferencing to get to an actual value 
// the use of [] notation is the same as a pointer, except you can allocate space 
// in memory. You may recognize the difference between 
// char *someString; //uninitialized, _points_ to 1 available bytes 
// char someString[12]; //uninitialized _points_ to 12 available bytes 
// now, in order to get a value from either of these _pointers_ you use [] 
// as a way of dereferencing 

// the way array dereferencing works is simply that you multiply the sizeof(obj) 
// with the index, and offset your pointer that many bytes 
// such that someString[3] == *(someString + sizeof(char)*3) 

// this means, namestruct is now an 'array' i.e it has memory allocated 
// for intVariable instances, those locations are typed to be SomeStruct ** 


for(int i=0; i < intVariable; i++) 
    namestruct[i] = new SomeStruct *[2]; // since we've learned that * and [] is 
    // almost the same thing, the type SomeStruct *[2] is the same that we expected here 
    // which was SomeStruct ** 
    // namestruct[i][x] will be typed to SomeStruct *, because we dereference two layers 
    // from the original three with the use of the array indexer 

for(int i=0; i < intVariable; i++) { // this is initializing the two pointers generated 
    namestruct[i][0] = NULL;   // in the loop above with new SomeStruct *[2]; 
    namestruct[i][1] = NULL;   // to 0 or NULL 
} 

// You can assign any SomeStruct* to a namestruct[x][y] deref 
// because the types will match. 

Answer 2

下面舉例說明你的指針數組的狀態之前有問題的任務：

[SomeStruct***("namestruct")] 
    | 
    V 
    [0:SomeStruct**][1:SomeStruct**][2:SomeStruct**][ ... 
      |    |    | 
      |    |    V 
      |    |    [0:SomeStruct*][1:SomeStruct*] 
      |    |     (NULL)   (NULL) 
      |    V 
      |    [0:SomeStruct*][1:SomeStruct*] 
      |     (NULL)   (NULL) 
      V 
      [0:SomeStruct*][1:SomeStruct*] 
       (NULL)   (NULL) 

[SomeStruct**("othername, function scope")] 
    | 
    V 
    [0:SomeStruct*("othername, main scope")] 

在這一點上，如果你想在葉節點之一分配SomeStruct*指向同一SomeStruct爲othername在main範圍內，你會做namestruct[x][0] = *othername。請注意，您可以消除指針的額外的水平，如果這是，事實上，你的目標：

SomeStruct *othername; 
function(othername); 
//... 
void function(SomeStruct *othername) 
{ 
    //... 
    namestruct[x][0] = othername;