C++:灵活且能够存储多种数据类型的数组

我目前正在开发一个C++库，我正在制作一个数组类，它就像向量一样，能够存储多种类型的数据。但是，我遇到了一些问题并试图解决它们，但我失败了。我缩短了代码，使其更易于查看和理解。

下面是我的代码：

class Char
{
public:
Char()
{
}
Char(char value)
{
v = value;
}
Char(Char& value)
{
v = value.val();
}
char val()
{
return v;
}
private:
char v;
};
class Int
{
public:
Int()
{
}
Int(int value)
{
v = value;
}
Int(Int& value)
{
v = value.val();
}
int val()
{
return v;
}
private:
int v;
};
class Array
{
private:
class ArrayDef
{
private:
enum class Types
{
Char,
Int
};
union ArrayTypes {
public:
Char CharV;
Int IntV;
ArrayTypes()
{
}
ArrayTypes(Char value)
: CharV(value)
{
}
ArrayTypes(Int value)
: IntV(value)
{
}
~ArrayTypes()
{
}
void assign(const ArrayTypes& value, const Array::ArrayDef::Types& type)
{
if (type == Types::Char)
CharV = value.CharV;
else if (type == Types::Int)
IntV = value.IntV;
}
};
public:
mutable Types tp;
mutable ArrayTypes v;
ArrayDef()
{
}
ArrayDef(const ArrayDef& value)
{
v.assign(value.v, value.tp);
tp = value.tp;
}
ArrayDef(Char value)
{
v.assign(value, Types::Char);
tp = Types::Char;
}
ArrayDef(Int value)
{
v.assign(value, Types::Int);
tp = Types::Int;
}
Char getChar()
{
if (tp != Types::Char)
throw(-1);
return v.CharV;
}
Int getInt() const
{
if (tp != Types::Int)
throw(-1);
return v.IntV;
}
void operator=(ArrayDef value)
{
v.assign(value.v, tp);
tp = value.tp;
}
};
mutable ArrayDef* v;
mutable int l = 0;
public:
Array()
{
}
~Array()
{
delete[] v;
}
int len() const
{
return l;
}
void add(const ArrayDef& value)
{
ArrayDef* temp = new ArrayDef[l + 1];
for (int i = 0; i < l; i++)
temp[i] = v[i];
l++;
v = temp;
v[l - 1] = value;
}
ArrayDef operator[](int value)
{
return v[value];
}
};

我创建了存储单个类型的Char和Int类(我这样做是为了模拟库中的类(。

我还创建了能够存储Char和Int类类型的主Array类。类ArrayDef中还有一个联合ArrayTypes，位于Array类的专用访问说明符下方。

以下是我的驱动程序代码：

int main()
{
Int i(100);
Char c('a');
Array arr;
arr.add(i);
arr.add(c);
std::cout << arr[0].getInt().val() << std::endl;
std::cout << arr[1].getChar().val() << std::endl;
}

输出的第一行错误，但输出的第二行正确。为什么会发生这种情况以及如何解决它？

由于一些技术问题，我无法使用 STL。

任何答案都值得赞赏。谢谢。和平。