Невозможно расшифровать «ошибка: ожидаемый неквалифицированный идентификатор до« int »

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 

Я убежище» t имел большой опыт работы с файлами заголовков, поэтому меня это не удивило бы, если бы я отформатировал что-то неправильно, но я смотрю на множество других образцов, предоставленных профессором, и нет ничего необычного в моем. Я подумал, что, возможно, это связано с порядком, указанным в файле .h, и что я не выполнял точный порядок в .cpp, но ничего не изменилось, когда у меня было все перечисленное в том же порядке.

Answer 1

Перед определением функции-члена вам необходимо указать имя класса и ::.

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

Сделайте то же самое с другими конструкторами, операторами и методами.

Answer 2

Существует много неправильного кода. Нам придется немного перепрыгнуть между заголовком и реализацией. Готов?

В вашем заголовке вы это делаете:

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

Прежде всего, название set плохой выбор: это имя класса в namespacestd ж, которые вы импортируете имея using namespace std в вашем файл заголовка. В лучшем случае это может сбить с толку.

Что еще более важно, синтаксис bool set[] не подходит в этом контексте. Даже если ваш компилятор разрешает это, это расширение. Кто знает, что он делает и как он будет вести себя на других компиляторах? Избегай это.

Если вы хотите объявить массив, объявите массив. Если вы хотите объявить указатель, объявите указатель. Просто запомните: массив не является указателем.

К сожалению, у вас нет, Becase позже в своем коде вы это сделать:

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, set и SENTINEL, которые действительны в любом в этой единице перевода (т.е. файл .cpp), независимо от переменных-членов в класс.

Это, конечно, означает, что переменные-члены с этими именами не инициализированы (ну, кроме 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) будут содержать файлы заголовков. Заголовочные файлы будут содержать только другие файлы заголовков.

Есть еще несколько вопросов, но вы, вероятно, должны исправить все эти вещи, а затем, если у вас все еще есть проблемы, отправьте новый вопрос, и мы можем идти оттуда.

Удачи вам!