Inner classes: Difference between revisions
Added Algol 68
(C++ entry) |
(Added Algol 68) |
||
Line 20:
* [[Classes]]
<br>
=={{header|ALGOL 68}}==
Algol 68 doesn't do OO as such but it can be simulated, one possible method is demonstrated here.
<br>
Note that in Algol 68 references to structure members are written as <code>a OF b</code>, whereas most languages would use <code>b.a</code>.
This tends to require more brackets: <code>a OF b( i )</code> selects the field a from b( i ), <code>( a OF b )( i )</code> calls the member procedure a with parameter i.
<br>
This example does not hide the details of the INNER "class" from the program. Also, the INNER structure is declared outside of the OUTER structure, as references to OUTER are required in the definition of INNER (and vice-versa), which would make it hard to define an anonymous INNER in OUTER.
<br>
As there is no OO syntax, the <code>this</code> and <code>super</code> references have to be passed as explicit parameters to the methods and constructors. The call to the print method of o for example, has to be written as <code>( print OF o )( o )</code>. Writing <code>print OF o</code> won't call the method as no "this" reference has been passed to it.
<br>
In this example, the OUTER structure contains a reference to an INNER instance. This is not required in general, the oinner field could be omitted (and the code using it) if not needed.
<syntaxhighlight lang="algol68">
BEGIN # demonstrate a possible method of simulating inner classes #
# declare OUTER and INNER "classes" #
MODE OUTER = STRUCT( INT omember # integer member #
, PROC REF REF OUTER new0 # noarg constructer #
, REF REF INNER oinner # INNER member #
, PROC( REF OUTER )VOID print # print method #
);
MODE INNER = STRUCT( REF REF OUTER super # parent OUTER #
, CHAR cmember # character member #
, PROC( REF REF OUTER )REF REF INNER
new0 # noarg constructor #
# but must be called withe the superclass "pointer" #
, PROC( REF INNER )VOID print # print method #
);
# constructors #
PROC new outer = REF REF OUTER:
BEGIN
HEAP OUTER thisv := OUTER( 0, new outer, NIL, print outer );
HEAP REF OUTER this := thisv;
oinner OF this := new inner( this );
this
END # new outer # ;
PROC new inner = ( REF REF OUTER super )REF REF INNER:
BEGIN
HEAP INNER thisv := INNER( super, " ", new inner, print inner );
HEAP REF INNER this := thisv;
this
END # new inner # ;
# print methods #
PROC print outer = ( REF OUTER this )VOID:
print( ( "[", whole( omember OF this, 0 ), "]" ) );
PROC print inner = ( REF INNER this )VOID:
print( ( "<<", cmember OF this
, "><", whole( omember OF super OF this, 0 )
, ">>"
)
);
REF OUTER o := new outer; # create an instance of OUTER #
omember OF o := 27; # set o's integer member #
cmember OF oinner OF o := "-"; # set o's inner member's character member #
( print OF oinner OF o )( oinner OF o ); # call o's INNER members' print #
( print OF o )( o ); # call o's print #
print( ( newline ) );
omember OF o := 42; # update o's integer member #
cmember OF oinner OF o := "!"; # and its inner member's character member #
( print OF oinner OF o )( oinner OF o ); # call o's INNER members' print #
( print OF o )( o ); # call o's print #
print( ( newline ) );
REF INNER i := new inner( o ); # create a separate INNER instance also #
# with parent o #
cmember OF i := "$"; # update the separate INNER's character member #
( print OF i )( i ); # call the separate INNER's print method #
( print OF o )( o ); # call o's print method again #
print( ( newline ) );
omember OF o := 91; # update o's integer member ... #
cmember OF oinner OF o := "?"; # and its INNER member's character member #
( print OF oinner OF o )( oinner OF o ); # call o's INNER members' print #
( print OF o )( o ); # call o's print method again #
print( ( newline ) );
( print OF i )( i ); # call the separate INNER's print method again #
( print OF o )( o ); # call o's print method again #
print( ( newline ) )
END
</syntaxhighlight>
{{out}}
<pre>
<<-><27>>[27]
<<!><42>>[42]
<<$><42>>[42]
<<?><91>>[91]
<<$><91>>[91]
</pre>
=={{header|C++}}==
| |||