How to avoid constructing a new string? - c++

Question

I have a 1D char vector emulating a 2D vector (this is a requirement). This vector is 000111 and it's equivalent to vector[0] = 000 and vector[1] = 111 of a 2D. So it has two strings, all of same length (3 in this case). I want to set every string as a key in a std::unordered_map, so I am doing:
#include <iostream>
#include <unordered_map>
#include <string>
#include <vector>
int main ()
{
std::unordered_map<std::string, int> mymap;
std::vector<char> keys(2 * 3); // 2 keys, each one of length 3
for(int i = 0; i < 2; ++i)
{
for(int j = 0; j < 3; ++j)
{
keys[j + i * 3] = (i) ? '1' : '0';
}
}
// keys = 000111
for(int i = 0; i < 2; ++i)
{
mymap[std::string(keys.begin() + i * 3, keys.begin() + (i + 1) * 3)] = i;
}
for (auto& x: mymap) {
std::cout << x.first << ": " << x.second << std::endl;
}
/*
Output:
111: 1
000: 0
*/
return 0;
}
which makes me unhappy because I have to construct a new string and then insert that to the map. It would be nice if I could just emplace it or something in one step. Can I?

Answer 1

I think this is a drop-in replacement for a c++17 string_view. A string_view doesn't own any of the strings, so const-ness can be a problem (see the const-cast when inserting into the map)
The only changes that nedded to be made was
const-cast, you'll have to solve this.
the type of the multimap.
Note the using statement just at the #endif
I just bolted a class, a hash-struct(in std::!) and a few overloads onto your code.
#include <iostream>
#include <unordered_map>
#include <string>
#include <vector>
#ifdef HAS_STRING_VIEW
#include <string_view>
#else
class lps_noz_view{
public:
lps_noz_view() = delete;
lps_noz_view(const char* start, size_t size):start(start), stop(start + size){}
lps_noz_view(const lps_noz_view& ) = default;
lps_noz_view(lps_noz_view&& ) = default;
const char* begin(){ return start;}
const char* end(){ return stop;}
const char* begin() const{ return start;}
const char* end() const{ return stop;}
std::string to_string() const{ return std::string(start, stop);}
private:
const char* start;
const char* stop;
};
bool operator < (const lps_noz_view& lhs, const lps_noz_view& rhs){
return lhs.to_string() < rhs.to_string();
// or use strncmp to avoid creating strings =)
}
bool operator == (const lps_noz_view& lhs, const lps_noz_view& rhs){
return lhs.to_string() == rhs.to_string();
// strncmp
}
std::ostream& operator << (std::ostream& os, const lps_noz_view& rhs){
return os << rhs.to_string();
}
namespace std{
template<>
struct hash<lps_noz_view>
{
using argument_type = lps_noz_view;
using result_type = size_t;
size_t operator()(const lps_noz_view& arg) const{
return std::hash<std::string>()(std::string(arg.begin(), arg.end()));
}
};
};
using string_view = lps_noz_view;
#endif
//
int main ()
{
std::unordered_map<string_view, int> mymap;
std::vector<char> keys(2 * 3); // 2 keys, each one of length 3
for(int i = 0; i < 2; ++i)
{
for(int j = 0; j < 3; ++j)
{
keys[j + i * 3] = (i) ? '1' : '0';
}
}
// keys = 000111
for(int i = 0; i < 2; ++i)
{
mymap[string_view(const_cast<const char*>(&(*keys.begin()) + i * 3),
(i + 1) * 3)] = i;
}
for (auto& x: mymap) {
std::cout << x.first << ": " << x.second << std::endl;
}
/*
Output:
111: 1
000: 0
*/
return 0;
}