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

Question

В C++1y, могу ли я иметь ссылочный класс, который связывается с строковым литералом, но не с char* или char[]& или аналогичным?

class LitRf{ 
    const char* data_; 
    size_t size_; 
public: 
    LitRf(const char* /*?*/ s) : data_{s},size_{sizeof(s)} { /*?*/ } 
}; 

Answer 1

Я думаю, что лучше всего использовать const char (&s)[N] (с template<size_t N>) в качестве типа параметра. Но он также связывается с любым массивом const char, отличным от строкового литерала.

Добавить удаленный конструктор массива без const char, чтобы запретить вызов его с помощью неконстантного массива.

class LitRf 
{ 
    const char* data_; 
    Sz size_; 
public: 
    template<size_t N> 
    LitRf(char const (&s)[N]) 
     : data_{s}, size_{N} 
    {} 

    template<size_t N> 
    LitRf(char (&s)[N]) = delete; 
}; 

Кроме этого, вы можете использовать макро-обертку, который (если конструктор никогда не используется без него) делает возможным только построить объект из буквальных, даже через переменный.

#define MakeLitRf(s) LitRf(s "") 

Идея состоит в том, чтобы объединить две строки литералов, из которых вторая одна является просто пустая строка. Это возможно только в том случае, если первый также является строковым литералом; при установке переменной возникает синтаксическая ошибка. После макрорасширения компилятор видит что-то вроде LitRf("foo" ""), что эквивалентно LitRf("foo"). Некоторые примеры:

auto x = MakeLitRf("foo"); // works 

const char *foo = "foo"; 
auto x = MakeLitRf(foo); // fails 

auto x = LitRf(foo);  // works, but we want it to fail... 

В последнем случае пользователь случайно (? Или намеренно) не использовать макрос, чтобы сделать нашу работу бесполезной. Для того, чтобы сделать это не в состоянии тоже добавить скрытый параметр в конструктор, который необходимо добавить, когда вызывается непосредственно (и в определении макроса, конечно):

class LitRf 
{ 
    const char* data_; 
    Sz size_; 
public: 
    // Called by the macro MakeLitRf. Unlikely to be called directly unless the user knows what he's doing. 
    LitRf(const char *s, void *) 
     : data_{s}, size_{N} 
    {} 

    // Called without macro! Throw a compiler error, explaining what's wrong. 
    LitRf(const char *s) 
    { 
     static_assert(false, "Please use the macro `MakeLitRf` with a string literal to construct a `LitRf`."); 
    } 
}; 

#define MakeLitRf(s) LitRf(s "", nullptr) 

Answer 2

class LitRf{ 
    const char* data_; 
    Sz size_; 
public: 
    LitRf(const char* /*?*/ s) : data_{s},size_{sizeof(s)} { /*?*/ } 
    LitRf(char*) = delete; 
}; 

Answer 3

C++ 11 удален единственный формальный способ обнаружения строкового литерала как таковые, а именно через ее неявное преобразование в указатель на неконстантный.

В любом случае, используя небольшой трюк, нужно было использовать макрос.

В C++ 11 и более поздних версиях вы можете установить сильное соглашение о том, что массив const тип символа - это буквальный.

т.е. с вашим примером,

class LitRf 
{ 
private: 
    const char* data_; 
    Sz size_; 

    template< size_t n > 
    LitRf(char (&)[n]) = delete; 

public: 
    template< size_t n > 
    LitRf(char const (&s)[n]) 
     : data_{s}, size_{sizeof(s) - 1} 
    {} 
}; 

Обратите внимание на использование size_t вместо возможно знакового типа Sz. Это гарантирует, что код будет скомпилирован с g ++. К сожалению, у этого компилятора или более старых версий есть ошибка, где он настойчив на size_t, иначе он отказывается принять код.