Почему argc не является константой?

int main( const int argc , const char[] const argv)

Поскольку в пункте № 3 эффективного C ++ сказано: «По возможности используйте const», я начинаю думать: «Почему бы не сделать эти« постоянные »параметры const?».

Есть ли какой-нибудь сценарий, при котором значение argcизменяется в программе?

В этом случае история играет важную роль. C определил эти входные данные как «непостоянные», и совместимость с (значительной частью) существующего кода C была ранней целью C ++.

Некоторые API-интерфейсы UNIX, например getopt, действительно манипулируют argv[], поэтому это невозможно сделать и constпо этой причине.

^{(В сторону: интересно, хотя getoptпрототип предполагает, что он не будет изменять, argv[]но может изменять строки, на которые указывает, страница руководства Linux указывает, что getoptпереставляет свои аргументы, и, похоже, они знают, что они непослушны . Страница руководства на Open Группа не упоминает об этой перестановке.)}

Положив constна argcи argvне будет покупать много, и это может сделать недействительными некоторые старой школы программирования практики, такие как:

// print out all the arguments:
while (--argc)
    std::cout << *++argv << std::endl;

Я написал такие программы на C и знаю, что не одинок. Я скопировал откуда- то пример .

Стандарт C (ISO / IEC 9899: 2011) гласит:

5.1.2.2.1 Запуск программы

¶1 Названа функция, вызываемая при запуске программы main. Реализация не объявляет прототипа для этой функции. Он должен быть определен с возвращаемым типом int и без параметров:

int main(void) { /* ... */ }

или с двумя параметрами (называемыми здесь argcи argv, хотя могут использоваться любые имена, поскольку они являются локальными для функции, в которой они объявлены):

int main(int argc, char *argv[]) { /* ... */ }

или эквивалент; ¹⁰⁾ или каким-либо другим способом, определяемым реализацией.

¶2 Если они объявлены, параметры mainфункции должны подчиняться следующим ограничениям:

• Значение argcдолжно быть неотрицательным.
• argv[argc] должен быть нулевым указателем.
• Если значение argcбольше нуля, элементы массива argv[0]до argv[argc-1]включительно должны содержать указатели на строки, которым среда хоста присваивает значения, определяемые реализацией, до запуска программы. Цель состоит в том, чтобы предоставить программе информацию, определенную перед запуском программы, из другого места в размещенной среде. Если среда хоста не способна предоставлять строки с буквами как в верхнем, так и в нижнем регистре, реализация должна гарантировать, что строки будут получены в нижнем регистре.
• Если значение argcбольше нуля, строка, на которую указывает, argv[0] представляет имя программы; argv[0][0]должен быть нулевым символом, если имя программы недоступно в среде хоста. Если значение argcбольше единицы, строки, на которые указывает argv[1]through, argv[argc-1] представляют параметры программы.
• Параметры argcи argvи строки, на которые указывает argvмассив, должны быть изменены программой и сохраняют свои последние сохраненные значения между запуском программы и ее завершением.

¹⁰⁾ Таким образом, intможет быть заменено именем typedef, определенным как int, или тип argvможет быть записан как char **argv, и так далее.

Обратите внимание на последний пункт. В нем говорится, что и то argcи другое argvдолжно быть изменяемым. Их не нужно изменять, но они могут быть изменены.

argcобычно не является константой, потому что подпись функции для main()предварительных дат const.

Поскольку argc является переменной стека, ее изменение не повлияет ни на что, кроме обработки вашей собственной командной строки.

Вы, конечно, можете заявить об этом, constесли хотите.

Верхний уровень constформального аргумента не является частью типа функции. Вы можете добавить или удалить его по своему усмотрению: он влияет только на то, что вы можете делать с аргументом в реализации функции.

Так что argcвы можете свободно добавлять const.

Но ведь argvвы не можете создать символьные данные, constне изменив тем самым сигнатуру функции. Это означает, что тогда это не одна из стандартных mainсигнатур функции, и ее не нужно будет распознавать как mainфункцию. Итак, не лучшая идея.

Хорошая причина не использовать стандартные mainаргументы в программах, не являющихся игрушечными, заключается в том, что в Windows они не могут представлять фактические аргументы программы, такие как имена файлов с международными символами. Это потому, что в Windows они очень строго кодируются как Windows ANSI. В Windows вы можете реализовать еще несколько переносимых средств доступа к аргументам в терминах GetCommandLineфункции API.

Подводя итог, ничто не мешает вам добавлять constк argc, но самый полезный const-ness на argvдаст вам нестандартную mainфункцию, скорее всего , не признаются в качестве таковых. К счастью (по иронии судьбы), есть веская причина не использовать стандартные mainаргументы для переносимого серьезного кода. Проще говоря, для практических целей они поддерживают только старый ASCII, содержащий только буквы английского алфавита.

Подпись mainявляется своего рода историческим артефактом из C. Исторически Cне было const.

Однако вы можете объявить свой параметр, constпоскольку константа влияет только на время компиляции.

Потому argcчто это локальная переменная (а в C ++ не ссылка или что-то в этом роде), и потому, что особое место mainозначает, что махинации с обратной совместимостью предоставляют ей огромную свободу действий без веских причин заставлять приложения делать ее константой.

main() {}

int main() {}

main() { return 0; }

main(int argc, char* argv[]) { return 0; }

int main(const int argc, const char** argv) { /* no return*/ }

эти и многие другие варианты будут компилироваться на широком спектре компиляторов C и C ++.

Так что в конечном итоге дело не в том, что argc не является const, просто это не обязательно, но может быть, если вы хотите, чтобы это было.

http://ideone.com/FKldHF , пример C:

main(const int argc, const char* argv[]) { return 0; }

http://ideone.com/m1qc9c , пример C ++

main(const int argc) {}

Помимо исторических причин, хорошая причина оставить argc и argv non- constсостоит в том, что реализация компилятора не знает, что вы собираетесь делать с аргументами для main, она просто знает, что она должна предоставить вам эти аргументы.

Когда вы определяете свои собственные функции и связанные с ними прототипы, вы знаете, какие параметры вы можете создать, constа какие - ваша функция будет изменять.

Взятый до крайности, вы могли бы заявить , что все параметры для всех функций должны быть объявлены const, а затем , если у вас есть причина , чтобы изменить их (например , уменьшение индекса для поиска через массив), то вы должны сделать местные Непро- constпеременным и скопируйте constзначения аргументов в эти переменные. Это создает напряженную работу и лишние LOC без реальной выгоды. Хороший статический анализатор подберет, если вы не изменяете значение аргумента, и порекомендует вам сделать параметр const.