对一组同构对象用单数组表示法实现（算法导论第十章10.3-2）

对一组同构对象用单数组表示法实现

（算法导论第十章10.3-2）
考虑到数据安全问题，多用了一个数组来处理安全问题。

#ifndef C11LEARN_SINGULARGROUPSREPRESENTISOMORPHICOBJECTS_H
#define C11LEARN_SINGULARGROUPSREPRESENTISOMORPHICOBJECTS_H
#include  <cstring>
template<typename T>
class SingularGroupsRepresentIsomorphicObjects
{
private:
    int capacity;
    char *buffer;
    int *array;
public:
    SingularGroupsRepresentIsomorphicObjects(int capacity = 50);
    virtual ~SingularGroupsRepresentIsomorphicObjects();
    SingularGroupsRepresentIsomorphicObjects(const  SingularGroupsRepresentIsomorphicObjects<T> & l);
    const SingularGroupsRepresentIsomorphicObjects<T>& operator=(const  SingularGroupsRepresentIsomorphicObjects<T> & l);
    T*allocate();
    void free(T*);
};
template<typename T>
SingularGroupsRepresentIsomorphicObjects<T>::SingularGroupsRepresentIsomorphicObjects(int capacity ):capacity(capacity){
    if(this->capacity<=0) this->capacity = 10;
    buffer = new char[sizeof (T)*this->capacity];
    array = new int[this->capacity];
    memset(buffer,0,sizeof (T)*this->capacity);
    memset(array,0,sizeof (int)*this->capacity);
}
template<typename T>
SingularGroupsRepresentIsomorphicObjects<T>::~SingularGroupsRepresentIsomorphicObjects(){
    if(buffer!= nullptr)
    {
        delete[] array;
        delete [] buffer;
        buffer = nullptr;
        array = nullptr;
    }
}
template<typename T>
SingularGroupsRepresentIsomorphicObjects<T>::SingularGroupsRepresentIsomorphicObjects(const SingularGroupsRepresentIsomorphicObjects<T> & l){
    capacity = l.capacity;
    buffer = new char[sizeof (T)*capacity];
    array = new int[capacity];
    memcpy(buffer,l.buffer,sizeof (T)*capacity);
    memcpy(array,l.array,sizeof (int)*capacity);
}
template<typename T>
const SingularGroupsRepresentIsomorphicObjects<T>& SingularGroupsRepresentIsomorphicObjects<T>::operator=(const  SingularGroupsRepresentIsomorphicObjects<T> & l){
    if(this == &l)return*this;
    if(buffer!= nullptr)
    {
        delete[] array;
        delete [] buffer;
    }
    capacity = l.capacity;
    buffer = new char[sizeof (T)*capacity];
    array = new int[capacity];
    memcpy(buffer,l.buffer,sizeof (T)*capacity);
    memcpy(array,l.array,sizeof (int)*capacity);
    return *this;
}
template<typename T>
T*SingularGroupsRepresentIsomorphicObjects<T>::allocate(){
    int index = -1;
    while (++index<capacity && array[index]!=0);
    if(index>=capacity)
        throw "out of space";
    array[index] = -1;
    return (T*)(buffer+index*sizeof (T));
}
template<typename T>
void SingularGroupsRepresentIsomorphicObjects<T>::free(T* t){
    int index = -1;
    while (++index<capacity && (T*)(buffer+index*sizeof (T)) != t);
    if(index<capacity)
    {
        memset(t,0,sizeof (T));
        array[index] = 0;
    }
}
#endif //C11LEARN_SINGULARGROUPSREPRESENTISOMORPHICOBJECTS_H

测试代码

	int arr[] = {1, 4, 6, -9, 2, -5, 10, -3, -7,12};
    int length = sizeof(arr)/sizeof (int);
    SingularGroupsRepresentIsomorphicObjects<int> isomorphicObjects(10);
    int *arr_tmp[10];
    int *arr_tmp_a[10];
    for (int i = 0; i < 10; ++i) {
        arr_tmp[i] = isomorphicObjects.allocate();
        *arr_tmp[i] = i;
    }
    for (int i = 0; i < 10; ++i) {
        cout<<*arr_tmp[i]<<" ";
    }
    for (int i = 0; i < 10; i+=2) {
        isomorphicObjects.free(arr_tmp[i]);
    }
    cout<<endl;
    for (int i = 0; i < 10; ++i) {
        cout<<*arr_tmp[i]<<" ";
    }
    cout<<endl;
    SingularGroupsRepresentIsomorphicObjects<int> isomorphicObjects_a;
    isomorphicObjects_a = isomorphicObjects;
    for (int i = 0; i < 5; i+=1) {
        arr_tmp_a[i] = isomorphicObjects_a.allocate();
        *arr_tmp_a[i] = i;
    }
    for (int i = 0; i < 5; ++i) {
        cout<<*arr_tmp_a[i]<<" ";
    }
    cout<<endl;
    SingularGroupsRepresentIsomorphicObjects<int> isomorphicObjects_b(isomorphicObjects);
    for (int i = 0; i < 5; i+=1) {
        arr_tmp_a[i+5] = isomorphicObjects_b.allocate();
        *arr_tmp_a[i+5] = i;
    }
    for (int i = 0; i < 10; ++i) {
        cout<<*arr_tmp_a[i]<<" ";
    }