container – Modern C++

std::array : safe C arrays

The std::array was a new container introduced in C++11. A std::array works in the same way as a plain old C array (like int values[5]) but has the advantage that it will not decay into a plain pointer.

Unlike the vector can an array not be resized once it has been created.

Creating

std::array is always allocated on the stack. It it allocated using uniform initialization:

std::array<double> a = {1.0, 2.0, 3.0}

1	std::array<double> a = {1.0, 2.0, 3.0}

Iterating

You can iterate through each of the values in the array using range-based for:

std::array<object> allItems = {object(2), object(5), object(9)};

for(object& singleItem : allItems)
{
    // do something here...
}

std::array<object> allItems = {object(2), object(5), object(9)};

for(object& singleItem : allItems)

{

// do something here...

}

or using std::for_each and a lambda

std::array<object> allItems = {object(2), object(5), object(9)};

std::for_each(begin(allItems), end(allItems), [&]{
    // do something here...
    });

std::array<object> allItems = {object(2), object(5), object(9)};

std::for_each(begin(allItems), end(allItems), [&]{

// do something here...

});

std::map : The C++ dictionary class

std::map is the C++ standard library implementation of a dictionary. It contains key-value pairs where the keys are all unique and the key values are used to find the associated values, much like a real-world dictionary. The map is, just like most of the standard library, implemented using templates and the types of the keys and the values are given when you create the map. Some examples of maps:

// this is a map, where the keys are integers and the values are strings
std::map<int, std::string> stringLookupTable;

// this is a map where the keys are strings and the values integers
std::map<std::string, int> passwordHashForUser;

// this is a map, where the keys are integers and the values are strings

std::map<int, std::string> stringLookupTable;

// this is a map where the keys are strings and the values integers

std::map<std::string, int> passwordHashForUser;

Each element of the map is of the type std::map<K, V>::value_type which is just a redefinition of std::pair<const K, V>.

Getting one element

To get the value associated with a specific key, use the bracket operator ([]). This operator will create the key-value pair if it doesn’t exist already.

// a map where the keys are integers and the values are strings
std::map<int, std::string> userNameForUserID;

// insert a user
userNameForUserID[0] = std::string("John Doe");

// retrieve a user
std::cout << "User #0 is named: " << userNameForUserID[0] << std::endl;

// a map where the keys are integers and the values are strings

std::map<int, std::string> userNameForUserID;

// insert a user

userNameForUserID[0] = std::string("John Doe");

// retrieve a user

std::cout << "User #0 is named: " << userNameForUserID[0] << std::endl;

Checking if a key exists in map

There are two ways to check if a key exists in a map.

Using the function std::map::count(). This returns the number of keys which matches the queried key, and since all keys in the std::map are unique can this only be zero or one. This is a good way to do it if you just need to see if the key exists and don’t need to do anything with the map.
Using the function std::map::find(). This returns an iterator to the found object, or std::map::end() if the object is not found. This is a better choice if you need to update the map, since you will get an iterator to the found key value pair.

Iteration

To iterate over all elements in the dictionary use range-based for:

std::map<int, std::string> values;
// ... 
for(std::map<int, std::string>::value_type& x : values)
{
    std::cout << x.first << "," << x.second << std::endl;
}

std::map<int, std::string> values;

// ...

for(std::map<int, std::string>::value_type& x : values)

{

std::cout << x.first << "," << x.second << std::endl;

}

or much simpler using auto

std::map<int, std::string> values;
// ... 
for(auto& x : values)
{
    std::cout << x.first << "," << x.second << std::endl;
}

std::map<int, std::string> values;

// ...

for(auto& x : values)

{

std::cout << x.first << "," << x.second << std::endl;

}

Notice that it is a good idea to make the variable in the loop a reference since this avoids copying the element and gives better performance. Also if you don’t intend to change the element then you can make this clear by also making it const.

Erasing one element

You can erase one element from the map by using the function erase(…) which takes either an iterator, a key or a two iterators defining a range of values to remove.

std::map<int, std::string> userNameForUserID;

// insert a couple of user
userNameForUserID[2971] = std::string("John Doe");
userNameForUserID[7362] = std::string("Jane Smith");
userNameForUserID[7952] = std::string("A Nonymous");

// Remove a user by key
userNameForUserID.erase(2971); // removes the entry [2971, "John Doe"]

// Remove a user by iterator
auto iterator = userNameForUserID.find("Jane Smith");
userNameForUserID.erase(iterator); // removes the entry [7362, "Jane Smith"]

std::map<int, std::string> userNameForUserID;

// insert a couple of user

userNameForUserID[2971] = std::string("John Doe");

userNameForUserID[7362] = std::string("Jane Smith");

userNameForUserID[7952] = std::string("A Nonymous");

// Remove a user by key

userNameForUserID.erase(2971); // removes the entry [2971, "John Doe"]

// Remove a user by iterator

auto iterator = userNameForUserID.find("Jane Smith");

userNameForUserID.erase(iterator); // removes the entry [7362, "Jane Smith"]

Range-based for

With C++11 we got a new way of writing for-loops to iterate over all elements in a range. The new range-based for loop is much clearer than the old way using iterators. It is intended to be used when you only look at the elements in a container, you are not supposed to change the container itself since this could cause problems in the loop.

An example of how the new range-based for works, using a vector as an example:

std::vector<int> values = {1, 2, 3};

// Runs the for loop over each element in the values vector
for(int x : values)
{
    std::cout << x << std::endl;
}

// The range variable can also be a reference, then it is possible to change the contents
for(int& x : values)
{
    ++x;
}

std::vector<int> values = {1, 2, 3};

// Runs the for loop over each element in the values vector

for(int x : values)

{

std::cout << x << std::endl;

}

// The range variable can also be a reference, then it is possible to change the contents

for(int& x : values)

{

++x;

}

When the vector contains an object then it’s a good idea to get a reference to the object to avoid copying the entire object in each round in the loop.

std::vector<SomeObject> values = CreateValues();

// Getting a reference to the object to avoid copying
for(SomeObject& x : values)
{
    std::cout << x << std::endl;
}

std::vector<SomeObject> values = CreateValues();

// Getting a reference to the object to avoid copying

for(SomeObject& x : values)

{

std::cout << x << std::endl;

}

If the contents of the vector shouldn’t be changed then we can show this by getting a const reference:

std::vector<SomeObject> values = CreateValues();

// Getting a reference to the object to avoid copying
for(const SomeObject& x : values)
{
    // the contents of 'x' cannot be changed here... 
    std::cout << x << std::endl;
}

std::vector<SomeObject> values = CreateValues();

// Getting a reference to the object to avoid copying

for(const SomeObject& x : values)

{

// the contents of 'x' cannot be changed here...

std::cout << x << std::endl;

}

We can use the auto keyword to avoid explicitly giving the type:

std::vector<SomeObject> values = CreateValues();

// Getting a copy of the object
for(auto x : values)
{
    // the contents of 'x' can be changed here but we cannot change 'values'
    std::cout << x << std::endl;
}

// Getting a reference to the object to avoid copying
for(auto&& x : values)
{
    // here we can change the contents of 'x' and then also the contents of 'value'
    std::cout << x << std::endl;
}

// Getting a const reference to the object to avoid copying
for(const auto&& x : values)
{
    // the contents of 'x' cannot be changed here... 
    std::cout << x << std::endl;
}

std::vector<SomeObject> values = CreateValues();

// Getting a copy of the object

for(auto x : values)

{

// the contents of 'x' can be changed here but we cannot change 'values'

std::cout << x << std::endl;

}

// Getting a reference to the object to avoid copying

for(auto&& x : values)

{

// here we can change the contents of 'x' and then also the contents of 'value'

std::cout << x << std::endl;

}

// Getting a const reference to the object to avoid copying

for(const auto&& x : values)

{

// the contents of 'x' cannot be changed here...

std::cout << x << std::endl;

}