Is casting std::pair const& to std::pair const& safe?

by

It’s NOT portable to do so.

std::pair requirements are laid out in clause 20.3. Clause 17.5.2.3 clarifies that

Clauses 18 through 30 and Annex D do not specify the representation of classes, and intentionally omit specification of class members. An implementation may define static or non-static class members, or both, as needed to implement the semantics of the member functions specified in Clauses 18 through 30 and Annex D.

This implies that it’s legal (although incredibly unlikely) for an implementation to include a partial specialization such as:

template<typename T1, typename T2>
struct pair<T1, T2>
{
    T1 first;
    T2 second;
};

template<typename T1, typename T2>
struct pair<const T1, T2>
{
    T2 second;
    const T1 first;
};

which are clearly not layout-compatible. Other variations including inclusion of additional non-static data members possibly before first and/or second are also allowed under the rule.

Now, it is somewhat interesting to consider the case where the layout is known. Although Potatoswatter pointed out DR1334 which asserts that T and const T are not layout-compatible, the Standard provides enough guarantees to allow us to get most of the way anyway:

template<typename T1, typename T2>
struct mypair<T1, T2>
{
    T1 first;
    T2 second;
};

mypair<int, double> pair1;
mypair<int, double>* p1 = &pair1;
int* p2 = reinterpret_cast<int*>(p1); // legal by 9.2p20
const int* p3 = p2;
mypair<const int, double>* p4 = reinterpret_cast<mypair<const int, double>*>(p3); // again 9.2p20

However this doesn’t work on std::pair as we can’t apply 9.2p20 without knowing that first is actually the initial member, which is not specified.

More Related Contents:

  1. When to use reinterpret_cast?
  2. How is a variable at the same address producing 2 different values? [duplicate]
  3. constant references with typedef and templates in c++
  4. casting via void* instead of using reinterpret_cast [duplicate]
  5. Is there any difference between “T” and “const T” in template parameter?
  6. Is reinterpret_cast type punning actually undefined behavior?
  7. Why doesn’t this reinterpret_cast compile?
  8. C++: Why is const_cast evil?
  9. Does reinterpret_cast lead to undefined behavior?
  10. Should I use a C++ reinterpret_cast over a C-style cast?
  11. C++ When should we prefer to use a two chained static_cast over reinterpret_cast
  12. Why Doesn’t reinterpret_cast Force copy_n for Casts between Same-Sized Types?
  13. Why do we have reinterpret_cast in C++ when two chained static_cast can do its job?
  14. Why can’t I use float value as a template parameter?
  15. Purpose of returning by const value? [duplicate]
  16. Explicit specialization in non-namespace scope [duplicate]
  17. SFINAE to check for inherited member functions
  18. ‘const int’ vs. ‘int const’ as function parameters in C++ and C
  19. error: cast from ‘void*’ to ‘int’ loses precision
  20. Function signature-like expressions as C++ template arguments
  21. How to detect existence of a class using SFINAE?
  22. C++ template copy constructor on template class
  23. SFINAE works differently in cases of type and non-type template parameters
  24. Making a template parameter a friend?
  25. Can the point-of-instantiation be delayed until the end of the translation unit?
  26. How to pass a template function in a template argument list
  27. c++ automatic factory registration of derived types
  28. access private member using template trick
  29. if / else at compile time in C++?
  30. How to test whether class B is derived from template family of classes

Leave a Comment