Prevent the usage of some types in templates

Question

I have designed my own implementation of std::vector which I call il::vector. I would like either to:

• Specialize it for types that you can copy using memcpy (int, double, std::array<double, n>, etc..).
• Use a different class for types that you can't copy with memcpy such as std::vector. In the latter case, I want to have a compile-time error if I want to instantiate with something that can't be copied with memcpy, such as il::vector<std::vector<double>>.

Is there a way to do that ?

PS: I always get answer such as: you should use std::vector instead. The main reasons I use my own library are:

• I want to use a pointer to construct my il::vector without the data being copied
• I want to use ptrdiff_t as an array index instead of this stupid size_t. Using unsigned integers for arrays indexes is one of the worst idea of the STL. Even Stroustrup seems to be against it.
• I want to use my own allocators which are designed to be allocators, not this strange model of the 90s which was designed for a different purpose.

Sorry to be a little bit rude, but I am sick of: STL is god, don't even say that it does not fit your needs.

Answer 1

Since C++11, you may use traits std::is_trivially_copyable.

For an error case, may do something like:

namespace il
{

template <typename T /*, typename Allocator*/>
class vector
{
    static_assert(std::is_trivially_copyable<T>::value, "type should be trivially copyable");

    /* Your implementation */
};

}

To select different implementations you may use std::conditional

template <typename T /*, typename A*/>
using myvector = typename std::conditional<std::is_trivially_copyable<T>::value,
        il::vector<T>,
        std::vector<T>
    >::type

Answer 2

You can use the type trait is_trivially_copyable in conjunction with static assert.

template<typename T>
class IlVector {
  static_assert(is_trivially_copyable<T>::value,
              "Vector requires memcpy able type");
// ...  
};

int main() {
  IlVector<int> a;
  IlVector<double> b;
  IlVector<std::array<int,3> > c;
  IlVector<std::string> d;
  // your code goes here
  return 0;
}

This will give you an compile time error if your type cannot be copied by memcpy.