Там, где это может быть неоднозначным, я буду ссылаться на стандарт C ++ 14.
При использовании https://en.cppreference.com/w/cpp/container/vector в качестве ссылки требования к параметру шаблона T для вектора относительно невелики
Требования, предъявляемые к элементам, зависят от фактических операций, выполняемых над контейнером. Как правило, требуется, чтобы тип элемента был полным и соответствовал требованиям Erasable, но многие функции-члены предъявляют более строгие требования.
Действительно, многие страницы (например, одна для insert ) на удивление четко описывают требования, предъявляемые к T. К сожалению, то же самое не верно для конструкторов или функции присвоения. Это упущение на сайте или в стандарте?
Мотивация
Мотивация для этого вопроса немного сложна. У меня есть класс Node, представляющий узел в дереве. Каждый узел имеет родителя (представлен Node*) и список дочерних элементов (представлен std::vector<Node, MyAllocator>). Это последний бит, где это становится интересным. Чтобы гарантировать, что Node продолжают указывать на правильных родителей, я реализовал собственный распределитель, который «предварительно загружает» каждый вызов конструктора с указателем на правильный Node. Код для этого выглядит следующим образом
#ifndef PRElOAD_ALLOCATOR_H
#define PRElOAD_ALLOCATOR_H
#include <tuple>
#include <utility>
#include <memory>
#include <vector>
/**
* @class PreloadAllocator
* Provides a generic allocator that is able to 'preload' some arguments for the
* construct function. Note that these arguments are *always* loaded at the
* front of any constructor call so modified move, copy constructors need to
* created to match.
* This allocator will only work with simple containers like vector that do not
* modify the type of the allocator being used. *It will not work* with types
* like list and map that internally represent the data in a different format.
* This is because the constructors for these objects behave differently and it
* is not simple to know how to insert the extra arguments into such a call.
*/
template <typename T, typename... Args>
class PreloadAllocator {
public:
// Standard allocator typedefs
using value_type = T;
using pointer = T*;
using const_pointer = const T*;
using reference = T&;
using const_reference = const T&;
using size_type = std::size_t;
using difference_type = std::ptrdiff_t;
PreloadAllocator(Args&&... args)
: tup(std::forward_as_tuple(args...) ) {}
template <typename U>
PreloadAllocator(const PreloadAllocator<U, Args...>& other)
: tup(other.tup) {}
pointer allocate(size_type count, const_pointer hint = 0) {
return m_defaultAlloc.allocate(count, hint);
}
void deallocate(pointer ptr, size_type count) {
return m_defaultAlloc.deallocate(ptr, count);
}
template <typename... Ts>
void construct(T* ptr, Ts&&... ts) {
// First preload the constructor arguments with the allocator's
// versions, then add on the rest, and let the default allocator do the
// rest.
return construct_impl<Ts...>(
ptr, std::forward<Ts>(ts)..., std::index_sequence_for<Args...>{});
}
// Hold the arguments that we will preload into every constructor call
const std::tuple<Args...> tup;
private:
// Compose the default STL allocator to use its version of allocate and
// deallocate.
std::allocator<T> m_defaultAlloc;
// Actual function that does the constructing
template <typename... Ts, std::size_t... Is>
void construct_impl(T* ptr, Ts&&... ts, std::index_sequence<Is...>) {
return m_defaultAlloc.construct(
ptr, std::get<Is>(tup)..., std::forward<Ts>(ts)...);
}
};
template <typename T, typename... Args>
bool operator==(
const PreloadAllocator<T, Args...>& lhs,
const PreloadAllocator<T, Args...>& rhs)
{
return lhs.tup == rhs.tup;
}
template <typename T, typename... Args>
bool operator!=(
const PreloadAllocator<T, Args...>& lhs,
const PreloadAllocator<T, Args...>& rhs)
{
return !(lhs==rhs);
}
#endif //> !PRElOAD_ALLOCATOR_H
class Node {
public:
using alloc_t = PreloadAllocator<Node, Node*>;
using vec_t = std::vector<Node, alloc_t>;
Node(Node* parent, int data)
: parent(parent), data(data), children(alloc_t(this) ) {}
Node(Node* parent, const Node& other)
: parent(parent), data(other.data), children(other.children, alloc_t(this) ) {}
Node(Node* parent, Node&& other)
: parent(parent), data(std::move(other.data) ), children(std::move(other.children), alloc_t(this) ) {}
// Copy/Move constructing is not going to give us the correct parent!
Node(const Node&) = delete;
Node(Node&&) = delete;
Node* parent;
int data;
vec_t children;
};
int main() {
Node root(nullptr, 0);
}
При компиляции этого кода в g ++ он компилируется и работает нормально. Однако, когда я компилирую в Clang, я получаю следующую ошибку
In file included from alloc_test.cxx:3:
/Library/Developer/CommandLineTools/usr/include/c++/v1/vector:1275:9: error: no matching member function for call to 'assign'
assign(_Ip(__x.begin()), _Ip(__x.end()));
^~~~~~
alloc_test.cxx:15:55: note: in instantiation of member function 'std::__1::vector<Node, PreloadAllocator<Node, Node *> >::vector' requested here
: parent(parent), data(std::move(other.data) ), children(std::move(other.children), alloc_t(this) ) {}
^
/Library/Developer/CommandLineTools/usr/include/c++/v1/vector:588:10: note: candidate function not viable: no known conversion from '_Ip' (aka 'move_iterator<__wrap_iter<Node *> >') to
'std::__1::vector<Node, PreloadAllocator<Node, Node *> >::size_type' (aka 'unsigned long') for 1st argument
void assign(size_type __n, const_reference __u);
^
/Library/Developer/CommandLineTools/usr/include/c++/v1/vector:576:9: note: candidate template ignored: requirement '!__is_forward_iterator<move_iterator<__wrap_iter<Node *> > >::value' was not satisfied
[with _InputIterator = std::__1::move_iterator<std::__1::__wrap_iter<Node *> >]
assign(_InputIterator __first, _InputIterator __last);
^
/Library/Developer/CommandLineTools/usr/include/c++/v1/vector:586:9: note: candidate template ignored: requirement 'is_constructible<value_type, typename iterator_traits<move_iterator<__wrap_iter<Node *>
> >::reference>::value' was not satisfied [with _ForwardIterator = std::__1::move_iterator<std::__1::__wrap_iter<Node *> >]
assign(_ForwardIterator __first, _ForwardIterator __last);
^
/Library/Developer/CommandLineTools/usr/include/c++/v1/vector:592:10: note: candidate function not viable: requires single argument '__il', but 2 arguments were provided
void assign(initializer_list<value_type> __il)
^
1 error generated.
Итак, является ли эта двусмысленность в стандарте, что g ++ и clang решили интерпретировать по-разному, или это действительно ошибка для одного из них?
Попытка написать такой распределитель предварительной загрузки - непростительное злоупотребление стандартом?
* Редактировать: * исправлены пропущенные элементы данных во фрагменте кода.