overloading

In the following code #include <iostream> using namespace std; class A { public: A() {} virtual ~A() {}; }; class B : public A { public: B() {} virtual ~B() {}; }; void process(const A&) { cout << "processing A" << endl; } void process(const B&) { cout << "processing B" << endl; } int main(void) { A* a = new B; process(*a); return 0; } the output of running it becomes processing A but I would have assumed that it should have been processing B since a points to the derived class B and not A . So why does it call the first implementation of process function and not the second? The static type of

case 1: you can overload two functions namely: void foo(int *); void foo(const int *); while in , case 2: you can not overload two functions: void foo(int); void foo(const int); I have coded and checked this concept and yet unable to find out the reason to this variation in overloading. From Standard §13.1 Parameter declarations that differ only in the presence or absence of const and/or volatile are equivalent . That is, the const and volatile type-specifiers for each parameter type are ignored when determining which function is being declared, defined, or called. [ Example: typedef const int

My Question: I'm trying to overload the assignment operator for pointers to two different classes. Here is an example: dc.h: #ifndef DC_H_ #define DC_H_ #include "ic.h" class dc { double d; char c; public: dc(): d(0), c(0) { } dc(double d_, char c_): d(d_), c(c_) { } dc* operator=(const ic* rhs); ~dc() { } }; #endif /* DC_H_ */ class ic.h: #ifndef IC_H_ #define IC_H_ class ic { int i; char c; public: ic(): i(0), c(0) { } ic(int i_, char c_): i(i_), c(c_) { } ~ic() { } }; #endif /* IC_H_ */ dc.cpp: #include "dc.h" dc* dc::operator=(const ic* rhs) { d = rhs->i; c = rhs->c; return this; } ic.cpp:

I am a groovy newbie. Maybe this is a piece of cake, but I want to overload the + operator for arrays/lists to code like this def a= [1,1,1] def b= [2,2,2] assert [3,3,3] == a + b I wouldn't recommend globally overriding well-established behaviors. But, if you insist, this will do as you ask: ArrayList.metaClass.plus << {Collection b -> [delegate, b].transpose().collect{x, y -> x+y} } A more localized alternative would be to use a category: class PlusCategory{ public static Collection plus(Collection a, Collection b){ [a, b].transpose().collect{x, y -> x+y} } } use (PlusCategory){ assert [3, 3

I hit a bump when I'm doing my Java code. I feel like I somehow got the concept messed up, like I not sure for this: void setScore(float[] sco) { sco = score; } public void setScore(float sco, int id) { sco[id] = score; } The error message corresponds to "sco[ID] = score; " The type of the expression must be an array type but it resolved to float I'm confused what I should put in the bracket, the book asks me to put "float[] score" instead of "float[] sco", but it doesn't work, so I edited a bit after several trials. This part of coding generally describes the method of overloading that stores

abstract class A { int met(A a) { return 0; } int met(B b) { return 1; } int met(C c) { return 2; } } class B extends A { int met(A a) { return 3; } int met(B b) { return 4; } int met(C c) { return 5; } } class C extends B { int f() { return ((A)this).met((A)this); } } public class teste { public static void main(String args[]) { C x = new C(); System.out.println(x.f()); } } The program will return 3 and I was expecting 0. Why does the first cast in the method f do nothing and the second one works? Is it because in the A and B classes the met methods are overloaded and therefore static binding