Title: Student Code Critique Competition

The first question that needs to be asked is "Is there a need to make the class T a template?" This question is important because, when we make a class a template, and there are too many instances of the template, then the space complexity of the resultant object code would increase. Paraphrased, improper usage of template class would lead to code bloat.

There is a more fundamental issue here. For example, in the above program, if the template parameter, specifies only the attributes of objects, rather than their behaviour, then its better made a member variable of the class, and the value could be assigned in the constructor. This means that, if

T<25> t1;
T<50> t2;

behave the same (only their state differ), then the usage of templates is not justified.

I'll assume that class T being a template is justified and proceed further.

When we specify an access modifier, like public: etc, it doesn't apply to one member of the class. Rather it applies to all the members of the class that are declared after the modifier, either till the end of the class declaration, or the occurrence of another access modifier, whichever is earlier. Because of this semantics, it would be more self-descriptive if the access modifier is specified in a line by itself, followed by the members which it qualifies.

For example, it is better to write

public:
  friend T operator+(const T&, const T&);

than

public: friend T operator+(const T&,
                           const T&);

The latter somehow gives the feeling that it applies only to the member along which it appears; the former, is self documenting. It seems to say that the following members are public. As a bonus, the former style helps to avoid errors like the one in the program, (reproduced below)

private data[N + 1]; // data type missing

While overloading an operator (like `+') for a user-defined data type, it is better kept as a member function of that class, unless the left operand of the operator being overloaded is of a different class. In that case, a friend function would be used.

In the above program we have

T operator+ (const T&, const T&);
                      // friend function

Since the left hand operand of the operator (the first parameter) is a reference to an object of the class, for which we are overloading the operator, this function is best made a member function of the relevant class (here it is T). So we should prefer the following in place of the above.

T operator+ (const T&); // member function

Suppose we want to do something like

T<25> p;
int j;
T<25> r = j + p;

then we would need,

T<N> operator+(const int&, const T<N>&);

which cannot be converted to be used as a member of template class T. Only in such cases friend functions (to overload operators) are to be used.

The classic example to demonstrate this requirement is the overloading of operator<< to work with the ostream object cout. Of course, there are other examples, but I have given one.

The declaration,

friend T operator+(const T&, const T&);

taking account of its context in the above program, is the same as

friend T<N> operator+(const T<N>&, const T<N>&);

This, in spite of our best intentions, doesn't make any friends. This is because we are looking for a non-template function with name "operator+", which doesn't exist. (g++ compiler, version 2.96, warned me of this!

The above declaration should be

friend T<N> operator+<N>(const T<N>&,
                         const T<N>&);

which can be simplified as, again taking account of its context in the above program,

friend T operator+<N>(const T&, const T&);

and further to,

friend T operator+<>(const T&, const T&);

By fixing the above program we get,

template<int N>
class T {
public:
  friend T operator+<> (const T&, const T&);
private:
  int data[N + 1]; // int or anything
};

template <int N>
T<N> operator+(const T<N>& S1, const T<N>&S2){
  return S1;
}

int main() {
  T<64> a, b, c = a + b;
}

The better way to write the above code is,

template<int N>
class T {
public:
  T operator+(const T&); // member function
private:
  int data[N + 1];
};

template<int N>
T<N> T<N>::operator+ (const T<N>& S1){
  return *this;
// first parameter in given program
}
 
int main() {
  T<64> a, b, c = a+b;
}

Note that Annamalai is a student in Bangalore. Until today, his was the only submission, which left me somewhat worried because I am not sure he has exactly pinned down the problem. Then the following arrived in my email:

Though the goal was to comment on C++ idioms, there are some syntax errors that will need to be corrected first, before the code can even be compiled. The original code, as printed, with line numbers added for clarity:

1   template <int N> 
2   class T { 
3   public: friend T operator+(const T&, 
4                              const T&); 
5   private data[N + 1]; 
6   }; 
7   template <int N> 
8   T<N> operator+ (const T<N>& S1, 
9                   const T<N>& S2) { 
10    return S1; 
11  } 
12  int main() { 
13    T<64> a, b, c = a + b; 
14  }
    

The syntax errors are in the declaration of data; the omission of a colon after private and the lack of a data type. Access control keywords like private and public are not to be confused with type modifiers such as const. They are labels that affect the access of all the declarations that follow them. For this reason, it is good style to keep them on lines of their own:

1  template <int N> 
2  class T { 
3    public: 
4      friend T operator+(const T&, 
5                         const T&); 
6    private: 
7      data[N + 1]; 
8  }; 

Now we can clearly see the other problem with data, the lack of a data type. Legacy C compilers allowed identifiers to be implicitly int in the absence of a type declaration. Although some C++ compilers allow it, this is not valid C++.

7      int data[N + 1];

Now the code will compile, but it will not link. The reason is subtle, and the answer in this case covers many points of style that code borrows from textbook examples. As we clean up the style of the example, hopefully the answer will become clear.

A major source of confusion in the class is the use of T as an identifier. T is (over)used in books on template programming, most commonly to represent the type of the template parameter. In this case, the template parameter is not a type, it is an integral value. This illustrates the importance of using parameter names and class names that represent the purpose of the class or parameter. In this example, there is not enough context to know the purpose of this class, so we'll use the name FixedBuffer for the class, and length for the template parameter.

template <size_t length> 
class FixedBuffer { 
public: 
  friend FixedBuffer operator+( 
      const FixedBuffer&, const FixedBuffer&); 
private: 
  int data[length + 1];
};
template <size_t length> 
FixedBuffer<length> operator+(
        const FixedBuffer<length>& S1, 
        const FixedBuffer<length>& S2){ 
  return S1; 
} 
int main() {
  FixedBuffer<64> a, b, c = a + b; 
}    

This looks better, but now that the obscuring type names are gone, you might notice that the two operator+ functions look a little different...

From the C++ specification:

""When a template is instantiated, the names of its friends are treated as if the specialization had been explicitly declared at its point of instantiation.""

In our code, the function is treated as if it was declared as it appears in the friend function declaration. This draws attention to what the friend function is saying. As is common in template classes, the compiler does not require that you include the template parameters when using the class name within its declaration. The precise declaration would read:

template <size_t length> 
class FixedBuffer { 
public: 
  friend FixedBuffer<length> operator+( 
        const FixedBuffer<length>& S1, 
        const FixedBuffer<length>& S1); 
... 
}; 

But since it is within a template declaration, the name lookup doesn't happen until the class template is instantiated. When our class declared in main, it's template declares a friend function that looks like:

FixedBuffer<64> operator+( 
        const FixedBuffer<64>& S1, 
        const FixedBuffer<64>& S1);

Aha! This is not a template function! This is why the program will not link, for the signature of this function does not match the template function that is defined later in the code. In this case, one correct declaration would be:

template <size_t length> 
class FixedBuffer { 
public: 
  friend FixedBuffer operator+<length>( 
                   const FixedBuffer& S1, 
                   const FixedBuffer& S1); 
... 
};
    

(There is another syntax that my compiler accepts that requires that you declare the function before defining the class. I prefer the above.) This designates operator+ as a template function, and shows that the concrete instance of the template function that has a matching length template parameter is the actual friend.

Wow, all these rules for template friends of template classes are hard! Fortunately, there is a better way. The important point to realize is that operator+ doesn't have to be a friend! Think about the following:

int a, b, c; 
// ... assign values 
a = b + c;

Are b and c any different after the assignment than before? Of course not. The calculated result doesn't affect either of its parameters. In fact, we can't change either parameter, because its arguments are (as in this case) almost always const! The few operations that need rights to change an operand include the assignment operators and their kin, and these are almost always member functions that don't need to be friends anyway.

template <size_t length> 
class FixedBuffer { 
public: 
  FixedBuffer& operator+=( const FixedBuffer& rhs){ 
    // ...add rhs to *this 
    return *this; 
  } 
... 
};    

This code illustrates the canonical definition of the add-and-assign operator that takes its right hand argument as an operator, and returns a reference to itself, allowing the result to be used as an r-value (in other words, you can add the result to other variables, use it as a function argument, etc.). We've contained the code for adding FixedBuffer types within a member function, without any complicated friend functions. Now, instead of duplicating that code in operator+, we'll simply reuse it in the canonical definition of addition:

template <size_t length>
FixedBuffer<length> operator+( 
               const FixedBuffer<length>& S1,
               const FixefBuffer<length>& S2){ 
  FixedBuffer<length> temp(S1); 
  temp += S2; 
  return temp; 
} 

This very neatly allows us to change the definition of operator+=, and get an updated definition of operator+ absolutely free. This is typically the way most of the arithmetical operators are defined for classes that need addition and subtraction to work the way that we expect that integers do. Remember this need not only apply to template classes; regular classes can benefit just as much from this technique.

This deceptively small piece of code contained a lot of complexity, and in our analysis we can deduce a couple general rules. Remember, like all rules there are exceptions, but these will give the student place from which to build experience:

I was about to put this column to bed when the following arrived in my inbox.