不使用继承，借助std::variant实现通用接口约束

Great question! Avoiding inheritance while maintaining strict interface constraints is totally doable in C++20, thanks to Concepts for compile-time checks and std::visit for type-safe unified dispatch. Here's a step-by-step solution that matches your requirements:

1. Enforce Interface Constraints with Concepts #

First, we'll define a concept that acts as a compile-time "contract" for all visual element types. It mandates that any valid type must implement your required methods (hitTest, boundingRect, uniqueId) with the correct signatures—just like unimplemented pure virtual functions in inheritance, but checked at compile time.

#include <concepts>
#include <variant>
#include <string>

// Forward declarations for dependent types
struct Point {};
struct Rect {};

template<typename T>
concept VisualElementConcept = requires(const T& obj, const Point& p) {
    // Require hitTest takes a Point and returns bool
    { obj.hitTest(p) } -> std::convertible_to<bool>;
    // Require boundingRect returns a Rect
    { obj.boundingRect() } -> std::convertible_to<Rect>;
    // Require uniqueId returns a std::string
    { obj.uniqueId() } -> std::convertible_to<std::string>;
};

2. Define Your Element Types #

Each type (Circle, Image, Polygon) simply implements the required methods—no inheritance or base class is needed. You can add type-specific members freely:

struct Circle {
    bool hitTest(const Point& p) const {
        // Your hit test logic here
        return true;
    }
    Rect boundingRect() const {
        // Your bounding rect calculation here
        return {};
    }
    std::string uniqueId() const {
        return "circle_001";
    }
    // Type-specific members
    double radius() const { return 5.0; }
    Point center() const { return {}; }
};

struct Image {
    bool hitTest(const Point& p) const { /* ... */ return true; }
    Rect boundingRect() const { /* ... */ return {}; }
    std::string uniqueId() const { return "image_001"; }
    // Type-specific members
    std::string imagePath() const { return "path_to_image.png"; }
};

struct Polygon {
    bool hitTest(const Point& p) const { /* ... */ return true; }
    Rect boundingRect() const { /* ... */ return {}; }
    std::string uniqueId() const { return "polygon_001"; }
    // Type-specific members
};

3. Create Your Variant and Validate Constraints #

Define your VisualElement variant, then use static_assert to ensure every type in the variant satisfies our concept. This prevents accidental inclusion of types that don't meet the interface:

using VisualElement = std::variant<Circle, Image, Polygon>;

// Compile-time checks to enforce all variant types meet the interface
static_assert(VisualElementConcept<Circle>);
static_assert(VisualElementConcept<Image>);
static_assert(VisualElementConcept<Polygon>);

4. Unified Method Calls with std::visit #

Since std::variant doesn't support direct member access like a base class pointer, we use std::visit to dispatch to the correct type's method. We can wrap this in helper functions for clean, readable calls:

Option 1: Per-Method Helpers #

Create dedicated functions for each interface method to mirror the inheritance-style experience:

#include <vector>
#include <iostream>

std::string getUniqueId(const VisualElement& elem) {
    return std::visit([](const auto& obj) {
        return obj.uniqueId();
    }, elem);
}

bool hitTestElement(const VisualElement& elem, const Point& p) {
    return std::visit([&p](const auto& obj) {
        return obj.hitTest(p);
    }, elem);
}

Rect getBoundingRect(const VisualElement& elem) {
    return std::visit([](const auto& obj) {
        return obj.boundingRect();
    }, elem);
}

Option 2: Generic Visitor #

For more flexibility, create a generic helper that lets you invoke any operation on the variant's underlying object:

template<typename Func>
auto applyToElement(const VisualElement& elem, Func&& func) {
    return std::visit(std::forward<Func>(func), elem);
}

5. Usage Example #

Now you can use your variant-based setup just like you intended, with type safety and compile-time checks:

int main() {
    std::vector<VisualElement> elements;
    elements.emplace_back(Circle{});
    elements.emplace_back(Image{});
    elements.emplace_back(Polygon{});

    // Using per-method helpers
    for (const auto& elem : elements) {
        std::cout << "Element ID: " << getUniqueId(elem) << "\n";
    }

    // Using generic visitor for ad-hoc operations
    Point testPoint;
    const auto& firstElem = elements[0];
    bool isHit = applyToElement(firstElem, [&testPoint](const auto& obj) {
        return obj.hitTest(testPoint);
    });
    if (isHit) {
        std::cout << "First element was hit!\n";
    }

    return 0;
}

Key Advantages Over Inheritance #

• Value Semantics: No need for smart pointers—your variant stores objects directly, avoiding heap allocation overhead and memory management headaches.
• Compile-Time Safety: Concepts and static_assert catch interface violations early, before runtime.
• No Slicing: Unlike storing derived objects in a base-class value container, std::variant preserves the full type of each element.
• Performance: Dispatch via std::visit is usually faster than virtual function calls (it's resolved at compile time).

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