This article includes a
list of references,
related reading, or
external links, but its sources remain unclear because it lacks
inline citations. (June 2013) |
C++ doesn't have:
ALGOL 68 doesn't have:
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;
|
Compare value referenced by two pointers | ref int x, y; if x = y then ... fi |
int* x; int* 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:
|
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;
|
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
.
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;
} newtype9+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.