Failures using 'std :: initializer_list' with 'const char *', 'const char * &' and 'std :: string'

According to the documentation :

  

Copying a std :: initializer_list does not copy the underlying objects.

So I do not think the allocation you make in init is going to be too productive. The reason? when you leave init the list is no longer valid because the data source has been deleted.

In fact if we do the following:

template <typename type_t, typename ... KV>
void init(type_t value, const char *name, KV ... kv)
{
    values<type_t> = {{value, name}};

    for (const auto &kv : values<int>)
        std::cout << kv.first << '\t' << kv.second << '\n';
}

We see as if it shows values ... but the original list, which is {{value, name}} (because we remember that at this point we are not initializing the global variable but making an assignment) will be destroyed.

Another example to control the life cycle:

struct T
{
  T() { std::cout << "T::T()\n"; }
  T(T const&){std::cout << "T::T(const&)\n"; }
  ~T() {std::cout << "T::~T()\n"; }
};

int main()
{
  std::cout << "Init()\n";
    init(T{}, "uno", T{}, "dos", T{}, "tres");
  std::cout << "Fin Init()\n";
  std::cout.flush();
    for (const auto &kv : values<int>)
        std::cout << /* kv.first << */ '\t' << kv.second << '\n';

  std::cout.flush();

  return 0;
}

Exit:

Init()
T::T()
T::T()
T::T()
T::T(const&)
T::~T()
T::~T()
T::~T()
T::~T()
Fin Init()

As many objects as have been created have been destroyed ... then the loop will access elements that are no longer alive.

Consider using another object type different from std::initializer_list

One possible solution:

#include <iostream>
#include <map>

using name_t = 
//const char *;
//const char *const &;
std::string;

template <typename key_t>
using key_name_t = std::map<key_t, name_t>;

template <typename type_t>
key_name_t<type_t> values;

template<class InsertIterator, class Type, class Value, class ... Args>
void FillContainer(InsertIterator iterator, Type type, Value value, Args... args)
{
  iterator = {type,value};

  if constexpr(sizeof...(args) > 1 )
    FillContainer(iterator,args...);
}

template <class type_t, typename ... KV>
void init(type_t value, const char *name, KV ... kv)
{
  FillContainer(std::inserter(values<type_t>,values<type_t>.end()),value,name,kv...);
}

int main()
{
    init(1, "uno", 2, "dos", 3, "tres");

    for (const auto &kv : values<int>)
        std::cout << kv.first << '\t' << kv.second << '\n';

    return 0;
}

You can see it working in Wandbox