如何在 C++ 中添加三个相同类的对象？ [复制]

Question

我可以在 C++ 中使用运算符重载添加三个对象吗？？

#include <iostream>
#include <conio.h>
using namespace std;

class complex{
private:
    int a;
public:
    void setdata(int x){
        a=x;
    }
    void showdata(){
        cout<<"\n"<<a;
    }
    int operator +(complex c,complex d){
        complex temp;
        temp.a=a+c.a+c+d.a;
        return (temp);
    }
};

int main(){
complex c1,c2,c3,c4;
c1.setdata(3);
c2.setdata(5);
c4.setdata(2);
c4=c1+c2+c3;
c4.showdata();
}

我正在使用这种方法，但它不起作用请帮助。

Answer 1

您必须更改一点操作符，并且您在变量的初始化中出现错误（C3 未初始化）。 您不必定义同时处理三个术语的运算符。总和将分为两部分 (c1 + c2) + c3;第一个总和返回一个添加到 c3 的“复杂”项目。最后一个和的结果分配给 c4。 请参阅下面的代码。

#include <iostream>
#include <conio.h>
using namespace std;

class complex{
private:
    int a;
public:
    void setdata(int x){
        a = x;
    }
    void showdata(){
        cout << "\n" << a;
    }
    complex operator +(complex c){
        complex temp;
        int i = 0;
        i = a + c.a;
        temp.setdata(i);
        return temp;
    }
};

int main(){
    complex c1, c2, c3, c4;
    c1.setdata(3);
    c2.setdata(5);
    c3.setdata(2);
    c4 = c1 + c2 + c3;
    c4.showdata();
}

Answer 2

在我的 cmets 中，我提出了两种替代解决方案，但在摆弄示例代码时，我什至找到了第三种解决方案。

示例代码：

#include <iostream>

// Version 1: (return type fixed)

class Complex1 {
  friend std::ostream& operator << (std::ostream &out, const Complex1 &c);
  private:
    int a;
  public:
    explicit Complex1(int a): a(a) { }
    // operator + as member
    Complex1 operator + (const Complex1 &c) const
    {
      return Complex1(a + c.a);
    }
};

std::ostream& operator << (std::ostream &out, const Complex1 &c)
{
  return out << c.a;
}

// Version 2: (two overloaded operators)

class Complex2 {
  friend std::ostream& operator << (std::ostream &out, const Complex2 &c);
  friend int operator+(const Complex2 &c, const Complex2 &d);
  friend int operator+(int c, const Complex2 &d);
  private:
    int a;
  public:
    explicit Complex2(int a): a(a) { }

};

std::ostream& operator << (std::ostream &out, const Complex2 &c)
{
  return out << c.a;
}

int operator+(const Complex2 &c, const Complex2 &d)
{
  return c.a + d.a;
}

int operator+(int c, const Complex2 &d)
{
  return c + d.a;
}

// Version 3: (implicit conversion with constructor)

class Complex3 {
  friend std::ostream& operator << (std::ostream &out, const Complex3 &c);
  private:
    int a;
  public:
    Complex3(int a): a(a) { }
    // operator + as member
    int operator+(const Complex3 &c) const
    {
      return a + c.a;
    }
};

std::ostream& operator << (std::ostream &out, const Complex3 &c)
{
  return out << c.a;
}

// Check everything out:

using namespace std;

int main()
{
  cout << "Version 1:" << endl;
  { Complex1 c1(3), c2(5), c3(2);
    Complex1 c4 = c1 + c2 + c3;
    cout << "c4: " << c4 << endl;
  }
  cout << "Version 2:" << endl;
  { Complex2 c1(3), c2(5), c3(2);
    Complex2 c4 = Complex2(c1 + c2 + c3);
    cout << "c4: " << c4 << endl;
  }
  cout << "Version 3:" << endl;
  { Complex1 c1(3), c2(5), c3(2);
    Complex1 c4 = c1 + c2 + c3;
    cout << "c4: " << c4 << endl;
  }
  cout << "done." << endl;
  return 0;
}

您可以在ideone 上编译和运行代码。

---

Complex1 提供固定运算符作为成员

Complex1 Complex1::operator + (const Complex1 &c) const;

因此，(c1 + c2) + c3 是

(Complex1 × Complex1 → Complex1) &times Complex1 → Complex1

---

Complex2 提供两个重载运算符作为非成员

  int operator+(const Complex2 &c, const Complex2 &d);
  int operator+(int c, const Complex2 &d);

因此，c1 + c2 是

Complex2 × Complex2 → int

和 (c1 + c2) + c3 是

int × Complex2 → int

---

Complex3 与原始示例非常相似，主要区别在于我提供了一个接受int 的非explicit 构造函数。这意味着编译器将在必要时将其用作转换运算符。

（使用适当的构造函数，可能不会很快注意到运算符问题。）

因此，c1 + c2 是

Complex3 × Complex3 → int

和 (c1 + c2) + c3 是

(int → Complex3) × Complex3 → int