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

これは2つで機能しますが、実質的に無制限の量で作成したいと思います。どこから始めたらいいのかわからないし、それが何と呼ばれているのかわからないので調べられません。

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

オペレーターバージョンを使用するよりも「便利」ではないかもしれませんが、とにかく使用すべきではない理由がいくつかあります. 何よりもまず、ポインター (少なくとも「裸の」ポインターは使用しないでください) を使用しないでください。また、メモリ リークのリスクが非常に高いため、演算子 new を使用しないでください。もう 1 つの理由は、演算子 + の使用が実際には合計演算を表していないことです。演算子をオーバーロードするときは、プリミティブ型と同じように動作させる必要があります。「2 + 3」を実行すると、結果は合計で 5 になります。ここで operator + にさせているのは、要素からコンテナーを作成している合計ではなく、それは operator + の予想される意味とは異なります。

于 2012-09-07T14:26:37.593 に答える