Dear Experts:

When C++14 introduces literals operators, we can conveniently use auto s =
"hello"s; to define an std::string, but before that, we must type using
std::string_literals::operator""s;.
This is very unfriendly for users who just want to save typing but often
need to define a simple std::string on different files (or for AAA-style
enthusiasts). It would be great if these literals operators can be
automatically introduced into the global scope when their corresponding
headers are included.

One of the approaches would be put using
std::literals::xxx_literals::operator""xxx; directly in their headers
content:

#include <string> // using declaration already in it.#include <chrono>
// using declaration already in it.int main() {
  auto str = "hello world"s; // works!
  auto sec = 10s; // works!
}

I know this must be opposed by many people, but here the reasons:

*1.* The standard operators do not conflict with each other since they are
in different namespaces, even with the same name operator""s. since their
signatures are different.

*2. *These operators will not conflict with user-define operators which
must begin with _.

*3. *We are *not* put using namespace std::literals::xxx_literals; in
header, we just declare using std::literals::xxx_literals::operator""xxx.
So the other stuff on the same namespace is not polluting the global scope
even though there are only literals operators in those namespaces which are
we usually want.

*4. *If the standard introduces a new library along with literals
operators with
the same signature and the same name in the future, this will occur an
ambiguity:

#include <string>#include <network>int main() {
  auto s = "140.113.203.189"s; // string or socket?
}

but in this case, we better choose a different name for socket literals
like operator""sk. Since even those two literals operators in different
namespaces, we still can use them on the same scope at the same time:

#include <string> #include <network>int main() {
  using std::string_literals::operator""s;
  auto str = "140.113.203.189"s;
  using std::network_literals::operator""s;
  auto soc = "140.113.203.189"s; // ambiguous,
string_literals::operator""s still visible
}

Any comments? Are there other flaws that I haven't noticed? Or are
there other better solutions? Very appreciate your reply.

Sincerely
Hewill Kang