The error you get is because you named a local variable the same as the function's argument.
double readScores(double scoreArray /* parameter named scoreArray */)
{
double scoreArray[maxStudents]; // this cannot have the same name!
The code you've shown reveals a lot of confusion. I'll try to explain the mistakes in it.
cout<<scoreArray[1],scoreArray[2];
This will not output the elements 1 and 2. To do that, it should be cout << scoreArray[1] << scoreArray[2];. Also, note that arrays in C++ are 0-based, so the first element will be scoreArray[0], the second scoreArray[1], the third scoreArray[2], and so on.
The code declares a function named readScores taking a pointer to double and returning a double:
double readScores(double[]);
But it only defines a function taking a double:
double readScores(double scoreArray)
I'm sure that's not what was intended, and once the compiler error is fixed, it will produce a linker error because there's no definition for the double readScores(double[]) function.
Now, the arrays.
When you write a parameter as double x[], it's not an array. It's a pointer to a double. It's exactly the same as double* x. Yes, the syntax is highly misleading. That's why you shouldn't use it. It sows confusion. It's better to be explicit and call a pointer a pointer.
You cannot directly return arrays in C++ and you cannot directly pass array arguments in C++. You can pass references to arrays and return references to arrays, but here it seems you have instructions to use pointers, so I won't go there.
The code doesn't seem to be making use of the value returned from readScores, so it's probably better to just use a void return type. The code writes the values directly into the array anyway.
void readScores(double* scorePtr)
The syntax *(scorePTR+count) is exactly the same as scorePTR[count], so there's no gain in using it. And the code is iterating with an index (count) anyway.
I suppose what the assignment meant with that restriction was something actually useful, even if only marginally: iterate using a pointer, not an index. In order to do that, you need to find three things: how to start the loop, how to move to the next element and how to end the loop.
How to start the loop? You should start with a pointer to the first element. Luckily, such a pointer is exactly what gets passed as an argument to the function.
for(double* ptr = scorePtr; /* ... */; /* ... */)
How to move to the next element? If you increment the pointer, it moves to the next element.
for(double* ptr = scorePtr; /* ... */; ++ptr)
How to end the loop? The loop ends when the pointer has passed over the entire array. The array has maxStudents elements, so the loop ends when the pointer is maxStudents elements away from the start:
double* end = scorePtr + maxStudents;
for(double* ptr = scorePtr; ptr != end; ++ptr)
And how do you use this pointer in the loop? As normal, with the dereferencing operator.
for(double* ptr = scorePtr; ptr != end; ++ptr)
{
cout<<"Please enter score for student "<< /* (1) */ <<" or -999 to end.\n";
cin>>*ptr;
if(*ptr == -999)
break;
}
// (1) left as an exercise for the reader