К>Беспочвенный шовинизм.

TYPE
  ArrayOfArray = ARRAY OF ARRAY OF INTEGER;

TYPE
  ArrayOfInteger = ARRAY OF INTEGER;
  ArrayOfArray = ARRAY OF ArrayOfInteger;

    typedef int ArrayOfArray[][]; // Ошибка компиляции

    typedef int Array[];
    typedef Array ArrayOfArray[]; // Ошибка компиляции

Visual C++ Concepts: Building a C/C++ Program
Compiler Error C2087'identifier' : missing subscript

The definition of an array with multiple subscripts is missing a subscript value for a dimension higher than one. The following sample generates C2087:

// C2087.cpp
int main()
{
char a[10][]; // C2087
char b[4][5]; // OK
}

lock lk(monitor);

while (buffered == 0)

    buffer_not_empty.wait(lk);

class bounded_buffer : private boost::noncopyable
{
public:
    typedef boost::mutex::scoped_lock lock;

    bounded_buffer(int n) : begin(0), end(0), buffered(0), circular_buf(n) 
{ }

    void send (int m) {
        lock lk(monitor);
        while (buffered == circular_buf.size())
            buffer_not_full.wait(lk);
        circular_buf[end] = m;
        end = (end+1) % circular_buf.size();
        ++buffered;
        buffer_not_empty.notify_one();
    }
    int receive() {
        lock lk(monitor);
        while (buffered == 0)
            buffer_not_empty.wait(lk);
        int i = circular_buf[begin];
        begin = (begin+1) % circular_buf.size();
        --buffered;
        buffer_not_full.notify_one();
        return i;
    }

private:
    int begin, end, buffered;
    std::vector<int> circular_buf;
    boost::condition buffer_not_full, buffer_not_empty;
    boost::mutex monitor;
};

Unless you know other programmers who manage to write a complete OO Framework such as Amadeus-3 in their "spare time", while developing about 20 serious applications for major, multi-national companies (Du Pont de Nemours, Royal Bank of Canada, HP etc.) over a period of 8 years, this should convince you that Oberon-2 programming is indeed as efficient as claimed on this site.

std::vector<std::vector<something> > - вот и массив массивов.

int arr[xdim*ydim];

template<class T> struct MatrixEntry
{
    MatrixEntry<T> *nextInRow, *prevInRow, *nextInColumn, *prevInColumn;
    T val;
};

AWAIT(n # 0);

The AWAIT statement was proposed and investigated by Brinch Hansen [3]
who showed its conceptual simplicity and elegance, but also thought it would
be impossible to implement it efficiently. We repropose it in Active Oberon,
with the conviction that it is a real improvement compared with signals and
semaphores, because of the unification and clarity it brings; it becomes particularly
obvious in an object-oriented programming style, where signals and
semaphores are completely inappropriate because of their unstructured use, as
they can be inserted arbitrarily in a program. Pieter Muller’s thesis [21] proves,
that with the appropriate restrictions, AWAIT can be implemented efficiently.
The language Ada 95 [14] has also a construct called barriers, which is se-mantically
very similar to Active Oberon’s AWAIT, although with a coarser
procedure-width granularity.

C>std::vector<std::vector<something> > - вот и массив массивов.
C>

C>int arr[xdim*ydim];
C>

C>template<class T> struct MatrixEntry
C>{
C>    MatrixEntry<T> *nextInRow, *prevInRow, *nextInColumn, *prevInColumn;
C>    T val;
C>};
C>

void foo(float a[][]);

std::vector<std::vector<something> > - вот и массив массивов.

int arr[xdim*ydim];

void foo(float a[][]);

void foo(float** a);

PROCEDURE Calculate(VAR vector: ARRAY OF REAL);