Проверка на подпись конструктора времени компиляции

Question

Есть ли способ проверить во время компиляции, если какой-либо класс имеет конструктор с определенными аргументами? ?

Например:

class foo { 
    foo(std::string &s) { 
    } 
}; 

Я хочу, чтобы проверить во время компиляции, что конструктор с станд :: строка & всегда определена. Может быть, boost обеспечивает такую ​​функциональность?

Answer 1

Если вам действительно нужно, вы можете добавить эту функцию:

static void _dummy() { std::string s; foo f(s); } 

Без вашего конструктора, компиляция потерпит неудачу. Примечание: ваш конструктор является закрытым. Если это специально, то в классе должен находиться _dummy. В противном случае вы можете получить его вне класса.

Кроме того, вы можете templatize или даже сделать его макросом, если это очень часто происходит в вашем коде.

Но, честно говоря, он по-прежнему выглядит как взломанный. Вы уверены, что вам это нужно?

Answer 2

То, о чем вы просите, звучит очень похоже на единичный тест. Я бы загрузил что-то вроде cppunit и интегрировал его в вашу компиляцию.

Все юнит-тесты, которые вы пишете, будут построены/выполнены во время компиляции. См. Unit Testing для получения дополнительной информации.

Answer 3

Если вам нужен этот вид проверки, вам, вероятно, потребуется некоторое другое время компиляции проверки

я предлагаю взглянуть повысить проверки библиотеки концепции (документация here). Вы можете найти документацию, классы и макросы, которые могут вам помочь.

Answer 4

Если вы пытаетесь проверить, является ли foo конструктивным из строки, вы можете использовать boost::is_convertible.

Например:

BOOST_STATIC_ASSERT((boost::is_convertible<std::string, foo>::value)); 

Answer 5

Использование проверки Концепция в наддува 1.39:

#include <boost/concept_check.hpp> 

class foo_c 
{ 
public: 
    foo_c(std::string& s) 
    {} 
}; 

template<typename T> 
class algo_c 
{ 
BOOST_CONCEPT_ASSERT((boost::Convertible<std::string,T>)); 
public: 
    algo_c() 
    {} 
}; 

Удаление или изменение конструктора foo_c результата в следующей компиляции ошибки времени:

error C2440: 'initializing' : cannot convert from 'std::string' to 'foo_c'

EDIT: Это может быть сделано для работы с явным конструктором с homem ADE проверка концепции:

template <typename T> 
struct HasTheRightConstructor 
{ 
    BOOST_CONCEPT_USAGE(HasTheRightConstructor) 
    { 
     std::string v; 
     T j(v); 
    } 
}; 

Answer 6

Распространенный способ проверить, является ли конкретная функция существует, чтобы взять его адрес и назначить его фиктивной переменной. Это намного точнее, чем упомянутые выше тесты, поскольку это проверяет точную сигнатуру функции. И вопрос был конкретно о string& в сигнатуре, поэтому неконстантный и, следовательно, предположительно изменяющий строку.

Однако в этом случае вы не можете использовать трюк take-the-address-and-assign-it: у конструкторов нет адресов. Итак, как вы проверяете подпись? Просто: Подружитесь с ним в фиктивном классе.

template<typename T> 
class checkSignature_StringRef { 
    friend T::T(string&); 
}; 

Это тоже очень специфическая проверка: она даже не будет соответствовать другим подобным конструкторам как foo::foo(std::string &s, int dummy = 0).

Answer 7

Я столкнулся с аналогичной проблемой, желающей переслать конструкторы в базовый класс, когда аргументы совместимы, и сделать что-то еще, когда нет.

Вот обобщенные черты работают на MSVC 2013 (требуется C++ 11 материала):

namespace detail { 
    template<class type,class...Args> 
    class constructible_from 
    { 
     template<class C> 
     static C arg(); 

     template <typename U> 
     static boost::mpl::true_ constructible_test(U *, decltype(U(arg<Args>()...)) * = 0); 
     static boost::mpl::false_ constructible_test(...); 

    public: 

     typedef decltype(constructible_test(static_cast<type*>(nullptr))) result; 

    }; 
} // namespace detail 

template<class type> 
struct constructible 
{ 
    template<class...Args> 
    struct from : 
     detail::constructible_from<type,Args...>::result {}; 
}; 

Вот пример использования черт, я оставляю enable_if применения в качестве упражнения: D:

struct b{}; 
struct c{}; 
struct d : c{}; 

struct a 
{ 
    a() {} 
    a(a &) {} 
    a(b,c) {} 
    a(c) {} 
}; 


static_assert(
    constructible<a>::from<>::value, 
    "a()" 
); 
static_assert(
    constructible<a>::from<a&>::value, 
    "a(a&)" 
); 
static_assert(
    ! constructible<a>::from<const a&>::value, 
    "a(const a&)" 
); 
static_assert(
    constructible<a>::from<b,c>::value, 
    "a(b,c)" 
); 
static_assert(
    ! constructible<a>::from<b>::value, 
    "a(b)" 
); 
static_assert(
    constructible<a>::from<c>::value, 
    "a(c)" 
); 
static_assert(
    constructible<a>::from<d>::value, 
    "a(d)" 
);