如何修改 push_back 以存储唯一向量

Question

我对向量和模板非常陌生。似乎还不能把我的头绕在他们身上。 代码如下：

template <class T>
class m_vector
{
    int m_iNextIndex;
    int m_iMaxSize;
    T* m_pArray;

public:

    m_vector()
    {
        m_pArray = 0;
        init();
    }

    m_vector(const m_vector<T>& other)
    {
        m_pArray = 0;
        m_iNextIndex = 0;
        m_iMaxSize = 0;
        *this = other;
    }

    ~m_vector()
    {
        if (m_pArray != 0)
            delete [] m_pArray;
    }

    void init()
    {
        m_iMaxSize = VECT_INC_SIZE;
        m_pArray = new T[m_iMaxSize];
        m_iNextIndex = 0;
    }

    inline void push_back(const T& item)
    {
        if (m_iNextIndex >= m_iMaxSize)
        {
            resize(m_iNextIndex + VECT_INC_SIZE);
            m_iNextIndex -= VECT_INC_SIZE;
        }
        m_pArray[m_iNextIndex] = item;
        ++m_iNextIndex;
    }

    void resize(int iNewSize)
    {
        if (iNewSize >= m_iMaxSize)
        {
            T* temp = new T[iNewSize];
            for (int i = 0; i < m_iNextIndex; ++i)
            {
                temp[i] = m_pArray[i];
            }
            delete [] m_pArray;
            m_pArray = temp;
            m_iMaxSize = iNewSize;
        }
        m_iNextIndex = iNewSize;
    }

};

push_back 使用 (x, y) 向量和 (x, y, width, height) 矩形调用。 我认为由于代码具有“m_pArray [m_iNextIndex] = item”，因此我可以简单地添加一个新函数来检查该项目是否唯一，然后再将其添加到向量列表中。所以我编写了一个例程如下：

int inline exists(const &item)
{
  for(int i = 0; i < m_iMaxSize; i++)
  {
    if(m_pArray[i] == item)
      return 1;
  }
  return 0;
}

编译器不高兴。它在if语句上报告了以下错误： “左操作数必须是指针或指向类成员的指针，或算术”

我想我可能需要类似的东西：

if (type == vector)
 if( (m_pArray[i].x == item.x) ....)
else
 if( (m_pArray[i].x == item.x) && (m_pArray[i].width == item.width) )

我在正确的轨道上吗？ 如果是这样，我如何检查项目的类型。

谢谢，比尔。

Answer 1

问题是您的Vector 或Rectangle 缺少比较运算符，例如

friend bool operator== (Vector const& lhs, Vector const& rhs){
    return lhs.x == rhs.x && lhs.y == rhs.y;
} 

但是你们其余的代码不好，需要重写。我已经将我的代码重写为旧式：

注意：不要盲目复制此代码。仅供参考。使用前测试

#define VECT_INC_SIZE 10

// replaced by iterator version
//template< class InputIt, class Size, class OutputIt>
//OutputIt copy_n(InputIt first, Size count, OutputIt result) {
//    while (count-- > 0) {
//        *result++ = *first++;
//    }
//    return result;
//}

template<class InputIt, class OutputIt>
OutputIt copy(InputIt first, InputIt last, OutputIt d_first) {
    while (first != last) {
        *d_first++ = *first++;
    }
    return d_first;
}

template<class T>
T exchange(T& obj, T new_value)
{
    T old_value = obj;
    obj = new_value;
    return old_value;
}

template <class T>
class m_vector
{
private:
    unsigned int size;
    unsigned int capacity;
    T* array;

public:
    m_vector()
    : size(0)
    , capacity(VECT_INC_SIZE)
    , array(new T[VECT_INC_SIZE])
    {}

    m_vector(m_vector<T> const& other)
    : size(other.size)
    , capacity(other.capacity)
    , array(new T[other.capacity]) {
        //copy_n(other.array, size, array);
        copy(other.cbegin(), other.cend(), begin());
    }

    // rule of 3
    m_vector& operator=(m_vector<T> const& other) {
        if (&other != this) {
            if (other.capacity != capacity){
                delete [] exchange(array, new T[other.capacity]);
                capacity = other.capacity;
            }
            size = other.size;
            //copy_n(other.array, size, array);
            copy(other.cbegin(), other.cend(), begin());
        }
        return *this;
    }

    ~m_vector() {
        if (array != 0) delete [] array;
    }


    void push_back(T const& item) {
        if (size >= capacity) {
            reserve(capacity + VECT_INC_SIZE);
        }
        array[size] = item;
        ++size;
    }

    void reserve(unsigned int newCapacity) {
        if (size > capacity) {
            T* const temp = new T[newCapacity];
            //copy_n(array, size, temp);
            copy(cbegin(), cend(), temp);
            delete [] exchange(array, temp);
            capacity = newCapacity;
        }
    }

    bool exists(T const& item) const {
        //for(unsigned int i = 0; i < size; ++i) {
        //    if(array[i] == item) return true;
        //}
        for(T const* it = cbegin(); it != cend(); ++it) {
            if(*it == item) return true;
        }
        return false;
    }

    void erase(T const& item) {
        T* it = begin();
        T* const endIt = end();
        while(it != endIt && *it != item) ++it;
        if (it == endIt) return;
        copy(it + 1, endIt, it);
        --size;
    }

    // iterators
    T* begin() { return array; }
    T* end() { return array + size; }
    T const* cbegin() const { return array; }
    T const* cend() const { return array + size; }
};

class Vector {
private: 
    int x,y;
public:
    Vector() : x(0), y(0) {}
    Vector(int x, int y) : x(x), y(y) {}

    friend bool operator== (Vector const& lhs, Vector const& rhs){
        return lhs.x == rhs.x && lhs.y == rhs.y;
    } 
    friend bool operator!= (Vector const& lhs, Vector const& rhs){
        return !(lhs==rhs);
    } 
};

#include <cstdio>

void VectorInM_Vector(m_vector<Vector> const& vec, Vector const& item) {
    if (vec.exists(item)) printf("Vector found in vector\n");
    else printf("Vector not found in vector\n");
}

int main(){
    m_vector<Vector> vec;
    vec.push_back(Vector(1,1));
    VectorInM_Vector(vec, Vector(1,1));
    m_vector<Vector> vec2(vec);
    vec.erase(Vector(1,1));
    VectorInM_Vector(vec, Vector(1,1));

    VectorInM_Vector(vec2, Vector(1,1));
    vec2 = vec;
    VectorInM_Vector(vec2, Vector(1,1));
}

on compiler explorer/godbolt