Jump to content

Comparison of ALGOL 68 and C++

From Wikipedia, the free encyclopedia

C++ doesn't have:

ALGOL 68 doesn't have:

Comparison of the assignment and equality operators[edit]

Intent ALGOL 68 C++
Define a constant int x=888; const int x = 888;
Initialise a variable int x:=888; int x = 888;
Assign a value 888 to a variable x x:=888; x = 888;
Compare two values if x = 888 then ... fi if (x == 888) { ... }
Allocate a variable from the heap ref int x = heap int;
or simply:
heap int x;
int* x = new int;
Compare address of two pointers ref int x, y;
if x :=: y then ... fi
int* x; int* y;

if (x == y) { ... }

Compare value referenced by two pointers ref int x, y;
if x = y then ... fi
int* x; int* y;

if (*x == *y) { ... }

Name a new type mode longreal = long real; typedef double longreal;
or (as of C++11):
using longreal = double;
Name a new record type mode cust = struct(string name, address); struct cust { std::string name, address; };
Name a new union type mode taggedu = union(string s, real r); union u { std::string s; float f; };
Name a procedure or function proc f = (real x) real: ( code; result ); float f(float x) { code; return result; }
Procedure default parameters proc p = (union (real, void) in x)void:

    ( real x = (in x|(real x):x|888); code );

void p(float x=888) { code; }
Name a new operator op ↑ = (real x,y) real: x**y;
Set priority on a new operator prio ↑ = 9;
Chain variables assignment a:=b:=c:=d; a = b = c = d;
Displacement operator - ALGOL 68C only a:=:=b:=:=c:=:=d; a = b; b = c; c = d;
Append "substr" to a variable str str +:= "substr"; str += "substr";
Prefix "substr" to a variable str "substr" +=: str; str = "substr" + str;

Code Examples[edit]

Union declaration and use[edit]

Assigning values into an A68 union variable is automatic, the type is "tagged" to the variable, but pulling the value back out is syntactically awkward as a conformity-clause is required.

ALGOL 68 example:

 union(int, char) x:=666;
 printf(($3d l$, (x|(int i):i) ))

C++ example:

  union { int i; char c; } x = { 666 };
  std::cout << x.i << std::endl;

The net effect of "type-tagging" is that Algol68's strong typing "half" encroaches into the union.

Mode declaration[edit]

A new mode (type) may be declared using a mode declaration:

int max=99;
mode newtype = [0:9][0:max]struct (
   long real a, b, c, short int i, j, k, ref real r

This has the similar effect as the following C++ code:

const int max=99;
typedef struct { 
    double a, b, c; short i, j, k; float& r;
} newtype[9+1][max+1];

Note that for ALGOL 68 only the newtype name appears to the left of the equality, and most notably the construction is made - and can be read - from left to right without regard to priorities.

External links[edit]