Re: What is faster Ada or C?

[Richard Riehle <richard@adaworks.com>]

Hyman Rosen wrote:

> In C++ it is perfectly legal to separate the declaration of a function
> from its implementation, even when it's inline:
>
>     struct a { int twice(int x); };
>     inline int a::twice(int x) { return 2 * x; }

Unless something has changed, C++ requires the full definition of the
inlined function at the place where it is declared.   Stroustrup does make
a little exception for this in his note about the "absence of unusually
clever compilation and linking facilities" (The C++ Programming
Language, Third Edition, page 144).    At present, the most compilers
require full definition in the header file.

> Any code which wants to call the function must arrange to see the definition,
> which is usually done through an #include. In Ada, the compiler can manage to
> find the definition on its own, because of the library system, but that's not
> exactly "separate compilation".

Well, actually, it is separate compilation.  Of course, if one chooses to use
some new definition of separate compilation, so be it.


Ada permits the designer to specify a declaration in the package specification
as inlined:

      package Not_C_Plus_Plus is
           procedure Friendly_Inline;
           pragma Inline(Friendly_Inline); -- no full definition required or permitted
      end Not_C_Plus_Plus;

This specification is compiled independently of its implementation.  If we really
want to defer the implementation to another separate compilation, we could,


    package body Not_C_Plus_Plus is
           procedure Friendly_Inline is separate;
      end Not_C_Plus_Plus;

thereby separating the compilation of the [definition of] the implementing
code to yet another separate subunit.

    separate (Not_C_Plus_Plus)
    procedure Friendly_Inline is
    begin
        -- algorithmic implementation
    end Friendly_Inline;

The library unit model of Ada, along with its many facilities for separate
compilation are one of the useful features of the language.    In fact, Ada's
separate compilation  helps maintain consistency across multiple library
units when development is being performed by multiple programmers.
The need for a #include, along with associated compiler directives in C++
is not as robust a model for preserving unit integrity as the Ada model,
even though the C++ model does have some offsetting advantages under
some circumstances.

Richard Riehle