TClonesArray


class description - source file - inheritance tree

class TClonesArray : public TObjArray


    protected:
public:
TClonesArray TClonesArray() TClonesArray TClonesArray(const char* classname, Int_t size = 1000, Bool_t call_dtor = kFALSE) virtual void ~TClonesArray() virtual void AddAfter(TObject*, TObject*) virtual void AddAt(TObject*, Int_t) virtual void AddAtAndExpand(TObject*, Int_t) virtual Int_t AddAtFree(TObject*) virtual void AddBefore(TObject*, TObject*) virtual void AddFirst(TObject*) virtual void AddLast(TObject*) TObject* AddrAt(Int_t i) void BypassStreamer(Bool_t bypass = kTRUE) Bool_t CanBypassStreamer() const static TClass* Class() virtual void Clear(Option_t* option) virtual void Compress() virtual void Delete(Option_t* option) virtual void Expand(Int_t newSize) virtual void ExpandCreate(Int_t n) virtual void ExpandCreateFast(Int_t n) TClass* GetClass() const virtual TClass* IsA() const virtual TObject*& operator[](Int_t i) virtual TObject* Remove(TObject* obj) virtual TObject* RemoveAt(Int_t idx) virtual void ShowMembers(TMemberInspector& insp, char* parent) virtual void Sort(Int_t upto = kMaxInt) virtual void Streamer(TBuffer& b) void StreamerNVirtual(TBuffer& b)

Data Members

protected:
TClass* fClass !Pointer to the class TObjArray* fKeep !Saved copies of pointers to objects public:
static const enum TObject:: kForgetBits static const enum TObject:: kNoSplit static const enum TObject:: kBypassStreamer

Class Description

                                                                      
 An array of clone (identical) objects. Memory for the objects        
 stored in the array is allocated only once in the lifetime of the    
 clones array. All objects must be of the same class. For the rest    
 this class has the same properties as TObjArray.                     
                                                                      
 To reduce the very large number of new and delete calls in large     
 loops like this (O(100000) x O(10000) times new/delete):             
                                                                      
   TObjArray a(10000);                                                
   while (TEvent *ev = (TEvent *)next()) {      // O(100000) events   
      for (int i = 0; i < ev->Ntracks; i++) {   // O(10000) tracks    
         a[i] = new TTrack(x,y,z,...);                                
         ...                                                          
         ...                                                          
      }                                                               
      ...                                                             
      a.Delete();                                                     
   }                                                                  
                                                                      
 One better uses a TClonesArray which reduces the number of           
 new/delete calls to only O(10000):                                   
                                                                      
   TCloneArray a("TTrack", 10000);                                    
   while (TEvent *ev = (TEvent *)next()) {      // O(100000) events   
      for (int i = 0; i < ev->Ntracks; i++) {   // O(10000) tracks    
         new(a[i]) TTrack(x,y,z,...);                                 
         ...                                                          
         ...                                                          
      }                                                               
      ...                                                             
      a.Delete();                                                     
   }                                                                  
                                                                      
 Considering that a new/delete costs about 70 mus, O(10^9)            
 new/deletes will save about 19 hours.                                
                                                                      


TClonesArray() : TObjArray()

TClonesArray(const char *classname, Int_t s, Bool_t) : TObjArray(s)
 Create an array of clone objects of classname. The class must inherit from
 TObject. If the class defines an own operator delete(), make sure that
 it looks like this:

    void MyClass::operator delete(void *vp)
    {
       if ((Long_t) vp != TObject::GetDtorOnly())
          ::operator delete(vp);       // delete space
       else
          TObject::SetDtorOnly(0);
    }

 The third argument is not used anymore and only there for backward
 compatibility reasons.

~TClonesArray()
 Delete a clones array.

void BypassStreamer(Bool_t bypass)
 When the kBypassStreamer bit is set, the automatically
 generated Streamer can call directly TClass::WriteBuffer.

void Compress()
 Remove empty slots from array.

void Clear(Option_t *)
 Clear the clones array. Only use this routine when your objects don't
 allocate memory since it will not call the object dtors.

void Delete(Option_t *)
 Clear the clones array. Use this routine when your objects allocate
 memory (e.g. objects inheriting from TNamed or containing TStrings
 allocate memory). If not you better use Clear() since if is faster.

void Expand(Int_t newSize)
 Expand or shrink the array to newSize elements.

void ExpandCreate(Int_t n)
 Expand or shrink the array to n elements and create the clone
 objects by caling their default ctor. If n is less than the current size
 the array is shrinked and the allocated space is freed.
 This routine is typically used to create a clonesarray into which
 one can directly copy object data without going via the
 "new (arr[i]) MyObj()" (i.e. the vtbl is already set correctly).

void ExpandCreateFast(Int_t n)
 Expand or shrink the array to n elements and create the clone
 objects by caling their default ctor. If n is less than the current size
 the array is shrinked and the allocated space is freed.
 This routine is typically used to create a clonesarray into which
 one can directly copy object data without going via the
 "new (arr[i]) MyObj()" (i.e. the vtbl is already set correctly).
 This is a simplified version of ExpandCreate used in the TTree mechanism.

TObject* RemoveAt(Int_t idx)
 Remove object at index idx.

TObject* Remove(TObject *obj)
 Remove object from array.

void Sort(Int_t upto)
 If objects in array are sortable (i.e. IsSortable() returns true
 for all objects) then sort array.

void Streamer(TBuffer &b)
 Write all objects in array to the I/O buffer. ATTENTION: empty slots
 are also stored (using one byte per slot). If you don't want this
 use a TOrdCollection or TList.



Inline Functions


            TClass* GetClass() const
               void AddFirst(TObject*)
               void AddLast(TObject*)
               void AddAt(TObject*, Int_t)
               void AddAtAndExpand(TObject*, Int_t)
              Int_t AddAtFree(TObject*)
               void AddAfter(TObject*, TObject*)
               void AddBefore(TObject*, TObject*)
             Bool_t CanBypassStreamer() const
           TObject* AddrAt(Int_t i)
          TObject*& operator[](Int_t i)
            TClass* Class()
            TClass* IsA() const
               void ShowMembers(TMemberInspector& insp, char* parent)
               void StreamerNVirtual(TBuffer& b)


Author: Rene Brun 11/02/96
Last update: root/cont:$Name: $:$Id: TClonesArray.cxx,v 1.11 2001/03/11 23:10:01 rdm Exp $
Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *


ROOT page - Class index - Top of the page

This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.