c++动态数组模板库

if (array == NULL)
throw MEMFAIL;
}
template <class el>
AeDynArray<el>::~AeDynArray()
{
if (array)
{
free(array); // Freeing memory
Clear(); // than we clear it, since it will be deleted
else
{
// otherwise, shift array elements
for(unsigned int i=pos; i<size-1; i++)
// or new size is less then half of the current
if ((size > realsize) || (size < realsize/2))
{
realsize = size;
array = (el *)realloc(array, sizeof(el)*size);
void AeDynArray<el>::SetSize(unsigned int newsize)
{
size = newsize;
if (size != 0)
{
// change array memory size
// if new size is larger than current
return *this;
}
template <class el>
unsigned int AeDynArray<el>::GetSize()
{
return size; // simply return size
}
template <class el>
compatible
# Any modern C++ compiler
AeDynArray class interface is quite simple. There are two
constructors(default constructor and copy constructor), assignment
C++ dynamic array template class
abstract
This article provides example of dynamic array implementation using *C++
templates*. It uses standard *malloc*/realloc memory allocation
void* AeDynArray<el>::getptr()
{
return array; // return void* pointer
}
template <class el>
el& AeDynArray<el>::operator [] (unsigned int index)
if (array == NULL)
throw MEMFAIL;
memcpy(array, a.array, sizeof(el)*a.realsize);
// memcpy call -- coping memory contents
realsize = a.realsize;
array = (el *)realloc(array, sizeof(el)*dyn_array_step);
// set initial memory size again
realsize = dyn_array_step;
}
template <class el>
array = NULL;
}
}
template <class el>
AeDynArray<el>::AeDynArray(const AeDynArray &a)
{
array = (el *)malloc(sizeof(el)*a.realsize);
* GetSize() — returns current size of an array
* SetSize(unsigned int size) — sets array size
* Fill(int c) — fills all array's memory with a given integer
// dyn_array_mult times )
};
//////////////////////////////////////////////////////////////////////
template <class el>
AeDynArray<el>::AeDynArray()
return *this;
if (a.size == 0) // is other array is empty -- clear this array
Clear();
SetSize(a.size); // set size
memcpy(array, a.array, sizeof(el)*a.size);
is a type parameter — it can be any type. Functions Add() and operator
[] uses type /el/ specified while instantiating a class.
source code: C++
#include <cstdlib>
Free, tested & ready to use examples!
</>
Web
Programming </programming/> / C++ </programming/cplusplus/>
void Delete(unsigned int pos); // delete array item
void* getptr(); // get void* pointer to array data
enum exception { MEMFAIL }; // exception enum
AeDynArray& operator = (const AeDynArray &a); // assignment operator
el& operator [] (unsigned int index); // get array item
void Add(const el &item); // Add item to the end of array
size = a.size;
}
template <class el>
AeDynArray<el>& AeDynArray<el>::operator = (const AeDynArray &a)
{
if (this == &a) // in case somebody tries assign array to itself
const static int dyn_array_step = 128; // initial size of array memory (elements)
const static int dyn_array_mult = 2; // multiplier (enlarge array memory
{
return array[index]; // return array element
if (array == NULL)
throw MEMFAIL;
}
}
else
Clear();
}
template <class el>
void AeDynArray<el>::Delete(unsigned int pos)
{
if (size == 1) // If array has only one element
template<class el>
class AeDynArray
{
public:
AeDynArray(); // constructor
AeDynArray(const AeDynArray &a); // copy constructor
~AeDynArray(); // distructor
* Clear() — removes all elemets from the array, resets memory alocation
* Delete(unsigned int pos) — deletes specified element from the array
AeDynArray class difinition is prefixed by the keyword *template*: /el/
unsigned int GetSize(); // get size of array (elements)