overload-resolution

Partial ordering of function templates containing template parameter packs is independent of the number of deduced arguments for those template parameter packs. template<class...> struct Tuple { }; template< class... Types> void g(Tuple<Types ...>); // #1 template<class T1, class... Types> void g(Tuple<T1, Types ...>); // #2 template<class T1, class... Types> void g(Tuple<T1, Types& ...>); // #3 g(Tuple<>()); // calls #1 g(Tuple<int, float>()); // calls #2 g(Tuple<int, float&>()); // calls #3 g(Tuple<int>()); // calls #3 The above is quoted from partial ordering of overload function templates

Consider you want to mock an interface using Mockito containing the following method signatures: public void doThis(Object o); public void doThis(Object... o) I need to verify that doThis(Object o) (and not the other method) has been invoked exactly one time. First I thought that the following line would do the trick: verify(mock, times(1)).doThis(anyObject()); However, as this seems to work on Windows, it doesn't on Linux because in this environment, a call to of the other doThis method is expected. This is caused because the anyObject() argument seems to match both method signatures and one

This question is inspired by this one . Consider the code: namespace ns { template <typename T> void swap(T& a, T& b) { using namespace std; swap(a, b); } } After some test with GCC, I found that swap(a, b); resolves to 1) std::swap if T has overloaded std::swap (e.g., standard container types) 2) ns::swap otherwise, leading to infinite recursion. So, it seems that the compiler will first try to find a match in the namespace ns . If a match is found, the search ends. But this is not the case when ADL comes in, in which case, std::swap is found anyway. The resolution process seems to be

Contrary to my expectations, this program works: #include <iostream> namespace a { struct item{}; } namespace b { struct item{}; } template<typename T> void func(T t) { do_func(t); } int main() { func(a::item{}); func(b::item{}); } namespace a { void do_func(item) { std::cout << "a::func\n"; } } namespace b { void do_func(item) { std::cout << "b::func\n"; } } Output: a::func b::func Verifications with online compilers: gcc 4.8 clang 3.4 If the instantation of func<T> occurs in the body of main then I would expect that a::do_func and b::do_func are not yet declared. How can this work? Update

Consider this simple pair of function templates. template <typename T> void foo(T& ) { std::cout << __PRETTY_FUNCTION__ << '\n'; } template <typename C> void foo(const C& ) { std::cout << __PRETTY_FUNCTION__ << '\n'; } If we call foo with a non-const argument: int i = 4; foo(i); The T& overload is preferred based on [over.ics.rank]/3.2.6, since the deduced reference int& is less cv -qualified than the deduced reference const int& . However, if we call foo with a const argument: const int ci = 42; foo(ci); The const C& overload is preferred because it is "more specialized" based on [over.match

I don't seem to get why would you use the move assignment operator : CLASSA & operator=(CLASSA && other); //move assignment operator over, the copy assignment operator : CLASSA & operator=(CLASSA other); //copy assignment operator The move assignment operator takes an r-value reference only e.g. CLASSA a1, a2, a3; a1 = a2 + a3; In the copy assignment operator , other can be constructor using a copy constructor or a move constructor (if other is initialized with an rvalue, it could be move-constructed --if move-constructor defined--). If it is copy-constructed , we will be doing 1 copy and that