You could use, when the condition, std::cin.fail() happens: std::cin.clear(); std::cin.ignore(); And then continue with the loop, with a continue; statement. std::cin.clear() clears the error flags, and sets new ones, and std::cin.ignore() effectively ignores them (by extracting and discarding them). Sources: cin.ignore() cin.clear()
No, it doesn’t. The capacity of a vector never decreases. That isn’t mandated by the standard but it’s so both in standard library implementations of VC++ and g++. In order to set the capacity just enough to fit the size, use the famous swap trick vector<T>().swap(foo); In C++11 standard, you can do it more explicitly: … Read more
Based on janm’s response at first I did this: template<class T> std::shared_ptr<T> to_std(const boost::shared_ptr<T> &p) { return std::shared_ptr<T>(p.get(), [p](…) mutable { p.reset(); }); } template<class T> boost::shared_ptr<T> to_boost(const std::shared_ptr<T> &p) { return boost::shared_ptr<T>(p.get(), [p](…) mutable { p.reset(); }); } But then I realized I could do this instead: namespace { template<class SharedPointer> struct Holder { … Read more
Only partially. C++11 <string> has std::to_string for the built-in types: [n3290: 21.5/7]: string to_string(int val); string to_string(unsigned val); string to_string(long val); string to_string(unsigned long val); string to_string(long long val); string to_string(unsigned long long val); string to_string(float val); string to_string(double val); string to_string(long double val); Returns: Each function returns a string object holding the character representation … Read more
In Visual Studio you must #include “stdafx.h” and be the first include of the cpp file. For instance: These will not work. #include <iostream> using namespace std; int main () { cout << “hey” << endl; return 0; } #include <iostream> #include “stdafx.h” using namespace std; int main () { cout << “hey” << endl; … Read more
Seeing from your G++ version, you need to update it badly. C++11 has only been available since G++ 4.3. The most recent version is 4.7. In versions pre-G++ 4.7, you’ll have to use -std=c++0x, for more recent versions you can use -std=c++11.
It’s almost always a bad idea to use the fscanf() function as it can leave your file pointer in an unknown location on failure. I prefer to use fgets() to get each line in and then sscanf() that. You can then continue to examine the line read in as you see fit. Something like: #define … Read more
The only case where it is OK to add a definition into the std namespace is specialization of a template that already exists in the namespace and to explicitly instantiate a template. However, only if they depend on a user defined type. [namespace.std] (standard draft): The behavior of a C++ program is undefined if it … Read more
Standard says (draft N3690; this is post C++11, pre C++14): [res.on.functions] 1 In certain cases (replacement functions, handler functions, operations on types used to instantiate standard library template components), the C++standard library depends on components supplied by a C++program. If these components do not meet their requirements, the Standard places no requirements on the implementation. … Read more
std::pair provides pre-written constructors and comparison operators. This also allows them to be stored in containers like std::map without you needing to write, for example, the copy constructor or strict weak ordering via operator < (such as required by std::map). If you don’t write them you can’t make a mistake (remember how strict weak ordering … Read more