Variadicテンプレートと可変関数の組み合わせ

Question

私は、一方では任意の数のパラメータを解析する必要がある一方で、常に__func__とで渡されるロギング関数を作成しています。このオブジェクトを呼び出す）。

私はこの

template<typename... Args> 
void 
log_device_message_template(const class *object, 
       char const *func, 
       char const *const format, 
       Args const &... args)noexcept 
{ 
log(format, to_str(object).c_str(),format, to_str(args).c_str()...); 
} 

ようのみ可変引数テンプレートを使用している場合、私はこのようlog_device_message_templateを呼び出す必要があり： log_device_message_template(this,__func__,some format,some parameters)

ので、私はマクロを追加しました：

#define log_api_call(format, ...)                                       \ 
    log_device_message_template(                         \ 
     this, __func__, "%s::%s(" format ")", ##__VA_ARGS__) 

問題は、おそらくフォーマットが正しくないためにsegフォルトが発生していることですどこに。 __attribiuteの__（フォーマット）を追加することにより、可変長引数テンプレートの使用に動作しません...ここ

はロガーをテストするPythonのテストからのエラーです：

lookup in file=***** [0] 
    28371: symbol=_ZN5***6logger27log_device_message_templateIINS_14*****E13****EEEvNS_21logger_component_eENS_17logger_level_eEPKcPKNS_9objectES7_DpRT_; lookup in file=**** [0] 
    28371: ****: error: symbol lookup error: undefined symbol: _ZN5***6logger27log_device_message_templateIINS_14****E13****EEEvNS_21logger_component_eENS_17logger_level_eEPKcPKNS_9objectES7_DpRT_ (fatal) 

Answer 1

ここでどのきちんとそれにアプローチする別の方法ですマクロを避ける。

この場合、ログレコードはstdoutに出力されていますが、簡単に変更できます。また、ログメッセージを作成するのにstd::ostringstreamを使用しています。パフォーマンスに関してはあまり知られていないので、カスタマイズポイントの候補もあります。

#include <iostream> 
#include <sstream> 
#include <tuple> 
#include <utility> 

// define a constant index type 
template<std::size_t N> using index_c = std::integral_constant<std::size_t, N>; 

// emitting an item at index 0 has no prefix  
template<class T> 
void emit_item(std::ostream &os, index_c<0>, T const &t) 
{ 
    os << t; 
} 


// emitting an item at index N (!= 0) has a comma prefix 
template<std::size_t N, class T> 
void emit_item(std::ostream &os, index_c<N>, T const &t) 
{ 
    os << ", " << t; 
} 

// emit args 0 .. N-1 
template<class Tuple, std::size_t...Is> 
void emit_arglist(std::ostream &sink, Tuple &&tuple, std::index_sequence<Is...>) 
{ 
    using expand = int[]; 
    void(expand{0, 
       (emit_item(sink, index_c<Is>(), std::get<Is>(tuple)), 0)... 
    }); 

}; 

// emitting a 'more' at index 0 has a prefix 
template<class T> 
void emit_more(std::ostream &os, index_c<0>, T const &t) 
{ 
    os << " : " << t; 
} 

// emitting a 'more' at index N (!= 0) has a space prefix 
template<std::size_t N, class T> 
void emit_more(std::ostream &os, index_c<N>, T const &t) 
{ 
    os << " " << t; 
} 

template<class Tuple, std::size_t...Is> 
void emit_more(std::ostream &sink, Tuple &&tuple, std::index_sequence<Is...>) 
{ 
    using expand = int[]; 
    void(expand{0, 
       (emit_more(sink, index_c<Is>(), std::get<Is>(tuple)), 0)... 
    }); 

}; 

template<typename... Args, typename ...MoreStuff> 
std::string 
make_log_string(const char *object, 
       char const *func, 
       std::tuple<Args const &...> const& args, 
       MoreStuff&&...morestuff) noexcept 
{ 
    std::ostringstream ss; 
    ss << object << "::" << func << '('; 
    emit_arglist(ss, args, std::make_index_sequence<sizeof...(Args)>()); 
    ss << ')'; 
    emit_more(ss, std::tie(morestuff...), std::make_index_sequence<sizeof...(MoreStuff)>()); 
    return ss.str(); 
} 

// syntactic sugar for indicating arguments  
template<class...Arg> 
decltype(auto) args(Arg const&...args) 
{ 
    return std::tie(args...); 
} 


int main() 
{ 
    int a = 0, b = 1, c = 2; 
    std::string sa = "xxx", sb = "yyy", sc = "zzz"; 

    const char* Class = "foo"; 
    const char* Func = "var"; 

    std::cout << make_log_string(Class, Func, args(a, b, c)) << std::endl; 
    std::cout << make_log_string(Class, Func, args(sa, b, sc)) << std::endl; 
    std::cout << make_log_string(Class, Func, args(sa, b, sc), "more stuff") << std::endl; 
    std::cout << make_log_string(Class, Func, args(), "empty", "argument", "list") << std::endl; 

} 

予想される出力は：

std::cout << make_log_string(method(Class, Func)(a, b, c)) << std::endl; 
std::cout << make_log_string(method(Class, Func)(sa, b, sc)) << std::endl; 
std::cout << make_log_string(method(Class, Func)(sa, b, sc), "more stuff") << std::endl; 
std::cout << make_log_string(method(Class, Func)(), "empty", "argument", "list") << std::endl; 

：

foo::var(0, 1, 2) 
foo::var(xxx, 1, zzz) 
foo::var(xxx, 1, zzz) : more stuff 
foo::var() : empty argument list 

そしてもう少し定型と

我々はこれを書くことができますが、アプローチを好きなら

しかし、これはあなたが始める必要があります

ここにあります：

#include <iostream> 
#include <sstream> 
#include <tuple> 
#include <utility> 

template<std::size_t N> using index_c = std::integral_constant<std::size_t, N>; 

template<class T> 
void emit_item(std::ostream &os, index_c<0>, T const &t) 
{ 
    os << t; 
} 

template<std::size_t N, class T> 
void emit_item(std::ostream &os, index_c<N>, T const &t) 
{ 
    os << ", " << t; 
} 

template<class Tuple, std::size_t...Is> 
void emit_arglist(std::ostream &sink, Tuple &&tuple, std::index_sequence<Is...>) 
{ 
    using expand = int[]; 
    void(expand{0, 
       (emit_item(sink, index_c<Is>(), std::get<Is>(tuple)), 0)... 
    }); 

}; 

template<class T> 
void emit_more(std::ostream &os, index_c<0>, T const &t) 
{ 
    os << " : " << t; 
} 

template<std::size_t N, class T> 
void emit_more(std::ostream &os, index_c<N>, T const &t) 
{ 
    os << " " << t; 
} 

template<class Tuple, std::size_t...Is> 
void emit_more(std::ostream &sink, Tuple &&tuple, std::index_sequence<Is...>) 
{ 
    using expand = int[]; 
    void(expand{0, 
       (emit_more(sink, index_c<Is>(), std::get<Is>(tuple)), 0)... 
    }); 

}; 

template<class...Args> 
struct method_with_args; 

struct method 
{ 
    constexpr method(const char* c, const char* f) : klass(c), func(f) {} 
    const char* klass; 
    const char* func; 

    template<class...Args> 
    auto operator()(Args const&...args) -> method_with_args<Args...>; 

    friend std::ostream& operator<<(std::ostream& os, const method& m) 
    { 
     return os << m.klass << "::" << m.func; 
    } 
}; 

template<class...Args> 
struct method_with_args 
{ 
    friend std::ostream& operator<<(std::ostream& os, method_with_args const& ma) 
    { 
     os << ma.m << '('; 
     emit_arglist(os, ma.args, std::make_index_sequence<sizeof...(Args)>()); 
     return os << ')'; 
    } 

    method m; 
    std::tuple<Args const&...> args; 
}; 

template<class...Args> 
auto method::operator()(Args const&...args) -> method_with_args<Args...> 
{ 
    return method_with_args<Args...>{*this, std::tie(args...)}; 

} 

struct function 
{ 
    const char* name; 
}; 

template<typename Method, typename ...MoreStuff> 
std::string 
make_log_string(Method m, 
       MoreStuff &&...morestuff) noexcept 
{ 
    std::ostringstream ss; 
    ss << m; 
    emit_more(ss, std::tie(morestuff...), std::make_index_sequence<sizeof...(MoreStuff)>()); 
    return ss.str(); 
} 


int main() 
{ 
    int a = 0, b = 1, c = 2; 
    std::string sa = "xxx", sb = "yyy", sc = "zzz"; 

    const char *Class = "foo"; 
    const char *Func = "var"; 

    std::cout << make_log_string(method(Class, Func)(a, b, c)) << std::endl; 
    std::cout << make_log_string(method(Class, Func)(sa, b, sc)) << std::endl; 
    std::cout << make_log_string(method(Class, Func)(sa, b, sc), "more stuff") << std::endl; 
    std::cout << make_log_string(method(Class, Func)(), "empty", "argument", "list") << std::endl; 
}