c++03

Should set_terminate / get_terminate set a different terminate exception processor for several threads in C++ 2011 or C++ 2003? E.g. if I have program and sets terminate handler to func_1 ; then I start 3 threads. What are terminate handlers in new threads? What if in every thread I will set terminate handler to func_2 in first thread, func_3 in second thread and so on. N3242 (C++ 2011 draft) says nothing about it in [handler.functions] or in [support.exception] / [exception.terminate] PS: You may answer for C++2011 or for C++2003 of for any popular implementation of these standards PPS: There

In this question we've learnt that RVO cannot be applied to an expression like p.first . In comments it was also suggested that RVO is generally not applied to an expression like r after a declaration like auto& r = p.first . It is less clear whether the standard mandates this behaviour. in a return statement in a function with a class return type, when the expression is the name of a non-volatile automatic object (other than a function parameter or a variable introduced by the exception-declaration of a handler ([except.handle])) with the same type (ignoring cv-qualification) as the function

I'm writing a hash class: struct hashmap { void insert(const char* key, const char* value); char* search(const char* key); private: unsigned int hash(const char* s); hashnode* table_[SIZE]; // <-- }; As insert() need to check if table[i] is empty when inserting a new pair, so I need all pointers in the table set to NULL at start up. My question is, will this pointer array table_ be automatically initialized to zero, or I should manually use a loop to set the array to zero in the constructor? The table_ array will be uninitialized in your current design, just like if you say int n; . However,

I have a 3rd-party class, say, class A , and a function accepting vector of class A from the same 3rd-party, say f3() (See simplified program below). For easier use of A , I created a derived class B . Many part of my program used class B . The question is, how can I call f3() with a vector of B as its argument? Is a forced casting in the argument of f3() like the program below a good practice? #include <vector> #include <iostream> #include <algorithm> using namespace std; // a 3rd-party class class A { public: int n; void f1(); }; // my class class B: public A { public: void f2(); }; // a 3rd

This is similar to What differences, if any, between C++03 and C++11 can be detected at run-time? . But in this case, I want detection to occur via the preprocessor. How should we guard the move constructor (and move assignment ) when the sources are used in both C++03 and C++11? Is the following sufficient (is move semantics something all C++ compilers adopted due to it being essential/core feature)? #if (__cpluplus >= 201103L) Foo(Foo&& other); #endif Or do I need to get into compiler specifics? If we need compiler specific macros, then how do we handle situations like Visual Studio 2012 _

I want to declare a friend class only if some (compile-time) condition is true. For example: // pseudo-C++ class Foo { if(some_compile_time_condition) { friend class Bar; } }; I did not find any solution on the internet. I went through all the answers to the question Generating Structures dynamically at compile time . Many of them use the C++11 std::conditional , but I would like to know if it is possible to do this in C++03 without using the preprocessor . This solution https://stackoverflow.com/a/11376710/252576 will not work because friend ship is not inherited ( friend class with

I need a std:map data structure that is read only, which means I have to fill it once with data and then only read those values, never change them or add additional ones. My non-const version looks like this: //in .h #include <string> #include <map> std::map<std::string, int> myMap; void initMap(); //in .cpp #include "foo.h" void initMap() { myMap["Keys"] = 42; } Then I'd call initMap() once in my code and be done. Now I've read several questions here already and it seems non-trivial to achieve const-ness for the map. Making it a std::map<std::string, const int> won't allow me to fill it in