C++ 从函数返回多个类型引用并将它们强制转换为我们需要的类型

C++ Returning multiple type references from function and casting them to a type that we need

本文关键字：类型 转换 我们 返回 函数 C++ 引用      更新时间：2023-10-16

我需要一个返回变量的函数，但我不想指定它将返回的变量类型（这是以后使用中要确定的）。

// unknownType is a char, because it uses only one byte of memory
typedef char unknownType;
unknownType& func (bool typeSelector) {
    // let's say we want to return double and int type
    double dblVal = 3.5;
    int intVal = 5;
    // return type depends on typeSelector's state
    if (typeSelector == true)
        return (unknownType&)dblVal;
    else
        return (unknownType&)intVal;
}

然后我会像这样使用它：

double dblVal = (double&) func(true);
std::cout << dblVal << std::endl;
std::cout << (int&) func(false);

上面的代码工作得很好（如果我不尝试返回更复杂的对象，例如 std：：string，但这可以满足我的需求）;我已经在Linux和Windows上编译了它。但我不相信这是否是我问题的便携式解决方案。

我的

问题是：这段代码中是否有任何内容可以分解我的程序并使其无用？就性能而言，它的效率如何？

编辑：为什么我不能在这里使用模板

我有一个基类：

class Base {
public:
    virtual unknownType& getValue () = 0;
};

然后是几个派生类，它们包含不同类型的变量：

class DerivedDbl : public Base {
private:
    double value;
public:
    DerivedDbl (double val) : value(val) {}
    unknownType& getValue () {
        double toReturn = value;
        return (unknownType&)toReturn;
    }
};
class DerivedInt : public Base {
private:
    int value;
public:
    DerivedInt (int val) : value(val) {}
    unknownType& getValue () {
        int toReturn = value;
        return (unknownType&)toReturn;
    }
};

然后我有一个类，它存储派生类并对它们进行一些操作：

class Storage {
private:
    std::vector <Base*> vec;
public:
    void operator+= (Base& obj) { vec.push_back(&obj); }
    unknownType& operator[] (int ID) {
        return vec[ID]->getValue();
    }
};

而且我希望有时能够获取存储的派生类的变量值（我知道我添加了哪一个，所以我知道它们的类型），但我不认为为每个方法创建单独的 getter 方法不是那么优雅的获取它们的方式，像这样的代码对我来说看起来更清晰：

DerivedDbl derivedDbl(3.5);
DerivedInt derivedInt(5);
Storage storage;
storage += derivedDbl;
storage += derivedInt;
std::cout << (double&)storage[0] << std::endl;
std::cout << (int&)storage[1];

但也许我错过了一些东西，可以使用不同的方法做同样的事情（我尝试过模板但没有想出任何好主意，你们劝阻了空指针，联合和结构需要更多的内存）。

您正在返回对局部变量的引用。这有时似乎有效，但这是未定义的行为，并且会在某个时候严重破坏您的程序。

如果你真的需要一个虚函数，它可能应该返回某种类型隐藏类（例如 boost：：any）。然后，可以将返回值强制转换为正确的类型。

或者，可以将函数设置为非虚拟函数，并从基类型强制转换为相应的派生类型。然后，派生类可以只返回您实际想要的类型。

模板可用于促进这种行为，例如：

class Base
{
public:
    virtual ~Base() { }
};
template<class T>
class ValueType : public Base
{
public:
    explicit ValueType(T value): value(value) { }
    T& GetValue()
    {
        return value;
    }
private:
    T value;
}
struct Storage
{
    std::vector<Base*> objects;
    template<class T> 
    T& GetValue(unsigned int index)
    {
        auto derived = dynamic_cast<ValueType<T>*>(objects[index]);
        return derived->GetValue();
    }
};

编辑：更改了访问控制。

相关文章：