Thread: A few questions regarding classes

I ran into two peculiar issues in a program I've been writing regarding class usage. Rather than posting pages upon pages of code, here's a few simplified examples to illustrate the issues:

Code:

class foo
{
public:
	foo()
	{
		//Do initialization stuff...
	}

	foo(bool bar)
	{
		if(bar)
			foo();  //Problem here....
	}
};

The problem is that when the version of foo() that takes an argument calls the version that doesn't, the "this" pointer in that function is invalid. I know an easy workaround would be having an extra DoInitialization() member that both versions of the constuctor could call, but I'm still curious as to why the "this" pointer is getting messed up.

Next issue:

Code:

class foo
{
public:
	foo()	{}

	DoStuff()
	{
		//Stuff getting done...
	}
};

class foobar : public foo
{
public:
	foobar()	{}

	DoStuff()
	{
		//Different stuff getting done...
	}
};

DoFoobarStuff(foo& foobar)
{
	//When you pass this function a class of the foobar type typecast as a foo type, the foobar version
	//of DoStuff() should get called

	foobar.DoStuff();

	//However,  no matter which type is passed, only the foo version of DoStuff() is ever used
}

The question is, how do you make sure the appropriate DoStuff() function gets called corresponding to the actual class that get's passed as an argument, and not the type as percieved by the function that calls DoStuff()? Keep in mind that dynamically determining the actual class type using RTI and casting it to that type first is not an option for me with my current code structure.

For your first problem, don't call constructors explicitly. Just make the DoInitialization method.

For your second problem, that's exactly what the virtual keyword is for. Make DoStuff virtual, and the appropriate version will be called. (Note that you should not actually be typecasting anything, when you pass by reference to the base class, it will only work if you just pass the actual derived object).

Originally Posted by Daved

For your first problem, don't call constructors explicitly. Just make the DoInitialization method.

Fair enough...

Originally Posted by Daved

For your second problem, that's exactly what the virtual keyword is for. Make DoStuff virtual, and the appropriate version will be called. (Note that you should not actually be typecasting anything, when you pass by reference to the base class, it will only work if you just pass the actual derived object).

Right, somehow I thought that in this case the compiler would have to use the version of DoStuff() from the derived class regardless of whether it was declared virtual because the code it excecuted was defined by the class instance rather than the class type. But, I guess getting that behavior was the point of having virtual functions in the first place. In the past I had only been using virtual for pure virtual functions, and somehow I forgot about it's other purpose. Well, I'm still a little inexperienced in C++, so cut me a little slack here.

Originally Posted by JaWiB

The constructor creates an object of the class. I really don't see why you even have the second constructor if you aren't even using the argument that you pass to it. I imagine something like this would work, though:

Code:

class Base
{
public:
  Base(){ /*...*/ }
  Base(int val) { *this = Base();  }
private:
  //...
}

But you would have to be careful to define an assignment operator that performs a deep copy (ie, allocates its own memory rather than copying pointers).

Edit: Now that I think about it I'm not sure there is ever a good reason to do this...

Yea, in my case it would be considerably easier to use a seporate DoInitialization() method than something like that anyway.