c++98

Let's say we have this legacy code from C++98: bool expensiveCheck(); struct Foo; bool someFunc() { Foo *ptr = 0; if( expensiveCheck() ) ptr = new Foo; // doing something irrelevant here ... if( ptr ) { // using foo } delete ptr; return ptr; // here we have UB(Undefined Behavior) in C++11 } So basically pointer here is used to keep dynamically allocated data and use it as a flag at the same time. For me it is readable code and I believe it is legal C++98 code. Now according to this questions: Pointers in c++ after delete What happens to the pointer itself after delete? this code has UB in C+

Compiling with Clang 3.0 -std=c++98, the following code is accepted: template<int> struct I { typedef int Type; }; template<class> struct S { static int f(int); //static int f(int*); // implicitly instantiates I<sizeof(int)> typedef I<sizeof(f(0))>::Type Type; }; S<int>::Type s; Uncommenting the overload of 'f' causes Clang to report an error "missing 'typename' prior to dependent type name". G++ 4.8 reports the same error with or without the overload. msvc10 does not give any errors with or without the overload. Where does the standard say whether or not 'f' is dependent and 'typename' is

The meta question proposes that the c++98 and c++03 tags should be made synonyms. The question asker followed it up with Is value initialization part of the C++98 standard? If not, why was it added in the C++03 standard? , an excellent question which sheds light on the addition of value initialization to C++03. Consider this question to be a follow-up to the latter. The OP asserts that modern compilers do not bother distinguishing between C++98 and C++03. This was surprising to me, as it turns out to be the case for three modern compilers. Although this question could boil down to "RTFM", my

Say I'm using a C API that lets you register callbacks that take a void* closure: void register_callback(void (*func)(void*), void *closure); In C++ it's nice to have stronger types than void* so I want to create a wrapper that lets me register strongly-typed C++ callbacks instead: template <typename T, void F(T*)> void CallbackWrapper(void *p) { return F(static_cast<T*>(p)); } void MyCallback(int* param) {} void f(void *closure) { register_callback(CallbackWrapper<int, MyCallback>, closure); } This works alright. One nice property of this solution is that it can inline my callback into the

I looked into the GCC STL (4.6.1) and saw that std::copy() uses an optimized version in case the builtin __is_trivial() evaluates to true . Since the std::copy() and std::reverse_copy() templates are very useful for copying elements in arrays, I would like to use them. However, I have some types (which are results of template instantiations) that are structs that contain some trivial values, no pointers and have no copy constructor or assignment operator. Is G++ smart enough to figure out that my type in fact is trivial? Is there any way in C++98 to make sure an STL implementation knows that

This question already has answers here : Closed 6 years ago . Is it possible to write a template to check for a function's existence? (25 answers) In C++11, to find out whether a class has a member function size , you could define the following test helper: template <typename T> struct has_size_fn { typedef char (& yes)[1]; typedef char (& no)[2]; template <typename C> static yes check(decltype(&C::size)); template <typename> static no check(...); static bool const value = sizeof(check<T>(0)) == sizeof(yes); }; Is there a similar trick for doing this in C++98 without relying on compiler

Please read the question entirely before you think to mark it as duplicate. The statement like int i=int(); most programmers will say that there is value initialization here & i will be value initialized. (0 as output). But it also prints 0 as output on C++98 compiler. Following program that I tested on C++98 implementation and gives me 0 as output. #include <iostream> int main() { int i=int(); std::cout<<i; } Don't say that i is value initialized in above C++98 program ,because value initialization introduced in C++03. So How i is initialized here? Is it really constructor call? int() looks