std::conditional 未知类型

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?

Answer 1

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)