C++ calling superclass with if statment

Question

I think I am missing something here but can't figure out what..

If I do this, I get compile error "error C2446: ':': no conversion from 'const boost::defer_lock_t' to 'const boost::try_to_lock_t'"

public: 
explicit BasicScopedLock( CCondition& condition, bool initiallyLocked = true ) 
    : LockType( condition.mutex, (initiallyLocked == true ? (boost::try_to_lock) : (boost::defer_lock)) ) 
    , m_condition( condition ) 
{ 
} 

But if I do this, it compiles.

public: 
explicit BasicScopedLock( CCondition& condition, bool initiallyLocked = true ) 
    : LockType( condition.mutex, boost::try_to_lock ) 
    , m_condition( condition ) 
{ 
} 

This works too...

public: 
explicit BasicScopedLock( CCondition& condition, bool initiallyLocked = true ) 
    : LockType( condition.mutex, boost::defer_lock ) 
    , m_condition( condition ) 
{ 
} 

Does anyone have a clue on why compiler doesn't like the if statement here?

Thank you!

Answer 1

The problem is that boost::try_to_lock and boost::defer_lock are of completely unrelated types, and LockType( condition.mutex, boost::try_to_lock) and LockType(condition.mutex, boost::defer_lock) are invoking separate overloads. As such, you can't use the ternary operator to pick between them.

Your options are:

A. to find another overload of the LockType constructor that will allow you to switch at runtime (this is obviously best)

B. if LockType is a moveable type, then you can write a function:

CLockType create_lock_type( CMutex& mutex, bool initiallyLocked)
{
    if (initiallyLocked)
        return CLockType(mutex,boost::try_to_lock);
    else
        return CLockType(mutex,boost::defer_lock);
}

C. to use the universal solution to problems in computer science: add another level of indirection. Change the declaration of LockType to:

    std::unique_ptr<CLockType> pLockType;

and the initialization to:

  : pLockType(initiallyLocked? 
         std::make_unique<CLockType>(condition.mutex, boost::try_to_lock):
         std::make_unqiue<CLockType>(condition.mutex, boost::defer_lock))

Answer 2

This is not an if statement, but an expression using the conditional operator^†. The "true" and "false" operands to this operator must have the same type (roughly speaking), but (as your compiler says) there is no conversion possible between these boost::try_to_lock and boost::defer_lock.

Without a MCVE and a description of what you're trying to do, I cannot give a proper suggestion as to how to achieve your goal, but I can tell you that this is not going to cut it.

_{^† Sometimes mistakenly called the "ternary operator", because it is a ternary operator and the only one currently defined.}