C++ 向量指向另一个向量

我这里有两个不同类型的数组，我正在转换成向量

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); 

和排序（wordvector）

---

有没有一种简单的方法可以做到这一点？

首先，这就是

char*word\u数组[]

，您将其声明为字符串的方式

无论如何，实现这一点的方法是声明一个结构，以保持这些内容成对：

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);

struct{string name；int number；}；
向量表；
//填表
//比较程序，用于比较两个这样的结构
布尔比较器（t&a，t&b）{返回a.number>=b.number；}
//并对列表进行排序
排序（list.begin（）、list.end（）、比较器）；

首先，这将是

char*word\u数组[]

，您将其声明为字符串的方式

无论如何，实现这一点的方法是声明一个结构，以保持这些内容成对：

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);

struct{string name；int number；}；
向量表；
//填表
//比较程序，用于比较两个这样的结构
布尔比较器（t&a，t&b）{返回a.number>=b.number；}
//并对列表进行排序
排序（list.begin（）、list.end（）、比较器）；

如果说简单，你指的是更直接的方式，那么是的。

std:：sort（）

也支持对原始数组进行排序：

sort(word_array, word_array + 5, wordcmp);

正如Blindy所示，您需要一个比较器函数来告诉

sort

如何对您的单词列表进行排序。否则，最终将按字符串所在的内存地址排序，而不是按字符串中的字母排序。像这样的方法应该会奏效：

int wordcmp(const char *lhs, const char *rhs)
{
    return strncmp(lhs, rhs, 256) < 0;
}

int-wordcmp（常量字符*lhs，常量字符*rhs）
{
返回strncmp（左、右、256）<0；
}

---

另一个注意事项是，在实践中，您可能希望使用

std:：vector

而不仅仅是原始指针数组，因为后者并不那么安全。

如果简单，您的意思是更直接的方法，那么是的。

std:：sort（）

也支持对原始数组进行排序：

sort(word_array, word_array + 5, wordcmp);

正如Blindy所示，您需要一个比较器函数来告诉

sort

如何对您的单词列表进行排序。否则，最终将按字符串所在的内存地址排序，而不是按字符串中的字母排序。像这样的方法应该会奏效：

int wordcmp(const char *lhs, const char *rhs)
{
    return strncmp(lhs, rhs, 256) < 0;
}

int-wordcmp（常量字符*lhs，常量字符*rhs）
{
返回strncmp（左、右、256）<0；
}

---

另一个注意事项是，在实践中，您可能更喜欢

std:：vector

，而不仅仅是原始指针数组，因为后者并不那么安全。

我以前曾试图找到类似问题的解决方案，最终不得不手动对其进行排序。我想象的另一种方法是编写一个sorter functor，它可以以某种方式计算出，基于哪个字符串被排序，哪个整数被关联，然后基于这个排序。这是非常低效的，因此我强烈建议您使用

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 << "Int\tString" << 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 << "Int\tString" << 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;
    }
}

#包括
#包括
#包括
#包括
#包括
模板
类CMappedSorter
{
std:：map*常量m_映射；
公众：
CMappedSorter（std:：map*映射）：m_映射（映射）
{
}
布尔运算符（）（键类型和LHS、键类型和RHS）
{
常量值类型lhsortingvalue=m_映射->查找（LHS）->秒；
常量值类型RhsortingValue=m_映射->查找（RHS）->秒；
返回值（lhsortingvaluestd：：cout我以前曾试图找到一个类似问题的解决方案，最终不得不手动排序。我想你可以这样做的另一种方法是编写一个排序器函子，它可以以某种方式计算出，根据哪个字符串被排序，哪个整数被关联，然后根据这个进行排序。这是非常低效的ng>，因此我强烈建议您使用
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 << "Int\tString" << 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 << "Int\tString" << 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;
    }
}

#包括
#包括
#包括
#包括
#包括
模板
类CMappedSorter
{
std:：map*常量m_映射；
公众：
CMappedSorter（std:：map*映射）：m_映射（映射）
{
}
布尔运算符（）（键类型和LHS、键类型和RHS）
{
常量值类型lhsortingvalue=m_映射->查找（LHS）->秒；
常量值类型RhsortingValue=m_映射->查找（RHS）->秒；
返回值（lhsortingvaluestd：：我可以假设他使用的是数组结构布局，而不是用于优化目的的数组结构布局。理想情况下，这使得其中一个的迭代更容易找到另一个。我假设h