如何在C++中实现类数组指定实例化类？（适配Python思维）

Hey there! I totally get where you're coming from—Python's dynamic typing makes this kind of string-to-class mapping feel second nature, but C++ is statically typed, so we need to tweak your approach a bit to make it work. Let's break down how to replicate that functionality cleanly.

First, Fix the Core Issue: Storing "Class Types" in C++ #

You can't directly store a class type in a struct like you tried in your example—C++ doesn't allow that. Instead, we'll use factory functions (or lambdas) to wrap the logic of creating new objects. We'll also use a base class for all your target classes so we can handle instances uniformly.

Step 1: Define Your Base and Derived Classes

First, create a base class that all your instantiable classes inherit from. This lets us treat all objects the same way:

#include <string>
#include <vector>
#include <memory>
#include <unordered_map>
#include <iostream>

// Base class for all your types
class BaseClass {
public:
    virtual ~BaseClass() = default; // Critical for proper cleanup of derived classes
    virtual void doSomething() const = 0; // Example virtual method to demonstrate polymorphism
};

// Your first class
class Class1 : public BaseClass {
public:
    void doSomething() const override {
        std::cout << "Hello from Class1!\n";
    }
};

// Your second class
class Class2 : public BaseClass {
public:
    void doSomething() const override {
        std::cout << "Hello from Class2!\n";
    }
};

Step 2: Create Your Type Mapping Structure

Instead of storing the class directly, we'll store a name and a factory function that creates an instance of the class. Here's how to make a struct matching your original idea, plus an array (or vector) of these entries:

// Struct to hold type name and object creator
struct InstanceType {
    std::string name;
    // Factory function: returns a smart pointer to a BaseClass instance
    std::function<std::unique_ptr<BaseClass>()> factory;
};

// Initialize your array of types (just like your original goal!)
std::vector<InstanceType> typesArray = {
    {"Type1", []() { return std::make_unique<Class1>(); }},
    {"Type2", []() { return std::make_unique<Class2>(); }}
};

Step 3: Implement the Matching & Instantiation Logic

Now we can loop through your object names, match them to the entries in typesArray, and create objects:

int main() {
    // List of object names you want to create
    std::vector<std::string> objectsToCreate = {"Type1", "Type2", "Type1"};

    for (const auto& objName : objectsToCreate) {
        for (const auto& typeEntry : typesArray) {
            if (typeEntry.name == objName) {
                // Create the object using the factory function
                std::unique_ptr<BaseClass> newObject = typeEntry.factory();
                // Use the object (polymorphism works here!)
                newObject->doSomething();
                // You can store newObject in a collection or use it directly here
                break;
            }
        }
    }

    return 0;
}

Bonus: Optimize with a Hash Map #

If you have many types, looping through an array every time can be slow. Swap the array for an unordered_map for O(1) lookups:

// Create a map of names to factory functions
std::unordered_map<std::string, std::function<std::unique_ptr<BaseClass>()>> typeMap = {
    {"Type1", []() { return std::make_unique<Class1>(); }},
    {"Type2", []() { return std::make_unique<Class2>(); }}
};

// Simplified lookup logic
for (const auto& objName : objectsToCreate) {
    auto it = typeMap.find(objName);
    if (it != typeMap.end()) {
        auto newObject = it->second();
        newObject->doSomething();
    } else {
        std::cout << "Warning: Unknown type '" << objName << "'\n";
    }
}

Key Notes #

• Smart Pointers: We use std::unique_ptr to automatically manage object memory—no manual delete needed!
• Polymorphism: The base class's virtual methods let us interact with all derived objects through a common interface, just like how you might use a base class or interface in Python.
• Flexibility: If your classes need constructor arguments, you can adjust the factory function to accept them (e.g., std::function<std::unique_ptr<BaseClass>(int, std::string)>).

This approach gives you the exact functionality you wanted: matching strings to classes and instantiating objects dynamically, while playing by C++'s static typing rules.

内容的提问来源于stack exchange，提问作者Jon Snow