Teaching new tricks to an old dog (C++ -->Ada)

[Turamnvia Suouriviaskimatta]

I 'm following various posting in "comp.lang. ada, comp.lang.c++ ,
comp.realtime, comp.software-eng" groups regarding selection of a
programming language of C, C++ or Ada for safety critical real-time
applications. The majority of expert/people recommend Ada for safety
critical real-time applications. I've many years of experience in C/C++ (and
Delphi) but no Ada knowledge.

May I ask if it is too difficult to move from C/C++ to Ada?
What is the best way of learning Ada for a C/C++ programmer?

[Ioannis Vranos]

Falk Tannhäuser wrote:

Perhaps the closest way you can get to this in C++ is

std::vector<foo _type> Data;
...
std::for_each(D ata.begin(), Data.end(), DoSomething);

where "DoSomethin g" evaluates to a so-called "function object"
having an "operator() " accepting a (reference to) "foo_type".

Yes you can write completely safe, bullet-proof code in C++ and without
sacrificing efficiency (and some times even improving it!) by using the
high level C++ constructs. Examples are: find family (which includes
find_if etc), search family, generate, fill, for_each, count, mismatch,
equal, transform, copy, swap, replace, remove, unique, rotate, sort,
bound, merge, partition, includes, set (like set_union), heap (like
make_heap - makes sequences behave as heaps), comparisons (like min,
max, lexicographical _compare), permutation, etc families.
We can say it is an entirely completely safe, high level language of its
own, and in this way you may never use loops for most things!


--
Ioannis Vranos

http://www23.brinkster.com/noicys

[Ioannis Vranos]

Jim Rogers wrote:

#include <iostream>
#include <vector>
#include <ctime>
#include <algorithm>
int main()
{
using namespace std;

vector<int> vec(1000);

// Seeds the random number generator
srand(time(0));

// Use rand() to fill vector with values
// As you see the operation is entirely safe.
generate(vec.be gin(), vec.end(), rand);

vector<int>::si ze_type i;

// Finds the first index where a value is smaller than 1000
// in low level style
for(i=0; i<vec.size(); ++i)
if(vec[i]<1000)
break;

i==vec.size()? cout<<"No number <1000 was found\n"
:cout<<"Number <1000 found at index "<<i<<"\n";
}

The idioms are somewhat different. For instance, the Ada for loop
does not iterate one past the end of the array, nor is the
value of the loop control variable visible outside the loop.

I did not see where you set the range of values for your
random number type. I am generating integer values in the
range of 0 through 10,000.

I used the default range.

with Ada.Text_Io;
with Ada.Numerics.Di screte_Random;

procedure Random_Fill is
type Rand_Values is range 0..10_000;
package My_Rand is new Ada.Numerics.Di screte_Random(R and_Values);

Seed : My_Rand.Generat or;
subtype Index_Type is Natural range 1..1000;
Vec : array(Index_Typ e) of Rand_Values;
Found : Natural := 0;
begin
My_Rand.Reset(S eed); -- seeds the random number generator

-- fill the array with random values in the range of 0
-- through 10,000
for I in Vec'range loop
Vec(I) := My_Rand.Random( Seed);
end loop;

-- finds first index where a value is less than 1000
for I in Vec'range loop
if Vec(I) < 1000 then
Found := I;
exit;
end if;
end loop;
if Found > 0 then
Ada.Text_Io.Put _Line("Number < 1000 found at index" &
Natural'Image(F ound));
else
Ada.Text_Io.Put _Line("No number < 1000 was found");
end if;
end Random_Fill;

Yes but what happens if you want to use the indexed found with the
associated value (ot could be inside a string for example) in an
associative container like a map?

That is, find the index and then use the index to add the value in a
map. I suppose you would create a separate procedure for this in which
you would pass the array along with the container and perhaps along with
the item to be found, just for one such operation!

--
Ioannis Vranos

http://www23.brinkster.com/noicys

[Ioannis Vranos]

Ioannis Vranos wrote:

Yes you can write completely safe, bullet-proof code in C++ and without
sacrificing efficiency (and some times even improving it!) by using the
high level C++ constructs. Examples are: find family (which includes
find_if etc), search family, generate, fill, for_each, count, mismatch,
equal, transform, copy, swap, replace, remove, unique, rotate, sort,
bound, merge, partition, includes, set (like set_union), heap (like
make_heap - makes sequences behave as heaps), comparisons (like min,
max, lexicographical _compare), permutation, etc families.
We can say it is an entirely completely safe, high level language of its
own, and in this way you may never use loops for most things!

More accurately described as "entirely completely safe, high level world
of its own".


--
Ioannis Vranos

http://www23.brinkster.com/noicys

[Larry Kilgallen]

In article <42********@new s.alphalink.com .au>, Song Yun Zhao <mr************ @yahoo.com.au> writes:

Larry Kilgallen wrote:

In article <1110052142.832 650@athnrd02>, Ioannis Vranos <iv*@remove.thi s.grad.com> writes:

Ludovic Brenta wrote:

The bug in the C++ library was that I was mistakenly reusing the loop
variable after the loop, instead of the intended variable. Of course,
the loop variable was an index pointing after the end of the buffer.
It looks like the code was not ISO C++ compliant.

In that case, it looks like the compiler failed to detect that shortcoming.

A real man's compiler

http://somewhere.fscked.org/rmcc/

:)

The VMS primitive debugger Delta (used to debug the system bootstrap
but not much else) is famous for having just one error message:

Eh ?

At one point somebody inside DEC created a fake Delta support Notes
conference with various questions about the way Delta works, each
receiving the response:

Eh ?

[Martin Dowie]

Jerry Coffin wrote:

If I made the kind of unfair generalizations sometimes made by some Ada
advocates, I'd say that Ada programmers only look at the surface, and
don't consider the deeper meaning of things. :-)

Look past the toolbox itself, and consider the systems on which it
runs. To save you the trouble of looking it up again, I'll point it
out: X running on top of either Windows or UNIX.

Now do you suppose some C and C++ might be involved?

Sorry, but if you make a link to a news item /about/ a particular tool,
at least /I/ am going to believe that you are making a point about the
tool and not the OS it works on! Why not provide a link directly to a
page about X running on top of either Windows or UNIX?! :-)

Cheers

-- Martin

[Jim Rogers]

Ioannis Vranos <iv*@remove.thi s.grad.com> wrote in news:1110429670 .232319
@athnrd02:

Yes but what happens if you want to use the indexed found with the
associated value (ot could be inside a string for example) in an
associative container like a map?

That is, find the index and then use the index to add the value in a
map. I suppose you would create a separate procedure for this in which
you would pass the array along with the container and perhaps along with
the item to be found, just for one such operation!

I assume the container type is already defined, including a procedure
to insert new values into the container. I would simply call the
insert or add procedure for that container, passing in the
appropriate information. This is no different than calling a
member function for a class in C++.

Jim Rogers

[Hans Malherbe]

Goeie dag Georg

Thanks for all the replies, I'll stop wasting bandwith with trivial
questions and go find out myself.

Groete
Hans

[Martin Dowie]

xpyttl wrote:

"Martin Dowie" <ma**********@b topenworld.com> wrote in message
news:d0******** **@titan.btinte rnet.com...

What on earth would the C advocate say!! ;-)

Leave me alone, I've got work to do!

Surely...

Leave me alone, I've got debugging to do!

;-)

[Ioannis Vranos]

Jim Rogers wrote:

I assume the container type is already defined, including a procedure
to insert new values into the container. I would simply call the
insert or add procedure for that container, passing in the
appropriate information. This is no different than calling a
member function for a class in C++.

How can this be done in Ada?
As it can be seen here, the bullet-proof high level facilities are used. :-)
#include <iostream>
#include <vector>
#include <ctime>
#include <algorithm>
#include <functional>
#include <map>
int main()
{
using namespace std;

vector<int> vec(1000);

map<int, int> iimap;

// Seeds the random number generator
srand(time(0));

// Use rand() to fill vector with values
// As you see the operation is entirely safe.
generate(vec.be gin(), vec.end(), rand);
// Finds the first occurrence of an int smaller than 1000
vector<int>::co nst_iterator p= find_if(vec.beg in(), vec.end(),
bind2nd(less<in t>(), 1000) );

int index= p-vec.begin();

// Stores the index and the value in a map
iimap[index]= *p;
cout<<index<<": \t"<<iimap[index]<<"\n";
}

--
Ioannis Vranos

http://www23.brinkster.com/noicys

[Falk Tannhäuser]

Wes Groleau wrote:

ji************* *@worldnet.att. net wrote:

The simple loop will always be an infinite loop unless
you break out early. The Ada reserved word used to
break out of a loop is "exit". In Ada "exit" does not
exit the program, only the enlcosing loop.

Or (for nested loops), each loop can have a name,
and the exit statement can exit out of two or more nested
loops by using the name of the level to get out of.

Java has a construct that can do something like that.
Does C++ ?

No. However, a 'return' from the middle of a function
(even from within the deepest nested loops) is possible.

Another way, especially designed for error handling, are
exceptions which allow "returning" from many function call
levels while cleaning up and leaving the program in a well-
defined, clean state through calling the destructors of all
stack-based objects on the way. However this requires some
care from the programmer - you have to code in an "exception-
safe" manner.
I believe Ada also has exceptions, but I don't know if
they work in the same manner. Does Ada have some equivalent
of C++ constructors and destructors?

Falk