July 1997

Using Delphi components in C++Builder

One of C++Builder's most promising features is that it lets you use your existing Delphi components. In many cases, you can use these components as-is. Sometimes, however, a Delphi component simply won't work in C++Builder. You may get compiler errors when you add the component to the Component Palette. Or the Delphi component may install without incident, but give you compiler or linker errors when you try to build the application that uses the component.

In this article, we'll point out some problem areas you may encounter when you're installing Delphi components in C++Builder. We'll first examine the most common (and most obvious) problems and also describe some of the more subtle difficulties that aren't as easy to resolve.

How C++Builder handles Delphi components

If the file extension is PAS, C++Builder invokes the Pascal compiler, which is slightly different from the one in Delphi. In C++Builder, the Pascal compiler will produce not only the DCU file for the component, as Delphi does, but will also produce an OBJ file and a header file with the extension HPP. The object file for the Pascal unit is necessary so C++Builder programs can link the component's code to the C++Builder executable file. The header file lets your application see the component's class declaration.

If you think about this process, you may shake your head in wonder. You have a Pascal source code unit that's compiled into an object file, which is compatible with C++ code. Not only that, C++Builder creates a header file for you so you can treat your Pascal classes as if they were C++ classes. All you have to do is add the Delphi component to the Component Palette, and C++Builder takes it from there.

Amazing! Well, it is amazing when it works (and it works 90 percent of the time), but there are still a few minor details to deal with. Some Pascal language features just don't translate well to C++, and those problem features can cause you headaches if you don't handle them properly.

As you're installing Delphi components in C++Builder, you may encounter problems on at least three fronts: while compiling the Pascal code when you install the component on the C++Builder Component Palette; in the headers generated by C++Builder (these problems won't show up until you try to use the component in a C++Builder application); and while linking a C++Builder application using your Delphi component. Let's examine these areas individually.

Pascal compiler issues

For the most part, these are legacy language features left over from TurboPascal days. It's unlikely that you'll use these features in your code--but we won't leave anything to chance. Let's look at three language features C++Builder doesn't support.

The Real data type

The Pascal object model

The fix for this problem isn't nearly as easy as that for the Real data type problem--you must take any code that uses the object model and convert the objects into classes. Doing so is a bit of a pain, since the object and class modules handle several items differently (de-referencing pointers, for instance).

Empty sets

In most of our units, this design goal yields const sections of code which look like the following:

const:
  DefComNumber = 0;
  DefBaud = 19200;
  DefParity = pNone;
  DefDatabits = 8;
  DefStopbits = 1;
  DefHWFlowOptions = []; 

TMyRecord = record
  Ch : Char; 
  Cmd : Byte; 
  X, Y : Byte; 
  case Byte of
    1 : (Other : array[1..11] of Byte);
    2 : (OtherStr : String[10]);
  end;
end;

C++ supports the concept of the variant record, albeit with different terminology. In C++, a structure may contain an anonymous union. The C++ equivalent to the Pascal record we just discussed would be as follows:

struct TMyRecord
{
  char Ch;
  Byte Cmd;
  Byte X;
  Byte Y;
  union
  {
    System::SmallString<10> OtherStr;
    Byte Other[11];
  };
};

Take the following Pascal constructors as an example:

constructor Create(Owner : TObject; X : Integer); constructor CreateEx(Owner : TObject; Y : Integer);

__fastcall MyComponent(TObject* Owner, int X);
__fastcall MyComponent(TObject* Owner, int Y);

Take this line of code, for instance:

const
DefPointer = nil;

const void * DefPointer = (void *)(0x0);

I don't know why this particular declaration is translated into a const declaration rather than a #define. Perhaps Borland will fix this problem in future versions of C++Builder. For the time being, you can work around it by declaring the constant as follows:

const DefPointer = 0;

const DefaultWidth = 100;

const DefaultWidth = 50;

For example, let's say you have a DoIt class method in a MyClass Pascal class. You could write this line of code:

MyClass.DoIt;

Suppose a component has a public method that takes a window handle as a parameter or that returns a window handle. For the sake of argument, let's say the function is declared in the Pascal source code as follows:

function GetHandle : hWnd;

When you install this component, C++Builder will generate a header with the following declaration:

HWND GetHandle();

A couple of solutions exist for this problem. One is to use the Integer data type anywhere you'd normally use hWnd. However, the code can be confusing to read later. Another solution is to declare a new type that does essentially the same thing as hWnd:

type TMyHwnd = Integer;