Как мне написать аддон Firefox? [закрыто]

(Извините, я только что заметил, что этот вопрос отмечен как c, а не c++. Возможно, мой ответ не так важен для этого вопроса!) [/ ​​g3]

Строковые литералы не совсем const или not-const, существует специальное странное правило для литералов.

(Резюме: литералы могут быть взяты с помощью ссылки на массив как foo( const char (&)[N]) и не могут быть приняты как не-const. Они предпочитают распадаться до const char *. Пока что это похоже на то, что они const. Но существует специальное правило, разрешает литералы распадаться на char *. См. эксперименты ниже.)

(После экспериментов, выполненных на clang3.3 с -std=gnu++0x. Возможно, это проблема C ++ 11 или конкретная для clang? Кстати, что-то странное происходит.)

Сначала литералы выглядят как const:

void foo( const char  * ) { std::cout << "const char *" << std::endl; }
void foo(       char  * ) { std::cout << "      char *" << std::endl; }

int main() {
        const char arr_cc[3] = "hi";
        char arr_c[3] = "hi";

        foo(arr_cc); // const char *
        foo(arr_c);  //       char *
        foo("hi");   // const char *
}

Эти два массива ведут себя так, как ожидалось, демонстрируя, что foo может указать нам, является ли указатель const или нет. Затем "hi" выбирает const версию foo. Кажется, что это решает: литералы const ... не так ли?

Но , если вы удалите void foo( const char * ), тогда это становится странным. Во-первых, вызов foo(arr_c) не выполняется с ошибкой во время компиляции. Это ожидается. Но буквальный вызов (foo("hi")) работает через неконстантный вызов.

Итак, литералы «больше const», чем arr_c (потому что они предпочитают распадаться на const char *, в отличие от arr_c. Но литералы «меньше const», чем arr_cc, потому что они желают распадаться на char *, если это необходимо.

(Кланг дает предупреждение, когда он распадается на char *).

Но как насчет разложения? Давайте избежим этого для простоты.

Давайте возьмем массивы по ссылке в foo вместо этого. Это дает нам более «интуитивные» результаты:

void foo( const char  (&)[3] ) { std::cout << "const char (&)[3]" << std::endl; }
void foo(       char  (&)[3] ) { std::cout << "      char (&)[3]" << std::endl; }

Как и раньше, литерал и массив const (arr_cc) используют версию const, а версия non-const используется arr_c. И если мы удалим foo( const char (&)[3] ), тогда мы получим ошибки с обоими foo(arr_cc); и foo("hi");. Короче говоря, если мы избежим распада указателя и будем использовать ссылку на массив, литералы будут вести себя так, как если бы они были const.

Шаблоны?

В шаблонах система выведет const char * вместо char *, и вы «застряли» с этим.

template<typename T>
void bar(T *t) { // will deduce   const char   when a literal is supplied
    foo(t);
}

Итак, буквально ведет себя как const на ll раз, за ​​исключением конкретного случая, когда вы непосредственно инициализируете char * литералом.