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 07:00, 12 May 2010 edit64.201.246.50 (talk) more things C++ has and Algol doesn't.← Previous edit Revision as of 23:10, 13 May 2010 edit undo64.201.246.50 (talk) more neutral language in comparison; fix, tidy examplesNext edit →
Line 16: Line 16:


ALGOL 68 doesn't have: ALGOL 68 doesn't have:
* public/private access protection, * public/private struct member access protection,
* ] (in contrast to operators), * ] (in contrast to operators),
* explicit memory deallocation, <!-- allocation was via the HEAP --> * explicit memory deallocation, <!-- instead, GC -->
* forward declarations (use before definition is allowed) * forward declarations (use before definition is allowed)
* textual ] (eg macros), <!-- std ALGOL 68 did have "library prelude option" --> * textual ] (eg macros), <!-- std ALGOL 68 did have "library prelude option" -->
* confusion between reference- and pointer-style, * distinct reference and pointer types,
* ] lines (only bracketed comments), * ] lines (only bracketed comments),
* ]. * ].
* virtual functions, destructors, exceptions, templates, namespaces, structured loop exits * destructors, exceptions, templates, namespaces, structured loop exits


==Comparison of the assignment and equality operators== ==Comparison of the assignment and equality operators==
Line 30: Line 30:
!bgcolor=#cccccc|Intent ||bgcolor=#cccccc|ALGOL 68 ||bgcolor=#cccccc|C++ !bgcolor=#cccccc|Intent ||bgcolor=#cccccc|ALGOL 68 ||bgcolor=#cccccc|C++
|- |-
|Assign a value 888 to a variable ''x'' || x:=888; || 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) { ... } |Compare two values || '''if''' x = 888 '''then''' ... '''fi''' || if (x == 888) { ... }
|- |-
|Define a constant || '''int''' x=888; || const int x = 888; |Define a constant || '''int''' x=888; || const int x = 888;
Line 40: Line 40:
|Allocate a variable from the '''heap''' || '''ref''' '''int''' x = '''heap''' '''int''';<br>or simply:<br>'''heap''' '''int''' x; || int* x = new int; |Allocate a variable from the '''heap''' || '''ref''' '''int''' x = '''heap''' '''int''';<br>or simply:<br>'''heap''' '''int''' x; || int* x = new int;
|- |-
|Compare address of two pointers || '''ref''' '''int''' x, y; <br>'''if''' x :=: y '''then''' ... '''fi''' || int* x; int* y; <br>if (x==y) { ... } |Compare address of two pointers || '''ref''' '''int''' x, y; <br>'''if''' x :=: y '''then''' ... '''fi''' || int* x; int* y; <br>if (x == y) { ... }
|- |-
|Compare value referenced by two pointers || '''ref''' '''int''' x, y; <br>'''if''' x = y '''then''' ... '''fi''' || int* x; int* y;<br>if (*x==*y) { ... } |Compare value referenced by two pointers || '''ref''' '''int''' x, y; <br>'''if''' x = y '''then''' ... '''fi''' || int* x; int* y;<br>if (*x == *y) { ... }
|- |-
|Name a new type || '''mode''' '''longreal''' = '''long''' '''real'''; || typedef double longreal; |Name a new type || '''mode''' '''longreal''' = '''long''' '''real'''; || typedef double longreal;
Line 56: Line 56:
| void p(float x=888) { code; } | void p(float x=888) { code; }
|- |-
|Name a new operator || '''op''' &uarr; = ('''real''' x,y) '''real''': x**y; || n/a |Name a new operator || '''op''' &uarr; = ('''real''' x,y) '''real''': x**y; || ''n/a''
|- |-
|Set priority on a new operator || '''prio''' &uarr; = 9; || n/a |Set priority on a new operator || '''prio''' &uarr; = 9; || ''n/a''
|- |-
|Duplication by assignment || a:=b:=c:=d; || a=b=c=d; |Duplication by assignment || a:=b:=c:=d; || a = b = c = d;
|- |-
|Displacement operator - ] only || a:=:=b:=:=c:=:=d; || a:=b; b:=c; c:=d; |Displacement operator - ] only || a:=:=b:=:=c:=:=d; || a = b; b = c; c = d;
|- |-
| Append "substr" to a variable ''str'' || str +:= "substr"; || str+= "substr"; | Append "substr" to a variable ''str'' || str +:= "substr"; || str += "substr";
|- |-
| Prefix "substr" to a variable ''str'' || "substr" +=: str; || str = "substr" + str; | Prefix "substr" to a variable ''str'' || "substr" +=: str; || str = "substr" + str;

Revision as of 23:10, 13 May 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:

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 Examples

Union declaration and use

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/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

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