Question

我正在开展一个基本上建立字典的学校项目。其中一个选项是搜索具有相同定义的单词并进行打印。在我的词典课中，我得到了：

#pragma once
#include "Definition.h"
class Dictionary
{
private:
    /*Private data members*/
    int num_words = 0;
    Definition** book;
public:

    /*Constructors & destructor*/
    Dictionary();
    Dictionary(const Dictionary&);
    ~Dictionary();

    /*Search for existing definition*/
    bool checkCopy(const Definition&);

    /*bool operator overloading*/
    bool operator==(const Dictionary&) const;
    bool operator!=(const Dictionary) const;

    /*Operator = -= += overloading*/
    Dictionary& operator=(const Definition&);
    Dictionary& operator=(const Dictionary&);
    Dictionary& operator-=(const int);
    Dictionary& operator+=(const Definition&);

    /*Input & output operators overloading*/
    friend ostream& operator<<(ostream&, const Dictionary&);
    friend istream& operator>>(istream&, Dictionary&);

    /*Index operator overloading*/
    Definition& operator[](int);
    Definition operator[](int) const;

    /*Sorting dictionary function*/
    void sortDictionary();

    /*Utility functions*/
    int getSize() const;
    bool search(const String&) const;
    void searchCommon() const;
    void findCopy(String&, String&, bool&);
};

然后在定义课中我得到了：

#pragma once
#include "String.h"
class Definition
{
private:
    /*Private class embers*/
    String word;
    String** def;
    int num_defs = 0;
public:

    /*Constructors & destructor*/
    Definition();
    Definition(const Definition&);
    ~Definition();

    /*Overloading = += -= operator*/
    Definition& operator=(const Definition&);
    Definition& operator+=(const String&);
    Definition& operator-=(int);

    /*Overloading bool operators*/
    bool operator==(const Definition&) const;
    bool operator!=(const Definition&) const;

    /*Overloading input & output operators*/
    friend ostream& operator<<(ostream&, const Definition&);
    friend istream& operator>>(istream&, Definition&);

    /*Overloading index operators*/
    String& operator[](int);
    String operator[](int) const;

    /*Sorting Functions*/
    void sortDefinition();
    void sortOrder();
    void sortDupl();
    const String& getWord() const;
    const String& getDef(int) const;
    int getNumDef() const;
};

现在我正在尝试通过复制字典来搜索公共区域，当找到搜索到的字典时，它会从复制的字典中删除它。但是我得到了数据违规，我猜其中一个索引或者getSize / getDefNum没有返回正常值：

void Dictionary::searchCommon() const {
    Dictionary temp;
    temp = (*this);
    for (int i = 0; i < num_words; ++i)
    {
        String comWord((*book)[i].getWord());
        for (int j = 0; j < (*book)[i].getNumDef(); ++j)
        {
            String comDef((*book)[i].getDef(j));
            bool flag = false;
            temp.findCopy(comDef, comWord, flag);
            if (flag)
            {
                cout << comWord << endl;
                cout << comDef << endl << "-----------------------------------------------" << endl;
            }
        }

    }
}

void Dictionary::findCopy(String& comDef, String& comWord, bool& flag) {
    for (int i = 0; i < num_words; i++)
    {
        for (int j = 0; j < (*book)[i].getNumDef(); j++)
        {
            if (comDef == (*book)[i].getDef(j) && comWord != ((*book)[i].getWord()))
            {
                cout << (*book)[i].getWord();
            (*book)[i] -= j;
                flag = true;
            }

        }
    }
}

帮助？

编辑：这是项目，如果有人可以在他的调试器中检查它会很棒： https://github.com/adamorad/Dictionary.git

Answer 1

问题在于您访问book对象的Dictionary属性的方式。

您将其指定为指针数组，使用这样的行，这很好：

book = new Definition*[input.num_words];

但您尝试在searchCommon和findCopy方法中的任何位置访问其元素，就像它是指向数组的指针一样：

(*book)[i].getNumDef()

要修复它，请将其替换为首先获取数组的第i个元素的表达式，这是一个指针，然后取消引用它：*(book[i])

或者更方便地访问Definition方法：

book[i]->getNumDef()

您在Definition::getDef(int idx)方法中遇到同样的问题。

更换所有这些代码后，您的代码运行正常，即使我不确定它是否打印出您想要的结果。

使用指针访问私有数据成员

1 个答案: