View source for Comparison of ALGOL 68 and C++

{{ProgLangCompare}}

C++ doesn't have:
* [[ALGOL 68#proc: Procedures|PROC]] – first class [[Nested function|nested function]]s (emulation due to local definitions of class types, which could be [[Function object|functors]]; also, [[C++11]] has [[C++11#Lambda functions and expressions|lambda functions]]),
* [[ALGOL 68#op: Operators|OP and PRIO]] – definable operator symbols and priorities,
* garbage collection (could be emulated with help of [[Smart pointer#C.2B.2B smart pointers|smart pointers]]),
* ''use before define'',
* [[ALGOL 68#formatted transput|formatted transput]] using complex formatting declarations,
* [[ALGOL 68#Dyadic operators with associated priorities|:=]] – assignment operation symbol (to avoid confusion with equal sign),
* [[ALGOL 68#struct.2C union .26 .5B:.5D: Structures.2C unions and arrays|array]] (and slice operations on them, but in layered libraries),
* automatic [[ALGOL 68#struct.2C union .26 .5B:.5D: Structures.2C unions and arrays|UNION]]s,
* [[ALGOL 68#Expressions and compound statements|CASE expressions]],
* nonlocal [[ALGOL 68#Code sample|GOTO]]
* intuitive declaration syntax due to its origin from C.

ALGOL 68 doesn't have:
* public/private struct member access protection,
* overloaded procedures (in contrast to operators),
* explicit memory deallocation, <!--  instead, GC -->
* forward declarations (use before definition is allowed)
* textual [[Preprocessor|preprocessing]] (e.g. macros), <!-- std ALGOL 68 did have "library prelude option" -->
* distinct reference and pointer types,
* [[ALGOL 68#pr .26 co: Pragmats and Comments|comment]] lines (only bracketed comments),
* [[C++#Objects|struct inheritance, struct member functions, virtual functions]].
* destructors, exceptions, templates, namespaces, structured loop exits

==Comparison of the assignment and equality operators==
{|class="wikitable"
!Intent !! ALGOL 68 !! C++
|-
|Define a constant || <code>'''int''' x=888;</code> || {{cpp|1=const int x = 888;}}
|-
|Initialise a variable || <code>'''int''' x:=888;</code> || {{cpp|1=int x = 888;}}
|-
|Assign a value 888 to a variable ''x'' || <code>x:=888;</code> || {{cpp|1=x = 888;}}
|-
|Compare two values || <code>'''if''' x = 888 '''then''' ... '''fi'''</code> || {{cpp|1=if (x == 888) { ... } }}
|-
|Allocate a variable from the '''heap''' || <code>'''ref''' '''int''' x = '''heap''' '''int''';</code><br>or simply:<br><code>'''heap''' '''int''' x;</code> || {{cpp|1=int* x = new int;}}
|-
|Compare address of two pointers || <code>'''ref''' '''int''' x, y;</code><br><code>'''if''' x :=: y '''then''' ... '''fi'''</code> || {{cpp|1=int* x; int* y;}}<br>
{{cpp|1=if (x == y) { ... } }}
|-
|Compare value referenced by two pointers || <code>'''ref''' '''int''' x, y;</code><br><code>'''if''' x = y '''then''' ... '''fi'''</code> || {{cpp|1=int* x; int* y;}}<br>
{{cpp|1=if (*x == *y) { ... } }}
|-
|Name a new type || <code>'''mode''' '''longreal''' = '''long''' '''real''';</code> || {{cpp|1=typedef double longreal;}}<br>or (as of C++11):<br>{{cpp|1=using longreal = double;}}
|-
|Name a new record type || <code>'''mode''' '''cust''' = '''struct'''('''string''' name, address);</code> || {{cpp|1=struct cust { std::string name, address; }; }} 
|-
|Name a new union type || <code>'''mode''' '''taggedu''' = '''union'''('''string''' s, '''real''' r);</code> || {{cpp|1=union u { std::string s; float f; }; }} 
|-
|Name a procedure or function || <code>'''proc''' f = ('''real''' x) '''real''': ( code; result );</code> || {{cpp|1=float f(float x) { code; return result; } }}
|-
|Procedure default parameters|| <code>'''proc''' p = ('''union''' ('''real''', '''void''') in x)'''void''': </code>
&nbsp;&nbsp;&nbsp;&nbsp;<code>( '''real''' x = (in x|('''real''' x):x|888); code );</code>
| {{cpp|1=void p(float x=888) { code; } }}
|-
|Name a new operator || <code>'''op''' ↑ = ('''real''' x,y) '''real''': x**y;</code> || {{n/a}}
|-
|Set priority on a new operator || <code>'''prio''' ↑ = 9;</code> || {{n/a}}
|-
|Chain variables assignment || <code>a:=b:=c:=d;</code> || {{cpp|1=a = b = c = d;}}
|-
|Displacement operator - [[Software:ALGOL 68C|ALGOL 68C]] only || <code>a:=:=b:=:=c:=:=d;</code> || {{cpp|1=a = b; b = c; c = d;}}
|-
| Append "substr" to a variable ''str'' || <code>str +:= "substr";</code> || {{cpp|1=str += "substr";}}
|-
| Prefix "substr" to a variable ''str'' || <code>"substr" +=: str;</code> || {{cpp|1=str = "substr" + str;}}
|-
|}

==Code Examples==

===Union declaration and use===
Assigning values into an A68 <code>'''union'''</code> 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:'''
<source lang="cpp">
  union { int i; char c; } x = { 666 };
  std::cout << x.i << std::endl; 
</source>
The net effect of "type-tagging" is that Algol68's strong typing
"half" encroaches into the <code>'''union'''</code>.

===Mode declaration===
A new mode (type) may be declared using a <code>mode</code> 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:
<source lang="cpp">
const int max=99;
typedef struct { 
    double a, b, c; short i, j, k; float& r;
} newtype[9+1][max+1];
</source>
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 ==
* [https://web.archive.org/web/20060202010259/http://comjnl.oxfordjournals.org/cgi/content/abstract/21/4/316 A comparison of PASCAL and ALGOL 68] - [[Biography:Andrew S. Tanenbaum|Andrew S. Tanenbaum]] - June 1977.
* [https://web.archive.org/web/20110609175836/http://remus.rutgers.edu/cs314/s2004/ryder/lectures/intro-1-2upNew.pdf Orthogonal language design] - Apr 2004 - retrieved May 10, 2007
* [https://web.archive.org/web/20060113120427/http://remus.rutgers.edu/cs314/s2004/ryder/lectures/formal-4-2upNew.pdf How Solve the Dangling Else?] - Apr 2004 - retrieved May 10, 2007
* [https://web.archive.org/web/20060113120810/http://remus.rutgers.edu/cs314/s2004/ryder/lectures/Types2-23New-2up.pdf A comparison of Pascal, C, C++ and Algol68: Types, cont Type system, Type checking, Type safety, Type conversion, Primitive types, Aggregate types: arrays] - Apr 2004 - retrieved May 10, 2007
* [https://web.archive.org/web/20110609180018/http://remus.rutgers.edu/cs314/s2004/ryder/lectures/Types-22-425-2up.pdf Arrays in Algol68] - Apr 2004 - retrieved May 10, 2007
* [https://web.archive.org/web/20120224213628/http://www.cs.virginia.edu/~mpw7t/cs655/pos2.html A Comparison of Arrays in ALGOL 68 and BLISS] - Michael Walker - February 21, 2000 - retrieved  December 21 2015

{{C++ programming language}}

{{DEFAULTSORT:ALGOL 68 and C comparison}}
[[Category:C++]]

{{Sourceattribution|Comparison of ALGOL 68 and C++}}