Can you evaluate a constructor call to boolean with an overloaded bool()?

Question

Can a constructor call be evaluated to a boolean if the bool() operator is overloaded?

class A
{
  public:
  A() {};
  operator bool() const { return true; }
}

main()
{
  if (A a = A())
  {
  // do stuff
  }
}

Is the above code valid, or do I need to implement main like:

int main(int argc, const char* argv[])
{
A a();
if (a)
  {
  // do stuff
  }
}

This code is going to wind up all over the place in my code base, so less lines, increased legibility, and reduced scope are important, and would be improved by this.

Any ideas?

Answer 1

The code contains a few syntactic and semantic bugs. Let's fix them

class A
{
public:
  A() {};
  operator bool() { return true; }
};

int main()
{
  if (A a = A())
  {
    // do stuff
  }
}

You may choose to change the type in the conversion function to something else. As written, the boolean conversion will also succeed to convert to any integer type. Converting to void* will limit conversion to only bool and void*, which is a commonly used idiom. Yet another and better way is to convert to some private type, called safe bool idiom.

class A
{
private:
  struct safe_bool { int true_; };
  typedef int safe_bool::*safe_type;
public:
  A() {};
  operator safe_type() { return &safe_bool::true_; }
};

Back to syntax: If you have an else part, you may use the name of the declared variable, because it's still in scope. It's destroyed after all branches are processed successfully

if(A a = A())
{ ... }
else if(B b = a)
{ ... }

You may also use the same name as before, and the variable will shadow the other variables, but you may not declare the same name in the most outer block of any branch - it will conflict rather than hide with the other declaration.

if(int test = 0)
{ ... }
else
{ int test = 1; /* error! */ }

The technique to declare and initialize a variable is most often used together with dynamic_cast though, but can be perfectly used together with a user defined type like above, too

if(Derived *derived = dynamic_cast<Derived*>(base)) {
  // do stuff
}

Note that syntactically, you have to initialize the variable (using the = expression form like for a default argument). The following is not valid

if(ifstream ifs("file.txt")) {
  // invalid. Syntactic error
}

Answer 2

The answer to your first question is "yes", but your "constructor call" is wrong. A a declares a variable. It's a statement, not an expression. A() is an expression which constructs an anonymous temporary instance of A:

struct A
{
    A() {};
    operator bool() { return true; }
};

int main()
{
    if (A())
    {
        // do stuff
    }
}

If you want to use the instance of A in "stuff", then you need:

if (A a = A()) {
    // do stuff
}

Answer 3

You can do this, but only when you're using the copy-initialization syntax to call your constructor. For example:

main()
{
    if (A a = A())
    {
       // do stuff
    }
}

Most compilers would elide the copy constructor in such an initializer when optimizations are enabled, but an accessible constructor is required nonetheless.

Also, naturally, if A would have a constructor such as A(int), you could also do this:

if (A a = 123) ...

Also, it is generally considered a bad idea to have operator bool() on your class for such purposes. The reason is that bool is in turn implicitly convertible to any numeric type (with false == 0 && true == 1); so, for example, the client of your class can write:

int x = A();

void foo(float y);
foo(A());

which is probably not something you want to allow. A simple trick is to use a pointer-to-member-of-private-class instead:

class A {
private:
    struct dummy_t { int dummy; };
    typedef int dummy_t::*unspecified_boolean_type;
public:
    operator unspecified_boolean_type() const {
        if (...) {
            return &dummy_t::dummy; // true
        } else {
            return 0; // false
        }
    }
};

Pointers-to-members have an implicit bool conversion (as usual, null pointer is false, anything else is true), but they are not compatible with any type but their own; and, since the inner class here is private, no client code can possibly declare a variable of that type (auto and decltype in C++0x provide a way, though).

As a side note, main() as written is not valid C++ - ISO C++ does not have "default int" rule the way C does, and a function without an explicit return type is invalid.

Answer 4

If you're trying to indicate failure, why not throw an exception?

#include <stdexcept>

class Foo
{
public:
    Foo(void)
    {
        if (/* something bad D: */)
        {
            throw std::runtime_error("Couldn't open file, etc...");
        }
    }
}

int main(void)
{
    try
    {
        Foo f;
        // do stuff with f
    }
    catch (std::exception& e)
    {
        std::cerr << "Error: " << e.what() << std::endl;
    }
}