数组类-获取最大值和最小值

您的代码有很多问题：

• 正如我在评论中提到的，构造函数中的my_Values [MAXSIZE] = 0;在数组的最大索引之外写入一个
• 你也可以在其他地方这样做。不能使用MAXSIZE作为索引，因为索引从0变为MAXSIZE - 1
• 不能像在addScores中那样将一个数组添加到另一个数组中

使用标准图书馆提供的设施（请参阅此处以获取良好的参考网站）将对您现在和将来都有很大帮助。

将来，无论何时考虑任何类型的动态数组，都应该考虑std::vector。

例如，向向量添加值就像一样简单

std::vector<int> vector;
vector.push_back(123);

要插入旧式数组，就像您想在addScores函数中插入的那样，您可以将std::copy与std::back_inserter:一起使用

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

要保持矢量排序，请使用std::sort标准函数：

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

我觉得grader.cpp应该是这样的。用于在不排序的情况下查找最大值和最小值

#include <iostream>
#define MAXSIZE 100
#include "Grader.h"
Grader::Grader( ){
my_Values [MAXSIZE] = 0;
my_ValuesSeenSoFar = 0;
}
void Grader::addScore( int score ){
if( my_ValuesSeenSoFar < MAX_SIZE)
    my_Values[my_ValuesSeenSoFar++] = score;
}
void Grader::addScores( int scores[], int size ){
    for(int i=0; (i < size) && (my_ValuesSeenSoFar < MAX_SIZE) ; i++)
        my_Values[my_ValuesSeenSoFar++] = scores[i];
}
void Grader::clear(){
    for(int i=0;  i < MAX_SIZE ; i++)
        my_Values[i] = 0;
}
int Grader::findBiggest() const{
   int max = my_Values[0];
   for(int i=1 i < my_ValuesSeenSoFar ; i++)
   {
        if( my_Values[i] > max)
            max = my_Values[i];
   }   
   return max;
}
int Grader::findSmallest( ) const{
    int min = my_Values[0];
    for(int i=1 i < my_ValuesSeenSoFar ; i++)
    {
        if( my_Values[i] < min )
            min = my_Values[i];
    } 
    return min;
}

问题是：

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

您总是在MAXSIZE上添加元素（这是不明智的）。你需要做一些类似的事情：

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

至于最大和最小，您可以在addScore()和addScores()上使用qsort。这样，最小的元素将在my_values[0]上，最大的元素在my_values[myValuesSoFar-1]上。

此外，您的代码还有很多问题（只需看看::clear()）。我推荐这篇关于使用数组的文章，或者尝试std::vector

您需要一个变量来显示my_Values中有多少元素。假设

    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;

}

如果我答对了问题的话，可以这样做。

a/不如有一个实例变量来指示数组的当前索引。添加n个元素时将其递增n，删除n个元素后将其递减n。

b/两个选项：
i.每次调用时，遍历所有元素并获得最小值/最大值。如果最大数组大小不太大，可以
ii。每次添加或删除值时，对所有元素进行迭代，并设置全局变量min/max，然后您可以在调用findSmallest（）和findBiggest（）时返回该变量。

要回答您的确切问题，您可以使用std::minmax_element（在C++11中）来获得数组的最大值和最小值：

#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";
}

此打印：

minimum: 70
maximum: 99

为了参考，这里有一个完整的实现：

#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());
  }
};

请注意，我没有对findBiggest或findBiggest中的分数进行排序，因为它们被声明为const。