如何使用默认值初始化固定长度的std：pair的std :: vector？

Question

Assuming a struct containing a std::vector with items of type std::pair.

struct block {
    std::vector<std::pair<key_t, value_t>> items;
    block(const Data& d) : items()
    {
        items = std::vector<std::pair<key_t, value_t>>(d.size_);
    }
};

Later in the code, I assign a value to the vector at position 0:

block<key_t, value_t> b(*this);
std::pair<key_t, value_t> item = std::pair<key_t, value_t>(k, v);
b.items[0] = item;

Later in the code, I want to iterate over the vector and expect &bucket_item != NULL to be true only at position 0, because I only assigned a value at this position. In fact, &bucket_item != NULL is always true.

for (std::pair<key_t, value_t> item : b.items)
{
    if (&item != NULL)
    {
       ...
    }
}

I am not able to initialize the vector with NULL values like so:

items = std::vector<std::pair<key_t, value_t>>(d.size_, NULL);

How to solve this?

Answer 1

It seems like you have Java background, C++ is a bit different.

items = std::vector<std::pair<key_t, value_t>>(d.size_);

items has already been initialized with its default constructor. The line above creates another default initialized container and assigns it to items , which is unnecessary.

In:

b.items[0] = item;

You need to make sure that the vector is big enough, because it does not allocate elements for you in operator[] . Either do b.items.push_front/back(item) or insert it at a specific position using vector::insert , eg b.items.insert(b.items.begin(), item) . push_xxx and insert do allocate memory for new elements.

When you do

for (std::pair<key_t, value_t> item : b.items) 
{
    if (&item != NULL)

It iterates over all existing elements in the container. item is stored by value (unlike Java) in the container, so that it exists at a non-NULL address and cannot be possibly be equal to NULL .

However, expression for(std::pair<key_t, value_t> item : b.items) creates a copy of each element on the stack (also at non-NULL address), you probably want that to be for(std::pair<key_t, value_t>& item : b.items) to just refer to the element rather than copy it (note the ampersand symbol on the left of items ). If you do not intend to modify item inside the loop, you may like to use const qualifier as well to make your intent clear to the reader of the code. eg for(std::pair<key_t, value_t> const& item : b.items) .

And because you use C++11 anyway, you do not have to spell out the type of the container element, just use auto :

for (auto const& item : b.items) 
    // do something to item

Answer 2

When you create an std::vector with a length len like this std::vector<T> tVec(len) , you are creating a vector with len default-constructed objects of type T . If you want to represent a null value, you will need to resort to one of the following ways:

1. Use a sentinel value of T to denote an invalid value.
2. Use a (smart-)pointer to T and use a nullptr as the natural invalid value.
3. Wrap a class around T which contains a bool marking it as invalid.

The last option is provided by boost::optional . Here's a rewrite of your code using it:

struct block {
    using OptionalPair_t = boost::optional<std::pair<key_t, value_t>>;
    std::vector<OptionalPair_t> items;
    block(const Data& d) : items(d.size_)
    {
    }
};

Since boost::optional is contextually convertible to bool , you can do this:

for (auto& item : b.items)
{
    if (item)
    {
       ...
    }
}

Answer 3

I think your mixing here a few definitions. an element of std::vector cannot be NULL , because it's not a pointer. and it defenilty exists. int arr[] = {1}; , can arr[0] be null? of course not. why would it be ? it's a real integer who seat somwhere in the memory which is not null.

if you're iterating over a std::vector elements, that means they exist, so they can not be null.

Answer 4

NULL , or better nullptr , can be used to initialize a pointer value, but makes no sense to initialize, for example, an std::string or std::pair<std::string, int> with it.

If you want your vector to be empty, you can use:

std::vector<std::pair<key_t, value_t>> items;

othwerwise, if you want n default constructed std::pair s you can use:

std::vector<std::pair<key_t, value_t>> items(n);

Answer 5

Pair are really a comination of values. So you have to define which combination of values you consider as being the NULL equivalent for your pairs.

You can then initialize your vector with the following constructor:

std::vector<std::pair<key_t, value_t>> items(d.size_, make_pair(0,0)) ;

You just have to replace 0 with the neutral values for key_t and value_t.

Please note that vectors really contain values, and pairs are values. So there is no NULL pointers that would show absence of values.