如何在C ++中初始化一个指向结构的指针数组？

Question

UPDATE : Answer at the bottom.

Hi Guys,

How to initialize an 'array of pointers to a struct' ? The catch is, the array is a member variable and the size passed to the declaration of the array in the constructor is variable entity.

    typedef struct Node {
        string key;
        int value;
        struct Node * left;
        struct Node * right;
    }doubly;

    class myHashStrKey{

    private:
        size_t hashsize;
        doubly * table[];

    public:
        myHashStrKey(){
            hashsize = ((size_t)-1);
            doubly * table[hashsize];
            memset(table,NULL,hashsize);// This is giving segmentation fault
        }

    };

//Called constructor;    myHashStrKey sss = myHashStrKey();

Here I want the table to be a array of pointers to the Doubly nodes and I want all the pointers to be initialized to NULL . Whats wrong with this code here ? What other better way are there to perform the above ? Thanks in advance.

UPDATE :

After the discussion, considering the size is big let down I have modified the code . But how to fill vector table with certain number of NULL values ?I tried the below code but it is not working .

<pre><code>
for(int i =0;i < hashsize;i++){
            table.push_back((doubly *)NULL);
        }

table.insert(table.begin(),hashsize,NULL);
//Both give invalid static_cast from type `int' to type `doubly*'
</code></pre>

ANSWER UPDATE :

    myHashStrKey::table(myHashStrKey::hashsize, static_cast(0));
    myHashStrKey::table(myHashStrKey::hashsize);
    //Above 2 does not work

    for(int i =0;i != myHashStrKey::hashsize;i++){ //lesser than symbol spoils the display
        myHashStrKey::table.push_back((doubly *)NULL);
    }
    //Above works 
    myHashStrKey::table.insert(myHashStrKey::table.begin(),hashsize,((doubly *)NULL));
    //This too works

Answer 1

Variable-length arrays are not supported by the C++ standard. Instead, simply use a std::vector :

private:
    std::vector<doubly *> table;

...

myHashStrKey()
    : table(num_elements, NULL)  // Initialises vector
{
    ...
}

Answer 2

The line

        doubly * table[hashsize];

creates a local variable table which over-shades the member of the same name.

Also note that the line

        memset(table,NULL,hashsize);// This is giving segmentation fault

is not correct as it sets hashsize bytes , whereas your table is an array of hashsize pointers , each of which is more than one byte (usually 4 on 32-bit machine), ie sizeof(table) >= hashsize * sizeof(doubly*)

The segfault however is probably a result of trying to write a huge chunk of memory (at least 4G), as @Nawaz pointed out).

Answer 3

As commented, you should really use std::vector.

You should probably look more carefully what the STL has to offer. Otherwise you will miss a lot of C++ nice features and would be doing C with classes. Try to get also familiar with RAII to know more about C++ memory management possibilities (http://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization). Things like memset aren't really much used in modern C++.