Check at compile time class constructor signature

Question

Hello!

Is there a way to check at compile time if some class has constructor with certain arguments ? ?

For example:

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

I want to check at compile time that constructor with std::string& always defined. Maybe boost provides such functionality ?

Answer 1

If you really need it, you can add this function:

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

Without your constructor, the compilation will fail. Note: your constructor is private. If it's on purpose, then _dummy should be inside the class. Otherwise, you can have it outside the class.

Also, you can templatize or even make it a macro, if this happens a lot in your code.

But to tell the truth, it still looks like a hack. Are you sure you need it?

Answer 2

What you are asking for sounds a lot like a unit test. I would download something like cppunit and integrate it into your compilation.

Any unit tests you write will be built/executed at compile time. See Unit Testing for more information.

Answer 3

If you need this kind of checks, you'll probably need some other compile time checking

I suggest to take a look to boost concept checking library (documentation is here). You can find some documentation, classes and macros that can help you.

Answer 4

If you're trying to check if foo is constructible from a string, you can use boost::is_convertible.

For example:

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

Answer 5

Using Concept check in boost 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()
    {}
};

Removing or changing the constructor of foo_c result in the following compile time error:

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

EDIT: That can be made to work with explicit constructor with a homemade concept check:

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

Answer 6

The common way to check if a specific function exists is to take its address and assign it to a dummy variable. This is a lot more precise than the tests mentioned so far, because this verifies the exact function signature. And the question was specifically about string& in the signature, so non-const and thus presumably modifying the string.

However, in this case you cannot use the take-the-address-and-assign-it trick: constructors don't have addresses. So, how do you check the signature then? Simply: Befriend it in a dummy class.

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

This too is a very specific check: it will not even match similar constructors like foo::foo(std::string &s, int dummy = 0).