std::conditional with unknown type

Question

I'm currently writing a library which makes use of C++20's std::span. Compiler library support for std::span is at this point rather scarce. Therefore, I have a marco which allows to use a 3rd-party implementation instead (in my case tcb::span). The macro looks like this:

#ifdef SPAN_BUILTIN
#   include <span>
#   define SPAN std::span
#else
#   include "3rdparty/span.hpp"
#   define SPAN tcb::span
#endif

Usage through the library looks like this:

void my_func(const SPAN<int>& s);

This is not pretty at all. I was looking for a better solution and I came across std::conditional which I have already used in the past. A naive attempt would looks like this:

constexpr const bool span_builtin = // ...

template <class T>
using span_type = typename std::conditional<span_builtin, std::span<T>, tcb::span<T>>::type;

Which would result in usage like this:

void my_func(const span_type& s);

The problem lies in the fact that std::span is an unknown type at compile time when std::span is not available which makes compilation fail.

Is there a nicer solution to this?

Why don't you just declare an alias called `span` in the `std` namespace, write code that simply references `std::span`, and simply drop the alias when you update your compiler? — Sam Varshavchik, Sep 21 '20 at 21:07
Change `# define SPAN std::span` to `template using span = std::span;`. Also make the corrisponding change to the third party lib line. — NathanOliver, Sep 21 '20 at 21:10
Why not just use `tcb::span` everywhere? That will save a great deal of debugging. — Pete Becker, Sep 21 '20 at 21:22
@SamVarshavchik: That would be Undefined Behavior, and break compilers where the `std::span` implementation exists but is not yet standard-conforming. — MSalters, Sep 22 '20 at 14:35

pratikpc · Accepted Answer · 2020-09-23T13:00:08.173

Nice question!

Let's answer it step-by-step

constexpr const bool span_builtin = // ...

Does something like this exist?

Would this work?

Probably not

https://stackoverflow.com/a/45594334/1691072

We could use this but the issue with this is that below C++20, Span would not be defined

Also we cannot officially add our own span Forward Declaration to std namespace

So what's the solution?

The solution would end up being very similar to yours

#include <type_traits>

#if __cplusplus > 201703L // Do something else for MSVC if you cannot use `/Zc:__cplusplus`
#include <span>
template<typename T, std::size_t N = std::dynamic_extent>
using span = std::span<T, N>;
#else
template<typename T>
using span = tcb::span<T>;
#endif

int main ()
{
#if __cplusplus > 201703L
   static_assert(std::is_same_v< span<int>, std::span<int>>);
#else
   static_assert(std::is_same_v< span<int>, tcb::span<int>>);
#endif
}

See also Proper way to define type (typedef vs #define)

std::conditional with unknown type

1 Answers1