Hi.

I'm writing a series classes that inherit from a base class using virtual. They are INT, FLOAT and STRING objects that I want to use in a scripting language. I'm trying to implement weak typing, but I don't want STRING objects to return copies of themselves when used in the following way (instead I would prefer to have a reference returned which can be used in copying):

a = "hello ";
b = "world";
c = a + b;

I have written the following code as a mock example:

#include <iostream>
#include <string>
#include <cstdio>
#include <cstdlib>

std::string dummy("<int object cannot return string reference>");

struct BaseImpl
{
    virtual bool is_string() = 0;
    virtual int get_int() = 0;
    virtual std::string get_string_copy() = 0;
    virtual std::string const& get_string_ref() = 0;
};

struct INT : BaseImpl
{
    int value;

    INT(int i = 0) : value(i)
    {
        std::cout << "constructor called\n";
    }
    INT(BaseImpl& that) : value(that.get_int())
    {
        std::cout << "copy constructor called\n";
    }
    bool is_string() { return false; }
    int get_int()
    {
        return value;
    }
    std::string get_string_copy()
    {
        char buf[33];
        sprintf(buf, "%i", value);
        return buf;
    }
    std::string const& get_string_ref()
    {
        return dummy;
    }
};

struct STRING : BaseImpl
{
    std::string value;

    STRING(std::string s = "") : value(s)
    {
        std::cout << "constructor called\n";
    }
    STRING(BaseImpl& that)
    {
        if (that.is_string())
            value = that.get_string_ref();
        else
            value = that.get_string_copy();

        std::cout << "copy constructor called\n";
    }
    bool is_string() { return true; }
    int get_int()
    {
        return atoi(value.c_str());
    }
    std::string get_string_copy()
    {
        return value;
    }
    std::string const& get_string_ref()
    {
        return value;
    }
};

struct Base
{
    BaseImpl* impl;

    Base(BaseImpl* p = 0) : impl(p) {}
    ~Base() { delete impl; }
};

int main()
{
    Base b1(new INT(1));
    Base b2(new STRING("Hello world"));
    Base b3(new INT(*b1.impl));
    Base b4(new STRING(*b2.impl));

    std::cout << "\n";
    std::cout << b1.impl->get_int() << "\n";
    std::cout << b2.impl->get_int() << "\n";
    std::cout << b3.impl->get_int() << "\n";
    std::cout << b4.impl->get_int() << "\n";
    std::cout << "\n";
    std::cout << b1.impl->get_string_ref() << "\n";
    std::cout << b2.impl->get_string_ref() << "\n";
    std::cout << b3.impl->get_string_ref() << "\n";
    std::cout << b4.impl->get_string_ref() << "\n";
    std::cout << "\n";
    std::cout << b1.impl->get_string_copy() << "\n";
    std::cout << b2.impl->get_string_copy() << "\n";
    std::cout << b3.impl->get_string_copy() << "\n";
    std::cout << b4.impl->get_string_copy() << "\n";

    return 0;
}

It was necessary to add an if check in the STRING class to determine whether its safe to request a reference instead of a copy:

Script code:

a = "test";
b = a;

c = 1;
d = "" + c; /* not safe to request reference by standard */

C++ code:

STRING(BaseImpl& that)
{
    if (that.is_string())
        value = that.get_string_ref();
    else
        value = that.get_string_copy();

    std::cout << "copy constructor called\n";
}

If was hoping there's a way of moving that if check into compile time, rather than run time.