C++ 儿童班'；动态方法调用父类'；虚拟方法用于lambda捕获/导致分段故障

编辑：在虚拟函数的实现中使用final关键字会导致打印正确的字符串，但是为什么这里需要final关键字呢？有人能解释一下吗

我正在修补可变模板，我有非常通用的类D1，D2，D3。。。它们都派生自一个类a。每个类都有一个静态和动态打印函数，父类有一个用于动态调度的虚拟动态打印函数。当我尝试在单个文件上复制它时：

A类{
公众：
虚空printDynamic（）；
静态void printStatic（）；
}
D1类：公共A{
公众：
虚空printDynamic（）；
静态void printStatic（）；
}

我有以下几种变体：

std:：variant apvar；
std：：变异型avar；

我用所有派生类D1、D2等实例化了这两个变量，。。。（我知道向上投射指针，我只是想去引用它们的类型，做一些随机的事情）

我已经为包装器实现了递归访问者，我需要捕获它，因为我将大多数函数封装在一个类中，当我在类上调用访问者时，我得到了名称“DX”、“DX”；X对应于1

模板
无效访问(演员){
性病：访问(
[此]（自动和值）{
如果constexpr（std:：is_same:：value）{
value.printStaticName（）；
value.printDynamicName（）；
}否则{
访问_actor（）；
}
}，艾瓦
);
}

但是如果我在指针变量上调用访问者，并且在调用函数时： 对于静态函数，我得到：“DX”，X对应于I，但是当我调用动态函数时，我得到了名称：“Abstract A”

模板
无效访问\u指针（）{
性病：访问(
[此]（自动和值）{
如果constexpr（std:：is_same:：value）{
值->printStaticName（）；
值->printDynamicName（）；
}否则{
访问_pointer（）；
}
}，apvar
);
}

我试着用C++文档阅读它，但是还没有找到原因。调用派生类的静态函数而调用父虚拟函数的原因可能是什么

对于最小可生产示例，您需要实例化这些类：

#include <variant>
#include <iostream>
#include <string>

template <class T>
using expr_type = std::remove_cv_t<std::remove_reference_t<T>>;

template<class A,class... As>
class ActorWrapper{
    public:
    std::variant<A,As...> var;
    template<class Ins>
    ActorWrapper(Ins ins) : var(ins) {}
};

template<class A,class... As>
class ActorPointer{
    public:
    std::variant<A,As... > var;
    template<class T>
    ActorPointer(T* t) : var(t) {}
};


class X {
    public:
    int a;

    virtual std::string getDynamicName() {
        return "dynamic X";
    }

    static std::string getStaticName(){
        return "static X";
    }
};

class D1 : public X{
    public:
    bool b;
    std::string getDynamicName()  override {
        return "dynamic D1";
    }

    static std::string getStaticName(){
        return "static D1";
    }
};

class D2: public X {
    public:
    bool b;
    std::string getDynamicName() override {
        return "dynamic D2";
    }

    static std::string getStaticName(){
        return "static D2";
    }
};




template<class A, class... As>
class TemplatedAGraph{
    private:
    //change aw to correspond to ap
    template<class X>
    void visit_actor(){
        std::visit(
            [this](auto&& value){
                if constexpr(std::is_same<expr_type<decltype(value)>, expr_type<X>>::value){
                    std::cout << "z" << std::endl;
                    std::cout << value.getStaticName() << std::endl;
                    std::cout << value.getDynamicName() << std::endl;
                }else{
                    std::cout << "d" << std::endl;
                    return;
                }
            }, aw.var
        );
    }

    template<class X, class Y, class... Zs>
    void visit_actor(){
        std::visit(
            [this](auto&& value){
                if constexpr(std::is_same<expr_type<decltype(value)>, expr_type<X>>::value){
                    std::cout << "x" << std::endl;
                    std::cout << value.getStaticName() << std::endl;
                    //std::cout << value.getDynamicName() << std::endl;
                } else{
                    std::cout << "y" << std::endl;
                    visit_actor<Y,Zs...>();
                }
            }, aw.var
        );
    }

    template<class X>
    void visit_pointer(){
        std::visit(
            [this](auto&& value){
                if constexpr(std::is_same<expr_type<decltype(value)>, expr_type<X>>::value){
                    std::cout << "a" << std::endl;
                    std::cout << value->getStaticName() << std::endl;
                    std::cout << value->getDynamicName() << std::endl;
                }else{
                    std::cout << "b" << std::endl;
                    return;
                }
            }, ap.var
        );
    }

    template<class X, class Y, class... Zs>
    void visit_pointer(){
        std::visit(
            [this](auto&& value){
                if constexpr(std::is_same<expr_type<decltype(value)>, expr_type<X>>::value){
                    std::cout << "c" << std::endl;
                    std::cout << value->getStaticName() << std::endl;
                    std::cout << value->getDynamicName() <<std::endl;
                } else{
                    //std::cout << typeid(decltype(value)).name() <<std::endl;
                    //std::cout << typeid(X).name() <<std::endl;
                    //std::cout << std::is_same_v<decltype(value),X> << std::endl;
                    std::cout << "d" << std::endl;
                    visit_pointer<Y,Zs...>();
                }
            }, ap.var
        );
    }

    public:
    ActorPointer<A*,As*...> ap;
    ActorWrapper<A,As...> aw;

    void print_names(){
        visit_actor<A,As...>();
    }

    void print_names_w_pointer(){
        visit_pointer<A*,As*...>();
    }

    //change ap to coresspond to aw

    template<class X>
    TemplatedAGraph(X a) : ap(&a), aw(a) {}

};

int main(){
    D2 d2;
    D2* d2ref = &d2;
    std::cout << d2ref->getDynamicName() << std::endl;
    TemplatedAGraph<D1,D2> tag(d2);
    tag.print_names();
    tag.print_names_w_pointer();
}

因此，我想我偶然发现了一个未定义的行为，但我仍然想知道原因。

模板图（xa）：ap（&a），aw（a）{}在

ap

中存储指向局部变量的指针。那指针很快就晃来晃去了。任何访问它的尝试都会显示未定义的行为

---

您可能是指

模板图（X&a）：…

。就我所知，这样做。

你能做一个简单的回答吗？我忘了提到，override关键字没有改变。你的例子仍然存在问题。我修正了拼写错误，公开了必要的函数，并添加了一个main来测试这一点。但我现在犯了个错误。如果你能提供一个完整的例子来演示发生了什么，那就更好了，否则我们可能会在修复程序时意外地改变行为。我已经尽可能地按照我原来的层次结构重新实现了它，我最后也出现了一个分段错误，如果不从指针调用动态函数，则不会发生这种情况。如果向函数添加“final”说明符，则会打印正确的类型！