Сводные данные и литьевые данные

Question

В этом question цитируется стандарт C++, чтобы продемонстрировать, что выравнивание и размер CV-типов должны быть такими же, как и для эквивалентного типа, отличного от CV. Это кажется очевидным, потому что мы можем косвенно лить объект типа T в const T& с использованием static_cast или reinterpret_cast.

Однако предположим, что у нас есть два типа, которые имеют одинаковые типы переменных-членов, за исключением того, что у одного есть все переменные-члены const, а другие нет. Такие, как:

typedef std::pair<T, T> mutable_pair; 
typedef std::pair<const T, const T> const_pair; 

Здесь, стандарт не позволяет нам производить const_pair& из экземпляра mutable_pair. То есть, мы не можем сказать:

mutable_pair p; 
const_pair& cp = reinterpret_cast<const_pair&>(p); 

Это даст неопределенное поведение, так как она не указана в качестве действительного использования reinterpret_cast в стандарте. Тем не менее, по-видимому, нет причин, концептуально, почему это нельзя допускать.

Итак ... зачем кому-то это нужно? Вы всегда можете просто сказать:

const mutable_pair& cp = p; 

Ну, вы мощь помощь в случае, если вы хотите только один член будет const квалификацию. Такие как:

typedef std::pair<T, U> pair; 
typedef std::pair<const T, U> const_first_pair; 

pair p; 
const_first_pair& cp = reinterpret_cast<const_first_pair&>(p); 

Очевидно, что это по-прежнему неопределенное поведение. Тем не менее, поскольку CV квалифицированные типы должны иметь одинаковый размер и выравнивание, нет концептуальной причины, по которой это должно быть неопределенным.

Итак, есть ли причина, по которой стандарт не позволяет? Или это просто вопрос, что стандартный комитет не думал об этом прецеденте?

---

Для тех, интересно, какого рода использования это может иметь: в моем конкретном случае, я побежал в прецеденте, где это было бы очень полезно, чтобы иметь возможность бросить std::pair<T, U> к std::pair<const T, U>&. Я реализовал специализированную структуру сбалансированных древовидных данных, которая обеспечивает поиск по ключевому слову log(N), но внутренне хранит несколько элементов на узел. Процедуры find/insert/rebalance требуют внутренней перетасовки элементов данных. (Структура данных известна как T-tree.) Поскольку внутренняя перетасовка элементов данных отрицательно влияет на производительность, вызывая множество бесчисленных конструкторов копий, полезно реализовать внутреннюю перетасовку данных, чтобы по возможности использовать конструкторы перемещения.

К сожалению ... Я также хотел бы быть в состоянии предоставить интерфейс, который отвечает на C++ стандартных требований к AssociativeContainer, что требует value_type из std::pair<const Key, Data>. Обратите внимание на const. Это означает, что отдельные пары объектов не могут быть перемещены (или, по крайней мере, ключи не могут). Они должны копировать, поскольку ключ хранится как объект const.

Чтобы обойти это, я хотел бы иметь возможность хранить элементы внутри себя как изменяемые объекты, но просто бросать ключ в ссылку const, когда пользователь обращается к ним через итератор. К сожалению, я не могу отличить std::pair<Key, Data> от std::pair<const Key, Data>&.И я не могу предоставить какое-то обходное решение, которое возвращает класс-оболочку или что-то в этом роде, потому что это не соответствует требованиям для AssociativeContainer.

Отсюда этот вопрос.

Так что, учитывая, что требования к размеру и выравниванию квалифицированного типа CV должны быть такими же, как у эквивалентного эквивалента, отличного от CV, существует ли какая-либо концептуальная причина, почему такой отбор не допускается? Или это просто то, о чем не думали стандартные авторы?

Answer 1

Наличие типа параметра шаблона не означает, что у вас не будет разных выравниваний, содержимое класса может быть изменено, например, посредством специализации или метапрограммирования шаблонов. Рассмотрите:

template<typename T> struct X { int i; }; 
template<typename T> struct X<const T> { double i; }; 

template<typename T> struct Y { 
    typename std::conditional<std::is_const<T>::value, int, double>::type x; 
};