1

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

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;
}

这将适用于两个，但我想以几乎无限的数量制作它。我不知道从哪里开始，因为我不知道那叫什么，所以我无法查找。

4

2 回答 2

2

你可以做类似的事情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);
}

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

于 2012-09-07T14:06:46.237 回答
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 new，因为内存泄漏的风险非常高。另一个原因是您对 operator + 的使用实际上并不代表求和运算。重载运算符时，您应该使它们像在原始类型上一样起作用。当您执行“2 + 3”时，结果是 5，也就是总和。你在这里让 operator + 做的不是你从元素创建一个容器的总和，这与 operator + 的预期含义不同。

于 2012-09-07T14:26:37.593 回答