哪个派生class对象调用了基class中的非虚函数

Question

背景：

我有一个基础 class、基础，它有大部分 'pure' 虚函数和一些非-虚函数（加上几个虚函数）。

基本上，所有派生的 classes Derived、Derived2 等的共同功能都存在于基础 class 作为非虚函数。

问题： 如果来自任何派生 classes 的对象之一调用来自 Base class 的任何非虚拟函数，如何（如果有的话）知道哪个派生-class-对象调用了这个非虚拟基-class函数。

实际上，我想调试一个调用并偶然发现这样一个事实，即无论是使用调试器还是使用任何跟踪线，我都可以确定我是从哪个派生-class-对象中偶然发现这个非-虚拟基础-class-函数。

想一想，当我写这个问题时，我能想到的一种方法是，我可以在每个派生 class 中有一个静态成员字符串变量，并将其作为参数传递给非虚拟基础 class 函数。但是，这是唯一的方法吗？

最小工作示例： 这是最小的工作示例。我尽可能地把它剥离了。

#include <iostream>


#include <pthread.h>
#include <string>
#include <errno.h>
#include <cstring>

class Base {
public:
    Base() {}
    virtual ~Base() {}
    int waitForThreadToExit() {
        int error = pthread_join(m_Thread, NULL);
        if (0 != error) {
            std::cerr << "Error from pthread_join(). errorCode:" << strerror(errno) << std::endl;
        }
        return error;
    }

    int start() {
        if ((startThread()) != 0) {
             std::cerr << "error returned from the start() function." << std::endl;
         }
    }

protected:
    virtual int runThread(void) {
      std::cout << "Reimplement" << std::endl;;
      return -1;
    }
    int startThread() {
        int error = pthread_create(&m_Thread, NULL, internalThreadEntryFunc, this);
        return error;
    }

private:
    static void* internalThreadEntryFunc(void* This) {
        ((Base *) This)->runThread();
        return NULL;
    }
    pthread_t m_Thread;
};


class Derived: public Base {
public:
    Derived() {}
    virtual ~Derived() {}

private:
    virtual int runThread(void) {
        while(1) {
             std::cout << "Sehr gut!" << std::endl;;
             return 0;
        }
    }

};

class Derived2: public Base {
public:
    Derived2() {}
    virtual ~Derived2() {}

private:
    virtual int runThread(void) {
        while (1)
        {
            std::cout << "Sehr sehr gut!" << std::endl;;
            return 0;
        }
    }

};


int main()
{
    std::cout << "Hello World!" << std::endl;
    Derived d;
    Derived2 d2;
    d.start();
    d2.start();
    d.waitForThreadToExit();
    d2.waitForThreadToExit();
    return 0;
}

Answer 1

所以为了完整起见，以防其他人（几个月后很可能是我自己）再次偶然发现这个问题，这里是我针对这个问题实施的总体思路。

#include <iostream>
#include <typeinfo>

class base {
public:
    virtual const char* name() {
        return typeid(*this).name();
    }
    virtual ~base(){}
};

class derived : public base {};
class otherDerived : public base {};

int main () {
    base b;
    derived d;
    otherDerived d2;

    std::cout << "base says:" << b.name() << std::endl;
    std::cout << "derived says:" << d.name() << std::endl;
    std::cout << "other derived says:" << d2.name() << std::endl;
}

在我的 QtCreator 中运行时给出输出：

base says:4base
derived says:7dervied
other derived says:12otherDerived

注意：最好做一个虚函数name()或className()然后到处调用那个函数，而不是到处撒typeid(*this).name()在代码中。

哪个派生class对象调用了基class中的非虚函数

Which derived class object called the non-virtual function in the base class

c++

base-class

derived-class