Question

所以我有一个类WayPoint（在名称空间HHN内）。我有一个类WayPointContainer。容器有一个私有矢量变量来存储“ HHN :: WayPoint”类型的对象

我现在想做的是我想重载运算符[]，这样我就可以像这样轻松访问向量中的对象：

WayPoint p1("name",1.5,2.0);
WayPointContainer c1; 
c1[0] = p1          // This would add the WayPoint p1 to the vector of the container on index 0
WayPoint p2 = c1[0] // This would get the WayPoint from the vector at index 0 and copy it to p2

...

我发现了不同的实现，但是它们是针对除vector之外的其他类型的，或者在vector中未使用复杂类型的。

这是我的WayPointContainer.h

#include <vector>
#include <iostream>
#include "WayPoint.h"

#ifndef SRC_WAYPOINTCONTAINER_H_
#define SRC_WAYPOINTCONTAINER_H_

class WayPointContainer {
    private:
        std::vector<HHN::WayPoint>* pContainer{ nullptr };

    public:
        WayPointContainer();
        WayPointContainer(const WayPointContainer& orig);
        virtual ~WayPointContainer();

        WayPointContainer& operator=(const WayPointContainer& rhs);
        HHN::WayPoint& operator[](int idx) const;

        void Add(const HHN::WayPoint& arg);

        int Size() const;
        void Print() const;
};

#endif /* SRC_WAYPOINTCONTAINER_H_ */

这是我的WayPointContainer.cpp

#include <vector>
#include "WayPointContainer.h"
#include <iostream>
using namespace std;

//Default Konstruktor
WayPointContainer::WayPointContainer() {
    //Heap bereich ... new ... pContainer
    pContainer = new std::vector<HHN::WayPoint>;
}

//Destruktor
WayPointContainer::~WayPointContainer() {} //TODO

//Copy Konstruktor
WayPointContainer::WayPointContainer(const WayPointContainer& orig) {
    pContainer = orig.pContainer;
}

WayPointContainer& WayPointContainer::operator=(const WayPointContainer& rhs) {
    if(&rhs == this) {
        return *this;
    }
    if ( pContainer != rhs.pContainer) {
        pContainer = rhs.pContainer;
    }
    return *this;
}

HHN::WayPoint& WayPointContainer::operator[](int idx) const {*
    //invalid initialization of reference of type 'HHN::WayPoint&' from expression of type 'std::vector<HHN::WayPoint>'
    return pContainer[idx];
}

void WayPointContainer::Add(const HHN::WayPoint& arg) {
    pContainer->insert(pContainer->begin(), arg);
}

int WayPointContainer::Size() const {
    int i = pContainer->size();
    return i;
}

void WayPointContainer::Print() const {
    for (auto waypoint = pContainer->begin(); waypoint != pContainer->end(); ++waypoint) {
        cout << waypoint->Name();
    }
}

我正在努力的方法：

HHN::WayPoint& WayPointContainer::operator[](int idx) const {*
    //invalid initialization of reference of type 'HHN::WayPoint&' from expression of type 'std::vector<HHN::WayPoint>'
    return pContainer[idx];
}

我在此处实施的代码遇到了上述无效的初始化错误。

因此，我希望使用如顶部所述的[]运算符，但目前尚未实现或未实现错误。

（我也在WayPointContainer的析构函数中缺少向量“ pContainer”的析构函数。因此，如果您知道可以随意添加的东西，那不是我的问题，而是奖金。）

如果您愿意，我还可以提供WayPoint类和我用来测试的main.cpp的代码。

Answer 1

有关操作员实施中的直接问题的错误消息非常清楚

invalid initialization of reference of type 'HHN::WayPoint&' from expression of type 'std::vector<HHN::WayPoint>'

pContainer[idx]取消引用pContainer，其偏移量为idx，因此结果的类型为std::vector<HHN::WayPoint>。

有两种解决方法：

您可以取消引用指针并对其应用idx：
```
return (*pContainer)[idx];
```
您根本不需要使用指针来保留您的std::vector<HHN::WayPoint>类成员（推荐的解决方案）：
```
class WayPointContainer {
     private:
         std::vector<HHN::WayPoint> container;
     // ...
};
```
在这种情况下，您无需处理指针的内存取消/分配，只需将操作符重载写为
```
HHN::WayPoint& WayPointContainer::operator[](int idx) const {
     return container[idx];
}
```

如何为包含我自己的类对象的向量重载运算符“ []”

1 个答案: