struct AbstractConverterFunction
{
    typedef bool (*Converter)(const AbstractConverterFunction *, const void *, void*);
    explicit AbstractConverterFunction(Converter c = nullptr)
        : convert(c) {}
    AbstractConverterFunction(const AbstractConverterFunction&)=delete;
    AbstractConverterFunction& operator=(const AbstractConverterFunction&)=delete;
    Converter convert;
};

template<typename From, typename To>
struct ConverterMemberFunction : public AbstractConverterFunction
{
    explicit ConverterMemberFunction(To(From::*function)() const)
        : AbstractConverterFunction(convert),
          m_function(function) {}
    ~ConverterMemberFunction();
    static bool convert(const AbstractConverterFunction *_this, const void *in, void *out)
    {
        const From *f = static_cast<const From *>(in);
        To *t = static_cast<To *>(out);
        const ConverterMemberFunction *_typedThis =
            static_cast<const ConverterMemberFunction *>(_this);
        *t = (f->*_typedThis->m_function)();
        return true;
    }

    To(From::* const m_function)() const;
};

template<typename From, typename To>
struct ConverterMemberFunctionOk : public AbstractConverterFunction
{
    explicit ConverterMemberFunctionOk(To(From::*function)(bool *) const)
        : AbstractConverterFunction(convert),
          m_function(function) {}
    ~ConverterMemberFunctionOk();
    static bool convert(const AbstractConverterFunction *_this, const void *in, void *out)
    {
        const From *f = static_cast<const From *>(in);
        To *t = static_cast<To *>(out);
        bool ok = false;
        const ConverterMemberFunctionOk *_typedThis =
            static_cast<const ConverterMemberFunctionOk *>(_this);
        *t = (f->*_typedThis->m_function)(&ok);
        if (!ok)
            *t = To();
        return ok;
    }

    To(From::* const m_function)(bool*) const;
};

template<typename From, typename To, typename UnaryFunction>
struct ConverterFunctor : public AbstractConverterFunction
{
    explicit ConverterFunctor(UnaryFunction function)
        : AbstractConverterFunction(convert),
          m_function(function) {}
    ~ConverterFunctor();
    static bool convert(const AbstractConverterFunction *_this, const void *in, void *out)
    {
        const From *f = static_cast<const From *>(in);
        To *t = static_cast<To *>(out);
        const ConverterFunctor *_typedThis =
            static_cast<const ConverterFunctor *>(_this);
        *t = _typedThis->m_function(*f);
        return true;
    }

    UnaryFunction m_function;
};

#include <string>
#include <cassert>

// 示例類：String
class String {
private:
    std::string m_str;
public:
    String(std::string s) : m_str(std::move(s)) {}
    
    // 成員函數(shù)：轉(zhuǎn)換為長度（size_t）
    size_t length() const { return m_str.size(); }
    
    // 帶校驗的成員函數(shù)：轉(zhuǎn)換為 int（類似 QString::toInt）
    int toInt(bool *ok) const {
        try {
            int val = std::stoi(m_str);
            *ok = true;
            return val;
        } catch (...) {
            *ok = false;
            return 0;
        }
    }
};

int main() {
    // 1. 使用 ConverterMemberFunction：String → size_t（調(diào)用 length()）
    ConverterMemberFunction<String, size_t> lenConverter(&String::length);
    String s1("hello");
    size_t len;
    // 調(diào)用轉(zhuǎn)換：通過基類指針
    AbstractConverterFunction *converter = &lenConverter;
    bool ok = converter->convert(converter, &s1, &len);
    assert(ok && len == 5);  // 成功，長度為5


    // 2. 使用 ConverterMemberFunctionOk：String → int（調(diào)用 toInt）
    ConverterMemberFunctionOk<String, int> intConverter(&String::toInt);
    String s2("123");
    int num;
    ok = intConverter.convert(&intConverter, &s2, &num);
    assert(ok && num == 123);  // 轉(zhuǎn)換成功

    String s3("abc");  // 無法轉(zhuǎn)換為int
    ok = intConverter.convert(&intConverter, &s3, &num);
    assert(!ok && num == 0);  // 轉(zhuǎn)換失敗，num為默認(rèn)值0


    // 3. 使用 ConverterFunctor：String → std::string（調(diào)用 lambda）
    auto strToStdStr = [](const String& s) { 
        return static_cast<std::string>(s);  // 假設(shè)String有轉(zhuǎn)換運算符
    };
    ConverterFunctor<String, std::string, decltype(strToStdStr)> functorConverter(strToStdStr);
    std::string stdStr;
    ok = functorConverter.convert(&functorConverter, &s1, &stdStr);
    assert(ok && stdStr == "hello");  // 轉(zhuǎn)換成功

    return 0;
}

#include <vector>

int main() {
    // 創(chuàng)建多種轉(zhuǎn)換器
    MyString s1("hello"), s2("123");
    std::string str("test");

    // 存儲轉(zhuǎn)換器指針（統(tǒng)一為 AbstractConverterFunction*）
    std::vector<AbstractConverterFunction*> converters;
    
    // 添加場景1的轉(zhuǎn)換器（MyString → int，成員函數(shù)）
    converters.push_back(new ConverterMemberFunction<MyString, int>(&MyString::toInt));
    // 添加場景2的轉(zhuǎn)換器（MyString → int，帶校驗）
    converters.push_back(new ConverterMemberFunctionOk<MyString, int>(&MyString::toInt));
    // 添加場景3的轉(zhuǎn)換器（string → size_t，lambda）
    auto lambda = [](const std::string& s) { return s.size(); };
    converters.push_back(new ConverterFunctor<std::string, size_t, decltype(lambda)>(lambda));

    // 動態(tài)調(diào)用第一個轉(zhuǎn)換器（MyString → int）
    int output1;
    converters[0]->convert(converters[0], &s1, &output1);
    std::cout << "轉(zhuǎn)換器1結(jié)果：" << output1 << std::endl; // 5

    // 動態(tài)調(diào)用第二個轉(zhuǎn)換器（帶校驗）
    int output2;
    converters[1]->convert(converters[1], &s2, &output2);
    std::cout << "轉(zhuǎn)換器2結(jié)果：" << output2 << std::endl; // 123

    // 動態(tài)調(diào)用第三個轉(zhuǎn)換器（string → size_t）
    size_t output3;
    converters[2]->convert(converters[2], &str, &output3);
    std::cout << "轉(zhuǎn)換器3結(jié)果：" << output3 << std::endl; // 4

    // 釋放內(nèi)存
    for (auto c : converters) delete c;
    return 0;
}