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
Your using declaration is in game.cpp, not game.h where you actually declare string variables. You intended to put using namespace std; into the header, above the lines that use string, which would let those lines find the string type defined in the std namespace. As others have pointed out, this is not good practice in … Read more
You can forward declare your own classes in header files to save compilation time. But you can’t for classes in namespace std. According to the C++11 standard, 17.6.4.2.1: The behavior of a C++ program is undefined if it adds declarations or definitions to namespace std or to a namespace within namespace std unless otherwise specified. … Read more
In C++17, the new map::extract function lets you change the key. Example: std::map<int, std::string> m{ {10, “potato”}, {1, “banana”} }; auto nodeHandler = m.extract(10); nodeHandler.key() = 2; m.insert(std::move(nodeHandler)); // { { 1, “banana” }, { 2, “potato” } }
I think the previous answers are misleading. fstream is a proper RAII object, it does close automatically at the end of the scope, and there is absolutely no need whatsoever to call close manually when closing at the end of the scope is sufficient. In particular, it’s not a “best practice” and it’s not necessary … Read more
I’ve always been taught that there is no guaranteed standard way to lower the capacity. All methods have been (and still are) implementation defined. § 23.2.1\8 says: The expression a.swap(b), for containers a and b of a standard container type other than array, shall exchange the values of a and b without invoking any move, … Read more
Yes, std::begin and std::end can work with parameters that are C style arrays. The trick is in passing a parameter that’s a C style array. When you specify a 1D array as a normal parameter to a normal function, its type is silently adjusted from “array of T” to “pointer to T”. When you call … Read more
You need a cast to disambiguate the overloaded function: (int(A::*)(int,int))&A::operator()
I don’t think you can get “atomic” operation but using the Filesystem Technical Specification that has now been accepted as part of the Standard Library (C++17) you can resize the file like this: #include <fstream> #include <sstream> #include <iostream> #include <experimental/filesystem> // compilers that support the TS // #include <filesystem> // C++17 compilers // for … Read more
The reason this fails is because when you specify foo<Movable>, the function you’re binding to is: void foo(Movable&&) // *must* be an rvalue { } However, the value passed by std::bind will not be an rvalue, but an lvalue (stored as a member somewhere in the resulting bind functor). That, is the generated functor is … Read more