Hi all,

I came across some unexpected behaviour in Java:  When I call a
member-function from a class' constructor, this call is done virtual as
usual calling the overridden method of the subclass.

This seems to me a bit problematic, as it calls a member-function of the
subclass which is not yet constructed and might therefore be well in an
inconsistent state.  One can even call an abstract function from a
class' constructor.

In C++, this is the other way round, there a constructor never calls an
overridden method from a subclass, so this inconsitent state can never
occur, which seems to me to be the better way.  Calling a pure virtual
function from a constructor yields at least a warning and of course a
linker-error later on.

Is there any rationale behind this as it is done in Java?  The only
reason I can think of is to handle function call's in constructors the
same way as it is done with ordinary calls.  But the function to call
there is would be known at compile-time, so it shouldn't be really hard
to implement C++'s behaviour.

Or is this even considered "a feature"?  However, I believe a function
should *never* be called on an unconstructed object except in the
constructor of the class itself where the programmer must take care this
call is valid there.

Cheers,
Daniel

******************************
Test.java

public class Test
{

  public Test()
  {
    foo();
  }

  public void foo()
  {
    System.out.println("A");
  }

  public static void main(String[] args)
  {
    Test t=new Test2();
  }

  public static class Test2 extends Test
  {

    public Test2()
    {
      super();
      foo();
    }

    public void foo()
    {
      System.out.println("B");
    }

  }

}

This produces:
B
B

********************************
Test.cpp

#include <iostream>
using namespace std;

class Test
{
  public:
    Test()
    {
      foo();
    }
    virtual void foo()
    {
      cout << "A" << endl;
    }
};

class Test2 : public Test
{
  public:
    Test2()
      : Test()
    {
      foo();
    }
    virtual void foo()
    {
      cout << "B" << endl;
    }
};

int main()
{
  Test* t(new Test2());
  delete t;
  return 0;
}

This produces:
A
B