array.h

粗糙集应用软件

	int n = in.size_;

	if (n == 0)
		return true;

	if (size_ + n > capacity_) { // Capacity exceeded, reallocate.

		// Compute physical size of new buffer.
		int capacity = size_ + n;

		// Allocate new buffer.
		T *elements = new T[capacity];

		// Copy already existing elements that lie before insertion point.
		if (elements_ != NULL && i > 0) {
			for (j = 0; j < i; j++) {
				elements[j] = elements_[j];
			}
		}

		T *ptr1 = elements + i;
		T *ptr2 = in.elements_;

		// Insert new elements at insertion point.
		for (j = 0; j < n; j++, ptr1++, ptr2++)
			*ptr1 = *ptr2;

		// Copy already existing elements that lie after insertion point.
		if (elements_ != NULL && i < size_) {
			for (j = 0; j < size_ - i; j++) {
				elements[i + n + j] = elements_[i + j];
			}
		}

		// Delete old buffer.
		delete [] elements_;

		// Update internal representation.
		elements_ = elements;
		capacity_ = capacity;

	}
	else {                       // There's still room!

		// Move existing elements that lie after insertion point.
		if (i < size_) {
			for (j = 0; j < size_ - i; j++) {
				elements_[i + n + j] = elements_[i + j];
			}
		}

		T *ptr1 = elements_ + i;
		T *ptr2 = in.elements_;

		int j;

		// Insert new elements at insertion point.
		for (j = 0; j < n; j++, ptr1++, ptr2++)
			*ptr1 = *ptr2;

	}

	size_ += n;

	return true;

}

//-------------------------------------------------------------------
// Method........: Insert
// Author........: Aleksander 豩rn
// Date..........:
// Description...: At position i, inserts n copies of the element.
// Comments......: Consider more optimal reallocation.
// Revisions.....:
//===================================================================

template <class T>
bool Array<T>::Insert(int i, int n, const T &element) {

	int j;

#if defined(_DEBUG)
	if (i < 0 || i > size_)
		return false;
	if (n < 0)
		return false;
#endif

	if (n == 0)
		return true;

	if (size_ + n > capacity_) { // Capacity exceeded, reallocate.

		// Compute physical size of new buffer.
		// Anticipate future insertions to minimize reallocations.
		int capacity = 2 * capacity_;
		if (capacity == 0)
			capacity = 1;
		if (capacity < size_ + n)
			capacity = size_ + n;

		// Allocate new buffer.
		T *elements = new T[capacity];

		// Copy already existing elements that lie before insertion point.
		if (elements_ != NULL && i > 0) {
			for (j = 0; j < i; j++) {
				elements[j] = elements_[j];
			}
		}

		T *ptr = elements + i;

		// Insert new elements at insertion point.
		for (j = 0; j < n; j++, ptr++)
			*ptr = element;

		// Copy already existing elements that lie after insertion point.
		if (elements_ != NULL && i < size_) {
			for (j = 0; j < size_ - i; j++) {
				elements[i + n + j] = elements_[i + j];
			}
		}

		// Delete old buffer.
		delete [] elements_;

		// Update internal representation.
		elements_ = elements;
		capacity_ = capacity;

	}
	else {                       // There's still room!

		// Move existing elements that lie after insertion point.
		if (i < size_) {
			for (j = 0; j < size_ - i; j++) {
				elements_[i + n + j] = elements_[i + j];
			}
		}

		T *ptr = elements_ + i;

		int j;

		// Insert new elements at insertion point.
		for (j = 0; j < n; j++, ptr++)
			*ptr = element;

	}

	size_++;

	return true;

}

//-------------------------------------------------------------------
// Method........: Insert
// Author........: Aleksander 豩rn
// Date..........:
// Description...:
// Comments......:
// Revisions.....:
//===================================================================

template <class T>
bool Array<T>::Insert(int i, const T &element) {
	return Insert(i, 1, element);
}

//-------------------------------------------------------------------
// Method........: Append
// Author........: Aleksander 豩rn
// Date..........:
// Description...:
// Comments......:
// Revisions.....:
//===================================================================

template <class T>
inline bool Array<T>::Append(const T &element) {
	return Insert(GetSize(), element);
}

//-------------------------------------------------------------------
// Method........: Append
// Author........: Aleksander 豩rn
// Date..........:
// Description...:
// Comments......:
// Revisions.....:
//===================================================================

template <class T>
inline bool Array<T>::Append(int n, const T &element) {
	return Insert(GetSize(), n, element);
}

//-------------------------------------------------------------------
// Method........: Append
// Author........: Aleksander 豩rn
// Date..........:
// Description...:
// Comments......:
// Revisions.....:
//===================================================================

template <class T>
inline bool Array<T>::Append(const Array<T> &in) {
	return Insert(GetSize(), in);
}

//-------------------------------------------------------------------
// Method........: Remove
// Author........: Aleksander 豩rn
// Date..........:
// Description...: Removes all entries with indices in [i, j).
// Comments......:
// Revisions.....:
//===================================================================

template <class T>
inline bool Array<T>::Remove(int i, int j) {

	if (i == 0 && j == size_)
		return Clear();

#if defined(_DEBUG)
	if (i < 0 || i >= size_)
		return false;
	if (j < 0 || j > size_)
		return false;
	if (i >= j)
		return false;
#endif

	int k;

	for (k = 0; k < size_ - j; k++) {
		elements_[i + k] = elements_[j + k];
	}

	size_ -= (j - i);

	return true;

}

//-------------------------------------------------------------------
// Method........: Remove
// Author........: Aleksander 豩rn
// Date..........:
// Description...:
// Comments......:
// Revisions.....:
//===================================================================

template <class T>
inline bool Array<T>::Remove(int i) {
	return Remove(i, i + 1);
}

//-------------------------------------------------------------------
// Method........: Assignment operator
// Author........: Aleksander 豩rn
// Date..........:
// Description...:
// Comments......:
// Revisions.....:
//===================================================================

template <class T>
Array<T> &Array<T>::operator=(const Array<T> &in) {

	int i;

	if (&in == this)
		return *this;

	// Can we reuse the current buffer?
	if (capacity_ >= in.size_) {
	}
	else {
		if (elements_ != NULL)
			delete [] elements_;
		capacity_ = in.size_;
		if (capacity_ > 0)
			elements_ = new T[capacity_];
		else
			elements_ = NULL;
	}

	size_ = in.size_;

	// Copy buffer.
	if (elements_ != NULL && in.elements_ != NULL) {
		for (i = 0; i < size_; i++) {
			elements_[i] = in.elements_[i];
		}
	}

	return *this;

}

//-------------------------------------------------------------------
// Method........: operator ==
// Author........: Aleksander 豩rn
// Date..........:
// Description...:
// Comments......:
// Revisions.....:
//===================================================================

template <class T>
inline bool operator==(const Array<T> &x, const Array<T> &y) {

	if (&x == &y)
		return true;

	if (x.size_ != y.size_)
		return false;

	if (x.size_ == 0)
		return true;
	else
		return (0 == memcmp(x.elements_, y.elements_, x.size_ * sizeof(T)));

}

//-------------------------------------------------------------------
// Method........: operator !=
// Author........: Aleksander 豩rn
// Date..........:
// Description...:
// Comments......:
// Revisions.....:
//===================================================================

template <class T>
inline bool operator!=(const Array<T> &x, const Array<T> &y) {
	return !(x == y);
}

//-------------------------------------------------------------------
// Method........: operator <
// Author........: Aleksander 豩rn
// Date..........:
// Description...: Lexicographical comparison, x < y.
// Comments......:
// Revisions.....:
//===================================================================

template <class T>
inline bool operator<(const Array<T> &x, const Array<T> &y) {

	if (&x == &y)
		return false;

	if (y.size_ == 0)
		return false;

	if (x.size_ == 0)
		return true;

	int size = (x.size_ < y.size_) ? x.size_ : y.size_;

	return (0 > memcmp(x.elements_, y.elements_, size * sizeof(T)));

}

//-------------------------------------------------------------------
// Method........: Format
// Author........: Aleksander 豩rn
// Date..........:
// Description...:
// Comments......:
// Revisions.....:
//===================================================================

template <class T>
String Array<T>::Format() const {

	int i;

	String s;

	for (i = 0; i < GetSize(); i++) {
		s += String::Format((*this)[i]);
		if (i < GetSize() - 1)
			s += ", ";
	}

  return s;

}

#endif