如何在 C++ 中为包含多种类型之一的包装器 class 实现多态性？

Question

I am an accomplished C programmer, and I have written an assembler and VM in C ( https://github.com/chucktilbury/assembler (mostly working but not complete)) and I am thinking of porting it to C++ so I can use the STL for obvious reasons. This is a hobby project with no expectations of actually being useful to anyone.

My VM has a notion of a Value, which can have exactly one of several types. I have implemented it using a struct with a union embedded in it. This has led to a bunch of huge macros to do simple things like addition and comparisons.

What I would like to do is have a base class that can be used to reference a Value and child classes that implement the specific type so that I don't have to spell out exactly how to retrieve the data that the Value implements.

In other words, This is what I have:

    ...
    switch(left_val->type) {
        ...
        case FLOAT:
            switch(right_val->type) {
            ...
                case INTEGER:
                    result->type = FLOAT;
                    result->data.float_val = left_val->data.float_val + right_val->data.int_val;
                    break;
            ...
            }
        ...
    }

What I would like to see:

  result->add(left_val, right_val); // over-simplified, I know....

Obviously, I can do this like I did it in C, and that's my knee-jerk reaction. But I feel that I am missing some major point of how this should work in C++.

As I understand it, there is no way to achieve what I want because C++ (like C) is a statically typed language. I may as well just encapsulate the ugly in a single class and just pass around Value(s) as I am currently doing in C.

Is there general agreement with that statement? Or am I totally wrong?

Answer 1

I suggest using a std::variant and std::visit to reduce the boilerplate.

Example:

#include <cstdint>
#include <variant>

using INTEGER = std::intmax_t;
using FLOAT = long double;

using Value = std::variant<INTEGER, FLOAT>;

auto operator+(const Value& lhs, const Value& rhs) {
    return std::visit([](auto&& l, auto&& r) -> Value { return l + r; }, lhs, rhs);
}

Now adding two INTEGER s would produce a variant holding an INTEGER . Involving a FLOAT in the addition would make the result FLOAT , just like in the normal rules of the language.

Example usage:

int main() {
    Value i = 10;
    Value f = 3.14159;

    auto r = i + f;
}

Demo

A C++20 version (kindly provided by user17732522):

auto operator+(const Value& lhs, const Value& rhs) {
    return std::visit<Value>(std::plus{}, lhs, rhs);
}

Answer 2

I have something very similar written in C++. I am assuming you have no expectation of performance. Here are some keypoints that might help:

You will need a way to store the type information for every piece of data. Instead of storing data type in an enum, you should use a class for this purpose. If you want to be able to support embedding additional types, your type system should be robust. Since I was aiming for an object oriented language, I have included data members and member functions (including operators and constructors) for types.

If you want to go built-in types only, you may register objects/classes to handle operators per type. Thus, once you have obtained a piece of data, you can get its type and invoke the necessary function. You may do this system using polymorphism but everytime you copy a the data, you will also copy the type. Therefore, you need to have a function that will clone your object properly. You could also go simpler route, but this will take more memory.

Type IntType() {
    Type t;
    t.addition = &add<int>;
    //...
    return t;
}

You can also create only one IntType and then distribute pointers of it for each data. Something similar to a vftable.

To actually store data, I have used my Any structure, it is very similar to std::any (I wrote this around 2014). You may use std::any for the data store. You have to be careful about types that cannot be copied.

If you want to see the project yourself, it is publically available at here . You should get 4.x-dev branch. The system is in Source/Scripting. Good luck.