如何从 c++ 中的 function 返回不同的类型？

Question

I have a homework in c++ to make a Vector for multi data types in the same vector, I stuck where I need to return different data types and I can't change the main.

The homework ask to make the main valid:

int main()
{
    Vector v;
    v.add(5);
    v.add(5.5f);
    v.add("this");
    for (int i = 0; i != v.size(); ++i) { // this code print 5 5.5 this
        std::cout << v.get(i) << "\t";
    }
    std::cout << "Displaying an object of type Vector in different way:\n";
    Integer x;
    x = v.get(0);
    std::cout << x << "\t"; // it prints 5
    Float y;
    y = v.get(1);
    std::cout << y << "\t"; // it prints 5.5
    String z;
    z = v.get(2);
    std::cout << z << "\t"; // it prints this
}

I tried what I know and I got 3 ways but still didn't fix that first I made all data pointer is char* and made a string type that worked with saving the data and cout but it stuck on return data type, I cant use template because I'm not allowed to change the main

int get(int n)
{
    Node* p = head;
    int i;
    for (i = 0; (i < n)&&p->next; i++)
        p = p->next;
    if (i != n)
        return NULL;
    if (p->type != "int")
        return NULL;
    else return *((int*)p->data);
}

still I cant overload functions by just the return type, I tried to make vector have 3 pointers to data but still I stuck

int* int_;
float* float_;
string* string_;
Node* next;
string type;
Node(string type_)

I searched on internet and still not found what I want, at last I tried to make the Node template but since the get function is on the vector and the main didn't send a type that's didn't solve the problem.

Answer 1

You might return wrapper with conversion operator, something like:

struct data
{
    int int_ = 0;
    float float_ = 0;
    string string_;

    operator int () const { return int_; }
    operator float () const { return float_; }
    operator std::string () const { return string_; }
};


const Node* get_node(int n) const
{
    Node* p = head;
    int i;
    for (i = 0; (i < n) && p->next; i++)
        p = p->next;
    return p;
}

data get(int n) const
{
    auto* node = get_node(n);
    if (node == nullptr) throw std::out_of_range{};
    return node->data;
}

Demo

Answer 2

If I understood correctly, what you are looking for is an heterogeneous container .

You need to create a wrapper that handle different types transparently inside your container. For your underlying type you have several options depending on your necessity.

If you know upfront the list of types that you need to support at compile type, you can use std::variant https://en.cppreference.com/w/cpp/utility/variant .

If the types that you need to support are unbounded at compile time you can use https://en.cppreference.com/w/cpp/utility/any

Finally, you can create a common interface and implement a wrapper for your supported types. The container will store a smart pointer of your objects.

UPDATE

• removed suggestion on designed decision based on the C++ version
• removed reference to std::vector