c++-standard-library

What is the preferred method of using std::rel_ops to add the full set of relational operators to a class? This documentation suggests a using namespace std::rel_ops , but this seems to be deeply flawed, as it would mean that including the header for the class implemented in this way would also add full relational operators to all other classes with a defined operator< and operator== , even if that was not desired. This has the potential to change the meaning of code in surprising ways. As a side note - I have been using Boost.Operators to do this, but I am still curious about the standard

Tonight I've been taking a look at some code I've been working on over the last few days, and began reading up on move semantics, specifically std::move. I have a few questions to ask you pros to ensure that I am going down the right path and not making any stupid assumptions! Firstly: 1) Originally, my code had a function that returned a large vector: template<class T> class MyObject { public: std::vector<T> doSomething() const; { std::vector<T> theVector; // produce/work with a vector right here return(theVector); }; // eo doSomething }; // eo class MyObject Given "theVector" is temporary in

Answering How to self-copy a vector? has got me a bit confused about iterator invalidation. Some literature says "if you use insert, push_back, etc. consider all iterators invalid". Thats clear, it might cause the vector to grow which invalidates iterators. What about the special case where I know there is going to be enough room? first try: myvec.reserve(myvec.size()*3); //does this protect me from iterator invalidation? vector<string>::iterator it = myvec.end(); myvec.insert(myvec.end(), myvec.begin(), it); myvec.insert(myvec.end(), myvec.begin(), it); After some excellent answers second try

By default, the standard input device is tied together with the standard output device in the form: std::cin.tie (&std::cout); which guarantees that the output buffer has been flushed before input is invoked. So I try to untie them by using std::cin.tie(0) , but it seems that the result, has no difference with the tied one. #include<iostream> using namespace std; int main(int argc, char *argv[]) { char c; cin.tie(0) cout << "Please enter c:"; cin >> c; cout << c ; return 0; } Am I testing wrong? Why do we need to tie them together? Do they share the same buffer? user1284631 There is nothing

I was working on a little project and came to a situation where the following happened: std::string myString; #GetValue() returns a char* myString = myObject.GetValue(); My question is if GetValue() returns NULL myString becomes an empty string? Is it undefined? or it will segfault? Interesting little question. According to the C++11 standard, sect. 21.4.2.9, basic_string(const charT* s, const Allocator& a = Allocator()); Requires: s shall not be a null pointer. Since the standard does not ask the library to throw an exception when this particular requirement is not met, it would appear that

Given that I have two std::map s, say: map<int, double> A; map<int, double> B; I'd like to get the intersection of the two maps, something of the form: map<int, pair<double,double> > C; Where the keys are the values in both A and B and the value is a pair of the values from A and B respectively. Is there a clean way using the standard-library? Mark Ransom template<typename KeyType, typename LeftValue, typename RightValue> map<KeyType, pair<LeftValue, RightValue> > IntersectMaps(const map<KeyType, LeftValue> & left, const map<KeyType, RightValue> & right) { map<KeyType, pair<LeftValue,