Правильный синтаксис для доступа к элементам массива в структурах?

Во-первых, «ссылочный массив» — это удивительный способ описания testScores. Элемент данных testScores в вашем struct имеет тип «указатель на int» и предположительно указывает на первый элемент массива, который вы выделили с помощью выражения new.

Во-вторых, вы получаете доступ к элементам этого массива, выполняя

newStudent.testScores[i] = tempScore;
// which is equivalent to ...
*(newStudent.testScores + i) = tempScore;

Вы также можете написать

std::cin >> newStudent.testScores[i];

... обходя необходимость в дополнительной локальной переменной tempScore.

Дальнейшие примечания

• Почему программистам на C++ следует свести к минимуму использование слова «новое»? (здесь было бы проще использовать std::vector)
• В чем проблема с «использованием пространства имен std;»? (предпочитаю std::cin)

Есть несколько вещей, которые вы должны знать, имея дело с прямым управлением памятью (с использованием new и delete) в C++.

Правило 3/5/0

Во-первых, это Правило Трех/Пяти/Нуля. По сути, если у вас new память, вы также delete должны ее использовать, и вы должны правильно с ней обращаться, когда ваш класс копируется/перемещается.

struct Student
{
    int * scores;  // This is a pointer (to an array)
    int   nscores;  // Number of elements used in that array

    Student();  // Constructor
    ~Student();  // Destructor
    Student( const Student & student );  // Copy constructor
    Student( Student && student );  // Move constructor
    Student & operator = ( const Student & student );  // Copy Assignment operator
    Student & operator = ( Student && student );  // Move Assignment operator
};

Student::Student()
{
    scores = new int[ NUM_TESTS ];  // allocate NUM_TESTS elements
    nscores = 0;
    ...
}

Student::~Student()
{
    delete [] scores;  // clean up!
}

Student::Student( const Student & student )
{
    // same as before, but COPY the data!
    scores = new int[ NUM_TESTS ];  // allocate NUM_TESTS elements
    for (int n = 0; n < student.nscores; n++)
        scores[n] = student.nscores[n];
    nscores = student.nscores;
}

Student::Student( Student && student )
{
    // MOVE the data instead!
    scores = student.scores;
    student.scores = nullptr;
    nscores = student.nscores;
    student.nscores = 0;
}

Student & operator = ( const Student & student )
{
    // And again, except that we already have an array of
    // test scores allocated so we only need to copy them
    for (int n = 0; n < student.nscores; n++)
        scores[n] = student.nscores[n];
    nscores = student.nscores;
    ...
    return *this;
}

Student & operator = ( Student && student )
{
    // and again, MOVE the data!
    nscores = student.nscores;
    student.nscores = nullptr;
    nscores = student.nscores;
    student.nscores = 0;
    return *this;
}

Тип массива/указателя и доступы

Обратите внимание, что тип указателя на массив — это просто указатель:

  int * scores;

И что мы получаем доступ к элементам массива обычным способом:

  scores[2] = 12;

Используй это

Следите за тем, чтобы пользователь (или любая другая часть программы) не вырос nscores до > NUM_TESTS.

cout << "How many tests did this student take: ";
cin >> numTests;

if (numTests > NUM_TESTS)
{
    cerr << "too many! ack!\n";
    return 1;
}

//iterate numTests amount of times through dynamic array
for (int i = 0; i < numTests; ++i)
{
    cout <<"Enter score #" << i + 1 << ": ";
    cin >> tempScore;
    newStudent.scores[i] = tempScore;
}

Массивы фиксированной длины

Если вы знаете, что ваш массив всегда имеет фиксированную длину (как в вашем примере), вам фактически не нужно его динамически выделять.

struct Student
{
    int scores[ NUM_TESTS ];
    int nscores;
};

Однако вам все равно необходимо правильно инициализировать nscores в своем конструкторе и позаботиться о том, чтобы не выйти за пределы конца массива.

Очевидно, что ваше задание составлено не так, но в любом случае это полезно знать.

Массив переменного размера

Я предполагаю, что в какой-то момент вам будет поручено увеличить массив, если это необходимо. Для этого требуется еще одно значение члена:

struct Student
{
    int * scores;             // array of test scores
    int   nscores;            // number of elements used in scores[]
    int   nscores_available;  // size of scores[] array
};

Это немного усложнит ситуацию, но позволит вам делать такие вещи, как создание заполнения большего массива, если текущий слишком мал.

Другими словами, вы заменяете глобальную константу NUM_TESTS на значение локального члена nscores_available, которое можно изменить и которое может отличаться в разных Student.

Впрочем, это на потом.