Re: conversion

["Robert I. Eachus" <rieachus@attbi.com>]

Alexander Kopilovitch wrote:

>   /* C/C++ example */
> 
>   char *Titles[] = {
>                     "Quizionary",
>                     "Nose To Nose",
>                     "Myself",
>                     "General Dissent",
>                     "Veteran's Opinion",
>                     "Corporate Science Weekly",
>                     "Truth, Wealth, Health",
>                     "Bribery Times"
>                    };
> 
> 
>   { Object Pascal example }
>                                                 
>   const
>         Dishes : array [1..4] of String = (
>                                            'black pudding',
>                                            'crab soup',
>                                            'steak & kidney pie',
>                                            'lemon tart'
>                                           );

Two examples.  One without any Ada support packages, and one that uses
Ada.Strings.Bounded.  Personally I think that during standarization, to 
much was added in, and as a result, Ada.Strings.Bounded is harder to use 
than it should be.  But of course, you can roll your own, the way you 
had to in Ada 83.

But notice two major differences between the Ada way, and the C and 
Pascal way.  The Ada solutions are built around standard Ada features, 
not special case features, and the Ada solution allows for non-constant 
arrays, in fact the individual elements can change in length. (Yes, I 
know that in the C++ case you can assign other pointers, but the 
original values can't be modified as such.)

procedure Varying is -- an example of how to create ragged arrays in Ada.

   subtype Lim_Int is Integer range 0..30;
   type Inner(L: Lim_Int := 0) is record S: String(1..L); end record;
   type Wrapper is record I: Inner; end record;
   type Ragged_Array is array (Integer range <>) of Wrapper;

   function "+" (S: in String) return Wrapper is
   begin return (I =>(S'Length, S)); end "+";

   function "+" (W: in Wrapper) return String is
   begin return W.I.S; end "+";

   Dishes: Ragged_Array := (+"black pudding",
                            +"crab soup",
                            +"steak & kidney pie",
                            +"lemon tart");

   Titles: Ragged_Array := (+"Quizionary",
                            +"Nose To Nose",
                            +"Myself",
                            +"General Dissent",
                            +"Veteran's Opinion",
                            +"Corporate Science Weekly",
                            +"Truth, Wealth, Health",
                            +"Bribery Times");

begin null; end Varying;

with Ada.Strings.Bounded;
procedure Varying2 is -- an example of how to use Ada.Strings.Bounded.

   package Bounded_Str is new
              Ada.Strings.Bounded.Generic_Bounded_Length(30);

   subtype Bounded_String is Bounded_Str.Bounded_String;

   function "+" (S: in String) return Bounded_String
   is begin return
        Bounded_Str.To_Bounded_String(S, Ada.Strings.Error);
   end "+";

   function "+" (B: in Bounded_String) return String renames
        Bounded_Str.To_String;

   type Ragged_Array is array (Integer range <>) of Bounded_String;

   Dishes: Ragged_Array := (+"black pudding",
                            +"crab soup",
                            +"steak & kidney pie",
                            +"lemon tart");

   Titles: Ragged_Array := (+"Quizionary",
                            +"Nose To Nose",
                            +"Myself",
                            +"General Dissent",
                            +"Veteran's Opinion",
                            +"Corporate Science Weekly",
                            +"Truth, Wealth, Health",
                            +"Bribery Times");

begin null; end Varying2;

-- 

                                                        Robert I. Eachus

�In an ally, considerations of house, clan, planet, race are 
insignificant beside two prime questions, which are: 1. Can he shoot? 2. 
Will he aim at your enemy?� -- from the Laiden novels by Sharon Lee and 
Steve Miller.