Hello,

I'm having a problem with virtual functions in a large program. I'm
basically assigning a pointer to a base class the address of a derived
class that overrides a virtual function in the base class, and then
calling the overridden function through the pointer. The problem is that
unless I declare the base classes' function nonvirtual, the program
crashes with an access violation at 00000000. Of course, when it's
nonvirtual, the wrong function executes.

I've been able to get the following (very small) program to run with
no problems, proving that this is allowed in a C++ program, but the
larger one (50+ modules, 900K+ EXE size), crashes. The following
program illustrates my problem:

class A {
  public:
  int data;

  // virtual function
  virtual void assign(int x) { }

};

class B : public A {
  public:

  void assign(int x) { data = x; }
};


void main() {

  B b; // object of type "B"

  A *pA = (A *)&b; // pointer to a "B" object...

  // this is where i get the access violation.
  pA->assign(5);
}

This works fine, and is exactly the same kind of stunt I'm pulling in
my large program, except that the large program crashes. I was wondering
if there are  any compiler switches that control this sort of thing, or
whether it's the fact that I'm using the Borland compiler, which is
getting all sorts of bad press for  being a piece of crap. If anyone can
suggest why this might not work, I'd be  real interested in hearing it.

Thanks,
Kelly

___
 X KWQ/2 1.2g NR X This tagline stolen by KWQ Mail/2.

--- Maximus/2 2.02