0

鉴于以下情况，根据某些条件，我的数据可能属于不同类型。

class myClass {
public:
    myclass() {
        if (condition1) {
          bool boolValue = false;
          data = boolValue;
        } else if (condition2) {
          int intValue = 0;
          data = intValue;
        } else if (condition3) {
          unsigned int unsignedIntValue = 0;
          data = unsignedIntValue;
        } else if (condition4) {
          long longValue = 0;
          data = longValue;
        } else if (condition5) {
          double doubleValue = 0.0;
          data = doubleValue;
        } else if (condition6) {
          float floatValue = 0.0;
          data = floatValue;
        } else if (condition7) {
          char *buffer = new char[10];
          data = buffer;
        }
    }

    void* getData() const { return data; }

private:
    void *data;
}

碰巧，我的 void 指针指向的值严格在每个语句中。因此，使用 getData() 返回的内容可能无效。如果我确实得到了数据，那只是因为我指向的内存位置还没有被覆盖。

我想出的解决方案是这样的：

class myClass {
public:
    myclass() {
        if (condition1) {
          boolValue = false;
          data = boolValue;
        } else if (condition2) {
          intValue = 0;
          data = intValue;
        } else if (condition3) {
          unsignedIntValue = 0;
          data = unsignedIntValue;
        } else if (condition4) {
          longValue = 0;
          data = longValue;
        } else if (condition5) {
          doubleValue = 0.0;
          data = doubleValue;
        } else if (condition6) {
          floatValue = 0.0;
          data = floatValue;
        } else if (condition7) {
          buffer = new char[10];
          data = buffer;
        }
    }

    void* getData() const { return data; }

private:
    void *data;
    bool boolValue;
    int intValue;
    unsigned int unsignedIntValue;
    long longValue;
    double doubleValue;
    float floatValue;
    char *buffer;
}


我在想必须有一种更优雅的方式来做到这一点。有什么建议么？

4

2 回答 2

1

您可以使用联合在内存中保存一些位，然后使用指针转换从联合中获取值：

#include<iostream>
using namespace std;

class myClass {
public:
    myClass(char *str){
        data.str = str;
    }
    myClass(double d){
        data.d = d;
    }
    myClass(float f){
        data.f = f;
    }

    void *getData() { return (void*)&data; }
private:
    union {
        double d;
        float f;
        char *str;
    } data;
};

int main(){
    myClass c(2.0);
    cout << *(double*)c.getData() << endl;

    myClass f(3.0f);
    cout << *(float*)f.getData() << endl;

    myClass s("test");
    cout << *(char**)s.getData() << endl;

    system("pause");
}

/* prints
2
3
test
*/
于 2012-11-28T12:14:44.097 回答
1

如果您在创建对象后不需要更改数据的类型，那么您可以使用模板类：

template <typename T>
class myBaseClass {
public:
    // Declare common functions here.
    T getData()
    { return data; }

protected:
    T data;

protected:
    // Disallow constructing instances of this class outside the child classes.
    myBaseClass(T val) : data(val) { }
};

template <typename T>
class myClass: public myBaseClass<T> {
public:
    myClass() : myBaseClass<T>(0) { }
};

然后你专攻char*：

template <>
class myClass<char*>: public myBaseClass<char*> {
public:
    myClass() : myBaseClass(new char[10]) { }
};

然后，您可以像这样创建实例：

myClass<int> a;
myClass<float> b;
myClass<char*> c;
// etc.
int i = a.getData();
float f = b.getData();
char* str = c.getData();
于 2012-11-28T12:29:41.443 回答