Misplaced Pages

Comparison of ALGOL 68 and C++: Difference between revisions

Article snapshot taken from[REDACTED] with creative commons attribution-sharealike license. Give it a read and then ask your questions in the chat. We can research this topic together.
Browse history interactively← Previous editNext edit →Content deleted Content addedVisualWikitext
Revision as of 21:54, 8 April 2010 edit64.201.246.50 (talk) more example, formatting fixes← Previous edit Revision as of 10:11, 12 April 2010 edit undoWildBot (talk | contribs)Bots142,891 editsm Repairing broken #section linkNext edit →
Line 8: Line 8:
* ''use before define'', * ''use before define'',
* ] using complex formatting declarations, * ] using complex formatting declarations,
* ] - assignment operation symbol (to avoid confusion with equal sign), * ] - assignment operation symbol (to avoid confusion with equal sign),
* ] (and slice operations on them, but in layered libraries), * ] (and slice operations on them, but in layered libraries),
* automatic ]s, * automatic ]s,

Revision as of 10:11, 12 April 2010

Comparison of
programming languages
Comparison of individual
languages

The nearest living sibling to ALGOL 68 may be C++, making this a good comparison candidate:

C++ doesn't have:

  • PROC - first class nested functions (emulation due to local definitions of class-types, which then could be functors) ,
  • OP and PRIO - definable operator symbols and priorities,
  • garbage collection,
  • use before define,
  • formatted transput using complex formatting declarations,
  • := - assignment operation symbol (to avoid confusion with equal sign),
  • array (and slice operations on them, but in layered libraries),
  • automatic UNIONs,
  • CASE expressions,
  • nonlocal GOTO
  • intuitive declaration syntax due to its origin from C.

ALGOL 68 doesn't have:

  • public/private access protection,
  • overloaded procedures (in contrast to operators),
  • explicit memory deallocation,
  • forward declarations (use before definition is allowed)
  • textual preprocessing (eg macros),
  • confusion between reference- and pointer-style,
  • comment lines (only bracketed comments),
  • hierarchical classes.

Comparison of the assignment and equality operators

Intent ALGOL 68 C++
Assign a value 888 to a variable x x:=888; x=888;
Compare two values if x = 888 then ... fi if (x==888) { ... }
Define a constant int x=888; const int x = 888;
Initialise a variable int x:=888; int 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;
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; n/a
Set priority on a new operator prio ↑ = 9; n/a
Duplication by 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 Example

Mode declaration

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

int max=99;
mode newtype = 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;

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 references

Category:
Comparison of ALGOL 68 and C++: Difference between revisions Add topic