Сравнение строковых литералов

void add( const char* const s, function<void()> fn )
{
      cont[s] = fn;
}
bool foundSome( const char* const s )
{
      return std::find( std::begin(cont), std::end(cont), s) != std::end( cont );
}
 
add( "Archer" );
foundSome( "Archer" );

#define str "str"

"str" == "str"

inline const std::string& my_str()
{
    static std::string str { "My String" };
    return str;
}
 
add( my_str() );
foundSome( my_str() );

//clang 3.7.0
 
#include <iostream>
#include <type_traits>
 
 
template<typename T>
class StringLiteralsWrapper
{
public:
    constexpr StringLiteralsWrapper(T const * const arr) noexcept
        : literalPtr(arr)
    {
    }
    constexpr StringLiteralsWrapper(const StringLiteralsWrapper&) noexcept = default;
    constexpr bool operator==(const StringLiteralsWrapper<T> &rhv) const noexcept
    {
        std::size_t index = 0;
        for(; literalPtr[index] && rhv.literalPtr[index]; ++index)
        {
            if(literalPtr[index] != rhv.literalPtr[index])
            {
                return false;
            }
        }
        return literalPtr[index] == rhv.literalPtr[index];
    }
private:
    T const * const literalPtr;
};
 
 
 
int main()
{
    constexpr auto Literal1 = StringLiteralsWrapper<char>("xxx");
    constexpr auto Literal2 = StringLiteralsWrapper<char>("xxx");
    constexpr auto Literal3 = StringLiteralsWrapper<char>("xxy");
    char arr1[(Literal1 == Literal3)+1];
    char arr2[(Literal1 == Literal2)+1];
    std::cout << sizeof(arr1) << " " << sizeof(arr2) << std::endl;
}

template<typename T>
constexpr StringLiteralsWrapper<T> makeLiteral(T const * const ptr)
{
    return StringLiteralsWrapper<T>(ptr);
}
 
 
constexpr StringLiteralsWrapper<char> operator "" _lit(char const * const ptr, std::size_t size)
{
    return StringLiteralsWrapper<char>(ptr);
}
 
 
int main()
{
    char arr1[("xxx"_lit == "xxy"_lit) + 1];
    char arr2[("xxx"_lit == "xxx"_lit) + 1];
    std::cout << sizeof(arr1) << " " << sizeof(arr2) << std::endl;
}

#include <iostream>
#include <utility>
 
namespace ct
{
 
template <char ...Chars>
struct string
{
    enum { length = sizeof...(Chars) - 1 };
 
    static char const value[];
};
 
template <char ...Chars>
char const string<Chars...>::value[] = { Chars... };
 
template <typename Str, typename I>
struct string_gen;
 
template <typename Str, size_t ...I>
struct string_gen<Str, std::index_sequence<I...>>
    : string<Str().chars[I]...>
{ };
 
template <typename Str, size_t Len>
struct make_string
    : string_gen<Str, std::make_index_sequence<Len>>
{ };
 
} // ct
 
#define UNIQUE(str) []() \
    {                                                          \
        struct S_ { char const * chars = (str); };             \
        return ::ct::make_string<S_, sizeof((str))>::value;    \
    }()
 
int main()
{
    std::cout << (UNIQUE("a") == UNIQUE("a")) << std::endl;
}

enum 
{
    x = (UNIQUE("a") == UNIQUE("a");//error
}

char arr[(UNIQUE("a") == UNIQUE("a")) + 1];//error

constexpr bool x = (UNIQUE("a") == UNIQUE("a"));//error

#include <boost/preprocessor/repetition/repeat.hpp>
#include <boost/preprocessor/punctuation/comma_if.hpp>
#include <boost/preprocessor/config/limits.hpp>
 
namespace ct
{
 
template <char ...Chars>
struct string
{
    static constexpr char const value[sizeof...(Chars)] = { Chars... };
};
 
template <char ...Chars>
char const string<Chars...>::value[];
 
} // ct
 
#define STRING_TO_CHARS_BY_ONE(Z, N, STR) \
        BOOST_PP_COMMA_IF(N) N >= sizeof(STR) ? '\0' : STR[N]
 
#define STRING_TO_CHARS(LEN, STR)  \
        BOOST_PP_REPEAT(LEN, STRING_TO_CHARS_BY_ONE, STR)
 
#define UNIQUE(STR) ::ct::string<STRING_TO_CHARS(100, STR)>::value
 
int main()
{
    enum 
    {
        x = (UNIQUE("a") == UNIQUE("a")) //ok
    };
}

#define UNIQUE(str) []() constexpr \
...