Явный указатель void в качестве параметра функции

у меня есть функция:

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

могу ли я синтаксически (не с предупреждениями компилятора и т. д.) в C++11/14 отключить передачу там указателей, отличных от ?

например, теперь его можно назвать так:

foo(new int(42));

мне нужно отключить это.

15
c++ c++11 c++14 void-pointers

6 ответов

вы можете превратить функцию в шаблон, а затем использовать static_assert и std::is_void С type_traits:

template<typename T>
int foo(T *ptr) {
    static_assert(std::is_void<T>::value, "!");
   // ....
}

в противном случае, вы можете использовать std::enable_if_t на тип возврата:

template<typename T>
std::enable_if_t<std::is_void<T>::value, int>
foo(T *ptr) {
    // ....
    return 0;
}

и так далее, Другие интересные решения уже были предложены другими пользователями с их ответами.

вот минимальный рабочий пример:

#include<type_traits>

template<typename T>
int foo(T *ptr) {
    static_assert(std::is_void<T>::value, "!");
    // ....
    return 0;
}

int main() {
    int i = 42;
    void *p = &i;
    foo(p);
    // foo(&i); // compile error
}
7

Я полагаю, есть много других способов сделать это.

использование функций шаблона просто (он также работает с C++98)

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;
 }

как указано frymode, предыдущее решение дает ошибку компоновщика, а не ошибку компилятора, и лучше получить ошибку компилятора.

используя delete (из C++11) мы можем получить ошибку компилятора, используя вместо этого:

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

надеюсь, что это помогает.

18

вы можете использовать педантичный указатель фразеологизм. Ваш код должен выглядеть как показано ниже. Он использует тот факт, что нет неявных преобразований на более высоком уровне косвенности:

[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**'
}
9

Если вы хотите точное соответствие типа, вы можете использовать std:: enable_if С std:: is_same

#include <iostream>
#include <type_traits>

template <typename T,
          typename = typename std::enable_if_t<std::is_same<T, void*>::value>>
int foo(T value)
{
    return 5;
}

int main()
{
    // return foo(new int(42)); // error: no matching function for call to 'foo(int*)'
    return foo((void*)(new int(42)));
}
9

идиоматическим способом было бы создать новый тип для представления void* чтобы избежать проблемы, которую вы описываете. Многие сторонники хорошей практики C++ предлагают создавать типы, чтобы избежать сомнений в том, что должно быть передано, а также избежать компилятора, позволяющего вам.

class MyVoid
{
//... implement in a way that makes your life easy to do whatever you are trying to do with your void* stuff
};

int foo(MyVoid ptr)
{
   // ...
}
5

вам не нужен C++11 для обеспечения ошибки времени компиляции:

template<class> struct check_void;

template<> struct check_void<void> { typedef void type; };

template<class T> typename check_void<T>::type *foo(T *ptr) { return ptr; }

int main()
{
    foo(static_cast<void *>(0));  // success
    foo(static_cast<int *>(0));  // failure
}
1