Question

我正在尝试在nontemplate类中定义模板类，下面你可能会看到我实际尝试做的代码（由于显而易见的原因，它不能编译）。主要问题是如何才能实现使用C ++ 11（首选）或C ++ 14？

实际上我已经使用std::variant或BOOST库中的相同函数获得了解决方案，但我需要知道另一种方法来解决这个问题。
我发现旧的类似question，Anne Quinn的回答听起来很有价值（他建议为我需要的每种类型声明子类），但是如何在代码中应用它？
< / LI>
代码：
```
#include <vector>
#include <cstdint>

enum Type {
    INT16,
    UINT32
};

template<typename T>
class Buffer {
public:
    Buffer(uint32_t paramSize) {
        buffer.resize(paramSize);
    }

private:
    std::vector<T> buffer;
};

class Foo {
public:
    Foo(Type paramType, uint32_t paramSize) {
        switch(paramType) {
        case UINT32:
            buffer = Buffer<uint32_t>(paramSize);
            break;
        case INT16:
            buffer = Buffer<int16_t>(paramSize);
            break;
        }
    }

private:
    Buffer buffer;
};

int main() {
    Foo var(INT16, 30);

    return 0;
}
```
@ user2308211的
UPD1：回答似乎有效，但我遇到了两个问题。如果我正在复制对象Foo和原始对象由于某种原因而被破坏（例如，移出范围），复制将保持指向无处的指针。第二个是如何通过Foo类检索我的缓冲区。

UPD2： shared_ptr解决了复制问题，但是复制将存储同一个对象，如果你想独立修改它们，请使用复制构造函数，如答案所示。至于对原始缓冲区的访问，void指针允许你检索指向vector的指针，然后你应该将它static_cast到你的类型。

谢谢！

Answer 1

将具有Buffer所有必需功能的基类作为纯虚拟。

#include <vector>
#include <cstdint>

enum Type {
    INT16,
    UINT32
};

class BufferBase {
public:
    virtual void someFn()=0;
    virtual ~BufferBase() {}
};

template<typename T>
class Buffer:public BufferBase {
public:
    Buffer(uint32_t paramSize) {
        buffer.resize(paramSize);
    }

    void someFn() override {
      //functionality.
    }
    ~Buffer() {}

private:
    std::vector<T> buffer;
};

class Foo {
public:
    Foo(Type paramType, uint32_t paramSize) {
        this->bufferType = paramType;
        switch(paramType) {
        case UINT32:
            buffer = new Buffer<uint32_t>(paramSize);
            break;
        case INT16:
            buffer = new Buffer<int16_t>(paramSize);
            break;
        }
    }
    ~Foo() {
        delete this->buffer;
    }
    Foo &operator=(const Foo &other) {
        this->bufferType = other.bufferType;
        switch(bufferType) {
        case UINT32:
            buffer = new Buffer<uint32_t>(*static_cast<Buffer<uint32_t>*>(other.buffer));
            break;
        case INT16:
            buffer = new Buffer<int16_t>(*static_cast<Buffer<int16_t>*>(other.buffer));
            break;
        }
        return *this;
    }
    Foo(const Foo &other) {
        *this=other;
    }

private:
    BufferBase *buffer;
    Type bufferType;
};

int main() {
    Foo var1(INT16, 30), var2(UINT32, 25);
    var1 = var2;

    return 0;
}

编辑：我已经用复制构造函数更新了答案。

C ++在构造函数中选择类成员的模板类型

1 个答案: