map<string, string> info;
info["name"] = "something";
info["id"] = "5665";
What would be a nicer way to initialize a map like this in C++?
EDIT: I want to do this without any c++ libraries or extra code. Something like this:
info["name", "id"] = {"something", "5665"};
Using the Boost.Assignment library, you can do this:
map<string,int> m;
insert( m )( "Bar", 1 )( "Foo", 2 );
Personally, I think this hurts readability and you're better off doing it the normal way.
Boost.Assign is probably the nicest you can get with C++03.
#include <boost/assign/list_of.hpp>
#include <map>
#include <string>
int main()
{
using namespace std;
map<string, string> info = boost::assign::map_list_of("name", "something")("id", "5665");
}
You could do this by loading the values from a text file or a resources file with a predefined syntax (for example, key(tab)value).
Your text / resource would look something like this:
name something
id 5665
And you'd just parse it line by line in a loop.
If you had regular expressions at your disposal, a simple (.+)\s(.+) would do, where group 1 matches your key, and group 2 matches your value.
The best way is to use a C++0x initializer list. But if your compiler doesn't implement this feature yet, you can use a class like the following
/**
* Class that creates an std::map using a chained list syntax. For example:
*
* @code
*
* std::map<int, int> SomeMap = MapInit<int, int>(1, 10)(2, 20)(3, 30);
*
* @endcode
*
* @tparam Key
* The key data type to be stored in the map.
* @tparam Type
* The element data type to be stored in the map.
* @tparam Traits
* The type that provides a function object that can compare two element values as sort keys to
* determine their relative order in the map. This argument is optional and the binary predicate
* less<Key> is the default value.
* @tparam Allocator
* The type that represents the stored allocator object that encapsulates details about the map's
* allocation and deallocation of memory. This argument is optional and the default value is
* allocator<pair <const Key, Type> >.
*/
template< class Key, class Type, class Traits = std::less<Key>,
class Allocator = std::allocator< std::pair <const Key, Type> > >
class MapInit
{
/** Local map instance used to construct the output map */
std::map<Key, Type, Traits, Allocator> myMap_;
/* Disallow default construction */
MapInit();
/* Disallow copy construction */
MapInit( const MapInit& );
/* Disallow assignment */
MapInit& operator=( const MapInit& );
public:
/** An alias for the type of this object */
typedef typename MapInit<Key, Type, Traits, Allocator> self_type;
/** An alias for the key-value pairs being stored in the map */
typedef typename std::map<Key, Type, Traits, Allocator>::value_type value_type;
/**
* Constructor that accepts a key and value to be inserted in the map
*
* @param[in] key
* The key value of the element that is to be inserted
* @param[in] value
* The element to be inserted
*/
MapInit( const Key& key, const Type& value )
{
myMap_[key] = value;
}
/**
* Constructor that accepts a key-value pair to be inserted into the map
*
* @param[in] kvpair
* The key-value pair to be inserted
*/
MapInit( const value_type& kvpair )
{
myMap_[kvpair.first] = kvpair.second;
}
/**
* Function call operator overload that accepts a key and value to be inserted in the map
*
* @param[in] key
* The key value of the element that is to be inserted
* @param[in] value
* The element to be inserted
*
* @return Reference to the operand after inserting the element into the std::map
*/
self_type& operator()( const Key& key, const Type& value )
{
myMap_[key] = value;
return *this;
}
/**
* Function call operator overload that accepts a key-value pair to be inserted in the map
*
* @param[in] kvpair
* The key-value pair to be inserted
*
* @return Reference to the operand after inserting the key-value pair into the std::map
*/
self_type& operator()( const value_type& kvpair )
{
myMap_[kvpair.first] = kvpair.second;
return *this;
}
/**
* Typecast operator to convert the operand to an std::map
*
* @return The std::map constrcuted by the operand
*/
operator std::map<Key, Type, Traits, Allocator>()
{
return myMap_;
}
};
Boost assign is one of neatest way of doing STL containers initialization:
Some good example for std::vector, set, map can be found here:
http://www.boost.org/doc/libs/1_47_0/libs/assign/doc/index.html#examples
