Explicit void pointer as function parameter

Question

I have a function:

int foo(void * ptr)
{
   // ...
}

Can I syntactically (not with compiler warnings, etc.) in C++11/14 disable passing there pointers other than void * itself?

For example, now it can be called like:

foo(new int(42));

I need to disable this.

Answer 1

I suppose there are many other ways of doing it.

Using template functions is simple (it works with C++98 too)

template <typename X>
int foo (X * ptr);

int foo (void * ptr)
 { return 1; }

int main()
 {
   int  i;
   void * vp = &i;

   foo(vp);  // OK
   foo(&i);  // linker error

   return 0;
 }

As pointed by frymode, the preceding solution give a linker error, not a compiler error, and it's better to get a compiler error.

Using delete (from C++11) we can get a compiler error by using this instead:

template <typename X>
int foo (X ptr) = delete;

Hope this helps.

Answer 2

You can make use of pedantic pointer idiom. Your code should look as bellow. It makes use of the fact that there is no implicit conversions at the higher that one level of indirection:

[live]

int foo_impl(void * ptr, void **)
{
   return 0;
}

template <typename T>  
void foo(T* t)  
{  
  foo_impl(t, &t);  
}  

int main()
{
    void* pv;
    foo(pv);
    //foo(new int(2)); // error: error: invalid conversion from 'int**' to 'void**'
}