sp> Hello?  Anyone there?  Hello?

Nope, we've all gone home.


 sp>  What's the closest one can get in C++, to Borland Pascal's enum/sets?

C enumerators are basically the same thing. But you can't declare an
enumerated variable in increment/decrement it over the list. You have to do
that manually, which is pretty much what Turbo Puke does anyway, only it is
'hidden' in your code.

Something like:

    enum cartype =
    {
        volvo = 6,
        citron = 8,
        ford = 9,
        holden = 12
    };

    enum cartype mytypes[] = { volvo, citron, ford, holden };
    int i;

    for (i = 0; i < (sizeof(mytypes)/sizeof(enum cartype)); i++)
    {
        enum cartype thistype = mytypes[i];
        /* code */
    }


Since you mention C++ specifically, and not C (yes, indeed there is a VAST
difference between the two even if C++ is an almost-superset of C), then
I'll also mention that if you define a class to emulate an enumerated type,
you can easily do the same 'hiding', and an overloaded operator++ and
operator--. Sets are trivial to implement in C++.


 sp>  And is it possible to do something like Pascal's nested procedures?

Not under either standard C or C++. However, some compiler implementations
such as Metaware's High-C, do have this (non-portable) feature.

The problem with introducing this into the general C/C++ climate is that
the benefits of a inherited/shared stack is not available or is difficult
to implement on many systems, or of little practical use when all is said
and done. In general, it is eaiser and simpler to use pointer-to-structs
anyway, and there's little, if any, loss of efficiency and an arguable gain
in code readability and maintainability.

BTW, you left the word "Borland" out before the word
"Pascal". Nested procedures is not a feature of ISO Pascal.

--- MaltEd/2 1.0.b6