如何用std::sort排序固定大小char[16]数组？编译报错求助

你的代码编译失败的核心原因是：数组类型（比如char[16]）不支持直接赋值操作，而std::sort要求迭代器指向的元素必须满足可移动赋值（MoveAssignable）的要求——当std::sort尝试交换数组元素时，会触发数组赋值的编译错误。

由于你无法修改t_name的类型，这里提供几个可行的解决思路：

方法一：通过指针数组间接排序 #

先创建指向每个数组元素的指针数组，排序这个指针数组后，再根据指针的顺序重新排列原数组内容：

#include <iostream>
#include <algorithm>
#include <cstring>

typedef char t_name[16];

// 比较函数接收指针，间接比较数组内容
bool compareNames(const t_name* name1, const t_name* name2) {
    return strcmp(*name1, *name2) < 0;
}

int main() {
    t_name names[] = {
        "bruno",
        "karl",
        "adrian",
        "yanick"
    };
    const int numNames = sizeof(names) / sizeof(names[0]);

    // 创建指针数组，指向原数组的每个元素
    t_name* namePtrs[numNames];
    for (int i = 0; i < numNames; ++i) {
        namePtrs[i] = &names[i];
    }

    // 排序指针数组
    std::sort(namePtrs, namePtrs + numNames, compareNames);

    // 临时数组保存原数据，再根据排序后的指针重写原数组
    t_name temp[numNames];
    memcpy(temp, names, sizeof(temp));
    for (int i = 0; i < numNames; ++i) {
        memcpy(names[i], *namePtrs[i], sizeof(t_name));
    }

    // 输出结果
    for (const auto& name : names) {
        std::cout << name << '\n';
    }

    return 0;
}

方法二：手动实现排序算法（直接操作数组） #

既然std::sort无法直接处理数组，我们可以自己实现简单的排序逻辑（比如冒泡排序），在交换元素时用memcpy完成数组内容的复制：

#include <iostream>
#include <cstring>

typedef char t_name[16];

bool compareNames(const t_name& name1, const t_name& name2) {
    return strcmp(name1, name2) < 0;
}

void sortFixedArrays(t_name* arr, int count) {
    for (int i = 0; i < count - 1; ++i) {
        for (int j = 0; j < count - i - 1; ++j) {
            if (!compareNames(arr[j], arr[j+1])) {
                // 用memcpy交换两个数组的内容
                t_name temp;
                memcpy(temp, arr[j], sizeof(t_name));
                memcpy(arr[j], arr[j+1], sizeof(t_name));
                memcpy(arr[j+1], temp, sizeof(t_name));
            }
        }
    }
}

int main() {
    t_name names[] = {
        "bruno",
        "karl",
        "adrian",
        "yanick"
    };
    const int numNames = sizeof(names) / sizeof(names[0]);

    sortFixedArrays(names, numNames);

    for (const auto& name : names) {
        std::cout << name << '\n';
    }

    return 0;
}

方法三：用std::reference_wrapper配合临时容器（C++11及以上） #

通过std::reference_wrapper把数组元素包装成可赋值的引用对象，排序这个包装后的容器后，再同步原数组的顺序：

#include <iostream>
#include <algorithm>
#include <cstring>
#include <functional>
#include <vector>

typedef char t_name[16];

bool compareNames(const t_name& name1, const t_name& name2) {
    return strcmp(name1, name2) < 0;
}

int main() {
    t_name names[] = {
        "bruno",
        "karl",
        "adrian",
        "yanick"
    };
    const int numNames = sizeof(names) / sizeof(names[0]);

    // 用vector存储数组的引用包装
    std::vector<std::reference_wrapper<t_name>> nameRefs;
    for (auto& name : names) {
        nameRefs.emplace_back(name);
    }

    // 排序引用包装的vector
    std::sort(nameRefs.begin(), nameRefs.end(), [](const auto& a, const auto& b) {
        return compareNames(a.get(), b.get());
    });

    // 临时数组保存排序后的内容，再复制回原数组
    t_name temp[numNames];
    for (int i = 0; i < numNames; ++i) {
        memcpy(temp[i], nameRefs[i].get(), sizeof(t_name));
    }
    memcpy(names, temp, sizeof(names));

    for (const auto& name : names) {
        std::cout << name << '\n';
    }

    return 0;
}

内容的提问来源于stack exchange，提问作者Kevin Meier