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

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

Chad R. Meiners wrote:

> What do you do when you need to map the data structure to a specific
> space in memory for a memory-mapped sensor array e.g. the temperature
> sensors for levels -2 to 8 in a building?


I am not sure I understood what you mean by this, but in C++ you can do 
use a specific numeric address in memory in the style:


int *p= reinterpret_cast<int *>(0x5556);


Of course this is system-specific and if nothing exists there will be a 
problem. :-)


You can also do:


// Complete safe and portable
#include <new>

class SomeClass {};


int main()
{
     // 1000 bytes in the stack
     unsigned char array[1000];

     // Create SomeClass object in the beginning of the array
     SomeClass *p= new(array)SomeClass;

     // Create a second SomeClass object after the first
     SomeClass *r= new(array+sizeof(*r))SomeClass;
}


With placement new you can create objects wherever you want. Also you 
can define your own versions of placement new, new, delete, new[], 
delete[] etc both globals and as parts of a class:


#include <cstddef>
#include <new>
#include <iostream>


class SomeClass
{
   static std::size_t occupied;
   static unsigned char *buffer;
   static const std::size_t MAX_SIZE=5*1024;

   public:

   ~SomeClass() { std::cout<<"Destructor called!\n"; }

   void *operator new(std::size_t size)
   {
    using namespace std;

    cout<<"Class member operator new was called!\n";

    if(occupied+size>MAX_SIZE)
      throw bad_alloc();

    occupied+=size;

    return buffer+occupied-size;
   }

   void operator delete(void *p)
   {
    std::cout<<"Class member operator delete was called!\n";

    occupied-=sizeof(SomeClass);
   }
};

std::size_t SomeClass::occupied=0;
unsigned char *SomeClass::buffer=new unsigned char[MAX_SIZE];


int main()
{
  // The member operator new is called implicitly
   SomeClass *p=new SomeClass;

   delete p;
}


So objects can undertake their memory management. C++ standard library 
containers use allocators, with the default one using the default new, 
and gives the ability to define your own ones, as also provides 
facilities to manage raw memory manually, but I do not know these yet.



Some pieces of Chapter 19 of TC++PL3 on the later:


"Implementers of containers often allocate() and deallocate() objects 
one at a time. For a naive implementation of allocate(), this implies 
lots of calls of operator new , and not all implementations of operator 
new are efficient when used like that. As an example of a user-defined
allocator, I present a scheme for using pools of fixed-sized pieces of 
memory from which the allocator can allocate() more efficiently than can 
a conventional and more general operator new().

I happen to have a pool allocator that does approximately the right 
thing, but it has the wrong interface (because it was designed years 
before allocators were invented). This Pool class implements the notion 
of a pool of fixed-sized elements from which a user can do fast 
allocations and deallocations. It is a low-level type that deals with 
memory directly and worries about alignment:"


Some other facilities:

"19.4.4 Uninitialized Memory

In addition to the standard allocator , the <memory > header provides a 
few functions for dealing with uninitialized memory. They share the 
dangerous and occasionally essential property of using a type name T to 
refer to space sufficient to hold an object of type T rather than to a 
properly constructed object of type T .

The library provides three ways to copy values into uninitialized space:"

and it talks about uninitialized_copy, uninitialized_fill and uninitial 
ized_fill_n.


Then, other facilities are mentioned like

"Algorithms often require temporary space to perform acceptably. Often, 
such temporary space is best allocated in one operation but not 
initialized until a particular location is actually needed.

Consequently, the library provides a pair of functions for allocating 
and deallocating uninitialized space:

template <class T> pair <T *,ptrdiff_t > get_temporary_buffer(ptrdiff_t 
); // allocate, don�t initialize

template <class T> void return_temporary_buffer(T *); // deallocate, 
don�t destroy

A get_temporary_buffer<X >(n) operation tries to allocate space for n or 
more objects of type X .

If it succeeds in allocating some memory, it returns a pointer to the 
first uninitialized space and the number of objects of type X that will 
fit into that space; otherwise, the second value of the pair is zero. 
The idea is that a system may keep a number of fixed-sized buffers ready 
for fast allocation so that requesting space for n objects may yield 
space for more than n . It may also yield less, however, so one way of 
using get_temporary_buffer() is to optimistically ask for a lot and then 
use what happens to be available."


And other stuff, it is an entire chapter.



C++ is very customizable, you can define handling functions for cases 
that uncaught exceptions occur, define your own behaviour when memory 
allocation error occurs instead of the default throwing of bad_alloc etc.


One of C++ design ideals has been

"Leave no room for a lower level language except assembly".



-- 
Ioannis Vranos

http://www23.brinkster.com/noicys