Re: [OT] Re: Teaching new tricks to an old dog (C++ -->Ada)

[Ioannis Vranos <ivr@remove.this.grad.com>]

Pascal Obry wrote:
>
> And what about:
> 
>  int main()
>  {
>    int i;
>       for(i=0; i<10; ++i)
>          ;
>  
>       i=7;
>  }
> 
> What is important for safety is not what a language permits but what
> it forbids. As long as you have traps in a language you know that some
> programmers will fall into it at some point.


Every variable is visible inside the scope that it was defined.

If you want to use i inside a for loop only, then define it in the for loop.


The restriction that you imply you desire, limits flexibility.

Once again, I have nothing against learning Ada, however personally I 
like the most powerful languages. The next thing I am going to learn 
after C++ (because I haven't learned it all yet), is probably some form 
of assembly language.


For example I like that I can do:

#include <iostream>
#include <string>
#include <bitset>
#include <limits>

class SomeClass
{
       std::string s;

       public:
              SomeClass()
              {
                         s="This is a text message";
              }
};


int main()
{
     using namespace std;

     SomeClass obj;

     unsigned char *p= reinterpret_cast<unsigned char *>(&obj);

     // Displays the individual bytes that obj
     // consists of as unsigned chars.
     for(unsigned i=0; i<sizeof(obj); ++i)
       cout<<"character: "<<p[i]<<"\n";

     cout<<"\n";


     p= reinterpret_cast<unsigned char *>(&obj);
     // Displays the decimal values of the
     // individual bytes that obj consists of.
     for(unsigned i=0; i<sizeof(obj); ++i)
       cout<<static_cast<unsigned>(p[i])<<" ";

     cout<<"\n\n";


     // Displays the bits of each byte that consist
     // this SomeClass object
      p= reinterpret_cast<unsigned char *>(&obj);
      for(unsigned i=0; i<sizeof(obj); ++i)
      {
           // A byte is not necessarily 8 bits
           // numeric_limits<unsigned char>::digits retrieves the number
           // of byte's bits, which *is* 8 usually.
           bitset<numeric_limits<unsigned char>::digits> bits(p[i]);

           for(unsigned j=0; j<bits.size(); ++j)
              cout<<bits[j];

           cout<<"\n";
      }
}


C:\c>temp
character: ⁿ
character: =
character: >
character:

252 61 62 0

00111111
10111100
01111100
00000000

C:\c>


I am sure that many ADA developers will say that this one is not needed 
(the ability to access the individual bytes of objects is needed in many 
cases, e.g. to create low level exact copies of objects ) and it is 
unsafe (yes it is, low level stuff are unsafe and it all depend on the 
programmer knowing what he does).


It is up to oneself to learn whatever languages fits his purposes. For 
example, a "safe" language is not an interest for me.

Someone who places much hopes on the language to protect him from his 
mistakes, probably ADA is better than C++ on this.


There is no language that provides satisfies all people desires, just 
because some desires are in contrast between them.



-- 
Ioannis Vranos

http://www23.brinkster.com/noicys