C++ 类如何知道谁调用了它的方法？

目前，我为每个使用该类的代码创建了一个新的类实例。构造函数采用字符串名称，因此我知道类内部调用我的方法的人

class Log {
public:
    Log(std::string Name) : name(Name) {}
    void Print(std::string Message) {
        std::cout << name << " said " << Message << std::endl;
    }
private:
    std::string name;
};

但是现在，我想为所有模块共享相同的

Log

实例。我如何才能做到这一点，并且仍然与方法调用的来源不同

---

背景：有很多模块，它们使用两种类型的类。首先，在模块之间全局共享的管理器。其次，上面的示例类等帮助程序是为每个模块分别创建的。但我想找到两者的单一抽象，以便进行更简单的设计。考虑一个日志助手，它应该以不同的、均匀分布的颜色为不同模块的消息着色。这样的助手需要在所有模块之间共享状态。

我想我知道您想要什么。试试这个：

class Module
{
public:
    Module(std::string name) : name(name) {}
    void Update()
    {
        VUpdate(name);
    }

private:
    virtual void VUpdate(const std::string &name) = 0;

protected:
    static Log *log;

private:
    std::string name;
};

class Renderer : public Module
{
private:
    virtual void VUpdate(const std::string &name)
    {
        log->Print(name, "Hello World!");
    }
};

Log *Module::log = new Log();

---

您的日志记录程序必须更改以在其

打印

成员中接受调用方的名称。

我想我理解您的要求。试试这个：

class Module
{
public:
    Module(std::string name) : name(name) {}
    void Update()
    {
        VUpdate(name);
    }

private:
    virtual void VUpdate(const std::string &name) = 0;

protected:
    static Log *log;

private:
    std::string name;
};

class Renderer : public Module
{
private:
    virtual void VUpdate(const std::string &name)
    {
        log->Print(name, "Hello World!");
    }
};

Log *Module::log = new Log();

---

您的日志记录程序必须更改以在其

打印

成员中接受调用方的名称。

我想我理解您的要求。试试这个：

class Module
{
public:
    Module(std::string name) : name(name) {}
    void Update()
    {
        VUpdate(name);
    }

private:
    virtual void VUpdate(const std::string &name) = 0;

protected:
    static Log *log;

private:
    std::string name;
};

class Renderer : public Module
{
private:
    virtual void VUpdate(const std::string &name)
    {
        log->Print(name, "Hello World!");
    }
};

Log *Module::log = new Log();

---

您的日志记录程序必须更改以在其

打印

成员中接受调用方的名称。

我想我理解您的要求。试试这个：

class Module
{
public:
    Module(std::string name) : name(name) {}
    void Update()
    {
        VUpdate(name);
    }

private:
    virtual void VUpdate(const std::string &name) = 0;

protected:
    static Log *log;

private:
    std::string name;
};

class Renderer : public Module
{
private:
    virtual void VUpdate(const std::string &name)
    {
        log->Print(name, "Hello World!");
    }
};

Log *Module::log = new Log();

---

您的记录器必须更改以在其

Print

成员中接受调用者的名称。

您可以通过对

Log

类进行一些更改，使其调用全局日志函数来简化此过程。这将减少或消除对日志记录当前使用方式的大量更改

class Log {
public:
    explicit Log(const std::string& name) : name(name) {}
    void Print(const std::string& message) const {
        GlobalLogPrint(name, message);
    }

private:
    const std::string name;
};

您可以继续动态分配

Log

对象的实例，也可以使用组合

class Module {
public:
    explicit Module(const std::string& name) : log(name) {}
    virtual void Update() = 0;
protected:
    Log log;
};

class Renderer : public Module {
public:
    void Update() {
        log.Print("Hello World!");
    }
};

---

您可以通过对

Log

类进行一些更改，使其调用全局日志函数来简化该过程。这将减少或消除对日志记录当前使用方式的大量更改

class Log {
public:
    explicit Log(const std::string& name) : name(name) {}
    void Print(const std::string& message) const {
        GlobalLogPrint(name, message);
    }

private:
    const std::string name;
};

您可以继续动态分配

Log

对象的实例，也可以使用组合

class Module {
public:
    explicit Module(const std::string& name) : log(name) {}
    virtual void Update() = 0;
protected:
    Log log;
};

class Renderer : public Module {
public:
    void Update() {
        log.Print("Hello World!");
    }
};

---

您可以通过对

Log

类进行一些更改，使其调用全局日志函数来简化该过程。这将减少或消除对日志记录当前使用方式的大量更改

class Log {
public:
    explicit Log(const std::string& name) : name(name) {}
    void Print(const std::string& message) const {
        GlobalLogPrint(name, message);
    }

private:
    const std::string name;
};

您可以继续动态分配

Log

对象的实例，也可以使用组合

class Module {
public:
    explicit Module(const std::string& name) : log(name) {}
    virtual void Update() = 0;
protected:
    Log log;
};

class Renderer : public Module {
public:
    void Update() {
        log.Print("Hello World!");
    }
};

---

您可以通过对

Log

类进行一些更改，使其调用全局日志函数来简化该过程。这将减少或消除对日志记录当前使用方式的大量更改

class Log {
public:
    explicit Log(const std::string& name) : name(name) {}
    void Print(const std::string& message) const {
        GlobalLogPrint(name, message);
    }

private:
    const std::string name;
};

您可以继续动态分配

Log

对象的实例，也可以使用组合

class Module {
public:
    explicit Module(const std::string& name) : log(name) {}
    virtual void Update() = 0;
protected:
    Log log;
};

class Renderer : public Module {
public:
    void Update() {
        log.Print("Hello World!");
    }
};

---

---

---

这不是一个好主意，但你可以试试这个：你不能。出于这个原因，我们使用访问修饰符。模块不能告诉记录器它们是哪个模块吗？或者，如果只是颜色的变化，使用哪种颜色呢？@托马斯克·阿克我并不是指某种反射或回溯，而是C++内部的一个设计来解决我的问题。类似于

log->Print（名称，“helloworld！”）。但是，我正在寻找一种方法，将该逻辑放在基本
模块
类或
日志
类中。出于这个原因，我们使用访问修饰符。模块不能告诉记录器它们是哪个模块吗？或者，如果只是颜色的变化，使用哪种颜色呢？@托马斯克·阿克我并不是指某种反射或回溯，而是C++内部的一个设计来解决我的问题。类似于
log->Print（名称，“helloworld！”）。但是，我正在寻找一种方法，将该逻辑放在基本
模块
类或
日志
类中。出于这个原因，我们使用访问修饰符。模块不能告诉记录器它们是哪个模块吗？或者，如果只是颜色的变化，使用哪种颜色呢？@托马斯克·阿克我并不是指某种反射或回溯，而是C++内部的一个设计来解决我的问题。类似于
log->Print（名称，“helloworld！”）。但是，我正在寻找一种方法，将该逻辑放在基本
模块
类或
日志
类中。出于这个原因，我们使用访问修饰符。模块不能告诉记录器它们是哪个模块吗？或者，如果只是颜色的变化，使用哪种颜色呢？@托马斯克·阿克我并不是指某种反射或回溯，而是C++内部的一个设计来解决我的问题。类似于
log->Print（名称，“helloworld！”）。但我正在寻找一种方法，将该逻辑放在基本
模块
类中，或者在
Log
类中。是否可以将
Log
类嵌入全局打开？仅当将
Log
类更改为不调用全局打开时才可以。否则，您将以循环依赖关系结束。仅当将
Log
类更改为不时才可以将
Log
类嵌入全局打开调用全局类，否则将导致循环依赖关系。只有将
Log
类更改为不调用全局类时，才可以将
Log
类嵌入全局打开。否则，将导致循环依赖关系。只有更改
Log
类时，才可以将
Log
类嵌入全局打开
Log
类不能调用全局类，否则会导致循环依赖关系。您认为有没有办法不每次显式传递
name
呢？不太可能。如果需要
日志
指令