Fatal编程技术网
  • cplusplus/
  • C++ 创建一个按升序对结构和整数进行排序的函数？

C++ 创建一个按升序对结构和整数进行排序的函数？

c++

C++ 创建一个按升序对结构和整数进行排序的函数？,c++,C++,我正在创建一个程序来计算学生的平均分数（已经完成了），但我还需要按升序（1,2,3,4,5,6）排序。唯一的问题是我把这些值存储在一个结构中，我需要一个函数将它们按升序排列。我还需要把它们放在一起，这样的格式应该像学生的名字——学生的分数 Austin 30 Tom 20 Emma 10

我正在创建一个程序来计算学生的平均分数（已经完成了），但我还需要按升序（1,2,3,4,5,6）排序。唯一的问题是我把这些值存储在一个结构中，我需要一个函数将它们按升序排列。我还需要把它们放在一起，这样的格式应该像学生的名字——学生的分数

                  Austin          30
                  Tom             20 
                  Emma            10
                  =============================
                  Average: 20
                  List: [10,20,30]
下面是我的程序

#include <iostream>
#include <array>
#include <algorithm>
#include <vector>

struct student
{
    int score;
    std::string name;
};

void sortarr(student &a);
void sortarr(student &a) {
    std::sort(a.begin(),a.end());
    
    for(int i{0}; i <= size; i++)
        std::cout <<"The sorted vector is: " << a.score << " ";
}

void average_score(std::vector <student> &arr,int size);
void average_score(std::vector <student> &arr, int size) {
    float average {0};
    
    for(int i{0}; i < size; i++) {
        average += arr[i].score;
    }
    
    std::cout << "The average is: " << average / size << std::endl;

}

int main() {
    
    int n;
    std::cout <<"Enter Size: ";
    std::cin >> n;
    std::vector<student> test_scores(n);

    int i = 0;
    
    student s;

        for (int i = 0; i < n; ++i) {
            std::cout << "Enter Student " << i+1 << " Name and Test Score: ";
            std::cin >> s.name >> s.score;
    
            test_scores[i] = s;
    
    }
    
    average_score(test_scores,3);
    
}

#包括
#包括
#包括
#包括
结构学生
{
智力得分；
std：：字符串名；
};
void sortarr（学生与a）；
void sortarr（学生与a）{
排序（a.begin（），a.end（））；
对于（int i{0}；i要按成员
得分
按升序对
向量
进行排序，可以编写：


std::ranges::sort(arr, std::less{}, &student::score);



std::sort(std::begin(arr), std::end(arr), 
          [](auto const & a, auto const & b) 
          {
              return a.score < b.score;
          });




如果不能使用c++20，可以编写：


std::ranges::sort(arr, std::less{}, &student::score);



std::sort(std::begin(arr), std::end(arr), 
          [](auto const & a, auto const & b) 
          {
              return a.score < b.score;
          });



std:：sort（std:：begin（arr），std:：end（arr），
[]（自动常数和a、自动常数和b）
{
返回a.score
要按成员
得分
按升序对
向量
排序，您可以编写：


std::ranges::sort(arr, std::less{}, &student::score);



std::sort(std::begin(arr), std::end(arr), 
          [](auto const & a, auto const & b) 
          {
              return a.score < b.score;
          });




如果不能使用c++20，可以编写：


std::ranges::sort(arr, std::less{}, &student::score);



std::sort(std::begin(arr), std::end(arr), 
          [](auto const & a, auto const & b) 
          {
              return a.score < b.score;
          });



std:：sort（std:：begin（arr），std:：end（arr），
[]（自动常数和a、自动常数和b）
{
返回a.score
您可以使用以下功能：


#include <iostream>
#include <string>
#include <algorithm>
#include <vector>




std::vector<std::pair<int, std::string>> m;

void fillMap();
void sortarr(std::vector<std::pair<int, std::string>> a);


void average_score(std::vector<std::pair<int, std::string>> arr);


int main() {

    fillMap();
    sortarr(m);
    average_score(m);
}

void sortarr(std::vector<std::pair<int, std::string>> a)
{
    std::sort(a.begin(), a.end());

    for (auto i : a)
        std::cout << i.first << " ";
}
void fillMap()
{
    unsigned lengthMap{}, score{};
    std::string name;
    std::cout << "Enter the length of your map: ";
    std::cin >> lengthMap;
    for (int i = 0; i < lengthMap; i++)
    {
        std::cout << "Enter the score: ";
        std::cin >> score;
        std::cout << "Enter the name: ";
        std::cin >> name;
        m.push_back(std::make_pair(score, name));
    }
}
void average_score(std::vector<std::pair<int, std::string>> arr) {
    float average{ 0 };

    for (auto i:arr) {
        average += i.first;
    }

    std::cout << "The average is: " << average / m.size() << '\n';

}



#包括
#包括
#包括
#包括
std：：向量m；
void fillMap（）；
void-sortarr（标准：：向量a）；
无效平均分（标准：：向量arr）；
int main（）{
fillMap（）；
索塔尔（m）；
平均分（m）；
}
void-sortarr（标准：：向量a）
{
排序（a.begin（），a.end（））；
用于（自动i:a）
std：：cout评分；
std:：cout>name；
m、 推回（标准：：配对（分数、名称））；
}
}
无效平均分（标准：：向量arr）{
浮动平均值{0}；
用于（自动i:arr）{
平均值+=第一；
}
std：：cout您可以使用：


#include <iostream>
#include <string>
#include <algorithm>
#include <vector>




std::vector<std::pair<int, std::string>> m;

void fillMap();
void sortarr(std::vector<std::pair<int, std::string>> a);


void average_score(std::vector<std::pair<int, std::string>> arr);


int main() {

    fillMap();
    sortarr(m);
    average_score(m);
}

void sortarr(std::vector<std::pair<int, std::string>> a)
{
    std::sort(a.begin(), a.end());

    for (auto i : a)
        std::cout << i.first << " ";
}
void fillMap()
{
    unsigned lengthMap{}, score{};
    std::string name;
    std::cout << "Enter the length of your map: ";
    std::cin >> lengthMap;
    for (int i = 0; i < lengthMap; i++)
    {
        std::cout << "Enter the score: ";
        std::cin >> score;
        std::cout << "Enter the name: ";
        std::cin >> name;
        m.push_back(std::make_pair(score, name));
    }
}
void average_score(std::vector<std::pair<int, std::string>> arr) {
    float average{ 0 };

    for (auto i:arr) {
        average += i.first;
    }

    std::cout << "The average is: " << average / m.size() << '\n';

}



#包括
#包括
#包括
#包括
std：：向量m；
void fillMap（）；
void-sortarr（标准：：向量a）；
无效平均分（标准：：向量arr）；
int main（）{
fillMap（）；
索塔尔（m）；
平均分（m）；
}
void-sortarr（标准：：向量a）
{
排序（a.begin（），a.end（））；
用于（自动i:a）
std：：cout评分；
std:：cout>name；
m、 推回（标准：：配对（分数、名称））；
}
}
无效平均分（标准：：向量arr）{
浮动平均值{0}；
用于（自动i:arr）{
平均值+=第一；
}

std:：cout您可以编写一个函数来比较（排序）两个结构并返回
bool
结果：


typedef std::pair<int, std::string> Item; // Makes typing and reading easier.
bool Compare_By_Score(const Item& a, const Item& b)
{
  return a.first < b.first;
}



typedef std:：pair Item；//使键入和读取更容易。
按分数进行布尔比较（常数项和a、常数项和b）
{
返回a.first

要对向量进行排序，请执行以下操作：


std::vector<Item> database;
std::sort(database.begin(), database.end(), Compare_By_Score);



std:：向量数据库；
排序（database.begin（），database.end（），按分数比较）；



要更改
数据库的排序，请编写并提供不同的排序函数。
您可以编写一个函数，比较（排序）两个结构并返回
bool
结果：


typedef std::pair<int, std::string> Item; // Makes typing and reading easier.
bool Compare_By_Score(const Item& a, const Item& b)
{
  return a.first < b.first;
}



typedef std:：pair Item；//使键入和读取更容易。
按分数进行布尔比较（常数项和a、常数项和b）
{
返回a.first

要对向量进行排序，请执行以下操作：


std::vector<Item> database;
std::sort(database.begin(), database.end(), Compare_By_Score);



std:：向量数据库；
排序（database.begin（），database.end（），按分数比较）；



若要更改
数据库的排序，请编写并提供不同的排序函数。
如果您有可用的代码，最好在上问这个问题。您的
sortarr
函数以几种方式被破坏。它通过引用使用单个
student
，而不是它们的集合。
student
结构没有“没有
begin
或
end
方法，尽管一旦您修复了签名，这将是不相关的。for循环使用未声明、未初始化的变量
size
，然后在主体中，它实际上并不以任何方式依赖于索引变量
i
。此外，
average\u score
函数确实如此不需要使用
size
参数，事实上也不应该这样做，因为只有
size
的值与
arr.size（）的值不匹配时，才会产生错误的可能性
。如果你有可用的代码，你最好在问这个问题。你的
sortarr
函数有几个方面被破坏了。它只引用一个
student
，而不是它们的集合。
student
结构没有
begin
或
end
方法，尽管一旦你使用了这些方法，它们就无关紧要了修复了签名。for循环使用未声明、未初始化的变量
size
，然后在主体中它实际上不以任何方式依赖于索引变量
i
。此外，您的
average_score
函数不需要使用
size
参数，实际上可能不应该，因为它只创建如果
size
的值与
arr.size（）
fillMap
和
lengthMap
的值不匹配，则可能出现错误，因为
m
不是任何类型的贴图。不完全是，它类似于场景后面的贴图，但使用它（带向量）让我使用sort:DIt就像一个地图，但它不是一个地图。如果你想，你可以一直写一个
std:：map
，这实际上是一个从名字到分数的地图。然而，我认为这是一个糟糕的方法。我不知道asker项目的全部范围，但像这样的学生数据是ob的自然候选数据面向对象的方法，将相关数据绑定到结构中以提高可读性。ETA：虽然是的，但键入字符串的
map
仍然不会按分数排序。关于命名和OO设计的诚实性的要点仍然存在。我更喜欢使用STL而不是在这里使用struct，因为他使用的是排序。对于可读性，它是si在顶部提及的示例