I am wondering how to resolve this problem where the vectors (vec, vec2) are destroyed after exiting storeData(), which causes a segmentation fault in main().
Should I allocate memories for each vector (vec, vec2)? If so, which is the best way to do it?
Also, how could I delete them after?
Thank you.
#include <map>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
void storeData();
multimap<int, vector<string> > mypairs;
void storeData()
{
vector<string> vec;
vec.push_back("one");
vec.push_back("two");
vector<string> vec2;
vec2.push_back("alpha");
vec2.push_back("beta");
mypairs.insert(make_pair(1, vec));
mypairs.insert(make_pair(2, vec2));
}
int main(int, char**)
{
storeData();
string str;
vector<string>::const_iterator it;
multimap<int, vector<string> >::const_iterator res;
res = mypairs.find(1);
for(it = res->second.begin(); it < res->second.end(); it++) {
str = *it;
}
//use string str to do something else later...
}
vec and vec2 will be copied into mypairs, so it doesn't matter if the original objects are destroyed.
You should post more information about the segfault.
Related
I had some help on a previous topic, where I had to change my map to use int in combination with strings. When I have done this it gives me a different issue. This is the issue:
src/main.cpp:11:29: error: no matching constructor for initialization of
'std::map<int, std::string>'
...tagMap {{"1", "data"}, {"2", "entry"}, {"3", "id"}, {"4", "content"}};
^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
It seems like the issue (which I looked up on another topic) seems to allude to the fact that the issue is to do with making your constructor take const references? I don't really understand how to implement this.
#include "pugi/pugixml.hpp"
#include <iostream>
#include <string>
#include <map>
int main()
{
pugi::xml_document doca, docb;
std::map<std::string, pugi::xml_node> mapa, mapb;
std::map<int, std::string> tagMap {{"1", "data"}, {"2", "entry"}, {"3", "id"}, {"4", "content"}};
if (!doca.load_file("a.xml") || !docb.load_file("b.xml")) {
std::cout << "Can't find input files";
return 1;
}
for (auto& node: doca.child(tagMap[1]).children(tagMap[2])) {
const char* id = node.child_value(tagMap[3]);
mapa[id] = node;
}
for (auto& node: docb.child(tagMap[1]).children(tagMap[2])) {
const char* idcs = node.child_value(tagMap[3]);
if (!mapa.erase(idcs)) {
mapb[idcs] = node;
}
}
}
Any help would be appreciated.
Try sth like:
#include <iostream>
#include <map>
#include <string>
using namespace std;
int main() {
std::map<int, std::string> tagMap {make_pair(1, "data"), make_pair(2, "entry")};
}
Edit: The version without make_pair function is also valid:
#include <iostream>
#include <map>
#include <string>
using namespace std;
int main() {
std::map<int, std::string> tagMap {{1, "data"}, {2, "entry"}};
}
The only thing you need to remember is that you shouldn't rely on compiler const string literal to number cast...
I followed this answer and wrote below code. But it gives below compilation error. I think it's because make_pair cannot accept another make_pair as an argument. What is the alternative then?
error: no matching function for call to ‘std::map<std::basic_string<char>, std::map<float, int>
>::insert(std::pair<std::basic_string<char>, std::pair<double, int> >)’
code below
#include <iostream>
#include <map>
#include <string>
int main() {
std::map<std::string, std::map<float, int> > map1;
std::string string1 = "alpha";
map1.insert(std::make_pair(string1, std::make_pair(1.1, 1)));
return 0;
}
Your initializing the second half of your "pair" with something that isn't a map.
#include <iostream>
#include <map>
#include <string>
int main() {
std::map<std::string, std::map<float, int> > map1;
std::string string1 = "alpha";
std::map<float,int> mapsub;
mapsub.insert(std::make_pair(1.1, 1));
map1.insert(std::make_pair(string1, mapsub));
return 0;
}
Or alternatively:
#include <iostream>
#include <map>
#include <string>
int main() {
std::map<std::string, std::map<float, int> > map1;
std::string string1 = "alpha";
map1.insert(std::make_pair(string1, std::map<float,int>{std::make_pair(1.1,1)}));
return 0;
}
Alternatively you can use the [] operator as follows:
map1[string1][1.1] = 1;
I am trying to copy the vector data from sample to Y as below
std::map<std::string, std::vector<double > >sample;
std::map<std::string, std::vector<double > >::iterator it1=sample.begin(), end1=sample.end();
std::vector<double> Y;
and am using the following code:
while (it1 != end1) {
std::copy(it1->second.begin(), it1->second.end(), std::ostream_iterator<double>(std::cout, " "));
++it1;
}
It prints the output ok, however when I replace the above std::copy block with the below, I get a segfault.
while (it1 != end1) {
std::copy(it1->second.begin(), it1->second.end(), Y.end());
++it1;
}
I just want to copy the contents of it1->second to Y. Why is it not working and how do I fix it?
Obviously, you want to insert objects into your vector. However, std::copy() merely takes the iterators passed and writes to them. The iterators obtained by the begin() and end() iterators don't do any insertion. What you want to use is something like this:
std::copy(it1->second.begin(), it1->second.end(), std::back_inserter(Y));
The std::back_inserter() function template is a factory function for an iterator using push_back() on its argument to append objects.
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
// your code goes here
vector<int> vec;
vector<int> test;
vec.push_back(1);
//test.push_back(0);
copy(vec.begin(),vec.begin()+1,test.begin());
cout << *(test.begin());
return 0;
}
output:
Runtime error time: 0 memory: 3424 signal:11
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
// your code goes here
vector<int> vec;
vector<int> test;
vec.push_back(1);
test.push_back(0);
copy(vec.begin(),vec.begin()+1,test.begin());
cout << *(test.begin());
return 0;
}
output:
*Success time: 0 memory: 3428 signal:0*
1
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
// your code goes here
vector<int> vec;
vector<int> test(5);
vec.push_back(1);
//test.push_back(0);
copy(vec.begin(),vec.begin()+1,test.begin());
cout << *(test.begin());
return 0;
}
Success time: 0 memory: 3428 signal:0
1
SO the reason is that you didn't initilize the vector,the vector.begin() point to somewhere restricted!
when you use a back_inserter(vector) it return a back_insert_interator that internally use a
vector.push_back rather than a *(deference) operation. So back_inserter works!
Below is a slightly modified code from one good example how to copy values fro one vector of strings to another vector of objects. (see: another copy algorithm )
#include <algorithm>
#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>
#include <boost/lambda/bind.hpp>
#include <boost/lambda/lambda.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>
using boost::shared_ptr;
using boost::make_shared;
using namespace boost::lambda;
class Object
{
public:
std::string Name;
Object(const std::string& Name_ = "")
: Name(Name_)
{
}
};
int main()
{
//std::vector<Object> objects(3, Object());
std::vector<shared_ptr<Object> > objects(3, make_shared<Object>());
std::vector<std::string> names;
names.push_back("Alpha");
names.push_back("Beta");
names.push_back("Gamma");
std::vector<std::string>::const_iterator names_it;
names_it = static_cast<const std::vector<std::string>&>(names).begin();
//std::for_each(objects.begin(), objects.end(), bind(&Object::Name, _1) = *var(names_it)++);
std::for_each(objects.begin(), objects.end(), bind(&Object::Name, *_1) = *var(names_it)++);
//std::vector<Object>::iterator it, end = objects.end();
std::vector<shared_ptr<Object> >::iterator it, end = objects.end();
for (it = objects.begin(); it != end; ++it) {
//std::cout << it->Name << std::endl;
std::cout << (*it)->Name << std::endl;
}
return EXIT_SUCCESS;
}
In this case I'm using dynamically allocated Objects, and because boost::lambda::bind can't handle such changes as boost::bind do, I need to dereference placeholder in order to compile:
std::for_each(objects.begin(), objects.end(), bind(&Object::Name, *_1) = *var(names_it)++);
But then at the output I've got:
Gamma
Gamma
Gamma
What is your explanation?
std::vector<shared_ptr<Object> > objects(3, make_shared<Object>());
This is equivalent to doing:
shared_ptr<Object> object = make_shared<Object>();
std::vector<shared_ptr<Object> > objects(3, object);
The vector constructor will then make 3 copies of that object pointer, which will all refer to same one and unique Object (that is to say, *object). Fill the vector with separate pointers each initialized with their own Object.
Given a multimap<A,B> M what's a neat way to create a vector<B> of all values in M with a specific key.
e.g given a multimap how can I get a vector of all strings mapped to the value 123?
An answer is easy, looping from lower->upper bound, but is there a neat loop-free method?
Here's the way to do it STL style :
// The following define is needed for select2nd with DinkumWare STL under VC++
#define _HAS_TRADITIONAL_STL 1
#include <algorithm>
#include <vector>
#include <map>
#include <string>
#include <functional>
#include <map>
#include <iterator>
#include <iostream>
using namespace std;
void main()
{
typedef multimap<string, int> MapType;
MapType m;
vector<int> v;
// Test data
for(int i = 0; i < 10; ++i)
{
m.insert(make_pair("123", i * 2));
m.insert(make_pair("12", i));
}
MapType::iterator i = m.lower_bound("123");
MapType::iterator j = m.upper_bound("123");
transform(i, j, back_inserter(v), select2nd<MapType::value_type>());
copy(v.begin(), v.end(), ostream_iterator<int>(cout, ","));
}
Let's go lambda
given: multimap<A,B> M
requested: vector<B> (of all values in M with a specific key 'a'.)
method:
std::pair<M::iterator, M::iterator> aRange = M.equal_range('a')
std::vector<B> aVector;
std::transform(aRange.first, aRange.second,std::back_inserter(aVector), [](std::pair<A,B> element){return element.second;});
System environment:
compiler: gcc (Ubuntu 5.3.1-14ubuntu2.1) 5.3.1 20160413 (with -std=c++11)
os: ubuntu 16.04
Code example:
#include <algorithm>
#include <vector>
#include <map>
#include <string>
#include <functional>
#include <iostream>
int main()
{
typedef std::multimap<std::string, int> MapType;
MapType m;
std::vector<int> v;
/// Test data
for(int i = 0; i < 10; ++i)
{
m.insert(std::make_pair("123", i * 2));
m.insert(std::make_pair("12", i));
}
std::pair<MapType::iterator,MapType::iterator> aRange = m.equal_range("123");
std::transform(aRange.first, aRange.second, std::back_inserter(v), [](std::pair<std::string,int> element){return element.second;});
for(auto & elem: v)
{
std::cout << elem << std::endl;
}
return 0;
}
You need a loop anyway. All "loop-free" methods just abstract the loop away.
#include <map>
#include <vector>
#include <algorithm>
#include <ext/functional>
using namespace std;
int main () {
multimap<int, double> mm;
mm.insert(make_pair(1, 2.2));
mm.insert(make_pair(4, 2.6));
mm.insert(make_pair(1, 9.1));
mm.insert(make_pair(1, 3.1));
vector<double> v;
transform(mm.lower_bound(1), mm.upper_bound(1),
back_inserter(v), __gnu_cxx::select2nd<pair<int, double> >());
// note: select2nd is an SGI extension.
for (vector<double>::const_iterator cit = v.begin(); cit != v.end(); ++ cit)
printf("%g, ", *cit); // verify that you've got 2.2, 9.1, 3.1
return 0;
}
template <class Key, class Val>
vector<Val>& getValues(multimap<Key, Val>& multi, Key& key)
{
typedef multimap<Key, Val>::iterator imm;
static vector<Val> vect;
static struct
{
void operator()(const pair<Key, Val>& p) const
{
vect.push_back(p.second);
}
} Push;
vect.clear();
pair<imm, imm> range = multi.equal_range(key);
for_each(range.first, range.second, Push);
return vect;
}
This is a bit contrived because of your 'no loop' requirement.
I prefer:
template <class Key, class Val>
vector<Val> getValues(multimap<Key, Val>& map, Key& key)
{
vector<Val> result;
typedef multimap<Key, Val>::iterator imm;
pair<imm, imm> range = map.equal_range(key);
for (imm i = range.first; i != range.second; ++i)
result.push_back(i->second);
return result;
}
You could initialise the vector by giving it two iterators, like this:
std::multimap<std::string, std::string> bar;
...
std::vector<pair<string,string> > foo(bar.lower_bound("123"), bar.upper_bound("123"));
but that would give you a vector of pairs (ie, with both the key and value).
Another option would be to use std::copy with something like a back_inserter, which is another way to hide the loop, but with the same downside as above.
std::copy(bar.lower_bound("123"), bar.upper_bound("123"), std::back_inserter(foo));
This would append the elements (if any) to the vector foo.
For extracting the values only, I can't think of any way but to loop over the results as I'm not aware of a standard way to get only the value out of a range.
Just some addenda to the other answers here…
std::mem_fn (from #include <functional>) can be used as a shorthand for the transform operator:
// previously we might've used this longhand
[](pair<int,string> element){return element.second;}
And we can use vector::resize and std::distance to allocate space for the vector in one go, rather than repeatedly resizing it with back_inserter.
#include <algorithm>
#include <vector>
#include <map>
#include <string>
#include <functional>
#include <iterator>
#include <iostream>
using namespace std;
typedef multimap<int, string> MapType;
int main()
{
MapType multimap;
vector<string> valuesForKey123;
multimap.emplace(0, "red");
multimap.emplace(123, "hello");
multimap.emplace(123, "world");
multimap.emplace(0, "herring");
MapType::iterator lower{multimap.lower_bound(123)};
MapType::iterator upper{multimap.upper_bound(123)};
valuesForKey123.resize(distance(lower, upper));
transform(
lower,
upper,
valuesForKey123.begin(),
mem_fn(&MapType::value_type::second));
copy(
valuesForKey123.begin(),
valuesForKey123.end(),
ostream_iterator<string>(cout, " "));
}
// outputs "hello world "