如何在C++中嵌套词法作用域可访问的作用域中声明静态信息?

好的，我找到了一个解决方案。

诀窍是，即使我们稍后在同一作用域中定义var，外部作用域中可见var的decltype(var)也会解析为该外部作用域的类型var。这允许我们通过外部类型的其他未使用的变量隐藏外部类型，但仍可以访问它，同时允许我们定义要在内部作用域中访问的同名变量。

我们的一般结构看起来像

struct __log_context__
{
typedef decltype(__log_context_var__) prev;
static const char * name() { return name_; }
static ::logging::log_context  context()
{
return ::logging::log_context(
name(), chain<__log_context__>::get() );
}
};
static __log_context__ __log_context_var__;

唯一的另一个细节是，在向上迭代上下文链时，我们需要一个终止条件，因此我们使用void*作为哨兵值，并在用于构造输出字符串的帮助程序类中专门使用它。

C++11 是decltype所必需的，并允许将本地类传递给模板参数。

#include <spdlog/spdlog.h>
namespace logging {
spdlog::logger & instance()
{
auto sink =
std::make_shared<spdlog::sinks::ansicolor_stdout_sink_mt>();
decltype(sink) sinks[] = {sink};
static spdlog::logger logger(
"console", std::begin( sinks ), std::end( sinks ) );
return logger;
}
class log_context
{
public:
log_context( const char *         name,
const std::string &  scope_name )
: name_ ( name       )
, scope_( scope_name )
{}
const char * name() const
{ return name_; }
const char * scope() const
{ return scope_.c_str(); }
private:
const char *  name_;
std::string   scope_;
};
class log_statement
{
public:
log_statement( spdlog::logger &           logger,
spdlog::level::level_enum  level,
const log_context &        context )
: logger_ ( logger  )
, level_  ( level   )
, context_( context )
{}
template<class T, class... U>
void operator()( const T &  t, U&&...  u )
{
std::string  fmt = std::string( "[{}] " ) + t;
logger_.log(
level_,
fmt.c_str(),
context_.scope(),
std::forward<U>( u )... );
}
private:
spdlog::logger &           logger_;
spdlog::level::level_enum  level_;
const log_context &        context_;
};
} // namespace logging
// Helpers for walking up the lexical scope chain.
template<class T, class Prev = typename T::prev>
struct chain
{
static std::string get()
{
return (chain<Prev, typename Prev::prev>::get() + ".")
+ T::name();
}
};
template<class T>
struct chain<T, void*>
{
static std::string get()
{
return T::name();
}
};
#define LOGGER ::logging::instance()
#define CHECK_LEVEL( level_name ) 
LOGGER.should_log( ::spdlog::level::level_name )
#define CHECK_AND_LOG( level_name )      
if ( !CHECK_LEVEL( level_name ) ) {} 
else                                 
::logging::log_statement(        
LOGGER,                      
::spdlog::level::level_name, 
__log_context__::context() )
#define LOG_TRACE CHECK_AND_LOG( trace )
#define LOG_DEBUG CHECK_AND_LOG( debug )
#define LOG_INFO CHECK_AND_LOG( info )
#define LOG_WARNING CHECK_AND_LOG( warn )
#define LOG_ERROR CHECK_AND_LOG( err )
#define LOG_CRITICAL CHECK_AND_LOG( critical )
#define LOG_CONTEXT_IMPL(prev_type,name_)            
struct __log_context__                               
{                                                    
typedef prev_type prev;                          
static const char * name() { return name_; }     
static ::logging::log_context  context()         
{                                                
return ::logging::log_context(               
name(), chain<__log_context__>::get() ); 
}                                                
};                                                   
static __log_context__ __log_context_var__
#define LOG_CONTEXT(name_) 
LOG_CONTEXT_IMPL(decltype(__log_context_var__),name_)
#define ROOT_CONTEXT(name_) 
LOG_CONTEXT_IMPL(void*,name_)
// We include the root definition here to ensure that
// __log_context_var__ is always defined for any uses of
// LOG_CONTEXT.
ROOT_CONTEXT( "global" );

在我的初始帖子中近似代码

#include <logging.hpp>
namespace app {
LOG_CONTEXT( "app" );
class Connector {
LOG_CONTEXT( "Connector" );
public:
void send( const std::string &  msg )
{
LOG_CONTEXT( "send()" );
LOG_TRACE( msg );
}
};
} // namespace app
void fn()
{
LOG_DEBUG( "in fn" );
}
int main()
{
LOG_CONTEXT( "main()" );
LOGGER.set_level( spdlog::level::trace );
LOG_INFO( "starting app" );
fn();
app::Connector c;
c.send( "hello world" );
}

收益 率

[2018-03-22 22:35:06.746] [console] [info] [global.main()] starting app
[2018-03-22 22:35:06.747] [console] [debug] [global] in fn
[2018-03-22 22:35:06.747] [console] [trace] [global.app.Connector.send()] hello world

如愿以偿。

有条件地继承问题示例中提到的外部作用域将保留为练习。

编写示例需要一些时间，但我会分享我如何处理这个问题。

• 您的LOG_CONTEXT可以在任何地方调用，因此如果我们创建多个静态对象，则它们的构造顺序是未知的。
• 您的上下文可以按行号排序，可通过__LINE__
• LOG_CONTEXT可以创建LoggingContext结构的静态对象，这些对象在创建时自行注册到本地容器。(本地我的意思是编译对象中唯一，可以通过匿名命名空间实现)
• LOG_*应采用其当前行，并从本地寄存器获取最新的 LoggingContext。(如果需要，最后几个)
• 我认为所有这些都可以通过constexpr语义来实现(但这是一个相当大的挑战)

未解决的问题：

• 函数中的静态对象(在第一次调用中创建)
• 嵌套上下文(也许比较__FUNCTION__会起作用)？

附言。我会尝试在周末实现它