Вектор указывает на другой вектор

Question

У меня есть два массива разных типов, которые я конвертирую в векторы.

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

Я собираюсь вызвать функцию сортировки для сортировки элементов ham_array от наименьшего к наибольшему. В то же время я хотел бы, чтобы word_array также сортировался так же, как Ham_vector сортируется по ссылкам.

Например,

после того, как я вызываю sort (hamvector)

ham_array[] = {12, 26, 32, 45, 71}

и sort (wordvector)

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

Есть ли простой способ сделать это?

Answer 1

Ну, с одной стороны, это будет 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);

Answer 2

Я уже пытался найти решение подобной проблемы и в конечном итоге пришлось отсортировать его вручную.Другим способом, который, я думаю, вы могли бы сделать, было бы написать функтор сортировщика, который может каким-то образом выяснить, на основе какой строки сортируется, какое целое число связано, и сортировать на основе этого.Это ужасно неэффективно , поэтому я настоятельно рекомендую выполнить собственную сортировку вручную, используя 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;
    }
}

Answer 3

Если просто, вы имеете в виду более прямой путь, чем да.std::sort() также поддерживает сортировку необработанных массивов:

sort(word_array, word_array + 5, wordcmp);

Как показал Блинди, вам нужна функция компаратора, чтобы сообщить sort, как должно быть выполнено упорядочение для вашего списка слов.В противном случае вы закончите сортировку по адресу памяти, в котором находится строка, а не по буквам в строке.Что-то вроде этого должно работать:

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

Еще одно замечание, на практике вы предпочтете std::vector, а не только необработанные массивы указателей, поскольку последнее не так безопасно.