我目前有2个函数重载:
void log(const char* format, ...);
void log(const string& message);
我希望在这次调用的情况下:log("hello");
将调用字符串版本,换句话说,只有在2个或更多参数的情况下才应调用第一个重载。
我想过这样做:
template<typename T>
void log(const char* format, T first, ...);
但在这种情况下,我将无法在代码中正确使用va_list
。
我可能缺少任何其他解决方案吗?
修改:
我考虑过从函数内部检查va_list
的大小,并在0的情况下重定向,但据我所知,它不可能达到va_list
的大小。
答案 0 :(得分:3)
log(std::string{"hello})
。但这并不是你真正想要的。在任一函数中,调用另一个函数。
void log(const string& s)
{
log(s.c_str());
}
但它不是很有效,因为你会有一个无用的string
对象,尽管编译器可能能够内联调用。
使用可变参数模板和SFINAE:
void log(const string&);
auto log(const char *ptr, Args&& ... args) ->
typename std::enable_if<sizeof...(Args) != 0, void>::type
只有存在尾随参数时,才会在候选函数集中提供第二个重载。 Showcase。在C ++ 14中,您可以使用std::enable_if
,std::enable_if_t
的简写版本,这使语法更清晰:
auto log(const char *ptr, Args&& ... args) -> std::enable_if_t<sizeof...(Args) != 0, void>
您仍然可以使用
在C ++ 11中简化它template <bool B, typename T>
using enable_if_t = typename std::enable_if<B, T>::type;
如果您正在调用接受va_list
的功能(例如printf
),您仍然可以扩展参数包:
std::printf(ptr, args...);
但反之亦然。
答案 1 :(得分:0)
您可以省略'printf'函数样式并使用流操作符(使用可变数量的参数(可变参数模板)):
// Header
// ============================================================================
#include <iostream>
#include <sstream>
#include <tuple>
// Format
// ============================================================================
namespace Detail {
template<unsigned I, unsigned N>
struct Format;
template<unsigned N>
struct Format<N, N> {
template<typename... Args>
static void write(std::ostream&, const std::tuple<Args...>&, std::size_t offset)
{}
};
template<unsigned I, unsigned N>
struct Format {
template<typename... Args>
static void write(
std::ostream& stream,
const std::tuple<Args...>& values,
std::size_t offset)
{
if(offset == 0) stream << std::get<I>(values);
else Format<I+1, N>::write(stream, values, offset - 1);
}
};
class FormatParser
{
public:
const char* fmt;
const std::size_t size;
FormatParser(const char* fmt, std::size_t size)
: fmt(fmt), size(size)
{}
virtual ~FormatParser() {}
void write(std::ostream& stream) const;
protected:
virtual void write_value(std::ostream&, std::size_t index) const = 0;
};
} // namespace Detail
template<typename... Args>
class Format : public Detail::FormatParser
{
public:
typedef std::tuple<const Args&...> Tuple;
static constexpr std::size_t Size = std::tuple_size<Tuple>::value;
const std::tuple<const Args&...> values;
Format(const char* fmt, const Args&... values)
: Detail::FormatParser(fmt, Size), values(values...)
{}
protected:
void write_value(std::ostream& stream, std::size_t index) const {
Detail::Format<0, Size>::write(stream, values, index);
}
};
template <typename... Args>
inline Format<Args...> format(const char* fmt, const Args&... values) {
return Format<Args...>(fmt, values...);
}
template <typename... Args>
inline std::ostream& operator << (std::ostream& stream, const Format<Args...>& format) {
format.write(stream);
return stream;
}
template <typename... Args>
inline std::string format_string(const char* fmt, const Args&... values) {
std::ostringstream result;
result << format(fmt, values...);
return result.str();
}
// Source
// ============================================================================
#include <cctype>
#include <cstdlib>
#include <stdexcept>
namespace Detail {
void FormatParser::write(std::ostream& stream) const {
const char* s = fmt;
while(*s) {
switch(*s) {
case '{':
if(*(++s) != '{') {
char* end;
unsigned long index = std::strtoul(s, &end, 10);
while(*end != '}') {
if( ! std::isspace(*end)) {
s = end;
if( ! *s) s = "End";
throw std::runtime_error(std::string(
"Invalid Format String `") + fmt + "` at " + s);
}
++end;
}
s = end + 1;
if(index < size) write_value(stream, index);
else throw std::runtime_error(std::string(
"Invalid Format Index `") + std::to_string(index)
+ "` in `" + fmt + '`');
continue;
}
break;
case '}':
if(*(++s) != '}') {
if( ! *s) s = "End";
throw std::runtime_error(
std::string("Invalid Format String `") + fmt + "`"
"Missing `}` at " + s);
}
break;
}
stream.put(*s++);
}
}
} // namespace Detail
// Usage
// ============================================================================
int main() {
// a = 1; b = 2; 1 + 2 = 3
std::cout << format("a = {0}; b = {1}; {0} + {1} = {2}", 1, 2, 3) << "\n";
}
另外:看看boost::format