overloading

I want to create two functions, say long min(long...); int min(int...); But when I try to invoke the second i.e min(1, 5) one I get ambiguous method call Is there workaround except renaming? It is a known bug The behaviour you describe is a bug which has been fixed with Java 7. See details in the release notes , section called "Changes in Most Specific Varargs Method Selection". The reason why it should compile Variable arity comes last in determining the most specific method. The rules to determine which vararg method applies when there are several are defined in JLS 15.12.2.4 - here is an

I just got a seg fault in overloading the assignment operator for a class FeatureRandomCounts, which has _rects as its pointer member pointing to an array of FeatureCount and size rhs._dim, and whose other date members are non-pointers: FeatureRandomCounts & FeatureRandomCounts::operator=(const FeatureRandomCounts &rhs) { if (_rects) delete [] _rects; *this = rhs; // segment fault _rects = new FeatureCount [rhs._dim]; for (int i = 0; i < rhs._dim; i++) { _rects[i]=rhs._rects[i]; } return *this; } Does someone have some clue? Thanks and regards! As mentioned, you have infinite recursion;

Yeah, the title can scare babies, but it's actually quite straightforward. I am trying to store a function pointer to a specialized template function, namely boost::make_shared (boost 1.41), as illustrated: boost::shared_ptr<int> (*pt2Function)() = boost::make_shared<int>; However, it won't compile (GCC 4.4.1) due to the fact that boost::make_shared has the following two specializations which the compiler can't tell apart in this context: template< class T > boost::shared_ptr< T > make_shared() ... template< class T, class... Args > boost::shared_ptr< T > make_shared( Args && ... args ) The

This question already has answers here : Is Method Overloading considered polymorphism? [closed] (8 answers) Closed 5 years ago . I was studying about static and dynamic polymorphism and got these links: http://guruzon.com/1/oop-concepts/polymorphism/what-is-polymorphism-example-tutorial-uml-diagram-notation http://www.coderanch.com/t/379004/java/java/static-polymorphism-dynamic-polymorphism http://javarevisited.blogspot.in/2011/08/what-is-polymorphism-in-java-example.html In all these links , It has been said that Overloading is an example of polymorphism , then I came across two more places

I am trying to write a small library that can either be used in a standard java app or as part of a servlet. I have defined a couple of overloaded methods as follows: // imports etc. public ExampleLibrary { /** * This one is meant to be used by a J2SE app */ public String processData(Map headers) throws MyException { // process // return result } /** * This one is meant to be used by a servlet */ public String processData(HttpServletRequest request) throws MyException { // extract headers from request // process // return result } // other methods..... } This works great when used as part of a

The following code (from C++ FAQs 24.11) is implementing virtual assignment operator overloading and overriding: #include <iostream> using namespace std; class B{ public: virtual ~B() throw(); virtual B& operator= (const B& b) throw(); }; B::~B() throw(){} B& B::operator= (const B& b) throw() { cout << "B::operator=(const B&)\n"; return *this; } class D : public B{ public: virtual D& operator= (const B& b) throw(); D& operator= (const D& d) throw(); }; D& D::operator= (const B& b) throw() {cout << "D::operator= (const B&)\n"; return *this;} D& D::operator= (const D& d) throw() {cout << "D:

I'm writing a template matrix class, and I am a bit confused as to how overloading the * operator would work. I would want to overload something like this (omitting irrelevant code): template<typename T>class Matrix4t { friend vector3 operator*(const vector3 &inputV3, const matrix4t &inputM4t); template <typename scalarT> friend scalarT operator*(const scalarT &inputSclT, const matrix4t &inputM4t); public: const matrix4t operator*(const matrix4t) vector3 operator*(const vector3 &inputV3); template <typename scalarT> const matrix4t operator*(const scalarT&); } Assuming correct definitions for