Не могу понять, как заставить g ++ принять мой код

TL; DR - http://ideone.com/rTVQUo

---

Первая и главная проблема заключается в следующем:

string snames[] = "";

Это объявление массива строк, содержащих только один элемент. Это сделает следующий код неопределенным поведением, если snumClasses больше 1:

for (i = 0; i < snumClasses; i++) {
    cin >> snames[i];
}

Вышеприведенный код вызовет неопределенное поведение, потому что вы будете получать доступ к адресам без привязки, если i вырасту больше одного. После того, как Undefined Behavior поражает вашу программу, вы не можете понять, какое поведение происходит из-за этого. Ваша программа может сломаться, ваш компьютер может закрыть или еще хуже - носовые демоны.

Чтобы исправить это, размер snames должен быть размером, указанным пользователем. В частности, snames должен быть указателем на динамически выделенный массив, размер которого - snumClasses:

std::string* snames;
std::cin >> snumClasses;

snames = new std::string[snumClasses];

^{Примечание. Я объясню позже, почему это не должно быть сделано.}

И когда данные будут закончены, сделайте это точкой для delete[] it:

delete[] snames;

---

Следующая проблема исходит из этой строки:

s1.InputData(sname, snumClasses, snames[i]);
//                               ^^^^^^^^^

Объект Student состоит из трех членов данных, имени класса, количества классов и массива классов. Функция-член InputData используется для назначения этих данных членам аргументов. Вы указали правильные аргументы для первых двух параметров (потому что string может быть назначена для string а int может быть назначена int), но ваш третий аргумент не соответствует типу элемента данных. Было бы разумно, если бы вы отправляли snames массивов вместо элемента внутри него, который вы сделали, сделав snames[i].

s1.InputData(sname, snumClasses, snames);
//                               ^^^^^^

Это также требует, чтобы InputData берет string* а не string& и что указатель classList просто присваивается новому массиву snames:

void Student::InputData(string nm, int nClasses, string* names)
{
    name = nm;
    numClasses = nClasses;

    delete[] classList;
    classList = names;                                                         /*
    ^^^^^^^^^^^^^^^^^^                                                         */
}

---

Теперь, когда я уменьшил основную массу ваших ошибок, переходим к улучшению вашей программы.

Я начну с основных очевидных проблем и отклоняюсь от более мелких (но важных) проблем дизайна.

Копировальный конструктор:

Student::Student(Student& obj)
{
    obj.name       = name;
    obj.numClasses = numClasses;
    obj.classList  = classList;
}

Этот конструктор не только работает скорее как оператор присваивания, но и переключает назначение членов. Предположим, вы должны назначить данные *this объекта копируемому объекту, а не наоборот. Кроме того, ваш экземпляр-конструктор должен ссылаться на const:

Student::Student(const Student& obj)
{
    name       = obj.name;
    numClasses = obj.numClasses;
    classList  = obj.classList;
}

Обратите внимание, что необходимо выполнить глубокую копию с учетом зависимостей времени жизни между *this и объектом, который копируется.

Student::Student(const Student& obj)
{
    name       = obj.name;
    numClasses = obj.numClasses;
    std::copy(obj.classList, obj.classList + numClasses, classList);
}

Еще одна ошибка, связанная с этим конструктором, заключается в том, что вместо инициализации используется назначение. Элементы данных вашего класса должны быть инициализированы с использованием списка инициаторов-членов:

Student::Student(const Student& obj)
    : name(obj.name),
      numClasses(obj.numClasses),
      classList(numClasses ? new std::string[numClasses]{} : nullptr)
{
    std::copy(obj.classList, obj.classList + numClasses, classList);
}

Оператор присваивания:

Student& operator=(const Student& rightSide)
{
    this->name       = rightSide.name;
    this->numClasses = rightSide.numClasses;
    this->classList  = rightSide.classList;
}

Этот оператор имеет ту же проблему, что и конструктор-копир, так как он рассматривает управление памятью. Если мы присваиваем *this rightSide, мы должны delete[] текущий объект classList и скопировать элементы из копируемого объекта. Если мы этого не сделаем, мы рискуем потерять память:

Student& operator=(const Student& rhs)
{
    name       = rhs.name;
    numClasses = rhs.numClasses;

    delete[] classList;  // delete classList
    classList = nullptr; // set to nullptr because if 'new' throws, we can still
                         // delete without causing undefined behavior

    classList = new std::string[numClasses]{};
    std::copy(rhs.classList, rhs.classList + numClasses, classList);

    return *this; // you forgot to return the object!
}

Это выглядит правильно, но его также можно улучшить. В его нынешнем виде этот код не обеспечивает надежную гарантию исключения. Если new броски, состояние *this будет отличаться от того, когда оно будет введено в оператор присваивания. Чтобы обойти это, мы можем применить идиому копирования и свопинга, чтобы обеспечить гарантию сильного исключения:

Student& operator=(Student rhs)
{
    swap(*this, rhs);
    return *this;
}

Параметр был изменен для принятия по значению, так что, когда передается lvalue, мы можем скопировать его и поменять его элементы данных. Функция swap инкапсулирует семантику подкачки. Он определяется внутри Student следующим образом:

friend void swap(Student& first, Student& second)
{
    using std::swap;
    swap(first.name, second.name);
    swap(first.numClasses, second.numClasses);
    swap(first.classList, second.classList);
}

Дополнительные сведения см. В разделе Что такое идиома копирования и свопинга?

---

Не используйте new:

Всякий раз, когда вы чувствуете, что используете new, рассмотрите альтернативы, приведенные в стандартной библиотеке. Они реализуют RAII и, как таковые, не требуют от пользователя освобождения памяти. Это очень выгодно, так как уменьшает потенциальную утечку памяти и сохраняет код чистым и эффективным. Мы можем использовать стандартный библиотечный контейнер std::vector<T> для списка классов и подставить его для string* classList данных string* classList:

private:
    std::string name;
    std::vector<std::string> classList;

Обратите внимание, как я также удалил numClasses данных numClasses. Нам это не нужно, поскольку вектор имеет функцию члена size(). Более того, поскольку нет необходимости в управлении памятью, мы можем реализовать правило Zero и не реализовывать по умолчанию-ctor, copy-ctor и destructor! Зачем? Поскольку компилятор будет генерировать эти функции-члены по умолчанию.

---

Используйте пользовательские вставки/экстракторы

Вы можете сократить много кода, указав свои собственные вставки/экстракторы. Вот реализация этих двух:

std::ostream& operator<<(std::ostream& os, const Student& s)
{
    s.OutputData(os);
    return os;
}

std::istream& operator>>(std::istream& is, Student& s)
{
    s.classList.assign(std::istream_iterator<std::string>{is >> s.name},
                       std::istream_iterator<std::string>{});

    return is;
}

И вот как вы можете использовать его в main():

int main()
{
    Student s1, s2;

    if (std::cin >> s1 >> s2)
         std::cout << s1 << s2;
}

---

Это должна быть структура вашего класса:

class Student
{
public:
    void InputData(std::string, const std::vector<std::string>&);
    void OutputData(std::ostream&) const;
    void ResetClasses();

    friend std::ostream& operator<<(std::ostream&, const Student&);
    friend std::istream& operator>>(std::istream&,       Student&);
private:
    std::string name;
    std::vector<std::string> numClasses;
};

И это реализация этих функций-членов:

void Student::InputData(std::string nm, const std::vector<std::string>& names)
{
    name = nm;
    numClasses = names;
}

void Student::OutputData(std::ostream& os) const
{
    os << "Students name: " << name << std::endl;
    os << "Number of classes: " << classList.size() << std::endl;
    os << "Classes: ";

    std::copy(classList.begin(), classList.end(),
        std::ostream_iterator<std::string>(os, "\n"));
}

void Student::ResetClasses()
{
    classList.clear();
}