Using TArray<class T>

Using TArray to avoid the need for overloaded variants

The use of a TArray object can avoid the need for the member function of an end-user class to have overloaded variants to handle all possible types of arrays of <class T> elements.

The following example illustrates the point. It constructs a fixed flat array, a variable flat array and a packed array of <TElement> objects.

By taking a TArray<TElement> argument, the CTot::Total() member function can access array elements regardless of the type of array containing them.

class TElement                 // array elements
 {
 public:
  TElement();
  inline TInt GetValue() const;
  void SetValue(TInt aVal);
 private :
  TInt iValue;
 };

class CTot : public CBase           
 {
 public :
  void Total(const TArray<TElement>& anArray);
 private :
  TInt iTotalElements;
  TInt iTotalValue;
 };

TElement::TElement()
 : iValue(0)
 {}

inline TInt TElement::GetValue() const
 {
 return iValue;
 }

void TElement::SetValue(TInt aVal)
 {
 iValue = aVal;
 }

void CTot::Total(const TArray<TElement>& anArray)
 {
 TInt count = anArray.Count();
 
 for (TInt jj = 0; jj < count; jj++)
  iTotalValue += anArray[jj].GetValue();
 
 iTotalElements += count;
 }

Then some code using these could be:

//           main body

CArrayFixFlat<TElement>* fix;
CArrayVarFlat<TElement>* var;
CArrayPakFlat<TElement>* pak;
TElement x;
CTot* ptr;

ptr = new CTot;

fix = new CArrayFixFlat<TElement>(2);
var = new CArrayVarFlat<TElement>(2);
pak = new CArrayPakFlat<TElement>(2);

x.SetValue(1);
fix->AppendL(x);
x.SetValue(2);
var->AppendL(x,sizeof(x));
x.SetValue(3);
pak->AppendL(x,sizeof(x));

ptr->Total(fix->Array());
ptr->Total(var->Array());
ptr->Total(pak->Array());

Without the use of TArray, the Total() member function would need overloaded variants to handle all the possible array types which it might expect. The CTot class would need redefining as:

class CTot : public CBase           
 {
 public :
  void Total(const CArrayFixFlat<TElement>& anArray);
  void Total(const CArrayFixSeg<TElement>& anArray);
  void Total(const CArrayVarFlat<TElement>& anArray);
  void Total(const CArrayVarSeg<TElement>& anArray);
  void Total(const CArrayPakFlat<TElement>& anArray);
 private :
  TInt iTotalElements;
  TInt iTotalValue;
 };

To allow the Total() function to handle arrays composed of different types of element, (i.e. arrays constructed with different template values), then a separate variant of Total() is required for each element type. For example, to handle arrays of <TElement1> elements and arrays of <TElement2> elements, the CTot class might be defined as:

class CTot : public CBase           
 {
 public :
  void TotalA(const TArray<TElement1>& anArray);
  void TotalB(const TArray<TElement2>& anArray);
 private :
  TInt iTotalElements;
  TInt iTotalValue;
 };

One important point to note; the referenced TElement returned by operator[] is declared as const. This means that any member function of TElement must also be declared as const, as shown in this example.