为什么在这里使用静态char const *而不是字符串文字会有所不同？

Question

In the code below (with a link here ) g++ produces an executable that prints garbage (while clang++ doesn't) unless I define THIS_WORKS .

The difference being,

#ifdef THIS_WORKS
  static char const* empty_string = "";
  return { separator, empty_string, args... };
#else
  return { separator, "", args... };
#endif

It greatly surprises me that this even can make a difference. The only reasons that I can come up with is that this has be a compiler bug, or is Undefined Behavior in the program itself that I am missing.

What is going on here? Why does g++ print garbage instead of a leading "" ?

Here is the complete compilable code snippet:

#include <tuple>
#include <iostream>

template<typename ...Args>
struct Join
{
  char const* m_separator;
  std::tuple<Args const&...> m_args;
  Join(char const* separator, Args const&... args) : m_separator(separator), m_args(args...) { }
  template<size_t ...I> void print_on(std::ostream& os, std::index_sequence<I...>);
};

template<typename ...Args>
template<size_t ...I>
void Join<Args...>::print_on(std::ostream& os, std::index_sequence<I...>)
{
  (..., (os << (I == 0 ? "" : m_separator) << std::get<I>(m_args)));
}

template<typename ...Args>
std::ostream& operator<<(std::ostream& os, Join<Args...> comm)
{
  comm.print_on(os, std::make_index_sequence<sizeof...(Args)>());
  return os;
}

template<typename ...Args>
Join<Args...> join(char const* separator, Args const&... args)
{
  return { separator, args... };
}

template<typename ...Args>
Join<char const*, Args...> join_more(char const* separator, Args const&... args)
{
#ifdef THIS_WORKS
  static char const* empty_string = "";
  return { separator, empty_string, args... };
#else // THIS_DOES_NOT
  return { separator, "", args... };
#endif
}

template<typename... Args>
void test_func(Args... args)
{
  std::cout << join_more(", ", args...) << std::endl;
}

int main()
{
  test_func(1, 2, 3);
}

The expected output is:

, 1, 2, 3

Namely, join_more is intended to print a template pack where each argument is prepended with a comma. join doesn't print a leading comma for the first argument.

Answer 1

The version with THIS_WORKS defined is fine, but yes, without THIS_WORKS the program has undefined behavior.

The code calls the specialization join_more<int, int, int> , which returns a Join<char const*, int, int, int> . That class type has a member of type std::tuple<char const* const&, int const&, int const&, int const&> . The int const& elements refer to the args... of test_func , and those live as long as needed.

But the first element of the tuple is not so lucky. It's true the string literal's const char[1] object containing '\\0' has no effective end to its lifetime. But the actual tuple element is a char const* const& reference. With THIS_WORKS , it refers to the object empty_string , which also lives long enough. Without THIS_WORKS , the compiler needs to create a temporary char const* object to initialize the second argument of constructor Join<const char*, int, int, int>::Join(char const*, char const* const&, int const&, int const&, int const&) for the return statement of join_more . Then the lifetime of that temporary char const* object immediately ends on function return.