我有一个“列”容器类型：
struct MyColumnType {
// Data: Each row represents a member of an object.
vector<double> a; // All vectors are guaranteed to have always
vector<string> b; // the same length.
vector<int> c;
void copy(int from_pos, int to_pos); // The column type provides an interface
void swap(int pos_a, int pos_b); // for copying, swapping, ...
void push_back(); // And for resizing the container.
void pop_back();
void insert(int pos);
void remove(int pos);
// The interface can be extended/modified if required
};
用法：
// If table is a constructed container with elements stored
// To acces the members of the object stored at the 4th position:
table.a[4] = 4.0;
table.b[4] = "4th";
table.c[4] = 4;
问题：如何为这种容器创建符合标准的随机访问迭代器（可能还需要代理引用类型）？
我希望能够将std::algorithms用于我的类型的随机访问迭代器，例如： sort（注意：对于排序，比较将由用户定义的函子提供，例如lambda）。
特别是迭代器应该提供类似于
的接口struct {
double& a;
string& b;
int& c;
};
注0：允许使用C ++ 11 / C ++ 14。
注1：有一篇旧文http://hci.iwr.uni-heidelberg.de/vigra/documents/DataAccessors.ps，其中也有类似的尝试。但是，我无法让他们的方法与排序一起工作。使用代理类型方法很难满足defaultConstructible等要求（为什么std::sort要求类型为默认可构造而不是可交换，这超出了我的理解。）
注2：我无法执行以下操作：
struct MyType {
double a;
string b;
int c;
};
std::vector<MyType> v;
然后使用std::algorithm。
动机：表现。高速缓存行通常是64字节，即8倍。在这个简单的结构中，如果迭代双精度数，则使用字符串和int来污染缓存行。在其他情况下，每个缓存行只能获得1次双转移。也就是说，你最终使用了1/8的内存带宽。如果你需要迭代几个双Gb，这个简单的决定可以将你的应用程序性能提高6到7倍。不，我不能放弃。
加分：答案应该尽可能通用。考虑添加/删除容器类型的字段作为向结构添加/删除成员。每次添加新成员时，您都不希望更改大量代码。
答案 0 :(得分：4)
我认为这样的事情可能符合标准。它使用一些C ++ 11特性来简化语法，但也可以更改为符合C ++ 03 AFAIK。
经过测试并使用clang ++ 3.2
前奏：
#include <vector>
#include <string>
#include <utility> // for std::swap
#include <iterator>
using std::vector;
using std::string;
// didn't want to insert all those types as nested classes of MyColumnType
namespace MyColumnType_iterator
{
struct all_copy;
struct all_reference;
struct all_iterator;
}
// just provided `begin` and `end` member functions
struct MyColumnType {
// Data: Each row represents a member of an object.
vector<double> a; // All vectors are guaranteed to have always
vector<string> b; // the same length.
vector<int> c;
void copy(int from_pos, int to_pos); // The column type provides an itface
void swap(int pos_a, int pos_b); // for copying, swapping, ...
void push_back(); // And for resizing the container.
void pop_back();
void insert(int pos);
void remove(int pos);
// The interface can be extended/modified if required
using iterator = MyColumnType_iterator::all_iterator;
iterator begin();
iterator end();
};
迭代器类：value_type（all_copy），reference类型（all_reference）和迭代器类型（all_iterator）。迭代是通过保持和更新三个迭代器（每个vector一个）来完成的。不过，我不知道这是否是性能最佳的选择。
工作原理：std::iterator_traits为迭代器定义了几个相关类型：
[iterator.traits] / 1
iterator_traits<Iterator>::difference_type
iterator_traits<Iterator>::value_type
iterator_traits<Iterator>::iterator_category
被定义为迭代器的差异类型，值类型和迭代器类别。另外，类型
iterator_traits<Iterator>::reference
iterator_traits<Iterator>::pointer
应定义为迭代器的引用和指针类型，即对于迭代器对象a，分别与*a和a->的类型相同
因此，您可以引入一个结构（all_reference），将三个引用保留为reference类型。此类型是*a的返回值，其中a是迭代器类型（可能是const - 限定的）。需要有一个不同的value_type，因为某些标准库算法（如sort）可能需要创建一个临时存储*a值的局部变量（通过复制或移入局部变量） 。在这种情况下，all_copy提供此功能。
您不需要在自己的循环中使用它（all_copy），这可能会影响性能。
namespace MyColumnType_iterator
{
struct all_copy;
struct all_reference
{
double& a;
string& b;
int& c;
all_reference() = delete;
// not required for std::sort, but stream output is simpler to write
// with this
all_reference(all_reference const&) = default;
all_reference(double& pa, string& pb, int& pc)
: a{pa}
, b{pb}
, c{pc}
{}
// MoveConstructible required for std::sort
all_reference(all_reference&& other) = default;
// MoveAssignable required for std::sort
all_reference& operator= (all_reference&& other)
{
a = std::move(other.a);
b = std::move(other.b);
c = std::move(other.c);
return *this;
}
// swappable required for std::sort
friend void swap(all_reference p0, all_reference p1)
{
std::swap(p0.a, p1.a);
std::swap(p0.b, p1.b);
std::swap(p0.c, p1.c);
}
all_reference& operator= (all_copy const& p) = default;
all_reference& operator= (all_copy&& p) = default;
// strict total ordering required for std::sort
friend bool operator< (all_reference const& lhs,
all_reference const& rhs);
friend bool operator< (all_reference const& lhs, all_copy const& rhs);
friend bool operator< (all_copy const& lhs, all_reference const& rhs);
};
struct all_copy
{
double a;
string b;
int c;
all_copy(all_reference const& p)
: a{p.a}
, b{p.b}
, c{p.c}
{}
all_copy(all_reference&& p)
: a{ std::move(p.a) }
, b{ std::move(p.b) }
, c{ std::move(p.c) }
{}
};
需要std::sort的比较功能。出于某种原因，我们必须提供所有这三个。
bool operator< (all_reference const& lhs, all_reference const& rhs)
{
return lhs.c < rhs.c;
}
bool operator< (all_reference const& lhs, all_copy const& rhs)
{
return lhs.c < rhs.c;
}
bool operator< (all_copy const& lhs, all_reference const& rhs)
{
return lhs.c < rhs.c;
}
现在，迭代器类：
struct all_iterator
: public std::iterator < std::random_access_iterator_tag, all_copy >
{
//+ specific to implementation
private:
using ItA = std::vector<double>::iterator;
using ItB = std::vector<std::string>::iterator;
using ItC = std::vector<int>::iterator;
ItA iA;
ItB iB;
ItC iC;
public:
all_iterator(ItA a, ItB b, ItC c)
: iA(a)
, iB(b)
, iC(c)
{}
//- specific to implementation
//+ for iterator_traits
using reference = all_reference;
using pointer = all_reference;
//- for iterator_traits
//+ iterator requirement [iterator.iterators]/1
all_iterator(all_iterator const&) = default; // CopyConstructible
all_iterator& operator=(all_iterator const&) = default; // CopyAssignable
~all_iterator() = default; // Destructible
void swap(all_iterator& other) // lvalues are swappable
{
std::swap(iA, other.iA);
std::swap(iB, other.iB);
std::swap(iC, other.iC);
}
//- iterator requirements [iterator.iterators]/1
//+ iterator requirement [iterator.iterators]/2
all_reference operator*()
{
return {*iA, *iB, *iC};
}
all_iterator& operator++()
{
++iA;
++iB;
++iC;
return *this;
}
//- iterator requirement [iterator.iterators]/2
//+ input iterator requirements [input.iterators]/1
bool operator==(all_iterator const& other) const // EqualityComparable
{
return iA == other.iA; // should be sufficient (?)
}
//- input iterator requirements [input.iterators]/1
//+ input iterator requirements [input.iterators]/2
bool operator!=(all_iterator const& other) const // "UnEqualityComparable"
{
return iA != other.iA; // should be sufficient (?)
}
all_reference const operator*() const // *a
{
return {*iA, *iB, *iC};
}
all_reference operator->() // a->m
{
return {*iA, *iB, *iC};
}
all_reference const operator->() const // a->m
{
return {*iA, *iB, *iC};
}
// ++r already satisfied
all_iterator operator++(int) // *++r
{
all_iterator temp(*this);
++(*this);
return temp;
}
//- input iterator requirements [input.iterators]/2
//+ output iterator requirements [output.iterators]/1
// *r = o already satisfied
// ++r already satisfied
// r++ already satisfied
// *r++ = o already satisfied
//- output iterator requirements [output.iterators]/1
//+ forward iterator requirements [forward.iterators]/1
all_iterator() = default; // DefaultConstructible
// r++ already satisfied
// *r++ already satisfied
// multi-pass must be guaranteed
//- forward iterator requirements [forward.iterators]/1
//+ bidirectional iterator requirements [bidirectional.iterators]/1
all_iterator& operator--() // --r
{
--iA;
--iB;
--iC;
return *this;
}
all_iterator operator--(int) // r--
{
all_iterator temp(*this);
--(*this);
return temp;
}
// *r-- already satisfied
//- bidirectional iterator requirements [bidirectional.iterators]/1
//+ random access iterator requirements [random.access.iterators]/1
all_iterator& operator+=(difference_type p) // r += n
{
iA += p;
iB += p;
iC += p;
return *this;
}
all_iterator operator+(difference_type p) const // a + n
{
all_iterator temp(*this);
temp += p;
return temp;
}
// doesn't have to be a friend function, but this way,
// we can define it here
friend all_iterator operator+(difference_type p,
all_iterator temp) // n + a
{
temp += p;
return temp;
}
all_iterator& operator-=(difference_type p) // r -= n
{
iA -= p;
iB -= p;
iC -= p;
return *this;
}
all_iterator operator-(difference_type p) const // a - n
{
all_iterator temp(*this);
temp -= p;
return temp;
}
difference_type operator-(all_iterator const& p) // b - a
{
return iA - p.iA; // should be sufficient (?)
}
all_reference operator[](difference_type p) // a[n]
{
return *(*this + p);
}
all_reference const operator[](difference_type p) const // a[n]
{
return *(*this + p);
}
bool operator<(all_iterator const& p) const // a < b
{
return iA < p.iA; // should be sufficient (?)
}
bool operator>(all_iterator const& p) const // a > b
{
return iA > p.iA; // should be sufficient (?)
}
bool operator>=(all_iterator const& p) const // a >= b
{
return iA >= p.iA; // should be sufficient (?)
}
bool operator<=(all_iterator const& p) const // a >= b
{
return iA <= p.iA; // should be sufficient (?)
}
//- random access iterator requirements [random.access.iterators]/1
};
}//- namespace MyColumnType_iterator
MyColumnType::iterator MyColumnType::begin()
{
return { a.begin(), b.begin(), c.begin() };
}
MyColumnType::iterator MyColumnType::end()
{
return { a.end(), b.end(), c.end() };
}
用法示例：
#include <iostream>
#include <cstddef>
#include <algorithm>
namespace MyColumnType_iterator
{
template < typename char_type, typename char_traits >
std::basic_ostream < char_type, char_traits >&
operator<< (std::basic_ostream < char_type, char_traits >& o,
std::iterator_traits<MyColumnType::iterator>::reference p)
{
return o << p.a << ";" << p.b << ";" << p.c;
}
}
int main()
{
using std::cout;
MyColumnType mct =
{
{1.0, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1}
, {"j", "i", "h", "g", "f", "e", "d", "c", "b", "a"}
, {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}
};
using ref = std::iterator_traits<MyColumnType::iterator>::reference;
std::copy(mct.begin(), mct.end(), std::ostream_iterator<ref>(cout, ", "));
std::cout << std::endl;
std::sort(mct.begin(), mct.end());
std::copy(mct.begin(), mct.end(), std::ostream_iterator<ref>(cout, ", "));
std::cout << std::endl;
}
输出：
1; j; 10,0.9; i; 9,0.8; h; 8,0.7; g; 7,0.6; f; 6,0.5; e; 5,0.4; d; 4,0.3; c; 3 ，0.2; b; 2,0.1; a; 1，
0.1; a; 1,0.2; b; 2,0.3; c; 3,0.4; d; 4,0.5; e; 5,0.6; f; 6,0.7; g; 7,0.8; h; 8,0.9; i; 9,1; j; 10，
答案 1 :(得分：0)
如果您真的关心性能而想要使用std::sort对容器进行排序，请使用允许您提供自定义比较对象的重载：
template <class RandomAccessIterator, class Compare>
void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);
..并将一系列索引排序到容器中。方法如下：
您的容器中需要以下成员：
struct MyColumnType {
...
int size() const;
// swaps columns
void swap(int l, int r);
// returns true if column l is less than column r
bool less(int l, int r) const;
...
};
然后定义以下比较对象：
struct MyColumnTypeLess
{
const MyColumnType* container;
MyColumnTypeLess(const MyColumnType* container)
: container(container)
{
}
bool operator()(int l, int r) const
{
return container->less(l, r);
}
};
并使用它来排序索引数组：
void sortMyColumnType(MyColumnType& container)
{
std::vector<int> indices;
indices.reserve(container.size());
// fill with [0, n)
for(int i = 0; i != container.size(); ++i)
{
indices.push_back(i);
}
// sort the indices
std::sort(indices.begin(), indices.end(), MyColumnTypeLess(&container));
}
容器的'less'成员控制要排序的顺序：
bool MyColumnType::less(int l, int r) const
{
// sort first by a, then b, then c
return a[l] != a[r] ? a[l] < a[r]
: b[l] != b[r] ? b[l] < b[r]
: c[l] < c[r];
}
排序的索引数组可用于其他算法 - 您可以避免在需要之前复制实际数据。
与RandomAccessIterators一起使用的所有std算法都有重载，允许您指定自定义比较对象，因此它们也可以与此技术一起使用。