Array Classes - Get Largest and Smallest Value

You have many problems with your code:

• Like I mentioned in a comment, my_Values [MAXSIZE] = 0; in the constructor writes one beyond the max index of the array.
• You also do this in other places. You can't use MAXSIZE as index, since index goes from 0 to MAXSIZE - 1.
• You can't add an array to another array like you do in addScores.

Using the facilities provided by the standard library (see here for a good reference site) will really help you now and in the future.

In the future, whenever you think about a dynamic array of any kind, you should be thinking about std::vector.

For example, adding a value to a vector is as simple as

std::vector<int> vector;

vector.push_back(123);

To insert an old-style array, like you want to do in your addScores function, you can use std::copy together with std::back_inserter:

std::copy(array, array + size, std::back_inserter(vector));

To keep the vector sorted, use the std::sort standard function:

std::sort(std::begin(vector), std::end(vector));

Here's the problem:

void Grader::addScore( int score ){
    my_Values[MAXSIZE] = score; <---
}

You're always adding on your MAXSIZE-th element (which isn't wise). You need to do something like:

void Grader::addScore( int score ){
    my_Values[myValuesSoFar++] = score;
}

As for biggest and smallest, you could use qsort on addScore() and addScores(). This way your smallest element will be on my_values[0] and the biggest on my_values[myValuesSoFar-1].

Also, there are a tons of problems with your code (just take a look at ::clear()). I recommend this article on working with arrays, or try std::vector

You need a variable that show how many elements are in my_Values. Suppose

    private:
    int my_Values[ MAXSIZE ];
    int my_ValuesSeenSoFar;
    int my_size;

Grader::Grader( ){
my_Values [MAXSIZE] = 0; //here you put 0 out of array (to array.size+1 place). delete it

my_ValuesSeenSoFar = 0;
my_size = 0; 
}

void Grader::addScore( int score ){
if (my_size < MAXSIZE )
   my_Values[my_size] = score;  //put new element on next place
   ++my_size;
else
   std::cout<<"No more place in array";
}    
void Grader::addScores( int scores[], int size ){
int i =0;
while (my_size < MAXSIZE && i<size)
{
    my_Values[my_size] = scores[i];
    ++my_size;
     ++i;
}
if (my_size == MAXSIZE && i==size)
    std::cout<<"no more place in array";
}

int Grader::findBiggest() const{
    int i;
    int max=my_Values[0];
    for (i = 0; i < my_size; i++)  //finding max element in array
    {
       if(my_Values[i]>max) 
          max = my_Values[i];
    }    
    return max;
}
int Grader::findSmallest( ) const{
    int i;
    int min=my_Values[0];
    for (i = 0; i < my_size; i++)  //finding min element in array
    {
       if(my_Values[i]<min) 
          min = my_Values[i];
    }    
    return min;

}

Something like that if i got question right.

a/ How about having an instance variable which indicates the current index of the array. increment it by n when you add n element, decrement it by n when you remove n elements.

b/ Two options:
i. Each time this is called, iterate through all elements and get the min/max. OK if max array size not too big.
ii. Each time a value is added or removed, iterate over all elements and set global variables min/max which you can then return on calls to findSmallest() and findBiggest()

To answer your exact question, you can use std::minmax_element (in C++11) to get the largest and smallest value of an array:

#include <algorithm>
#include <iostream>

int main()
{
    double d[] = { 99, 70, 85, 93, 84 };

    auto result = std::minmax_element( std::begin( d ), std::end( d ) );
    std::cout << "minimum: " << *(result.first) << "\n"
              << "maximum: " << *(result.second) << "\n";
}

This prints:

minimum: 70
maximum: 99

For reference, here's a complete implementation:

#include <vector>
#include <iterator>
#include <algorithm>

class Grader {
  std::vector<int> scores_;

public:
  void addScore(int score) {
    scores_.push_back(score);
  }

  void addScores(int *scores, int nscores) {
    std::copy(scores, scores + nscores,
              std::back_inserter(scores_));
  }

  void clear() { scores_.clear(); }

  int findBiggest() const {
    if (scores_.empty()) return -1; // handle this error somehow
    return *std::max_element(scores_.begin(),
                             scores_.end());
  }

  int findSmallest() const {
    if (scores_.empty()) return -1; // handle this error somehow
    return *std::min_element(scores_.begin(),
                             scores_.end());
  }
};

Note that I didn't sort the scores in findBiggest or findBiggest, since they're declared const.