Question

到目前为止我的代码：

#include <iostream>
#include <vector>

using namespace std;

class Dictionary
{
private:
    string dictName;
    struct wordCard
    {
        string word;
        string translation;
    };
    vector<wordCard> Dict;
    bool foundit = false;
public:
    // My attemtp at swap function for copy-and-swap:
    void swap(Dictionary& dict1, Dictionary& dict2)
    {
        Dictionary dict3("tmp");
        dict3.dictName = dict1.dictName;
        dict3.Dict = dict1.Dict;
        dict1.dictName = dict2.dictName;
        dict1.Dict = dict2.Dict;
        dict2.dictName = dict3.dictName;
        dict2.Dict = dict3.Dict;
    }
    // Very basic constructor (setting the dictionary name while creating an object was part of the assignment):
    Dictionary(string name)
    {
        setDictName(name);
    }

    /* various functions that work fine */

    // Overloading "+" operator:
    // The result is supposed to be a new dictionary (without changing the source) where all words from the
    // original dictionaries are present without doubles.
    Dictionary& operator+ (const Dictionary& dict)
    {
        bool doubleword = false;
        string plusname;
        plusname = "Augmenting " + this->dictName + " & " + dict.dictName;
        Dictionary plusDict(plusname);
        plusDict.Dict = this->Dict;
        for (int i = 0; i < dict.Dict.size(); i++)
        {
            doubleword = false;
            for (int i2 = 0; i2 < plusDict.Dict.size(); i2++)
            {
                if (plusDict.Dict[i2].word == dict.Dict[i].word)
                {
                    doubleword = true;
                }
            }
            if (!doubleword)
            {
                plusDict.Dict.push_back(dict.Dict[i]);
            }
        }
        return *this;
    }

    /* 2 other overloads that are very similar */

    // Overloading "=" operator (using copy-and-swap):
    // Not part of the assignment, but I couldn't think of another way to make the other operators work.
    Dictionary& operator=(Dictionary dict)
    {
        swap(*this, dict);
        return *this;
    }
};

我遇到的问题：

理想情况下，它应该像这样工作：

Obj1 = result of operation Obj2 + Obj3;

我现在得到的是：

Obj1 = Obj2 (ignores Obj3)

我有一个模糊的想法，为什么它发生（或实际上，两个想法）。首先，operator+返回*this，而不是实际结果。但当我试图将其更改为临时类对象时，编译器开始尖叫我。其次，我知道我正在使用局部变量（临时类对象），但我不知道如何将其公开，以便我以后可以使用它。当我尝试将类对象添加到public:部分（或private:）时，编译器将其视为函数声明，而不是类对象。

那么，我怎样才能公开我的临时类对象，或者返回a+b而不是*this的结果，或者让operator=抓住结果或operator+代替什么回来？

Answer 1

operator +应该按值返回一个新对象并且是const - 即类似

Dictionary operator+ (const Dictionary& dict) const
{
    Dictionary ret;
    //modify ret
    return ret;
}

算术和赋值运算符重载 - 返回值，范围，组合表达式

1 个答案: