So as some of you might know, as of now it is not possible to create conversion operators that are not part of the corresponding class.
This causes ugly situations, where one has one class, and eg. std::string, both not editible by yourself for whatever reason i might add, and needs to add a conversion operator simply because value(std::string) is cumbersome and will not work for all cases (easy transformation using <algorithm> for example).
For all of those, i got some very basic solution here:
#include <memory>
#include <string>
#include <iostream>
class data
{
public:
virtual std::string to_string() const = 0;
};
class value
{
private:
std::shared_ptr<data> m_data;
public:
value() : m_data() {}
value(std::shared_ptr<data> data) : m_data(data) {}
template<typename T>
value(T t) : m_data(to_data(t)) {}
std::shared_ptr<data> get() { return m_data; }
};
class d_string : public data
{
private:
std::string m_value;
public:
d_string(std::string s) : m_value(s) {}
virtual std::string to_string() const override { return m_value; }
};
inline std::shared_ptr<data>& to_data(std::shared_ptr<data>& input, std::string str)
{
input = std::make_shared<d_string>(str);
return input;
}
int main(int argc, char** argv)
{
value val;
val = std::string("test");
std::cout << val.get()->to_string() << std::endl;
}This fancy "hack" will output test as expected and work on all major compilers :)
It works because whilst conversion operators might not be possible, operator overloading (like the << operator we abuse here) is!