_DATA ATTRIBUTE NOTATION RELATIONSHIPS_
by Reginald B. Charney 

Listing One

class Person { /*...*/ };
enum Model { Ford, Chevy };

Person ted(Ford);
int owner(Person& p, Model m);
// ... 
if (owner(ted,Chevy)) // ...


Listing Two

class Person { };
class Car { };
class Owner {
  Person p; // part 1
  Car   c;  // part 2
};


Listing Three

class Ford : public Car { };
class FordOwner : public Person
{
  Ford f;
};


Listing Four

class Person { };
class Chev { };
class ChevOwner : 
  public Person, 
  public Chev
{
};


Listing Five

int isRenewed() 
  { return Renewed(*this)==1; }
// . . .
Owner o;
// . . .
if (o.isRenewed()) // . . .


Listing Six

#include <iostream.h>
#include <string.h>

class Renewed {
  int r;
public:
  Renewed(const int rr=0)
     { r = rr; }
  operator int() const
     { return r; }
};
class Car { };
class Person {
  char *n;
public:
  Person(const char *nn="")
     { strcpy(n,nn); }
  friend ostream& operator <<
       (ostream& os, Person& p)
     { os << p.n; }
};
 class Owner : public Person
{
  Car c;
  Renewed r;
public:
  Owner(const char *n) :
     Person(n) { }
  operator Renewed() const
     { return r; }
  Owner& operator <<
       (const Renewed& rr)
     { r = rr; return *this; }
};
class IsRenewed {
  Renewed r;
public:
  IsRenewed(const Owner& o)
     { r = Renewed(o); }
  operator int() const
     { return r; }
};
int main()
{
  Owner owner("Ted");
  owner << Renewed(1);
  if (IsRenewed(owner))
     cout << Person(owner)
         << " has renewed\n";
  return 0;
}


Listing Seven

class Person { };
class Car { };

class People   // any # of people
{
  Person **pp;
};
class Fleet    // any # of cars
{
  Car **cp; 
};
// 1:1 relationship of CarOwner
class CarOwner
{
  Person p;
  Car c;
};
// 1:m relationship of one person owning any number of cars
 class FleetOwner
{
  Person p; // one person
  Fleet f;     // many cars
};
// m:1 relationship of a group of people owning one Car
class TaxiCoop
{
  People p; // many people
  Car cp;   // one car
};
// m:m relationship of many cars owned by many people
class FleetOwners
{
  People p; // many people
  Fleet f;     // many cars
};


Listing Eight

class FleetOwner
{
  friend class FOIter;
  Person p;
  Fleet f;
};
class FOIter
{
  int status;  // =0 if empty
  CurrElem c;  // save cur elem
public:
  FOIter(FleetOwner& fo);
  int next();  // =0 at end
  int prev();  // =0 at start
  void reset();
  friend ostream& operator <<
     (ostream& os, FOIter& foi)
     { return os << foi.c; }
};
int main()
{
  FleetOwner fo;
  FOIter foI(fo);
  foI.reset();
  while(foI.next())
     cout << foI << endl;
  return 0;
}


Listing Nine

class FleetOwner
{
  friend class FOIter;
  Person p;
  Fleet f;
};
class Next { };
class Prev { };
class Reset { };

class CurrElem
{
public:
  friend ostream& operator <<
     (ostream& os, CurrElem& c);
};
class FOIter{
  int status;  // =0 if empty
  CurrElem c;  // save cur elem
public:
  FOIter(FleetOwner& fo)
     { status = 0; }
  operator Next();
  operator Prev();
  operator Reset();
  operator int()
     { return status; }
  friend ostream& operator <<
     (ostream& os, FOIter& foi)
       { return os << foi.c; }
};
int main()
{
  FleetOwner fo;
  FOIter foI(fo);

  Reset(foI);
  while(Next(foI))
     cout << foI << endl;
  return 0;
}


Listing Ten

class Code { };
class Init : public Code { };
class Body : public Code { };
class Term : public Code { };
class Fragment // order of parts
{           // in this class
  Init ii;     // determines the
  Body bb;     // order of
  Term tt;     // initialization
public:
  Fragment(Init i,Body b,Term t)
     : ii(i), bb(b), tt(t) { }
  Fragment() { }
  Fragment& operator <<
     (Fragment& f);
};


Listing Eleven

Init i1, i2;
Body b1, b2;
Term t1, t2;
Fragment f1(i1,b1,t1);
Fragment f2;

f2 << f1;

Fragment p1(i2,b2,t2);
Fragment p2;

p2 << f1 << f2;


Listing Twelve

Init i1("FleetOwner fo;
       FOIter foI(fo);
       ");
Init i2("foI << r;");
Body b2("while(Next(foI))
          cout << foI << endl;
       ");
Term t1("return 0;");
Fragment f1(i2,b2,Term(""));
Fragment program(i1,f1,t1);