Thread: Object of any type

With all this PHP programming I've been doing lately, I've been thinking about writing a class that acts like it's variables. For those who are completely unfamiliar with PHP, you can assign essentially any type to a variable. For example:

PHP Code:

$somevar = 123;
$somevar = "a string!";
$somevar = new array();
$somevar[0] = 456;
$somevar[1] = "another string"; 


This is a very neat magic trick and I thought it would be fun to implement something like that myself in C++. I am completely unaware if there is already something like it already exists for C++ (even if it does I'd like to do it myself), but if there is I'd like to know about it.

Basically why I'm telling you all this is that I'm in the middle of implementing it and all is going well. You can assign any primitive type to an object and cast from any type to another. You can even have an array of mixed types; here's a line from my testing (It's really neat stuff):

Code:

  Morph arr[COUNT] = { "null", 1, "Three3", 4444, 'X', 3.14159f, UINT_MAX, str, wchar_t(65535) };

Anyway, as I'm getting deeper into it things are getting more complicated. For example, if you want to assign an array you can use a constructor that also accepts the number of elements and a copy is made on the heap for the object. Now I'm thinking that you should also be able to assign an object to a pointer (just pointing, not copying). What issues come to mind when you contemplate building such a class? I still haven't given much thought to how it will handle being assigned user-defined types and such. Right now the class is so filled with templates and explicit specializations that it's sort of depressing to look at. There are some complications and problems I don't understand, but I'm saving that fun for later.

If you have any thoughts on how such a class should be implemented or on some things that one shouldn't forget (special cases, etc), please share them.

That is basically what I'm using. I store a void*, the size of a single element (to help determine it's type), the number of elements we're pointing at (0 for a single variable, >0 for an allocated array, and UINT_MAX for a pointer to somewhere else), and whether or not it is signed. I use all this data to determine the object's type and so on, but it is not very attractive at all because in order to determine if it is signed/unsigned I have to have all sorts of ugly specializations just for the unsigned's so I can set the internal "signed" variable to false.

Either way, what you've suggested is pretty much what I'm doing. Have you any other thoughts with regard to the more nitty-gritty innerworkings? I'm talking pointers, arrays, operator*, operator[], operator&, etc.

Some tricky things are, for example, that you can cast to a const char* and regardless of the actual type it will return a string with the value, but if you cast to a char* for a numeric value nothing good is returned because there is no accessible char* for the user to touch. Another is operator[]. You can use it to retrieve a variable, but you can't use it to return a reference. With operator& should you return the address of the void* or ? Depending on the actual stored type, lots of different do lots of different things and all these decisions are based on the size of an element (that doesn't feel too safe). Many things to ponder...

See that is one of the caveat's I'm talking about (and a very dirty one to work around). As far as int and long go, it doesn't matter which one you use to manipulate/print the value because they represent the same number (when they are the same size). Now float is another thing altogether. If you use a float, the class internally thinks it's a double since a double is 8 bytes, and doing that causes a lot of other little issues (like when printing, casting, etc).

It is really a messy thing to do, using templates and explicit specialization and such, and I'm thinking of forgetting all that and just coding an assignment operator for every built-in type. So instead of a template <typename T> Morph(T val); I would have Morph(int val); Morph(short val); Morph(unsigned int val); ... You can see why I didn't (and still don't) want to do that, but if I do it will provide me the luxury of knowing without a doubt what type the user is trying to use. Although I'm still unsure about how I'd go about handling user-defined data types. Maybe I'll just skip them altogether. Anyone have any ideas about how you could go about casting a void* to a user-defined class without ever possibly knowing the class before-hand?

This can be pretty simple to do in C++.

Suppose you have $varname = <value>

With C++, you can use RTTI to get the type of the object, or you could define the type yourself using reasoning. Here's a very inefficient way:
1. Create a std::map mapping the var names to a class you define
2. That class you define simply allocates a new object of the type the value is on the heap. The destructor can be useful for deallocating. The class defines all the operators you need for an object (simply deferring it to the object's inherent operators).

Maybe I'll try it out later.

EDIT: In case I wasn't clear, here's what I mean:
The interpreter sees the expression $varname = 12345;. It takes '12345' and interprets it (no quotes, all numbers == integer type). It sees it's an integer and creates a new std::map pair <"varname", CVar>. Then it does what it needs to in the CVar object. The class has this:

Code:

class CVar{
    void *ptr;//pointer to the object we will create
    std::string type;//the type of the object to create
public:
    CVar(){};
    //blah blah blah, implement copy constructor for $var1 = $var2, destructor, etc.
};

Yes, you need to know the type, but you can figure it out and do something like that.

Just for reference, Boost.Any and Boost.Variant are two classes that represent such stuff.

Thanks for the reference CornedBee. I've read through those classes and have implemented a class like ("like" meaning "identical to") the Any class. It's implementation is very interesting, however it doesn't actually accomplish what I'd like it to. The best thing about it is how it allows you to assign any type of variable to it. The problems I have with it are that you can not assign any variable to it (two-dimensional arrays and such don't compile, understandably) and if you assign it an array it just takes on the value of the pointer instead of allocating a copy. Perhaps I'm asking too much (it certainly appears that way), and if so I'm just going to give up on it. It seems some of the concepts I'm trying to implement just cannot be written with C++.

Well, I believe that it would be best, given that you're already dealing with advanced C++, to simply give up the raw types. Use vectors instead of arrays, std::strings instead of C-style strings etc.