벡터가 다른 벡터를 가리키고 있습니다

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가 참조를 사용하여 정렬되는 것과 같은 방식으로 정렬되기를 바랍니다. 내가

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

이 작업을 수행 할 수있는 간단한 방법이 있을까요 (hamvector)

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

및 종류 (wordvector) 종류 호출 한 후 예를 들어

,

?

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::sort()뿐만 아니라 원시 배열의 정렬을 지원 않습니다

sort(word_array, word_array + 5, wordcmp); 

Blindy 보여준 바와 같이, 당신은 주문이 단어의 목록을 위해 수행되어야한다고 가정하는 방법을 sort를 알려줄 수있는 비교 기능이 필요합니다. 그렇지 않으면 문자열에있는 문자 대신 문자열이있는 메모리 주소별로 정렬됩니다. ,

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

다른 한 메모를, 후자는 안전하지 않기 때문에 실제로 당신은 원시 포인터 배열을 통해 std::vector을 선호 할 것이다 : 이런 식으로 뭔가 작업을해야합니다.

Answer 3

나는 비슷한 문제에 대한 해결책을 찾기 위해 노력했지만 궁극적으로 그것을 수동으로 정렬해야했습니다. 여러분이 이것을 할 수 있다고 상상하는 또 다른 방법은 어떤 문자열이 정렬되고, 어떤 정수가 연관되는지에 따라 어떻게 든 알아낼 수있는 분류기 펑터를 작성하는 것입니다. 이것은 매우 비효율적 인입니다. 따라서 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; 
    } 
}