C++ 结构成员是否可以另存为变量？

我有一个switch语句，它基于用户的输入，将基于数组[I].name或按数组[I]排序。标记

开关（输入）{
案例1：
对于（int i=1；iwhile（j>=0&&tolower（choice.name[0]）=0&&choice.mark不需要复制排序算法，您可以只复制一次，然后将输入比较放入排序算法中。类似于您尝试做的事情是确定正确的比较器，并将其传递给常规排序函数。如果没有任何需要，您可以恕我直言，我只想使用
std:：sort
来：

#include <iostream>
#include <array>
class foo {
public:
    int mark;
    std::string name;
};
int main() {
    std::array<foo, 100> Array;
    // initialize Array here
    int input;
    std::cin >> input;
    if (input == 1) {
        std::sort(Array.begin(), Array.end(), [](foo& a, foo& b) {
            return a.mark > b.mark;
        });
    }
    else if (input == 2) {
        std::sort(Array.begin(), Array.end(), std::less<int>());
    }
    else
        std::cout << "Invalid input of " << input << ", did not sort." << std::endl;
}

#包括
#包括
福班{
公众：
整数标记；
std：：字符串名；
};
int main（）{
std：：数组；
//在这里初始化数组
int输入；
std:：cin>>输入；
如果（输入=1）{
排序（Array.begin（），Array.end（），[]）（foo&a，foo&b）{
返回a.mark>b.mark；
});
}
else if（输入=2）{
std:：sort（Array.begin（）、Array.end（）、std:：less（））；
}
其他的
STD::CUT
如果这些字段有相同的类型，那么简单。注意，C++中的专有项是成员变量，不是字段。可以使用指针指向成员。
struct structure_name {
    std::string name;
    std::string mark;
};

int main()
{
    structure_name S  = { "name", "test"};

    // p now points at name field
    // p can point at any std::string in structure_name 
    std::string structure_name::* p  = &structure_name::name;

    // p is dereferenced using  object S.
    std::cout << (S.*p) << std::endl;
}

struct结构\u名称{
std：：字符串名；
字符串标记；
};
int main（）
{
结构_name S={“name”，“test”}；
//p现在指向name字段
//p可以指向结构名称中的任何std:：字符串
std:：string structure_name:：*p=&structure_name:：name；
//p使用对象S取消引用。
std：：cout我认为您可以使用不同的比较器函数作为“选项”。并为排序函数提供所需的比较器，无论您使用的是
std：：sort
还是自定义手工制作的

考虑以下
struct
（您忘记指定）：

您可以将“选项”定义为比较器函数：

int mark_cmp(const MyStruct & lhs, const MyStruct & rhs)
{
    return lhs.mark < rhs.mark; // Compare by mark
}
int name_cmp(const MyStruct & lhs, const MyStruct & rhs)
{
    return lhs.name.compare(rhs.name); // Compare by name
}

注意：您不必在
开关中的最后一条语句之后
中断
（在您的情况下，在
默认
之后，无需
中断
）

注2:我使用了一个原始数组，以便与您所做的一样更接近，但我建议您使用
std:：array
。如果您需要动态容器，则使用
std:：vector


如果您不能使用
std:：sort
，您可以创建自己的排序函数，该函数将比较器函数作为参数，它也可以工作。
我认为您可以这样做：

auto f1 = [](fix_type name1, fix_type name2) {
 return tolower(choice.name[0]) <= tolower(Array[j].name[0]);
}

auto f2 = [](fix_type name1, fix_type name2) {
 return choice.mark <= Array[j].mark;
}

std::function<bool(fix_type, fix_type)> f;

if(input == 1){
  f = f1;
}else if(input == 2){
  f = f2;
}

auto f1=[]（固定类型名称1，固定类型名称2）{
返回tolower（选项名称[0]）谢谢，我应该并将补充说，我必须使用我编写的排序算法。@Choski然后使用指向成员的指针，也许还可以将其转换为模板。一般来说，这种方法是合法的，可以使用lambdas代替，但在某些情况下，它是一个次要的选项，使用一个单独的函数进行比较。这很容易阅读代码与速度问题相比。@Swift FridayPie是的，但OP似乎有明确的“选项”.我认为分离函数更好地说明了这一点。由于这里的代码只是为了说明策略、想法，我选择了更清晰的解决方案。但事实上，使用lambdas也很好。OP完全可以自由地调整此代码示例。此外，这只是一个调用，因此u的速度确实没有问题使用lambda或显式函数：）回答得很好，但是
name
和
mark
不太可能是同一类型。name
和
mark
是同一类型吗？如果是，则use name是字符串，mark是int。
int main()
{
    unsigned int input = 1;

    MyStruct arr[5] {{"foo", 5}, {"bar", 6}, {"baz", -9}, {"foobar", 0}, {"foobaz", -3}};

    switch(input)
    {
        case 1: std::sort(arr, arr+5, &name_cmp); // input == 1 ? sort by name
            break;
        case 2: std::sort(arr, arr+5, &mark_cmp); // input == 2 ? sort by mark
            break;
        default:;
    }

    return 0;
}

auto f1 = [](fix_type name1, fix_type name2) {
 return tolower(choice.name[0]) <= tolower(Array[j].name[0]);
}

auto f2 = [](fix_type name1, fix_type name2) {
 return choice.mark <= Array[j].mark;
}

std::function<bool(fix_type, fix_type)> f;

if(input == 1){
  f = f1;
}else if(input == 2){
  f = f2;
}