Compiling based on container type - c++

Question

In the code below, suppose that I decided to use deque instead of vector in the definition of mcc. How can I bypass cell.reserve(size) which is not defined for deque?
#include <vector>
#include <deque>
typedef std::vector<int> mcc;
//typedef std::deque<int> mcc;
void reserve(mcc& cell, int size)
{
cell.reserve(size);
}
int main()
{
mcc cell;
reserve(cell, 10);
return 0;
}

Answer 1

As the other answer and some comments have pointed out, in C++20, there are concepts, a feature which makes this task fairly trivial. However, as of now, C++20 support isn't complete in any compiler.
In the current C++ version, C++17, we don't have concepts. So, we need to use templates to emulate this concept behavior:
// The default case for can_reserve is false
template<typename T, typename = void>
struct can_reserve : std::false_type {};
// An overload of the struct allows us to verify we can call a value of type T
// If substitution doesn't fail, this overload is selected.
template<typename T>
struct can_reserve<T, std::void_t<decltype(std::declval<T>().reserve(1))>> : std::true_type {};
// With inline constexpr values, we can make this a type trait
template<typename T>
inline constexpr bool can_reserve_v = can_reserve<T>::value;
// We can then verify we can reserve with the types
static_assert(can_reserve_v<std::vector<int>>);
static_assert(!can_reserve_v<std::deque<int>>);
The function then becomes:
template<typename T>
void reserve(T& cell, int size)
{
if constexpr(can_reserve_v<T>)
cell.reserve(size);
}
Creating this kind of template is boilerplate-y and sometimes failure-prone. To solve that, we can use the detection idiom, which reduces the boilerplate and makes the code more readable:
// Using FluentCPP's is_detected implementation of the detection idiom
template<typename T>
using reserve_expression = decltype(std::declval<T&>().reserve(1));
template<typename T>
constexpr bool can_reserve_v = is_detected<reserve_expression, T>;
(The reserve function stays the same)
For completeness, the equivalent in C++20 would be:
template<typename T>
concept can_reserve = requires(T& t){
{ t.reserve(1) };
};
template<typename T>
void reserve(T& cell, int size)
{
if constexpr(can_reserve<T>)
cell.reserve(size);
}

Answer 2

There is a neat C++20 solution:
#include <vector>
#include <deque>
//typedef std::vector<int> mcc;
typedef std::deque<int> mcc;
mcc cell;
template<typename T>
void reserve(T& cell, int size)
{
if constexpr(requires{cell.reserve(size);}) {
cell.reserve(size);
}
}
int main()
{
reserve(cell, 10);
return 0;
}