That’s two-phase lookup for you. Base<T>::NO_ZEROFILL (all caps identifiers are boo, except for macros, BTW) is an identifier that depends on T. Since, when the compiler first parses the template, there’s no actual type substituted for T yet, the compiler doesn’t “know” what Base<T> is. So it cannot know any identifiers you assume to be … Read more
In that code, there doesn’t seem to be an advantage. But consider the following overloaded functions: void f(char const *ptr); void f(int v); f(NULL); //which function will be called? Which function will be called? Of course, the intention here is to call f(char const *), but in reality f(int) will be called! That is a … Read more
Intel x86 processors use 80-bit extended precision internally, whereas double is normally 64-bit wide. Different optimization levels affect how often floating point values from CPU get saved into memory and thus rounded from 80-bit precision to 64-bit precision. Use the -ffloat-store gcc option to get the same floating point results with different optimization levels. Alternatively, … Read more
Use boost::lexical_cast. If the cast cannot be done, it will throw an exception. #include <boost/lexical_cast.hpp> #include <iostream> #include <string> int main(void) { std::string s; std::cin >> s; try { int i = boost::lexical_cast<int>(s); /* … */ } catch(…) { /* … */ } } Without boost: #include <iostream> #include <sstream> #include <string> int main(void) { … Read more
You can only specialize it explicitly by providing all template arguments. No partial specialization for member functions of class templates is allowed. template <typename T,bool B> struct X { void Specialized(); }; // works template <> void X<int,true>::Specialized() { … } A work around is to introduce overloaded functions, which have the benefit of still … Read more
Here is what I have gathered so far: Buffering: If by default the buffer is very small, increasing the buffer size can definitely improve the performance: it reduces the number of HDD hits it reduces the number of system calls Buffer can be set by accessing the underlying streambuf implementation. char Buffer[N]; std::ifstream file(“file.txt”); file.rdbuf()->pubsetbuf(Buffer, … Read more
Yes. There are two common options. One – which is generally discouraged – is to call the operator= from the copy constructor explicitly: MyClass(const MyClass& other) { operator=(other); } However, providing a good operator= is a challenge when it comes to dealing with the old state and issues arising from self assignment. Also, all members … Read more
Put simply, var is not initialized and reading an uninitialized variable leads to undefined behavior. So don’t do it. The moment you do, your program is no longer guaranteed to do anything you say. Formally, “reading” a value means performing an lvalue-to-rvalue conversion on it. And ยง4.1 states “…if the object is uninitialized, a program … Read more
When the language was first evolving, in early releases with real users, there were no references, only pointers. References were added when operator overloading was added, as it requires references to work consistently. One of the uses of this is for an object to get a pointer to itself. If it was a reference, we’d … Read more
It is correct that std::move(x) is just a cast to rvalue – more specifically to an xvalue, as opposed to a prvalue. And it is also true that having a cast named move sometimes confuses people. However the intent of this naming is not to confuse, but rather to make your code more readable. The … Read more