Overwrite Cast Operator in C++

Question

As a C++ beginner I want to write some simple type casts. It there a way to create casting logic which can be used in the type new = (type)old format with the prefix parentheses?

string Text = "Hello";
char* Chars = "Goodbye";
int Integer = 42;

string Message = Text + (string)Integer + (string)Chars + "!";

I'd like to stick with this syntax if possible. For example the string cast of boost int Number = boost::lexical_cast<int>("Hello World") has an unattractive long syntax.

Answer 1

Just use a normal function that you overload for different types:

std::string str(int i) {
   return "an integer";
}

std::string str(char* s) {
   return std::string(s);
}

Then use if not like a cast, but as a normal function call:

string Message = Text + str(Integer) + str(Chars) + "!";

Answer 2

It's the most common thing in C++ to cast using a NAME<TYPE>(ARGUMENT) syntax, like in static_cast<int>(char) . It makes sense to extend this the way boost does.

However, if you want to convert non-primitive types, you can use non-explicit constructors with a single argument and the cast operator.

class MyType {
  public:
    MyType(int); // cast from int
    operator int() const; // cast to int
};

This is not possible if you are dealing with already existing types.

You cannot change the behaviour of the C-style cast. C++ will make up its mind how to interpret such a cast.

You could however come up with an intermediate type that shortens the syntax:

template <typename From>
struct Cast {
  From from;
  Cast(From const& from) : from(from) {}
  template <typename To>
  operator To() const {
    return convert(from,To());
  }
};

template <typename From>
Cast<From> cast(From const& from) {
  return Cast<From>(from);
};

std::string convert(int, std::string const&);

This would allow you to convert things explicitly but without stating how exactly:

int i = 7;
std::string s = cast(i);