Question

EDIT: Following Mike Seymour’s comment, I replaced operator std::string () const; with operator char * () const; and changed the implementation accordingly. This allows implicit casting, but, for some reason, the unsigned long int operator has precedence over the char * operator, which just does not feel right… Also, I don’t want to expose nasty C stuff like char * outside the class, when I have std::string. I have a hunch that my CustomizedInt class needs to inherit from some stuff in order to support the feature that I desire. Could anybody please elaborate Mike’s comment regarding std::basic_string? I’m not sure I understood it properly.

---

I have this piece of code:

#include <string>
#include <sstream>
#include <iostream>

class CustomizedInt
{
private:
    int data;
public:
    CustomizedInt() : data(123)
    {
    }
    operator unsigned long int () const;
    operator std::string () const;
};

CustomizedInt::operator unsigned long int () const
{
    std::cout << "Called operator unsigned long int; ";
    unsigned long int output;
    output = (unsigned long int)data;
    return output;
}

CustomizedInt::operator std::string () const
{
    std::cout << "Called operator std::string; ";
    std::stringstream ss;
    ss << this->data;
    return ss.str();
}

int main()
{
    CustomizedInt x;
    std::cout << x << std::endl;
    return 0;
}

Which prints “Called operator unsigned long int; 123”. My questions are these:

1. After I remove the operator unsigned long int, why do I need to cast x to std::string explicitly? Why does it not call the implicit cast operator (std::string) directly?
2. Is there any documentation that explains which implicit casts are allowed and which is their order of precedence? It seems that if I add an operator unsigned int to this class together with the operator unsigned long int, I receive a compiler error about ambiguity for the << operator…
3. Also, I know that defining such an operator may be poor practice, but I am not sure I fully understand the associated caveats. Could somebody please outline them? Would it be better practice to just define public methods ToUnsignedLongInt and ToString?

Answer 1

After I remove the operator unsigned long int, why do I need to cast x to std::string explicitly? Why does it not call the implicit cast operator (std::string) directly?

The version of << for strings is a template, parametrised by the parameters of the std::basic_string template (std::string itself being a specialisation of that template). It can only be chosen by argument-dependent lookup, and that only works if the argument is actually a specialisation of std::basic_string, not something convertible to that.

Is there any documentation that explains which implicit casts are allowed and which is their order of precedence?

The rules are quite complex, and you’d need to read the C++ standard for the full story. Simple rules of thumb are that implicit conversions can’t contain more than one user-defined conversion and (as you’ve found out) the result of an implicit conversion can’t be used to choose a template specialisation by argument-dependent lookup.

I am not sure I fully understand the associated caveats. Could somebody please outline them?

I don’t fully understand them either; the interactions between implicit conversions, name lookup and template specialisation (and probably other factors that I can’t think of right now) are rather complex, and most people don’t have the inclination to learn them all. There are quite a few instances where implicit conversion won’t happen, and others where it might happen when you don’t expect it; personally, I find it easier just to avoid implicit conversions most of the time.

Would it be better practice to just define public methods ToUnsignedLongInt and ToString?

That’s probably a good idea, to avoid unwanted conversions. You can fix your problem by leaving them and use them explicitly when necessary:

std::cout << std::string(x) << std::endl;

In C++11, you can declare them explicit, so that they can only be used in this manner. In my opinion, that would be the best option if you can; otherwise, I would use explicit conversion functions as you suggest.

By the way, the return type of main() must be int, not void.