Liskov Substitution Principle Generally you don’t want you method signature to vary in derived types. This can cause problems if you want to swap the use of derived types. This is often referred to as the Liskov Substitution Principle. Benefits of Explicit Signatures At the same time I don’t think it’s correct for all your … Read more
It’s because of type coercion. Say you have the following functions: int x(double); float x(double); double y = x(1.0); Now, which of the two prototypes should you call, especially if they do two totally different things? Basically, a decision was made early on in the language design to only use the function name and arguments … Read more
It follows the C convention. The C convention in turn is based on CPU architectures which pass arguments on the stack. The first non-vararg arguments end up at a fixed offset in the stackframe. If you could put the vararg arguments first, the stack offset of the following arguments would depend on how many vararg … Read more
Quoting from Oracle Docs: Definition: Two of the components of a method declaration comprise the method signature—the method’s name and the parameter types. Since the question was edited to include this example: public class Foo { public int myMethod(int param) {} public char myMethod(int param) {} } No, the compiler won’t know the difference, as … Read more
int* test(); but it would be “more C++” to use vectors: std::vector< int > test(); EDIT I’ll clarify some point. Since you mentioned C++, I’ll go with new[] and delete[] operators, but it’s the same with malloc/free. In the first case, you’ll write something like: int* test() { return new int[size_needed]; } but it’s not … Read more