1

私は3つのオブジェクトへの3つのポインタを持っています:

MyClass* a = new MyClass(...);
MyClass* b = new MyClass(...);
MyClass* c = new MyClass(...);

今、私はできるように MyClass で演算子を指定したいと思います:

a = b*c;

したがって、a、b、および c は、追加のコピーを作成したくない既存の大きなオブジェクトです。乗算を行い、結果「a」を直接書きたいと思います。

1) これは C++ 演算子でも可能ですか? 2) 構文のヒントを教えてください。（私はオペレーターに少し慣れていません..）

助けてくれてありがとう。

4

2 に答える 2

1

operator*のために書いた場合MyClass。

MyClass* a = new MyClass(...);
MyClass* b = new MyClass(...);
MyClass* c = new MyClass(...);

以下のように使用する必要があります。

*a = (*b) * (*c);

そして、ポインタに対してはできません。たとえば、これは不可能です:

MyClass *operator*(const MyClass *a, const MyClass *b) // Impossible
{
 ...   
}

演算子の定義には の引数が必要なためですMyClass。

于 2013-05-10T14:42:07.370 に答える
0

あなたは本当にこれをしたくありません。値へのポインターではなく、値の演算子を定義する標準的な方法に固執することで、すべてがよりクリーンになり、保守が容易になります。

EDIT ascheplerがコメントで指摘しているように、これを行うことさえできません。引数の少なくとも 1 つは、クラス型またはクラスへの参照である必要があります。

大規模なコピー操作を回避したい場合は、C++11 の移動セマンティクスを使用するMoveProxyか、Boost.Moveサポート ライブラリなどを使用してそれらをエミュレートする必要があります。

コード例:

// loads of memory with deep-copy
struct X {
  int* mem; 

  X() : mem(new int[32]) { }
  // deep-copy
  X(const X& other) 
    : mem(new int[32]) { std::copy(other.mem, other.mem+32, this.mem); }
  ~X() { delete[] mem; }
  X& operator=(const X& other) { std::copy(other.mem, other.mem+32, this.mem); return *this; }
  X(X&& other) : mem(other.mem) { other.mem = nullptr; }
  X& operator=(X&& other) { delete[] mem; this.mem = other.mem; other.mem = nullptr; return this; }

  friend void swap(const X& x, const X& y)
  { std::swap(x.mem, y.mem); }


  friend
  X operator*(const X& x, const X& y)
  { return X(); }
};
于 2013-05-10T14:50:09.810 に答える