Data Attribute Notation in C++

A coding style that emphasizes data abstraction

Reg is president of Charney & Day and a voting member of ANSI's X3J16 Committee on the C++ Language. He can be reached on CompuServe at 70272,3427.

Most C++ classes are composed of one or more components. As such, a class can be thought of as a collection of components. By implication, a derived class then is also a collection of components. Normally, components have a type and a unique name. These names usually reflect an attribute or property of a class. For example, a product has an id, a description, a cost price, and a list price. In Listing One , pid, desc, cost_price, and list_price are attributes of a product. If another component were added to the class, it would form another attribute for the abstract entity called a "product." For instance, a quantity attribute could be added to the class Product.

At this point, there are no surprises: A class is defined in terms of its components, or "attributes."

Attribute Classes

Constructors, including copy and conversion constructors, are used to create instances consistent with the meaning of the data. Conversion operators are also needed to allow instances of attribute classes to be used with non-user-defined data types. To read or write instances of attribute classes, input and output operations need to be defined. There may also be other member functions for attribute classes, depending on their requirements. Using the example of the product code, you can define an attribute class called Pid; see Listing Two .

Note that now, only certain defined operations are possible on a product id. Also, the actual implementation of a product code is hidden inside the class and its member functions. Thus, the Product class can be defined in terms of attribute classes (as in Listing Three), where the member names play a less important role in attribute classes than they would in normal classes that use normal coding practices. As such, the names in attribute classes tend to be shorter than normal. Since the elements of the class Product are private, Product users can treat the implementation of the class as a black box, allowing the implementation of any attribute class to change. Thus, the class Product can be considered a collection of attributes, and this leads to the question of how to manipulate the value of Product attributes.

Changing Attribute Class Values

An assignment operator is used to change values. However, it does not work well for assigning values to implicit members of the class Product. For example, in Listing Four , to what component is the value 7 assigned?

Defining assignment operators for individual attributes does not work well either, since it requires both that the user know the names of the components of the Product class and that the components be public, a clear violation of the principle of data hiding. Listing Five is a poor solution to this problem. Listing Six is the classic C++ method for changing attribute values. It requires that a user learn the names and prototypes for a number of member functions that can be used to get and set attribute values. An approach that uses data attributes and the black box, however, avoids the problems associated with both Listings Six and Seven.

DAN treats a given class as being defined by its attribute classes. Also, all attributes are unique in a given collection. In the Product example, both cost and list prices started out as type double, but ended up being represented by the unique attribute classes Cost and List.

There is a final piece of groundwork that needs to be laid; it is the analogy to the I/O streams classes. Most programmers use these classes without knowing how they are implemented. However, you can change the contents of a stream by using friend functions and overloading operator functions: for example, << for inserting data, and >> for extracting data. Thus, the stream classes are treated as black boxes that are modified using the insert and extract operators. Overloading the << and >> operators also allows streams to appear in expressions and be extensible.

DAN uses the insert and extract operators for the same reasons that I/O streams do. Other operators could have been used, and originally were, but the correspondence between I/O streams as black boxes and collection classes as black boxes was too good to ignore. Therefore, DAN uses the insert and extract operators to get and set data in collection classes. Single components can also be extracted from a collection by using the attribute classes as conversion operators. Listing Seven illustrates this.

Relationships

While attributes define the properties of a class, they also define relationships within a class. For example, all instances of the Product class must have a product id and a description. Attributes can define relationships between different classes. For example, you can define an invoice line-item class, called LineItem; see Listing Eight .

A relationship between an invoice line item and a product is formed by the product id. A product is part of an invoice line item if both have the same value for their product id. This relationship is expressed in Listing Nine . At execution time, the isIn function returns nonzero if the supplied product is in the given invoice line item. Otherwise, it returns zero. This isIn function can be defined outside either class Product or class LineItem. It depends on the linking or key attribute. In this case, the key attribute is Pid.

Static and Dynamic Relationships

Conclusion

Listing One

// classic C++ style

class Product {
  long pid;
  char desc[30];
  double cost_price;
  double list_price;
};

Listing Two

class Pid {
  long p;
public:
  Pid(long pp = 0) { p = pp; }
  Pid(const Pid& pp) { p = pp.p; }
  Pid operator long() { return p; }
  Pid operator +(const long pp)
     { return Pid(p+pp); }
  Pid operator -(const long pp)
     { return Pid(p-pp); }
  friend ostream& operator <<
       (ostream& os, Pid& pp)
     { return os << pp.p; }
  friend istream& operator >>
       (istream& is, Pid& pp)
     { return is >> pp.p; }
};

Listing Three

class Product {
  Pid  p; // product code
  Desc d; // description
  Cost c; // cost price
  List l; // list price
public:
  Product(const Pid& pp,
          const Desc& dd,
          const Cost& cc,
          const List& ll)
     :p(pp), d(dd), c(cc), l(ll) { }
  ~Product() { }
  friend ostream& operator <<
     (ostream& os, Product& p);
  friend istream& operator >>
     (istream& is, Product& p);
}; 

Listing Four

Product p;  // product instance
p = 7;    // assign 7 to what?

Listing Five

// poor solution - do not use
class Product
{
public:
  Pid p;  // bad practise
  // ... other members
}
      Product aP;
      aP.p = 7;

Listing Six

// classic C++ coding style

class Product {
  Pid  p;
  Desc d;
  Cost c;
  List l;
public:
  Cost getCost() const
      { return c; }
  void setCost(const Cost& cc)
     { c = cc; }
  // ... other members
};
  Product aP;
  Cost aCost;
  aCost = aP.getCost();
  aP.setCost(aCost);

Listing Seven

// Data Attribute Notation style
class Product
{
  Pid  p; // product code
  Desc d; // description
  Cost c; // cost price
  List l; // list price
public:
  // insert & extract operators
  Product& operator <<(Pid& pp)      { p = pp; return *this; }
  Product& operator <<(Desc& dd)
     { d = dd; return *this; }
  Product& operator <<(Cost& cc)
     { c = cc; return *this; }
  Product& operator <<(List& ll)
     { l = ll; return *this; }
  Product& operator >>(Pid& pp)
     { p = pp; return *this; }
  Product& operator >>(Desc& dd)
     { dd = d; return *this; }
  Product& operator >>(Cost& cc)
     { cc = c; return *this; }
  Product& operator >>(List& ll)
     { ll = l; return *this; }
  // attribute conversion ops
  operator Pid()  const  
     { return p; }
  operator Desc() const
     { return d; }
  operator Cost() const
     { return c; }
  operator List() const
     { return l; }
  // constructors/destructor
  Product() { }
  Product(  const Pid& pp, 
            const Desc& dd,
            const Cost& cc, 
            const List& ll)
  : p(pp),d(dd),c(cc),l(ll) { }
  ~Product() { }
  // I/O stream friend functions
  friend ostream& operator <<
     (ostream& os, Product& pp);
  friend istream& operator >>
     (istream& is, Product& pp);
};
ostream& operator <<
  (ostream& os, Product& prod)
{
  os << " Prod: " << prod.p
     << " Desc: " << prod.d
     << " Cost: " << prod.c
     << " List: " << prod.l
  return os;
}
istream& operator >>
  (istream& is, Product& prod)
{
  is >> prod.p >> prod.d
     >> prod.c >> prod.l;
  return is;
}
int main() {
  Product prod;
  Pid pid(184389);
  Desc desc("Angle Bracket");
  Cost cost;
  // using insert/extract ops
  prod << pid << desc;
  prod >> desc >> pid;
  prod << Pid(34562);
  prod >> cost;
  // using conversion operators
  cout << " Prod: " <<Pid(prod)
       << " Desc: " <<Desc(prod)
       << " Cost: " <<Cost(prod)
       << " List: " <<List(prod)
       << endl;
  // using stream I/O
  cin >> prod;
  cout << prod;
  return 0;
}

Listing Eight

class LineItem {
  Iid  i;   // invoice id
  Pid  p;   // product id
  Quant q;  // quantity
public:
  // ... other members
};

Listing Nine

Bool isIn(Product& p,LineItem& i)
{
  return Pid(p)==Pid(i);
}