0

我真的很想解决这个问题。

如果有人能把我推向正确的方向。我将不胜感激

以下是我的代码

分级机.h

#ifndef GRADER_H
#define GRADER_H
#define MAXSIZE 100
#include <iostream>
#include <cstdlib>

class Grader {

public:
Grader( );

void addScore( int score );
void addScores( int scores[], int size );
void clear(); 


int findBiggest( ) const;
int findSmallest( ) const;

private:
int my_Values[ MAXSIZE ];
int my_ValuesSeenSoFar;

};
#endif

分级机.cpp

#include <iostream>
#define MAXSIZE 100
#include "Grader.h"

Grader::Grader( ){
my_Values [MAXSIZE] = 0;
my_ValuesSeenSoFar = 0;
}

void Grader::addScore( int score ){
    my_Values[MAXSIZE] = score;
}
void Grader::addScores( int scores[], int size ){
    my_Values[MAXSIZE] = scores[size];
}
void Grader::clear(){
    my_Values[0];
}

int Grader::findBiggest() const{
    int i;
    for (i = 0; i < MAXSIZE; i++)
    return my_Values[i];
}
int Grader::findSmallest( ) const{
}

驱动程序.cpp

#include <iostream>
#include "Grader.h"
using namespace std;
int main( )
{
Grader g;
double d[5]= {99,70,85,93,84};
double e[4]= {100,81,60,91};

g.addScore( 75 );
g.addScore( 82);
g.addScores( d, 5 ); 

cout << "Best Score = " << g.findBiggest( ) << endl;
/// should give value 99
cout << "Worst Score = " << g.findSmallest( ) << endl;
/// should give value 70
g.clear( );

g.addScore( 50 );
g.addScore( 74 );
g.addScores( e, 4 ); 

cout << "Best Score = " << g.findBiggest( ) << endl;
/// should give value 100
cout << "Worst Score = " << g.findSmallest( ) << endl;
/// should give value 50 
}

我无法弄清楚 a) 如何准确地实现 addScore/addScores

b) 如何将这些分数称为 findBiggest 和 findSmallest。

4

7 回答 7

1

您的代码有很多问题：

  • 就像我在评论中提到的那样，my_Values [MAXSIZE] = 0;在构造函数中写入一个超出数组最大索引的值。
  • 你也可以在其他地方这样做。您不能MAXSIZE用作索引，因为索引从0到MAXSIZE - 1。
  • 您不能像在addScores.

使用标准库提供的工具（请参阅此处以获取良好的参考站点）将在现在和将来真正为您提供帮助。

将来，每当您考虑任何类型的动态数组时，您都应该考虑std::vector.

例如，将值添加到向量就像

std::vector<int> vector;

vector.push_back(123);

要插入一个旧式数组，就像你想在你的addScores函数中做的那样，你可以使用std::copywith std::back_inserter：

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

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

std::sort(std::begin(vector), std::end(vector));
于 2013-07-29T09:27:50.967 回答
0

作为参考，这是一个完整的实现：

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

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

于 2013-07-29T09:58:19.420 回答
0

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

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

于 2013-07-29T09:32:05.567 回答
0

这是问题所在：

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

你总是在你的 MAXSIZE 元素上添加（这是不明智的）。您需要执行以下操作：

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

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

此外，您的代码存在大量问题（只需查看::clear()）。我推荐这篇关于使用数组的文章，或者试试std::vector

于 2013-07-29T09:26:10.137 回答
0

要回答您的确切问题，您可以使用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
于 2013-07-29T09:50:24.417 回答
0

我觉得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;
}
于 2013-07-29T09:37:29.960 回答
0

您需要一个变量来显示 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;

}

如果我的问题正确，类似的事情。

于 2013-07-29T09:40:50.633 回答