source: tests/zombies/constructors.c @ 474d610

arm-ehjacob/cs343-translationnew-ast-unique-expr
Last change on this file since 474d610 was 506d4f0, checked in by Peter A. Buhr <pabuhr@…>, 13 months ago

updated zombie programs but still not ready for prime time

  • Property mode set to 100644
File size: 3.0 KB
Line 
1#include <fstream.hfa>
2#include <stdlib.hfa>
3
4int main() {
5    // initialize basic structure
6    struct S {
7        int i, j, k;
8    };
9    void ?{}( S & s ) { s.i = 1, s.k = 2; }             // default constructor
10    void ?{}( S & s, int i, int k ) { s.i = i, s.k = k; } // 2 parameter constructor
11    void ?{}( S & s, S c ) { /* s @= c */ s.[i,j,k] = c.[i,j,k]; } // copy constructor
12    void ^?{}( S & s ) { s.i = 0, s.k = 0; }            // default destructor
13    void ^?{}( S & s, int i ) { s.i = i, s.k = i; }     // 1 parameter destructor
14    {
15        S s1;                                           // default constructor
16        S s2 = { 3, 7 };                                // 2 parameter constructor
17        S s3 @= { .k:3, .i:7 };                         // 2 parameter C initialization
18        ?{}( s3, 2, 5 );                                // explicit 2 parameter constructor
19        ^?{}( s1 );                                     // explicit call to default destructor
20    } // implicit call to default destructor for s2, explicit call s1, no call for s3
21    S s4 @= {};                                         // no default construction
22    (s4){ 2, 5 };                                       // explicit 2 parameter constructor
23    ^s4{ 3 };                                           // explicit call to 1 parameter destructor
24
25    // initialize pointer to a basic structure
26
27    void ?{}( S *& s ) { s = malloc(); s->i = 1, (*s).k = 2; } // default constructor
28    void ?{}( S *& s, int i, int k ) { s = malloc(); (*s).i = i, (*s).k = k; } // 2 parameter constructor
29    void ^?{}( S *& s ) { (*s).i = 0, (*s).k = 0; free( s ); &s = 0p; } // default destructor
30    {
31        S * ps1;                                        // default constructor
32        S * ps2 = { 3, 7 };                             // 2 parameter constructor
33        sout | ps1 | ps2;
34
35        S * ps3 @= 0p;                                  // C initialization
36        S * ps4 @= { 3 };                               // no default construction
37        sout | ps3 | ps4;
38
39        ?{}( ps3, 2, 5 );                               // explicit 2 parameter constructor
40        (ps4){ 2, 5 };                                  // explicit 2 parameter constructor
41        sout | ps3 | ps4;
42
43        ^?{}( ps3 );                                    // explicit call to default destructor
44        ^ps4{};                                         // explicit call to default destructor
45        sout | ps3 | ps4;
46    } // implicit call to default destructor for ps2 and ps1, checks ordering of explicit destructor calls
47
48    // initialize complex structure
49
50    struct T {
51        struct S s;
52    };
53
54    void ?{}( T & t ) {}        // default constructor => implicitly call constructor for field s
55    void ?{}( T & t, int i, int k ) { (t.s){ i, k }; } // 2 parameter constructor => explicitly call constructor for field s
56    void ?{}( T & t, S c ) { (t.s){ c }; }// 1 parameter constructor => explicitly call copy constructor for field s
57    void ^?{}( T & s ) {}       // destructor => implicitly call destructor for field s
58    void ^?{}( T & s, int i ) {}// destructor => implicitly call destructor for field s
59    {
60        S s;                                            // default constructor
61        T t1;                                           // default constructor
62        T t2 = { s };                                   // 1 parameter constructor
63        ^?{}( t1, 3 );                                  // explicit call to default destructor => implicit call to t1.s's destructor
64        T t3;                                           // default constructor
65        T t4 @= { { 1, 3 } };                           // C initialization
66        (t4){ 2, 5 };                                   // explicit 2 parameter constructor
67    } // implicit call to default destructor for t2 and implicit call for s;
68
69    T *pt = malloc(){ 3, 4 };   // common usage
70} // implicit call to default destructor for t3
Note: See TracBrowser for help on using the repository browser.