Question

首先：我知道更改对象的类通常是一个坏主意，但我实现了自己的编程语言，并且它包含可以包含任何值的变量类型，甚至可以随意改变他们的类型，所以请假设我不是一个不了解OO基础知识的初学者。

目前，我在C中实现我的变量变量。每个变量都有一个指向函数指针表的指针，包含SetAsInt()，SetAsString()等函数，后面跟着实例变量C ++。所有对象的大小都相同。

当变量包含字符串并且有人为其分配Int时，我手动调用析构函数，将函数指针表更改为指向用于variadic int值的表，然后然后设置它的int实例变量。

这有点难以维护，因为每次添加新类型时，我都要添加一个新的函数指针表，并在其中填写 all 函数指针。函数指针的结构似乎是非常糟糕的类型检查，丢失的字段不会导致投诉，所以我很容易意外忘记列表中的一个指针并获得有趣的崩溃。另外，我必须重复大多数类型中相同的所有函数指针。

我希望用C ++实现我的可变参数类型，其中很多这种类型检查和继承默认行为是由编译器为我完成的。有安全的方法吗？

PS - 我知道我可以创建一个包装器对象并使用new来分配一个新对象，但我不能为每个int变量增加额外的分配开销在堆栈上。

PPS - 目前，代码需要在Linux，Mac，iOS和Windows上可移植，但如果有人拥有标准的C ++解决方案，那就更好了。

PPPS - 类型列表是可扩展的，但在编译时预先确定。我语言的基础层只定义了基本类型，但我编译的语言的宿主应用程序增加了几种类型。

用法示例：

CppVariant someNum(42); // Creates it as CppVariantInt.

cout << "Original int: " << someNum->GetAsInt()
    << " (" << someNum->GetAsDouble() << ")" << endl;

someNum->SetAsInt(700); // This is just a setter call.

cout << "Changed int: " << someNum->GetAsInt()
    << " (" << someNum->GetAsDouble() << ")" << endl;

someNum->SetAsDouble(12.34); // This calls destructor on CppVariantInt and constructor on CppVariantDouble(12.34).

cout << "Converted to Double: " << someNum->GetAsInt()
    << " (" << someNum->GetAsDouble() << ")" << endl; // GetAsInt() on a CppVariantDouble() rounds, or whatever.

（想象一下，除了double和int之外，将来会有其他类型，比如字符串或布尔值，但GetAsInt（）/ SetAsInt（）的调用者不应该知道它的存储内容，只要它可以在运行时转换）

Answer 1

这是一个基于类型擦除，联合和模板特化的解决方案我不确定它是否符合您的要求无论如何，这是它得到的：

任何内容都放在动态存储空间
不需要等级

您可以轻松地进一步改进它以减少代码量，但这旨在作为开始的基点。

它遵循一个基于问题中预期用途的最小工作示例：

#include<iostream>

class CppVariant {
    union var {
        var(): i{0} {}
        int i;
        double d;
    };

    using AsIntF = int(*)(var);
    using AsDoubleF = double(*)(var);

    template<typename From, typename To>
    static To protoAs(var);

public:
    CppVariant(int);
    CppVariant(double);

    int getAsInt();
    double getAsDouble();

    void setAsInt(int);
    void setAsDouble(double);

private:
    var data;
    AsIntF asInt;
    AsDoubleF asDouble;
 };

template<>
int CppVariant::protoAs<int, int>(var data) {
    return data.i;
}

template<>
int CppVariant::protoAs<double, int>(var data) {
    return int(data.d);
}

template<>
double CppVariant::protoAs<int, double>(var data) {
    return double(data.i);
}

template<>
double CppVariant::protoAs<double, double>(var data) {
    return data.d;
}

CppVariant::CppVariant(int i)
    : data{},
      asInt{&protoAs<int, int>},
      asDouble{&protoAs<int, double>}
{ data.i = i; }

CppVariant::CppVariant(double d)
    : data{},
      asInt{&protoAs<double, int>},
      asDouble{&protoAs<double, double>}
{ data.d = d; }

int CppVariant::getAsInt() { return asInt(data); }
double CppVariant::getAsDouble() { return asDouble(data); }

void CppVariant::setAsInt(int i) {
    data.i = i;
    asInt = &protoAs<int, int>;
    asDouble = &protoAs<int, double>;
}

void CppVariant::setAsDouble(double d) {
    data.d = d;
    asInt = &protoAs<double, int>;
    asDouble = &protoAs<double, double>;
}

int main() {
    CppVariant someNum(42);
    std::cout << "Original int: " << someNum.getAsInt() << " (" << someNum.getAsDouble() << ")" << std::endl;
    someNum.setAsInt(700);
    std::cout << "Changed int: " << someNum.getAsInt() << " (" << someNum.getAsDouble() << ")" << std::endl;
    someNum.setAsDouble(12.34);
    std::cout << "Converted to Double: " << someNum.getAsInt() << " (" << someNum.getAsDouble() << ")" << std::endl;
}

Answer 2

在百灵鸟上，我尝试使用贴装新来做这件事，我有......某事......它编译，它完成了工作，但我不确定是否它是对纯C的改进。由于我不能拥有C ++对象的联合，我创建了一个CPPVMAX()宏来传递所有子类中最大的sizeof()作为大小mBuf[]，但那也不是很好。

#include <iostream>
#include <string>
#include <cmath>

#define CPPVMAX2(a,b)       (((a) > (b)) ? (a) : (b))
#define CPPVMAX3(a,b,c)     CPPVMAX2((a),CPPVMAX2((b),(c)))

using namespace std;


class CppVariantBase
{
public:
    CppVariantBase() { cout << "CppVariantBase constructor." << endl;  }
    virtual ~CppVariantBase() { cout << "CppVariantBase destructor." << endl; }

    virtual int     GetAsInt() = 0;
    virtual double  GetAsDouble() = 0;

    virtual void    SetAsInt( int n );
    virtual void    SetAsDouble( double n );
};


class CppVariantInt : public CppVariantBase
{
public:
    CppVariantInt( int n = 0 ) : mInt(n)
    {
        cout << "CppVariantInt constructor." << endl;
    }
    ~CppVariantInt() { cout << "CppVariantInt destructor." << endl; }

    virtual int     GetAsInt()      { return mInt; }
    virtual double  GetAsDouble()   { return mInt; }

    virtual void    SetAsInt( int n )           { mInt = n; }

protected:
    int     mInt;
};


class CppVariantDouble : public CppVariantBase
{
public:
    CppVariantDouble( double n = 0 ) : mDouble(n)
    {
        cout << "CppVariantDouble constructor." << endl;
    }
    ~CppVariantDouble()
    {
        cout << "CppVariantDouble destructor." << endl;
    }

    virtual int     GetAsInt()
    {
        if( int(mDouble) == mDouble )
            return mDouble;
        else
            return round(mDouble);
    }
    virtual double  GetAsDouble()           { return mDouble; }

    virtual void    SetAsDouble( int n )    { mDouble = n; }

protected:
    double mDouble;
};


class CppVariant
{
public:
    CppVariant( int n = 0 ) { new (mBuf) CppVariantInt(n); }
    ~CppVariant()           { ((CppVariantBase*)mBuf)->~CppVariantBase(); }

    operator CppVariantBase* () { return (CppVariantBase*)mBuf; }
    CppVariantBase* operator -> () { return (CppVariantBase*)mBuf; }

protected:
    uint8_t mBuf[CPPVMAX3(sizeof(CppVariantBase),sizeof(CppVariantInt),sizeof(CppVariantDouble))];
};

void    CppVariantBase::SetAsInt( int n )
{
    this->~CppVariantBase();
    new (this) CppVariantInt(n);
}


void    CppVariantBase::SetAsDouble( double n )
{
    this->~CppVariantBase();
    new (this) CppVariantDouble(n);
}


int main(int argc, const char * argv[]) {
    CppVariant someNum(42);

    cout << "Original int: " << someNum->GetAsInt()
        << " (" << someNum->GetAsDouble() << ")" << endl;

    someNum->SetAsInt(700); // This is just a setter call.

    cout << "Changed int: " << someNum->GetAsInt()
        << " (" << someNum->GetAsDouble() << ")" << endl;

    someNum->SetAsDouble(12.34);    // This changes the class to CppVariantDouble.

    cout << "Converted to Double: " << someNum->GetAsInt()
        << " (" << someNum->GetAsDouble() << ")" << endl;

    return 0;
}

如何更改C ++对象的类（实现可变参数类型）

用法示例：

2 个答案: