• Skip to content
  • Skip to link menu
KDE 3.5 API Reference
  • KDE API Reference
  • API Reference
  • Sitemap
  • Contact Us
 

kviewshell

DArray< TYPE > Class Template Reference

Dynamic array for general types. More...

#include <Arrays.h>

Inheritance diagram for DArray< TYPE >:

Inheritance graph
[legend]

List of all members.


Public Member Functions

virtual ~DArray ()

Arrays.h

Files #"Arrays.h"# and #"Arrays.cpp"# implement three array template classes.

Class {TArray} implements an array of objects of trivial types such as char#, int#, float#, etc. It is faster than general implementation for any type done in {DArray} because it does not cope with element's constructors, destructors and copy operators. Although implemented as a template, which makes it possible to incorrectly use {TArray} with non-trivial classes, it should not be done.

A lot of things is shared by these three arrays. That is why there are more base classes: {itemize} {ArrayBase} defines functions independent of the elements type {ArrayBaseT} template class defining functions shared by {DArray} and {TArray} {itemize}

The main difference between {GArray} (now obsolete) and these ones is the copy-on-demand strategy, which allows you to copy array objects without copying the real data. It's the same thing, which has been implemented in {GString} long ago: as long as you don't try to modify the underlying data, it may be shared between several copies of array objects. As soon as you attempt to make any changes, a private copy is created automatically and transparently for you - the procedure, that we call "copy-on-demand".

Also, please note that now there is no separate class, which does fast sorting. Both {TArray} (dynamic array for trivial types) and {DArray} (dynamic array for arbitrary types) can sort their elements.

{ Historical comments} --- Leon chose to implement his own arrays because the STL classes were not universally available and the compilers were rarely able to deal with such a template galore. Later it became clear that there is no really good reason why arrays should be derived from containers. It was also suggested to create separate arrays implementation for simple classes and do the copy-on-demand strategy, which would allow to assign array objects without immediate copying of their elements.

At this point {DArray} and {TArray} should only be used when it is critical to have the copy-on-demand feature. The {GArray} implementation is a lot more efficient.

Template array classes.

Author:
Andrei Erofeev <eaf@geocities.com> -- Copy-on-demand implementation.
Version:
$Id: Arrays.h,v 1.10 2004/05/13 15:16:34 leonb Exp $#


 DArray (const int lobound, const int hibound)
 DArray (const int hibound)
 DArray (void)

Detailed Description

template<class TYPE>
class DArray< TYPE >

Dynamic array for general types.

Template class DArray<TYPE># implements an array of elements of type TYPE#. Each element is identified by an integer subscript. The valid subscripts range is defined by dynamically adjustable lower- and upper-bounds. Besides accessing and setting elements, member functions are provided to insert or delete elements at specified positions.

This template class must be able to access {itemize} a null constructor TYPE::TYPE()#, a copy constructor TYPE::TYPE(const TYPE &)#, and a copy operator TYPE & operator=(const TYPE &)#. {itemize}

The class offers "copy-on-demand" policy, which means that when you copy the array object, array elements will stay intact as long as you don't try to modify them. As soon as you make an attempt to change array contents, the copying is done automatically and transparently for you - the procedure that we call "copy-on-demand". This is the main difference between this class and {GArray} (now obsolete)

Please note that most of the methods are implemented in the base classes {ArrayBase} and {ArrayBaseT}.

Definition at line 758 of file Arrays.h.


Constructor & Destructor Documentation

template<class TYPE >
DArray< TYPE >::DArray ( void   )  [inline]

Constructs an empty array.

The valid subscript range is initially empty. Member function touch# and resize# provide convenient ways to enlarge the subscript range.

Definition at line 855 of file Arrays.h.

template<class TYPE >
DArray< TYPE >::DArray ( const int  hibound  )  [inline]

Constructs an array with subscripts in range 0 to hibound#.

The subscript range can be subsequently modified with member functions touch# and resize#.

Parameters:
hibound upper bound of the initial subscript range.

Definition at line 862 of file Arrays.h.

template<class TYPE >
DArray< TYPE >::DArray ( const int  lobound,
const int  hibound 
) [inline]

Constructs an array with subscripts in range lobound# to hibound#.

The subscript range can be subsequently modified with member functions touch# and resize#.

Parameters:
lobound lower bound of the initial subscript range.
hibound upper bound of the initial subscript range.

Definition at line 869 of file Arrays.h.

template<class TYPE>
virtual DArray< TYPE >::~DArray (  )  [inline, virtual]

Definition at line 776 of file Arrays.h.


The documentation for this class was generated from the following file:
  • Arrays.h

kviewshell

Skip menu "kviewshell"
  • Main Page
  • Namespace List
  • Class Hierarchy
  • Alphabetical List
  • Class List
  • File List
  • Namespace Members
  • Class Members

API Reference

Skip menu "API Reference"
  • kviewshell
Generated for API Reference by doxygen 1.5.9
This website is maintained by Adriaan de Groot and Allen Winter.
KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal