Question

我想要完成的是以下内容：

foo* f = foo(1) + foo(2) + foo(3)

与

相同

foo* f = new foo[3];
f[0] = foo(1);
f[1] = foo(2);
f[2] = foo(3);

我必须这样做的代码是：

foo*& operator+(foo f){
     foo* ret = new foo[2];
     ret[0] = *this;
     ret[1] = f;
     return ret;
}

这将适用于两个，但我想让它几乎无限量。我不知道从哪里开始，因为我不知道那叫什么，我不能查一查。

Answer 1

您可以使用vector执行类似操作：

#include <vector>
#include <iostream>

struct foo {
  foo(int) {}
};

std::vector<foo>
operator+(const foo& lhs, const foo& rhs) {
  std::vector<foo> v;
  v.push_back(lhs);
  v.push_back(rhs);
  return v;
}

std::vector<foo>
operator+(std::vector<foo> lhs, const foo& rhs) {
  lhs.push_back(rhs);
  return lhs;
}

int main () { 
  std::vector<foo> f = foo(1) + foo(2) + foo(3);
}

但我无法想象你为什么要这样做。

Answer 2

如果你需要一个大小不一的容器，那就像使用std :: vector一样：

#include <iostream>
#include <vector>

class Foo
{
public:
    Foo(int x) : x_(x) {}

private:
    int x_;
}

int main(int argc, char* argv[])
{
    std::vector<Foo> fooContainer;

    fooContainer.push_back(Foo(1));
    fooContainer.push_back(Foo(2));
    fooContainer.push_back(Foo(3));

    return 0;
}

它可能不如使用您的操作员版本那么“方便”，但有多种原因导致您无论如何都不应该使用它。首先，您不应该使用指针（至少不是“裸”指针）并且应该避免操作员新的，因为内存泄漏的风险非常高。另一个原因是你使用operator +实际上并不代表求和运算。重载运算符时，应该使它们像原始类型一样运行。当你做“2 + 3”时，结果是5也就是总和。你在这里做的操作符+做的不是你从元素创建一个容器的总和，而是与operator +的预期含义不同。

c ++中指针结构的运算符重载

2 个答案: