c++03

I only have access to C++03 and I often want to move a vector into a function the way you can do it in C++11. The question how to do it not to confuse the user of the code too much. So my question is how did programmers do it before C++11. I know that vector can be "moved" using swap function. So here is what I have come up with: class Foo { public: Foo(std::vector<int>& vec) { using std::swap; swap(vec, m_vec); // "move" vec into member vector } private: std::vector<int> m_vec; }; // usage: std::vector<int> v(100, 1337); Foo foo(v); // v.empty() == true The problem with this approach is that

NOTE : This question was originally asked way back in 2012. Before the decltype specifier was fully implemented by any major compilers. You should not be looking at this code unless you only have access to C++03. All major C++11 compliant compilers now support decltype . Is there an easy way to retrieve the type of a member? In C++03 struct Person { std::string name; int age; double salary; }; int main() { std::vector<Person> people; // get a vector of people. std::vector<GET_TYPE_OF(Person::age)> ages; ages.push_back(people[0].age); ages.push_back(people[10].age); ages.push_back(people[13]

In another answer it was stated that prior to C++11, where i is an int , then use of the expression: *&++i caused undefined behaviour. Is this true? On the other answer there was a little discussion in comments but it seems unconvincing. It makes little sense to ask whether *&++i in itself has UB. The deferencing doesn't necessarily access the stored value (prior or new) of i , as you can see by using this as an initializer expression for a reference. Only if an rvalue conversion is involved (usage in such context) is there any question to discuss at all. And then, since we can use the value

The tags ask the question, but nonetheless, consider the following: template<typename F, typename A, typename R> R call(F function, A arg) { return function(arg); } int foo(char) { return 5; } int main() { call(foo, 'a'); } The compiler happily compiles this if parameter R is removed and int is inserted manually as the return type. As shown, the compiler has no way of knowing what to make of R. How can I deduce function return types in C++03? I'm looking for methods that do not require manually specifying the return type and do not require intrusive changes to the other parameters. If this is

I want to define a global container (C++03), and here's an example code I tried, which does not work. #include <vector> #include <string> using namespace std; vector<string> Aries; Aries.push_back("Taurus"); // line 6 int main() {} Compile error: prog.cpp:6:1: error: 'Aries' does not name a type It seems I can define an empty global vector, but cannot fill it up. Looks like in C++03, I cannot specify an initializer either, such as: vector<string> Aries = { "Taurus" }; Have I made a mistake here, or how do I get around this problem? I tried searching on StackOverflow to see if this has been

Is there such a tool that is able to convert a code that uses some C++11 features to C++03 compatible code (perhaps using some third party libraries like Boost)? Because nobody has answered with an actual answer, the answer is "No". Just upgrade your toolchain. There are a lot of good reasons to do that anyway. For Ubuntu and other Linux variants, you can even download the package in source form and compile it for your ancient system if you want to use a new toolchain on a very old system. Of course, if you then ship programs with this you will have to link libstdc++ statically or ship the

Consider this: #include <iostream> #include <map> #include <string> #include <boost/assign/list_of.hpp> using boost::assign::map_list_of; const std::map<int, std::map<int, char> > test = map_list_of (100, map_list_of (1, 'a') (2, 'b') ) (101, map_list_of (1, 'c') (2, 'd') ) ; int main() { std::cout << test.find(101)->second.find(2)->second << "\n"; } I wanted the result to be a program that, when executed, outputs d . Instead, I get this : $ clang++ -std=c++03 -O2 -Wall -pedantic -pthread main.cpp In file included from main.cpp:1: In file included from /usr/local/bin/../lib/gcc/x86_64-unknown

I have a question about the different meanings of a curly-brace enclosed list . I know that C++03 did not support C++11's initializer_list . Yet, even without the -std=c++11 compiler flag, gcc 6.3 will properly initialize interpolate with this code: map<string, string> interpolate = { { "F", "a && b && c" }, { "H", "p ^ 2 + w" }, { "K", "H > 10 || e < 5" }, { "J", "F && !K" } }; I was challenged on why this would work, and I realized I didn't have an answer. This is a Brace-Init-List, but the way we get from that to initializing a standard container is typically through an initializer_list .