non-member-functions

Every time I have some functionality which is in the direction of "utility", I end up wondering which option is the best. For instance, printing message structs (own or external), some encoding/decoding code or simply a few useful conversion functions in the context I'm working. The options I think about are: 1) Static function in helper class/struct. struct helper { static bool doSomething(...); }; 2) Nonmember function. namespace helper { bool doSomething(...); } 3) Static nonmember function. namespace helper { static bool doSomething(...); } In some cases there might be necessary to

As most C++ programmers should know, partial template specialization of free functions is disallowed. For example, the following is illegal C++: template <class T, int N> T mul(const T& x) { return x * N; } template <class T> T mul<T, 0>(const T& x) { return T(0); } // error: function template partial specialization ‘mul<T, 0>’ is not allowed However, partial template specialization of classes/structs is allowed, and can be exploited to mimic the functionality of partial template specialization of free functions. For example, the target objective in the last example can be achieved by using:

Consider a legacy class template with overloaded addition operators += and + template<class T> class X { public: X() = default; /* implicict */ X(T v): val(v) {} X<T>& operator+=(X<T> const& rhs) { val += rhs.val; return *this; } X<T> operator+ (X<T> const& rhs) const { return X<T>(*this) += rhs; } private: T val; }; Upon code review, it is observed that + is implementable in terms of += , so why not make it a non-member (and have guaranteed symmetry for left and right arguments)? template<class T> class X { public: X() = default; /* implicit */ X(T v): val(v) {} X<T>& operator+=(X<T> const&

It seems that the way that most people find the size of a string is they just use the my_string.size() and it works fine. Well, I recently did an assignment for class where I did... if (size(my_string) < 5) store[counter].setWeight(stoi(my_string)); Instead of.... if (my_string.size() < 5) store[counter].setWeight(stoi(my_string)); But to my suprise my instructor, who I believe is running an older compiler, wasn't able to run that line of code. On my compiler it works both ways and I'm not quite sure why. A complete program (it outputs 4 for both): #include <string> #include <iostream> using

I'm trying something like this: Foo & operator=(Foo & to, const Bar &from); But I'm getting this error: E2239 'operator =(Foo &, const Bar &)' must be a member function Are there limitations on which operators can/cannot be defined as Free Functions, and if so, why? The assignment operator must be a non-static member function and must have exactly one parameter: An assignment operator shall be implemented by a non-static member function with exactly one parameter (C++03 13.5.3/1). operator() , operator[] , and operator-> must also be implemented as non-static member functions. Class-specific