A>Тогда прошу предъявить мне либо ссылку, где правительства Канады и Великобритании заявляют, что "Си++ — язык для детской песочницы", либо доказательства того, что AVC является правительством Канади и Великобритании

That is where we learned that Canada and the UK (and probably other countries as well) strictly prohibit the use of C and C++ for developments related to any nuclear application.

At this conference, Dr. Clemens Szyperski also gave a memorable speech about the relationship between the tools and programming languages used and the quality and reliability of the code produced.

A famous quote (from memory): "It is a matter of disbelieve that so many people insist on using a fundamentally flawed tool for the most complex jobs that humanity ever had to face."

C>Она сильная, но отключаемая

Сильный-то я сильный. Но легкий.

"Я не пукну. Я не пукну."
Пук!
"Это не я. Это не я."

Вот Вася проснется, а голова-то в тумбочке!

AVC>Я не против других вариантов.

AVC>Ах, увы... впрочем, что это я?

AVC>А что, массива — просто мас-си-ва — сегодня в продаже нет?

Element square[X][Y];

Element* jagged[X];
jagged[0] = new Element[Y1];
jagged[1] = new Element[Y2]; ...

square[1][2] = Element(123);
jagged[1][2] = Element(456);

К>Element square[X][Y];

К>Element* jagged[X];
К>jagged[0] = new Element[Y1];
К>jagged[1] = new Element[Y2]; ...

К>square[1][2] = Element(123);
К>jagged[1][2] = Element(456);
К>

TYPE
  A1 = ARRAY dim0, dim1 OF Element;
  A2 = ARRAY OF ARRAY OF Element;
  A3 = POINTER TO ARRAY dim0, dim1 OF Element;
  A4 = POINTER TO ARRAY OF ARRAY OF Element;
  A5 = ARRAY OF POINTER TO ARRAY OF Element;
  A6 = ARRAY dim0 OF POINTER TO ARRAY OF Element;
  A7 = POINTER TO ARRAY OF POINTER TO ARRAY OF Element;
  A8 = POINTER TO ARRAY OF POINTER TO ARRAY dim1 OF Element;
  A9 = POINTER TO ARRAY dim0 OF POINTER TO ARRAY dim1 OF Element;
  A10 = POINTER TO ARRAY dim0 OF POINTER TO ARRAY OF Element;
  ...
  и так далее - разных вариантов превеликое множество....

MODULE  Test;

    PROCEDURE P1 (VAR array: ARRAY OF REAL);
        VAR i: INTEGER;
    BEGIN
        FOR i := 0 TO LEN(array)-1 DO
            array[i] := 0.0
        END
    END P1;

    PROCEDURE Calculate (VAR mat: ARRAY OF ARRAY OF REAL);
        VAR dim0, dim1, i, j: INTEGER;
    BEGIN
        dim0 := LEN(mat, 0);
        dim1 := LEN(mat, 1);
        FOR i := 0 TO dim0-1 DO
            FOR j := 0 TO dim1-1 DO
                mat[i, j] := 0.0;
            END
        END
    END Calculate;

    PROCEDURE Test (  );
        VAR a: ARRAY 192, 256 OF REAL;
        b: POINTER TO ARRAY 4096, 1024 OF REAL;
        c: POINTER TO ARRAY OF ARRAY OF REAL;
    BEGIN
        Calculate(a);
        P1(a[2]);
        
        NEW(b);
        Calculate(b);
        P1(b[3]);
        
        NEW(c, 8128, 512);
        Calculate(c);
        P1(c[4]);
        
    END Test;
    

END  Test.

typedef int five_ints[5];
five_ints a[3]; // массив 3*5
five_ints b[] = { {0}, {0}, {0}, {0} }; // 4*5
vector<five_ints> c(n); // n*5, где n - переменная

C>CAppThread

MODULE BoundedBuffers;
  TYPE
    Item* = OBJECT; (* generic object *)

    Buffer* = OBJECT
      VAR h, n: INTEGER; 
      B: ARRAY * OF Item;

    PROCEDURE Get*(): Item;
      VAR x: Item;
    BEGIN {EXCLUSIVE}
      AWAIT(n # 0); (* buffer not empty *)
      x := B[h]; h := (h+1) MOD LEN(B); DEC(n);
      RETURN x
    END Get;

    PROCEDURE Put*(x: Item);
    BEGIN {EXCLUSIVE}
      AWAIT(n # LEN(B)); (* buffer not full *)
      B[(h+n) MOD LEN(B)] := x; INC(n)
    END Put;

    PROCEDURE &Init(max: INTEGER);
    BEGIN (* initializer *)
      NEW(B, max); h := 0; n := 0
    END Init;

  END Buffer;

END BoundedBuffers.

5.9.1 Process States

A process can be in one of several states, and with every state (except
Terminated) is associated a data structure which stores descriptors of
processes in that state. It follows that a process can only be in one of
these data structures at any time — when it switches state it is also
moved from one data structure to another. The states and all possible
transitions between them are shown in figure 5.6 and described below:

Ready This is the initial state of a process. It is ready to run and
waiting for a processor to be assigned to it, at which time it will
move to the Running state.

Running A process is in this state when it is running on one of the
available processors. It leaves this state when it terminates, is
preempted, or starts waiting for a lock, condition or interrupt.

AwaitingLock A process is in this state when it is waiting to acquire
an object lock that is held by another process. When it eventually
acquires the lock, it moves back to the Ready state.

AwaitingCondition A process is in this state when it is waiting for
a condition to be made true by some other process. When the
condition is eventually found to be true by the runtime system,
the process moves back to the Ready state.

AwaitingInterrupt A process (typically a device driver) is in this
state when it is waiting for a specific interrupt to occur. This
is similar to the previous state, except that the process will be
enabled to run by an interrupt, and not the actions of another
process (cf. 4.3.3). When it is enabled, it moves back to the Ready
state.

Terminated This is the final state, which is entered when a process terminates.
Terminated process descriptors are not in any programdefined
data structure, but remain in the heap until they are
cleaned up by the garbage collector.

delete p;

delete [] p;

void foo(float a[][]);

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