C++ 是否可以在不使用指针的情况下将变量的范围扩展到if语句之外？

我有一个简单的

Trace

类，它记录了方法的输入和退出：

#include <iostream>

class Trace
{
public:
    Trace()   {std::cout << "Enter" << std::endl;}

    ~Trace()
    {
        std::cout << "Exit" << std::endl;    
    }
};

void foo()
{
    Trace trace;
    std::cout << "foo..." << std::endl;    
}

int main()
{
    foo();
    return 0;
}

#包括
类跟踪
{
公众：
Trace（）{std:：cout为什么不在跟踪构造函数和析构函数中启用测试？
将
跟踪类重写为

class Trace
{
public:
    Trace()   
    {
        if(Trace::enabled)
            std::cout << "Enter" << std::endl;
    }

    ~Trace()
    {
        if(Trace::enabled)
            std::cout << "Exit" << std::endl;    
    }
    static bool enabled;
};
bool Trace::enabled = false;

你想要这样的东西：

#include <iostream>

class Trace
{
public:
    Trace()   {std::cout << "Enter" << std::endl;}

    ~Trace()
    {
        std::cout << "Exit" << std::endl;    
    }
    static bool enabled;
};
bool Trace::enabled = false;

void foo()
{
    if(Trace::enabled)
        Trace trace;
    std::cout << "foo..." << std::endl;    
}

int main()
{
    Trace::enabled = true;
    foo();
    return 0;
}

class Trace
{
public:
    Trace()   {
        if (enabled) {
            std::cout << "Enter" << std::endl;
        }
    }

    ~Trace() {
        if (enabled) {
                std::cout << "Exit" << std::endl;
        }  
    }
    static bool enabled;
};  
bool Trace::enabled = false;

类跟踪
{
公众：
跟踪（）{
如果（已启用）{
std:：cout除了建议将启用跟踪的检查放入跟踪类之外，如下所示

是否可以在不使用指针的情况下将变量的范围扩展到if语句之外

您不应该尝试此操作。即使使用指针，变量的范围限制也无法扩展。（好吧，只是为了记录，在
if
条件中声明的变量范围还包括
else
子句，因此也链接了
else if
s。）

更新：关于跟踪类方法的个人想法
甚至我都认为这种追踪助手

class Trace
{
public:
    Trace(const char* scope): m_scope(scope) { 
        out("enter "); 
    }
    ~Trace() { 
        out("leave "); 
    } 
    const char* m_scope;
    static void out(const char* s) {
        if (enabled) {
            std::cout << s << m_scope << std::endl;    
        }
    }
    static bool enabled;
};  
bool Trace::enabled = false;

类跟踪
{
公众：
跟踪（const char*scope）：m_scope（scope）{
退出（“进入”）；
}
~Trace（）{
退出（“离开”）；
} 
const char*m_范围；
静态无效输出（常量字符*s）{
如果（已启用）{
标准：：cout
在后一种情况下，有没有办法在不使用智能指针的情况下获得正确的输出？如果禁用跟踪，我希望开销尽可能小

现代编译器完全优化了简单的智能指针。在代码中有意义的地方，您可以随意使用RAII和智能指针。代码清晰明了，避免像这样的微优化，因为它们几乎没有帮助，而且常常会使事情变得更糟。
堆栈上的对象有代码将它们放在那里由编译器在编译时创建。因此，确保不在堆栈上创建对象的唯一方法是在编译时创建对象。在运行时无法实现这一点

现在假设您确实需要优化跟踪对象（您已经分析了您的程序），实现所需的一种方法是使用宏（在编译之前由预处理器进行评估）-类似于：

  #define TRACE_ON  // comment this to disable Trace

  #ifdef TRACE_ON       
    #define TRACE() Trace trace
  #else       
    #define TRACE()   
  #endif

然后像这样使用它：

void foo()
{
    TRACE();
    std::cout << "foo..." << std::endl;    
}

void foo（）
{
TRACE（）；
std：：难道是什么让你认为如果禁用跟踪，智能指针会引入开销？！为什么要投否决票？这个想法不好，但问题本身就是。@Wolf这个问题基于错误的假设和过早的优化。（我没有投否决票。）更新有点过早优化的味道。如果禁用跟踪，您可能希望降低构造的成本。或者您的做法完全错误。智能指针不会有帮助，因为它们具有相同的作用域。我添加了另一个关于可能的跟踪类的建议，以及关于中异常的一些想法。感谢拥有一个look。我应该更清楚。请看下面的问题。如果跟踪被禁用，我不想让 Trace类被实例化。@ Meysam应该考虑使类本身便宜：根据运行时变量跳过范围广泛的声明是不可能的。出于纯粹的兴趣：您倾向于找到跟踪类吗？有用吗？@Wolf是的，特别是用于捕获比预期时间长得多的内容。我明白了，谢谢……但这不是评测的目的吗？（嗯，有时没有评测器，我知道…@Wolf在运行真实世界的代码时，您无法轻松评测它。但是您可以使用这样的评测。
void foo()
{
    TRACE();
    std::cout << "foo..." << std::endl;    
}