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.