c++ - 无法破译“错误：'int'之前的预期不合格ID”

Question

我一直在环顾四周，并没有提出任何切实可行的解决方案。听起来它正在寻找一个默认的构造函数，而不是现有的构造函数，但我在下面有一个。将它作为第一个列出的构造函数向上移动并没有改变错误消息，所以我错了。这是完整的错误消息（使用 jGRASP）：

In file included from intset.h:47:0,
                 from IntSet.cpp:1:
IntSet.cpp:12:11: error: expected unqualified-id before 'int'
    IntSet(int a, int b, int c, int d, int e) {
           ^
IntSet.cpp:12:11: error: expected ')' before 'int'

这是 IntSet.cpp 代码：

#include "intset.h"
//#include <algorithm>
//#include <iostream>

    int size;
    const int MAXSIZE = 25000;
    bool set[MAXSIZE];
    const int SENTINEL = -1;


    //Constructors
   IntSet(int a, int b, int c, int d, int e) {
      size = a;

      if(b > size) {
            size = b;
        }
        if(c > size) {
            size = c;
        }
        if(d > size) {
            size = d;
        }
        if(e > size) {
            size = e;
        }

        set = new bool[size];
        for(int i = 0; i <= size; i++) {
            if(i == a || i == b || i == c || i == d || i == e) {
                insert(i);
            } else {
                remove(i);
            }
        }
   }

    IntSet(int a, int b, int c, int d) {
        IntSet(a, b, c, d, -1);
    }

    IntSet(int a, int b, int c) {
        IntSet(a, b, c, -1, -1);
    }

    IntSet(int a, int b) {
        IntSet(a, b, -1, -1, -1);
    }

    IntSet(int a) {
        IntSet(a, -1, -1, -1, -1);
    }

    //Copy constructor
    IntSet(const IntSet& x) {
        size = x.size;
        for (int i = 0; i <= x.size; i++ ) {
            set[i] = x.set[i];
        }
    }

    //Destructor
    ~IntSet()
    {
        //for(int i = this.length(); i >= 0; i--) {
        //  this[i]
        //}
    }

    ////////////////////////

    bool insert(int a) {
        if(a <= size && a >= 0) {
            set[a] = true;
            return true;
        }
        else if(a >= 0) {
            //removed "new" from line below
            IntSet temp = IntSet(a);
            &this += temp;
            set[a] = true;
            return true;
        }
        return false;
    }

    bool remove (int a) {
        if (isInSet(a)) {
            set[a] = false;
            return true;
        }
        return false;
    }

    bool isEmpty() {
        bool retVal = true;
        for (int i = 0; i <= size; i++) {
            if (set[i] == true) {
                retVal = false;
            }
        }
        return retVal;
    }

    bool isInSet (int a) {
        if (set[a]){
            return true;
        }
        return false;
    }

    /////////////////////////////////////////////

    IntSet operator + (IntSet a) {
        IntSet c = IntSet(max(size, a.size));
        for (int i = 0; i <= c.size; i++) {
            if (set[i] || a.set[i]){
                c.set[i] = true;
            }
            else {
                c.set[i] = false;
            }
        }
        return c;
    }

    IntSet operator * (IntSet a) {
        IntSet c = IntSet(max(size, a.size));
        for (int i = 0; i <= c.size; i++) {
            if (set[i] && a.set[i]) {
                c.set[i] = true;
            }
            else {
                c.set[i] = false;
            }
        }
        return c;
    }

    IntSet operator - (IntSet a) {
        IntSet c = IntSet();
        c.size = 0;
        for (int i = 0; i <= size; i++) {
            if (set[i] && !a.set[i]) {
                c.set[i] = true;
            }
            else {
                c.set[i] = false;
            }
            c.size++;
        }
        return c;
    }

    IntSet operator = (const IntSet a) {
        return IntSet(a);
    }

    IntSet operator += (IntSet a) {
        return IntSet(operator+(a));
    }

    IntSet operator *= (IntSet a) {
        return IntSet(operator * (a));
    }

    IntSet operator -= (IntSet a) {
        return IntSet(operator - (a));
    }

    IntSet operator == (const IntSet a) const{
        for(int i = 0; i < size; i++) {
            if(set[i] != a.set[i]) {
                return false;
            }
        }

        return true;
    }

    IntSet operator != (IntSet a) {
        for(int i = 0; i < size; i++) {
            if(set[i] != a.set[i]) {
                return true;
            }
        }

        return false;
    }

    IntSet operator << (IntSet a) {
        cout << "{";
        for(int i = 0; i < size; i++) {
            if(set[i]) {
                cout << " " << i;
            }
        }
        cout << "}";
    }

    IntSet operator >> (IntSet a) {
        int index;
        while(cin >> index && index != SENTINEL) {
            insert(index);
        }
    }

这是附加的 intset.h 代码：

#ifndef INTSET_H
#define INTSET_H
#include <iostream>
#include <algorithm>
using namespace std;

class IntSet {

public:
    //Constructors
    IntSet();
    IntSet(int);
    IntSet(int, int);
    IntSet(int, int, int);
    IntSet(int, int, int, int);
    IntSet(int, int, int, int, int);
    IntSet(const IntSet&);  // M: Added the &; must be a pointer or reference
    ~IntSet();

    //Overloaded Operators  M:  Added 'IntSet' in front of the word 'operator.'
    // It was required syntax.
    IntSet operator+(IntSet);
    IntSet operator*(IntSet);
    IntSet operator-(IntSet);
    IntSet operator=(IntSet);
    IntSet operator+=(IntSet);
    IntSet operator*=(IntSet);
    IntSet operator-=(IntSet);
    IntSet operator==(IntSet);
    IntSet operator!=(IntSet);
    IntSet operator<<(IntSet);
    IntSet operator>>(IntSet);

    //Functions
    bool insert(int);
    bool remove(int);
    bool isEmpty();
    bool isInSet(int);

private:
    const int MAXSIZE;
    int size;
    bool set[];
    const int SENTINEL;
};

#include "IntSet.cpp"
#endif

我对头文件没有太多经验，所以如果我的格式不正确，我不会感到惊讶，但我正在查看教授提供的许多其他示例，我的并没有什么不寻常的地方。我想这可能与 .h 文件中列出的顺序有关，并且我没有遵循 .cpp 中相同的确切顺序，但是当我以相同的顺序列出所有内容时，没有任何变化。

score 2 · Accepted Answer

您的代码有很多问题。我们将不得不在标题和实现之间跳来跳去。准备好？

在你的标题中，你这样做：

class IntSet {
    /* stuff */
private:
    bool set[];
};

首先，名称set是一个不好的选择：它是namespace stdw 中的一个类的名称，您通过using namespace std在头文件中导入该名称。这充其量是令人困惑的。

更重要的是，在这种情况下语法bool set[]不正确。即使您的编译器允许它，它也是一个扩展。谁知道它的作用以及它在其他编译器上的表现？躲开它。

如果要声明数组，请声明数组。如果要声明指针，请声明指针。请记住：数组不是指针。

不幸的是，您没有这样做，因为稍后在您的代码中您会这样做：

set = new bool[size];

这应该做什么？set不是指针，它是某种数组，您不能将指针分配给数组。

现在，我们来解决第二个问题：在头文件中为类声明一些成员变量：

class IntSet {
/* some stuff here */
private:
    const int MAXSIZE;
    int size;
    bool set[];
    const int SENTINEL;
};

然后在您的实现中，您会在顶部浮动以下代码：

int size;
const int MAXSIZE = 25000;
bool set[MAXSIZE];
const int SENTINEL = -1;

我不认为这会像您认为的那样。似乎您的意图是初始化这些变量，但事实并非如此。请记住，这些变量仅作为属于某个类的特定实例的成员变量存在，它们不是“独立的”。那么这里发生了什么？

好吧，这再次声明了所有这些变量，因此您拥有名为MAXSIZE,的变量size，它们在该翻译单元（即 .cpp 文件）中的任何位置都有效，set与类中的成员变量无关。SENTINEL

当然，这意味着具有这些名称的成员变量没有被初始化（好吧，除了set你分配一个指针，我们已经知道这是错误的）。这将导致您的代码表现出未定义的行为。毕竟，未初始化变量的值可以是任何值。

如果您的意图是初始化类成员，那么您应该删除该代码并在构造函数中初始化这些变量：

IntSet::IntSet(int a, int b, int c, int d, int e) 
    : size(a), MAXSIZE(25000), SENTINEL(-1) 
{
    /* whatever*/ 
}

请注意，顺便说一下，我是如何IntSet::在构造函数名称前面使用的？这称为范围解析运算符。请记住，没有调用构造函数IntSet。构造函数属于一个名为的类，IntSet在该类之外，它的正确名称是IntSet::IntSet。一个小例子可能会有所帮助：

class Test
{
    int Length;

public:
    /* notice how inside the class, you only need Test 
     * when providing a body for the constructor. This
     * makes sense. You know which class you inside of.
     */
    Test()
        : Length(0)
    {

    }

    Test(int len);
};

/* Now we are outside the class. We need to help 
 * the compiler out and tell it what class the
 * function belongs to.
 */
Test::Test(int len)
    : Length(len)
{
}

与您正在使用的名称有关的切线点。是什么a？为什么你用a初始化一个叫做的东西size？您应该选择有意义的变量名称来帮助记录代码，这样当您必须阅读它时，您的头脑就不会爆炸。

另一个切入点是，如果变量喜欢MAXSIZE并且SENTINEL将在类的所有实例之间共享，那么，为了将来参考，您可能应该考虑将它们设为static类成员。

最后，你的头文件中有这段代码

#include "IntSet.cpp"

几乎可以肯定，这是不正确的。你永远不应该这样做（可能有些人认为有例外，但在这一点上不要学习坏习惯。当你知道足以合法地偶然发现这一点时，你就会知道它是否是正确的做或不做）。

更糟糕的是您的实现文件包含：

#include "IntSet.h"

想想你在这里做什么：当编译器正在处理文件时，IntSet.h你告诉你也要处理文件IntSet.cpp。该文件IntSet.cpp告诉编译器处理该文件IntSet.h。它告诉编译器处理文件IntSet.cpp。等等等等。

一般来说，实现文件（.cpp）会包含头文件。头文件只会包含其他头文件。

还有一些其他问题，但您可能应该解决所有这些问题，然后，如果您仍然遇到问题，请发布一个新问题，我们可以从那里开始。

祝你好运！

score 1 · Accepted Answer

您需要::在定义成员函数之前输入类的名称。

  IntSet::IntSet(int a, int b, int c, int d, int e) {
//^^^^^^^^
//here

对其他构造函数、运算符和方法执行相同的操作。

c++ - 无法破译“错误：'int'之前的预期不合格ID”

2 回答 2

Related

Reference