矢量指向另一个矢量

我在这里有两个不同类型的数组,我正在转换为向量。
int ham_array[] = {32,71,12,45,26};

char word_array[] = {"cat", "bat", "green", "red", "taxi"};


vector < int > hamvector (ham_array, ham_array + 5);               

vector < char > wordvector(word_array, word_array + 5); 
我将调用一个sort函数来将ham_array的元素从最小到最大排序。与此同时,我希望word_array也可以使用引用以相同的方式对ham_vector进行排序。 例如, 在我调用sort(hamvector)之后
ham_array[] = {12, 26, 32, 45, 71}
和排序(wordvector)
word_array[] = {"green", "taxi", "cat", "red", "bat"};
是否有捷径可寻?     
已邀请:
好吧,有一件事,那将是
char *word_array[]
,你宣称它将是一个字符串的方式。 无论如何,这样做的方法是声明一个结构来保持这些东西配对:
struct t {string name; int number;};
vector<t> list;
// fill in list

// comparer to compare two such structs
bool comparer(t &a, t &b) { return a.number>=b.number; }

// and to sort the list
sort(list.begin(), list.end(), comparer);
    
如果简单,你的意思是更直接的方式,然后是。
std::sort()
也支持对原始数组进行排序:
sort(word_array, word_array + 5, wordcmp);
正如Blindy所示,你需要一个比较器函数来告诉你如何对你的单词列表进行排序。否则,您最终将按字符串所在的内存地址而不是字符串中的字母进行排序。这样的事情应该有效:
int wordcmp(const char *lhs, const char *rhs)
{
    return strncmp(lhs, rhs, 256) < 0;
}
另外需要注意的是,在实践中你会更喜欢
std::vector
而不是原始指针数组,因为后者不那么安全。     
我曾试图找到类似问题的解决方案,最终不得不手动排序。我想你可以这样做的另一种方法是编写一个分类器仿函数,它可以根据正在排序的字符串,与哪个整数相关联,并根据它进行排序。这非常低效,所以我强烈建议使用
std::swap
进行自己的手动排序。
#include <map>
#include <string>
#include <vector>
#include <algorithm>
#include <iostream>

template<typename KeyType, typename ValueType>
class CMappedSorter
{
    std::map<KeyType, ValueType>* const m_Mappings;
public:
    CMappedSorter(std::map<KeyType, ValueType>* Mappings) : m_Mappings(Mappings)
    {

    }

    bool operator()(KeyType& LHS, KeyType& RHS)
    {
        const ValueType LHSSortingValue = m_Mappings->find(LHS)->second;
        const ValueType RHSSortingValue = m_Mappings->find(RHS)->second;
        return (LHSSortingValue < RHSSortingValue);
    }
};

int main(int argc, char* argv[])
{
    std::vector<int> Integers;
    std::vector<std::string> Strings;

    Integers.push_back(3);
    Integers.push_back(1);
    Integers.push_back(2);

    Strings.push_back("Apple");
    Strings.push_back("Banana");
    Strings.push_back("Cherry");

    std::map<std::string, int> Mappings;

    if(Integers.size() == Strings.size())
    {
        const unsigned int ElementCount = Strings.size();

        // Generate mappings.
        auto StringsIterator = Strings.begin();
        auto IntegersIterator = Integers.begin();
        for(unsigned int i = 0; i < ElementCount; ++i)
        {
            Mappings[*(StringsIterator)] = *(IntegersIterator);
            ++StringsIterator;
            ++IntegersIterator;
        }

        // Print out before sorting.
        std::cout << "Before Sorting" << std::endl;
        std::cout << "InttString" << std::endl;
        StringsIterator = Strings.begin();
        IntegersIterator = Integers.begin();
        for(unsigned int i = 0; i < ElementCount; ++i)
        {
            std::cout << *(IntegersIterator) << 't' << *(StringsIterator) << std::endl;
            ++StringsIterator;
            ++IntegersIterator;
        }

        // Sort
        std::sort(Strings.begin(), Strings.end(), CMappedSorter<std::string, int>(&(Mappings)));
        std::sort(Integers.begin(), Integers.end());

        // Print out after sorting.
        std::cout << "After Sorting" << std::endl;
        std::cout << "InttString" << std::endl;
        StringsIterator = Strings.begin();
        IntegersIterator = Integers.begin();
        for(unsigned int i = 0; i < ElementCount; ++i)
        {
            std::cout << *(IntegersIterator) << 't' << *(StringsIterator) << std::endl;
            ++StringsIterator;
            ++IntegersIterator;
        }
    }
    else
    {
        std::cout << "Error: Number of elements in each container are not equivalent." << std::endl;
    }
}
    

要回复问题请先登录注册