Collapse all Symbian^3 Application Developer Library

How to access elements

The elements of an array can be accessed by specifying the position of the element in the array.

The elements of an array can be referenced using the indexing operator[] and specifying the position of the element.

For all arrays except the RArray<class T> and RPointerArray<class T> types, the At() member function can also be used.

All of the following code fragments use a CArrayFixFlat<class T> array.

This code constructs a fixed flat array containing the required number of TInt type elements - in this case four.

The indexing operator is used to fetch the value of the second element. This element is then changed, showing two different methods for changing the element: the At() function and the [] operator.

      
       
      
      CArrayFixFlat<TInt>* array;
array = new CArrayFixFlat<TInt>(4);
...
for (TInt value = 0; value < 4; value++)
 array->AppendL(value);
...
TInt somevalue = (*array)[1];  //fetch the element
TInt somevalue = array->At(1);  //... alternative way
(*array)[1]    = 21;    //change the element
array->At(1)   = 21;    // ... alternative way

Accessing functions

If the array elements are objects of a class with member functions, these functions can be easily accessed as shown in the following code fragment:

       
        
       
       class TMyClass
 {
public :
 void SetValue(TInt aval);
 TInt GetValue();
private
 TUint iValue;
 };

       
        
       
       CArrayFixFlat<TMyClass>* array;          // an array of
                                         // TMyClass objects
TMyClass myclass;
array = new CArrayFixFlat<TMyClass>(1);
array->AppendL(myclass);
(*array)[0].SetValue(21);

Accessing functions of CBase derived objects

Where the elements are pointers to CBase derived objects (i.e. elements of an array of type CArrayPtrFlat or CArrayPtrSeg ), the members of those CBase derived objects can easily be accessed. For example, an array of pointers to CElement objects can be accessed as follows:

       
        
       
       CArrayPtrFlat<CElement>* ptrflat;
...
ptrflat = new (ELeave) CArrayPtrFlat<CElement>(16)
...
...   // add elements to ptrflat
...
(*ptrflat)[0]->SetTextL(_LIT("New text for the first CElement"));
ptrflat->At(1)->SetTextL(_LIT("New text for the second CElement"));

(where SetTextL() is a member function of Celement) .

Note that both At() and the index operator[] return a reference to the object in the array.

Refreshing the pointer

If a pointer to the referenced object is taken, be aware that the pointer value may become invalid once elements are added to, or removed from the array. In this event, always refresh the pointer.

       
        
       
       class TMyClass
 {
public :
 void SetValue(TInt aval);
 TInt GetValue();
private
 TUint iValue;
 };

       
        
       
       CArrayFixFlat<TMyClass>* array;
...
TMyClass myclass;
array = new CArrayFixFlat<TMyClass>(16);
...
for (TInt val = 0; val < 10; val++)
 {
 myclass.SetValue(val)
 array->AppendL(myclass;
 }
...
TMyClass* myptr;
myptr = &(array->At(9));
myptr->GetValue();  // references the tenth element
array->Delete(0,4); // Delete first four elements
array->Compress();  
myptr->GetValue();  // myptr is invalid. An exception may occur
...

After deleting the first four elements, myptr points to a location outside the logical array. Once the array has been compressed, the pointer is invalid.

Parent topic: How to Use Dynamic Arrays