当然不是像JS和（AFAIK）Dart这样的动态语言所允许的方式。
C++是静态类型的，所以当你在一个（非模板的）函数中写cout << ptr->item.value时，必须知道item和value的类型，不能在运行时混淆不相关的类型，比如int和string。
然而，你也可以使用继承来达到你想要的效果。一个对象的指针总是可以被转换成指向它的（可访问的，例如public）基的指针，并且像基一样被访问--但是对象将保留它的实际类型，并且base的所有 virtual 方法将作用于该类型，并且可以被覆盖：

class foo {
public:
    virtual ~foo() = default; // optional but highly recommended
    virtual randomize() {
        // the default implementation
    }
    // or: virtual randomize() = 0; // if you want ALL subclasses to override it
};

class bar_1: public foo {
public:
    int value = 99;
    void randomize() override {
        // the bar_1-specific implementation
    }
};

class bar_2: public foo {
public:
    std::string value = "something";
    void randomize() override {
        // the bar_2-specific implementation
    }
};

...

foo *obj = new bar_1(); // create an object of type bar_1, but treat it as foo
obj->randomize(); // will call bar_1::randomize as obj points to an object of type bar_1
// obj->value = 42; // won’t work: value is not a member of foo
delete obj;

obj = new bar_2(); // now, create an object of type bar_2, but treat it as foo again
obj->randomize(); // will call bar_2::randomize as obj now points to an object of type bar_2
delete obj;

或使用智能指针（强烈推荐）：

std::unique_ptr<foo> obj = std::make_unique<bar_1>()
// std::unique_ptr<foo> obj{new bar_1()}; // if you can’t afford C++17
obj->randomize();

obj = std::make_unique<bar_2>();
// obj.reset(new bar_2()); // if you can’t afford C++17
obj->randomize();

正如注解所指出的，不能在块结束后使用指向块中声明的变量的指针，可以使用std::unique_ptr或std::optional来解决这个问题。
这里有两种可能的解决方案。

1：std::variant<foo<bar_1>, foo<bar_2>>可以包含任何一种类型的对象，而不需要对现有的类做任何修改（也不需要任何动态分配），然后我们可以使用std::visit来处理它所包含的任何对象。

#include <variant>
#include <optional>
int main()
{
    int i;
    std::cin >> i;
    std::optional<std::variant<foo<bar_1>, foo<bar_2>>> the_foo;
    if (i > 0) {
        the_foo = foo<bar_1>{};
    }
    else {
        the_foo = foo<bar_2>{};
    }

    // run the function to randomise 'value'
    std::visit([](auto &foo) { foo.item.randomise(); }, *the_foo);
    std::visit([](auto &foo) { std::cout << foo.item.value; }, *the_foo);
    return 0;
}

2如果你可以改变类，注意bar_1和bar_2都包含一些公共操作“randomise item”和“print item”。所以我们可以创建一个接口，允许多态使用这些操作，而不需要知道实际类型。如果你以后添加其他类似的类，这也更容易扩展。

class IBar {
public:
    virtual ~IBar() = default;
    virtual void print(std::ostream& os) const = 0;
    virtual void randomise() = 0;
};

class bar_1 : public IBar {
public:
    int value;

    void print(std::ostream& os) const override
    { os << value; }

    void randomise() override;
};

class bar_2 : public IBar {
public:
    std::string value;

    void print(std::ostream& os) const override
    { os << value; }

    void randomise() override;
};

现在foo甚至不需要是一个模板，它只需要使用一个接口指针来代替实际类型的成员：

#include <memory>
class foo {
public:
    std::unique_ptr<IBar> pItem;
    explicit foo(std::unique_ptr<IBar> p) : pItem(std::move(p)) {}
    foo() = default;
};

int main()
{
    int i;
    std::cin >> i;
    foo the_foo;
    if (i > 0) {
        the_foo.pItem = std::make_unique<foo<bar_1>>();
    }
    else {
        the_foo.pItem = std::make_unique<foo<bar_2>>();
    }

    // run the function to randomise 'value'
    the_foo.pItem->randomise();
    the_foo.pItem->print(std::cout);
    return 0;
}