Note that there is a way to get the best of both worlds in this case, and just provide default paramiters
Code:
drawShape(int x=640,int y=480);
foo.drawShape(); // calls drawshape(640,480);
foo.drawShape(1024); // calls drawshape(1024,480);
Having a function that calls another function with little more changed than a paramiter is generally called "syntatic sugar". Personally, particularly if the call can be inlined, I think its fine. Often sugar consists of operators that call named methods.
Code:
template<class T>
class foo {
...
public:
foo<T> & append(const T &):
foo<T> & operator += (const T &rhs) {return append(rhs);}
};
template<class T> inline
foo<T> operator +(foo<T> lhs, const T &rhs) {return lhs += rhs;}
template<class T> inline
foo<T> operator +(const T &lhs, foo<T> rhs) {return rhs + lhs;}
foo<int> a = 3 + b; // becomes a = foo<int>(b).append(3);
Note that the compiler is frequently smart enough to avoid function call overhead, but not always, a = 3+b could make up to 4 copies of b and 4 stack frames, so sugar is not always without cost. I generally like to give the compiler a crack at it though. It's much easyer to make an slow program that's easy to work with much faster, then a kinda fast, but confusing program even a little bit faster.
