Among other important paradigms in software design, object orientation is a common set of design techniques these days. Hierarchies of classes, derivative class instantiations and virtual calls can be often found on software codebases. Hence, the relevance of the Performing Half-baked object case while designing object-oriented software.
The Performing Half-baked object case occurs where a virtual call is executed onto an unborn or uncreated or uninitialized class instance: the actual behavior can be unexpected, of course.
A couple of examples.
Consider the output of this Windows/Visual C++ code:
#include <iostream>
class AA
{
public:
AA()
{
std::cout << "AA()\n";
f();
}
virtual void f() { std::cout << "AA.f\n"; }
};
class BB : public AA
{
public:
BB()
{
std::cout << "BB()\n";
f();
}
virtual void f() { std::cout << "BB.f\n";}
};
void main()
{
auto x = new BB;
}
For another –different– behavior, consider the output of this .NET/Visual C# code:
using static System.Console;
class AA
{
public AA()
{
WriteLine("AA()");
f();
}
public virtual void f() => WriteLine("AA.f");
}
class BB : AA
{
public BB()
{
WriteLine("BB()");
f();
}
public override void f() => WriteLine("BB.f");
}
class Program
{
public static void Main()
{
var x = new BB();
}
}
The Performing Half-baked object is a case that designers of object-oriented languages and runtimes have typically faced. Any designer using those languages and runtimes should be aware of this and other cases during the process of object creation.
