Possible to create std::map as rvalue? - c++

Question

I'm not sure if this is an error with my C++ syntax, or if this is something that cannot be accomplished at all.
I want to define a class that takes a std::map as a constructor argument. I then want to create an instance of that class by passing a "temporary" (appropriate to call this "rvalue"?) std::map. I.e. I do not want to create an lvalue std::map and then pass that to the constructor.
Can this be accomplished? I have tried the following (commented lines show failed attempts)
#include <map>
#include <string>
#include <iostream>
class Test
{
public:
Test(std::map<int,char>& rMap)
{
std::map<int,char>::iterator iter;
for (iter = rMap.begin(); iter != rMap.end(); ++iter)
{
mMap[iter->first] = mMap[iter->second];
}
}
virtual ~Test(){}
protected:
std::map<int, char> mMap;
};
int main()
{
std::cout << "Hello world!" << std::endl;
//Test test({1,'a'}); // Compile error.
//Test test(std::map<int,char>(1,'a')); // Also compile error.
//Test test(std::map<int,char>{1,'a'}); // Yet again compile error.
return 0;
}
This is my compiler:
g++ (GCC) 4.4.7 20120313 (Red Hat 4.4.7-11)
Compile errors can be posted upon request, but I'm not sure if they would be useful if my problem is syntactic.
Thank you.

Answer 1

Do
Test(std::map<int, char> rMap) : mMap(std::move(rMap)) {}
or
Test(std::map<int, char>&& rMap) : mMap(std::move(rMap)) {}
or
Test(const std::map<int, char>& rMap) : mMap(rMap) {}
Temporary cannot bind to non const l-value reference.
And use it as
Test test({{1,'a'}});
Test test2({{1,'a'}, {2, 'b'}});

Answer 2

Yes but your constructor takes an lvalue reference. It must instead be a reference-to-const, or an rvalue reference.
Just like with any other type.

Answer 3

#include <map>
class Test {
public:
Test(std::map<int,char> const& cMap)
{
std::map<int,char>::const_iterator iter;
for (iter = cMap.cbegin(); iter != cMap.cend(); ++iter)
{
mMap[iter->first] = mMap[iter->second];
}
}
virtual ~Test() { }
protected:
std::map<int, char> mMap;
};
int main() {
Test test(std::map<int,char>({{1,'a'}, {2, 'b'}}));
return 0;
}
Some explanations:
You need Test(T), Test(const T&) or Test(T&&) constructor if you want to pass temporary object (like std::map<int,char>()) into it. Don't forget what T&& constructors is used for. If in doubt do not use them.
If you work with const std::vector/map/list/... you can't use .begin() and .end() to iterate through elements -- use .cbegin() and .cend(). Moreover it will become more easy with auto. Just try
for (auto iter = rMap.cbegin(); iter != rMap.cend(); ++iter)
instead
std::map<int,char>::const_iterator iter;
for (iter = rMap.cbegin(); iter != rMap.cend(); ++iter)
To initialize std::map use "double-bracket" initializers like {{1,'a'}, {2, 'b'}} -- {{key, value}, {second_key, second_value}, ...} this construction is available because
1) std::map has this constructor:
map( std::initializer_list<value_type> init,
const Compare& comp = Compare(),
const Allocator& alloc = Allocator() );
// see http://en.cppreference.com/w/cpp/container/map/map
2) inner braces {1,'a'} is interpreted as value_type constructor call. And value_type for std::map<int, char> is std::pair<int, char>.
P. S. don't forget that std::map<int,char>() and std::map<int,char>{} constructor calls are equal. That means you can drop front brackets: std::map<int,char>({{1,'a'},{2,'b'}}) --> std::map<int,char>{{1,'a'},{2,'b'}}

Answer 4

You should use:
class Test
{
public:
Test(const std::map<int,char>& rMap) : mMap(rMap)
{}
Test(std::map<int,char>&& rMap) : mMap(std::move(rMap))
{}
virtual ~Test(){}
protected:
std::map<int, char> mMap;
};
This provides two constructors: one which takes a const lvalue reference and copies its contents into mMap and one which takes an rvalue reference and moves its contents into mMap. This allows you to construct a Test instance using either a named std::map or a temporary:
int main()
{
std::map<int,char> m{{1, 'a'}, {2,'b'}};
Test t1{m};
Test t2{{{1, 'a'}, {2, 'b'}}};
}
This lets you avoid unnecessary copies when you can, but still lets you make a copy of the map when you need to.