從 MSVC 19.27 (VS 16.7) 更新到 MSVC 19.28 (VS 16.8 ) 后，我的自定義迭代器根據另一個容器對一個容器進行排序，因為編譯器更改了排序演算法。我對面向資料的結構（陣列結構）進行操作，因此我有必要擁有兩個單獨的容器。
我的迭代器基于https://stackoverflow.com/a/46370189/209649
測驗：
#include <iterator>
namespace SortHelper
{
template <typename OrderT, typename DataT>
struct ValueReference;
template <typename OrderT, typename DataT>
struct Value
{
OrderT Order;
DataT Data;
Value(OrderT order, DataT data) :
Order(order),
Data(data)
{
}
Value(const ValueReference<OrderT, DataT>& rhs);
bool operator <(const Value<OrderT, DataT>& rhs) const { return Order < rhs.Order; }
};
template <typename OrderT, typename DataT>
struct ValueReference
{
OrderT* Order;
DataT* Data;
ValueReference(OrderT* orderIterator, DataT* dataIterator) :
Order(orderIterator),
Data(dataIterator)
{
}
ValueReference& operator =(const ValueReference& rhs)
{
*Order = *rhs.Order;
*Data = *rhs.Data;
return *this;
}
ValueReference& operator =(const Value<OrderT, DataT>& rhs)
{
*Order = rhs.Order;
*Data = rhs.Data;
return *this;
}
bool operator <(const ValueReference& rhs) const { return *Order < *rhs.Order; }
};
template <typename OrderT, typename DataT>
struct ValueIterator
{
typedef Value<OrderT, DataT> value_type;
typedef Value<OrderT, DataT>* pointer;
typedef ValueReference<OrderT, DataT> reference;
typedef std::ptrdiff_t difference_type;
typedef std::random_access_iterator_tag iterator_category;
OrderT* OrderIterator;
DataT* DataIterator;
ValueIterator(OrderT* orderIterator, DataT* dataIterator) :
OrderIterator(orderIterator),
DataIterator(dataIterator)
{
}
std::ptrdiff_t operator -(const ValueIterator& rhs) const { return OrderIterator - rhs.OrderIterator; }
ValueIterator operator (std::ptrdiff_t off) const { return ValueIterator(OrderIterator off, DataIterator off); }
ValueIterator operator -(std::ptrdiff_t off) const { return ValueIterator(OrderIterator - off, DataIterator - off); }
ValueIterator& operator ()
{
OrderIterator;
DataIterator;
return *this;
}
ValueIterator& operator --()
{
--OrderIterator;
--DataIterator;
return *this;
}
ValueIterator operator (int) { return ValueIterator(OrderIterator , DataIterator ); }
ValueIterator operator --(int) { return ValueIterator(OrderIterator--, DataIterator--); }
Value<OrderT, DataT> operator *() const { return Value<OrderT, DataT>(*OrderIterator, *DataIterator); }
ValueReference<OrderT, DataT> operator [](difference_type n) const { return ValueReference<OrderT, DataT>(OrderIterator n, DataIterator n); }
ValueReference<OrderT, DataT> operator *() { return ValueReference<OrderT, DataT>(OrderIterator, DataIterator); }
bool operator <(const ValueIterator& rhs) const { return OrderIterator < rhs.OrderIterator; }
bool operator ==(const ValueIterator& rhs) const { return OrderIterator == rhs.OrderIterator; }
bool operator !=(const ValueIterator& rhs) const { return OrderIterator != rhs.OrderIterator; }
};
template <typename OrderT, typename DataT>
Value<OrderT, DataT>::Value(const ValueReference<OrderT, DataT>& rhs) :
Order(*rhs.Order),
Data(*rhs.Data)
{
}
template <typename OrderT, typename DataT>
bool operator <(const Value<OrderT, DataT>& lhs, const ValueReference<OrderT, DataT>& rhs)
{
return lhs.Order < *rhs.Order;
}
template <typename OrderT, typename DataT>
bool operator <(const ValueReference<OrderT, DataT>& lhs, const Value<OrderT, DataT>& rhs)
{
return *lhs.Order < rhs.Order;
}
template <typename OrderT, typename DataT>
void swap(ValueReference<OrderT, DataT> lhs, ValueReference<OrderT, DataT> rhs)
{
std::swap(*lhs.Order, *rhs.Order);
std::swap(*lhs.Data, *rhs.Data);
}
}
#include <algorithm>
#include <iostream>
int main()
{
int Age[] = { 45, 14, 5, 24 };
const char* Names[] = { "Karl", "Paul", "Martin", "Jennie" };
std::sort(SortHelper::ValueIterator<int, const char*>(Age, Names), SortHelper::ValueIterator<int, const char*>(Age 4, Names 4));
for (int i = 0; i < 4; i)
std::cout << Age[i] << ": " << Names[i] << "\n";
}
預期結果：
{ "Martin", "Paul", "Jennie", "Karl" };
{ 5, 14, 24, 45 };
當前結果：
{ "Karl", "Karl", "Karl", "Karl" };
{ 45, 45, 45, 45 };
更新后，我不得不添加operator <內部struct Value來修復以前不需要的編譯。我假設 MSVC 19.28 (VS 16.8) 或更高版本中的更改排序演算法現在使用了其他一些缺失或錯誤的運算子，因為它在 GCC 和 Clang 中作業。
任何幫助將不勝感激。
uj5u.com熱心網友回復：
感謝Swift和其他人的幫助，我基于https://artificial-mind.net/blog/2020/11/28/std-sort-multiple-ranges重寫了迭代器，它現在似乎可以在 MSVC、GCC 和鐺：
#include <iterator>
namespace SortHelper
{
template <typename OrderT, typename DataT>
struct Value
{
OrderT Order;
DataT Data;
};
template <typename OrderT, typename DataT>
struct ValueReference
{
OrderT* Order;
DataT* Data;
ValueReference& operator=(ValueReference&& r) noexcept
{
*Order = std::move(*r.Order);
*Data = std::move(*r.Data);
return *this;
}
ValueReference& operator=(Value<OrderT, DataT>&& r)
{
*Order = std::move(r.Order);
*Data = std::move(r.Data);
return *this;
}
friend void swap(ValueReference a, ValueReference b)
{
std::swap(*a.Order, *b.Order);
std::swap(*a.Data, *b.Data);
}
operator Value<OrderT, DataT>()&&
{
return { std::move(*Order), std::move(*Data) };
}
};
template <typename OrderT, typename DataT>
bool operator<(const ValueReference<OrderT, DataT>& a, const Value<OrderT, DataT>& b)
{
return *a.Order < b.Order;
}
template <typename OrderT, typename DataT>
bool operator<(const Value<OrderT, DataT>& a, const ValueReference<OrderT, DataT>& b)
{
return a.Order < *b.Order;
}
template <typename OrderT, typename DataT>
bool operator<(const ValueReference<OrderT, DataT>& a, const ValueReference<OrderT, DataT>& b)
{
return *a.Order < *b.Order;
}
template <typename OrderT, typename DataT>
struct ValueIterator
{
using iterator_category = std::random_access_iterator_tag;
using difference_type = size_t;
using value_type = Value<OrderT, DataT>;
using pointer = value_type*;
using reference = ValueReference<OrderT, DataT>;
OrderT* Order;
DataT* Data;
bool operator==(const ValueIterator& r) const
{
return Order == r.Order;
}
bool operator!=(const ValueIterator& r) const
{
return Order != r.Order;
}
bool operator<(const ValueIterator& r) const
{
return Order < r.Order;
}
ValueIterator operator (difference_type i) const
{
return { Order i, Data i };
}
ValueIterator operator-(difference_type i) const
{
return { Order - i, Data - i };
}
difference_type operator-(const ValueIterator& r) const
{
return Order - r.Order;
}
ValueIterator& operator ()
{
Order;
Data;
return *this;
}
ValueIterator& operator--()
{
--Order;
--Data;
return *this;
}
ValueReference<OrderT, DataT> operator*() const
{
return { Order, Data };
}
};
}
#include <algorithm>
#include <iostream>
int main()
{
int Age[] = { 45, 14, 5, 24 };
const char* Names[] = { "Karl", "Paul", "Martin", "Jennie" };
std::sort(SortHelper::ValueIterator<int, const char*>{ Age, Names }, SortHelper::ValueIterator<int, const char*>{ Age 4, Names 4 });
for (int i = 0; i < 4; i)
std::cout << Age[i] << ": " << Names[i] << "\n";
}
uj5u.com熱心網友回復：
我標記了至少缺少的必需行。我已經使參考和迭代器可復制和迭代器 - 完全排序。與比較運算子一起，operator =應該宣告an ，因為某些實作會使用它。那些迭代器仍然不符合迭代器的概念，例如過去的迭代器會做什么？
#include <iterator>
#include <algorithm> //! You should not rely on fact that swap is defined.
#include <utility> //! even if it was used and didn't produce error
namespace SortHelper
{
template <typename OrderT, typename DataT>
struct ValueReference;
template <typename OrderT, typename DataT>
struct Value
{
OrderT Order;
DataT Data;
Value(OrderT order, DataT data) :
Order(order),
Data(data)
{
}
Value(const ValueReference<OrderT, DataT>& rhs);
bool operator <(const Value<OrderT, DataT>& rhs) const { return Order < rhs.Order; }
};
template <typename OrderT, typename DataT>
struct ValueReference
{
OrderT* Order;
DataT* Data;
ValueReference(const ValueReference& v) = default; ///!
ValueReference(OrderT* orderIterator, DataT* dataIterator) :
Order(orderIterator),
Data(dataIterator)
{
}
ValueReference& operator =(const ValueReference& rhs)
{
*Order = *rhs.Order;
*Data = *rhs.Data;
return *this;
}
ValueReference& operator =(const Value<OrderT, DataT>& rhs)
{
*Order = rhs.Order;
*Data = rhs.Data;
return *this;
}
bool operator <(const ValueReference& rhs) const { return *Order < *rhs.Order; }
};
template <typename OrderT, typename DataT>
struct ValueIterator
{
typedef Value<OrderT, DataT> value_type;
typedef Value<OrderT, DataT>* pointer;
typedef ValueReference<OrderT, DataT> reference;
typedef std::ptrdiff_t difference_type;
typedef std::random_access_iterator_tag iterator_category;
OrderT* OrderIterator;
DataT* DataIterator;
ValueIterator(const ValueIterator& v) = default; ///!
ValueIterator(OrderT* orderIterator, DataT* dataIterator) :
OrderIterator(orderIterator),
DataIterator(dataIterator)
{
}
std::ptrdiff_t operator -(const ValueIterator& rhs) const { return OrderIterator - rhs.OrderIterator; }
ValueIterator operator (std::ptrdiff_t off) const { return ValueIterator(OrderIterator off, DataIterator off); }
ValueIterator operator -(std::ptrdiff_t off) const { return ValueIterator(OrderIterator - off, DataIterator - off); }
ValueIterator& operator ()
{
OrderIterator;
DataIterator;
return *this;
}
ValueIterator& operator --()
{
--OrderIterator;
--DataIterator;
return *this;
}
// operator =, -= ? that may be used.
ValueIterator operator =(int v) { return ValueIterator(OrderIterator v, DataIterator v); }
ValueIterator operator (int) { return ValueIterator(OrderIterator , DataIterator ); }
ValueIterator operator --(int) { return ValueIterator(OrderIterator--, DataIterator--); }
// This may cause problems, depending on implementation of components
// It confuses elements referenced being of non-copyable but movable type, while it's actually their copy.
//Value<OrderT, DataT> operator *() const { return Value<OrderT, DataT>(*OrderIterator, *DataIterator); }
ValueReference<OrderT, DataT> operator [](difference_type n) const { return ValueReference<OrderT, DataT>(OrderIterator n, DataIterator n); }
ValueReference<OrderT, DataT> operator *() { return ValueReference<OrderT, DataT>(OrderIterator, DataIterator); }
/// this can be replaced by starship operator <=>
bool operator >(const ValueIterator& rhs) const { return OrderIterator > rhs.OrderIterator; } ///!
bool operator <=(const ValueIterator& rhs) const { return OrderIterator <= rhs.OrderIterator; } ///!
bool operator <(const ValueIterator& rhs) const { return OrderIterator < rhs.OrderIterator; }
bool operator >=(const ValueIterator& rhs) const { return OrderIterator >= rhs.OrderIterator; } ///!
bool operator ==(const ValueIterator& rhs) const { return OrderIterator == rhs.OrderIterator; }
bool operator !=(const ValueIterator& rhs) const { return OrderIterator != rhs.OrderIterator; }
};
template <typename OrderT, typename DataT>
Value<OrderT, DataT>::Value(const ValueReference<OrderT, DataT>& rhs) :
Order(*rhs.Order),
Data(*rhs.Data)
{
}
template <typename OrderT, typename DataT>
bool operator <(const Value<OrderT, DataT>& lhs, const ValueReference<OrderT, DataT>& rhs)
{
return lhs.Order < *rhs.Order;
}
template <typename OrderT, typename DataT>
bool operator <(const ValueReference<OrderT, DataT>& lhs, const Value<OrderT, DataT>& rhs)
{
return *lhs.Order < rhs.Order;
}
template <typename OrderT, typename DataT>
void swap(ValueReference<OrderT, DataT> lhs, ValueReference<OrderT, DataT> rhs)
{
std::swap(*lhs.Order, *rhs.Order);
std::swap(*lhs.Data, *rhs.Data);
}
}
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/351254.html
下一篇：2與列進行比較的檔案