Альтернативный способ получения argc и argv процесса

В Linux вы можете получить эту информацию из файловой системы proc процесса, а именно /proc/$$/cmdline:

int pid = getpid();
char fname[PATH_MAX];
char cmdline[ARG_MAX];
snprintf(fname, sizeof fname, "/proc/%d/cmdline", pid);
FILE *fp = fopen(fname);
fgets(cmdline, sizeof cmdline, fp);
// the arguments are in cmdline

Аргументы main определяются средой выполнения C и являются единственным стандартным/переносимым способом получения аргументов командной строки. Не боритесь с системой. :)

Если все, что вы хотите сделать, это предоставить доступ к параметрам командной строки в других частях программы с помощью вашего собственного API, есть много способов сделать это. Просто инициализируйте свой собственный класс, используя argv/argc в main, и с этого момента вы можете игнорировать их и использовать свой собственный API. Шаблон singleton отлично подходит для такого рода вещей.

Чтобы проиллюстрировать это, Qt, одна из самых популярных сред C++, использует этот механизм:

int main(int argc, char* argv[])
{
    QCoreApplication app(argc, argv);

    std::cout << app.arguments().at(0) << std::endl;

    return app.exec();
}

Аргументы перехватываются приложением и копируются в файл QStringList. Дополнительные сведения см. в разделе QCoreApplication::arguments().

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

#import <Cocoa/Cocoa.h>

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

Затем аргументы доступны в любом месте приложения с помощью NSProcessInfo.arguments.

Я заметил в вашем обновленном вопросе, что ваш класс напрямую хранит копию argc/argv в своем экземпляре:

int const argc_;
char const** const argv_;

Хотя это должно быть безопасным (время жизни указателей argv должно соответствовать полному времени жизни процесса), это не очень похоже на C++. Рассмотрите возможность создания вектора строк (std::vector<std::string>) в качестве контейнера и скопируйте в него строки. Тогда они даже могут безопасно изменяться (если хотите!).

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

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

Я предлагаю вам рассмотреть использование синглтона, чтобы убедиться, что существует только один экземпляр вашего класса Application. Аргументы могут быть переданы через main, но никакому другому коду не нужно знать или заботиться о том, откуда они взялись.

И если вы действительно хотите скрыть тот факт, что аргументы main передаются вашему конструктору Application, вы можете скрыть их с помощью макроса.

Чтобы частично ответить на вопрос, касающийся Windows, командную строку можно получить как возврат функции GetCommandLine, которая задокументирована здесь, без явного доступа к аргументам функции main.

Я полностью согласен с @gavinb и другими. Вы действительно должны использовать аргументы из main и хранить их или передавать там, где они вам нужны. Это единственный портативный способ.

Однако только в образовательных целях у меня работает следующее с clang в OS X и gcc в Linux:

#include <stdio.h>

__attribute__((constructor)) void stuff(int argc, char **argv)
{
    for (int i=0; i<argc; i++) {
        printf("%s: argv[%d] = '%s'\n", __FUNCTION__, i, argv[i]);
    }
}

int main(int argc, char **argv)
{
    for (int i=0; i<argc; i++) {
        printf("%s: argv[%d] = '%s'\n", __FUNCTION__, i, argv[i]);
    }
    return 0;
}

который выведет:

$ gcc -std=c99 -o test test.c && ./test this will also get you the arguments
stuff: argv[0] = './test'
stuff: argv[1] = 'this'
stuff: argv[2] = 'will'
stuff: argv[3] = 'also'
stuff: argv[4] = 'get'
stuff: argv[5] = 'you'
stuff: argv[6] = 'the'
stuff: argv[7] = 'arguments'
main: argv[0] = './test'
main: argv[1] = 'this'
main: argv[2] = 'will'
main: argv[3] = 'also'
main: argv[4] = 'get'
main: argv[5] = 'you'
main: argv[6] = 'the'
main: argv[7] = 'arguments'

Причина в том, что функция stuff помечена как __attribute__((constructor)), которая запустит ее, когда текущая библиотека будет загружена динамическим компоновщиком. Это означает, что в основной программе он будет работать еще до main и иметь аналогичную среду. Таким образом, вы можете получить аргументы.

Но позвольте мне повторить: это только для образовательных целей и не должно использоваться ни в каком производственном коде. Он не будет портативным и может сломаться в любой момент без предупреждения.

В Windows, если вам нужно получить аргументы как wchar_t *, вы можете использовать CommandLineToArgvW():

int main()
{
    LPWSTR *sz_arglist;
    int n_args;
    int result;
    sz_arglist = CommandLineToArgvW(GetCommandLineW(), &n_args);
    if (sz_arglist == NULL)
    {
        fprintf(stderr, _("CommandLineToArgvW() failed.\n"));
        return 1;
    }
    else
    {
        result = wmain(n_args, sz_arglist);
    }
    LocalFree(sz_arglist);
    return result;
}

Это очень удобно при использовании MinGW, потому что gcc не распознает int _wmain(int, wchar_t *) как действительный прототип main.

Передача значений не означает создание зависимости. Ваш класс не заботится о том, откуда берутся эти значения argc или argv — он просто хочет, чтобы они были переданы. Однако вы можете захотеть скопировать значения куда-нибудь — нет гарантии, что они не будут изменены (то же самое относится к альтернативным методам, таким как GetCommandLine).

Наоборот, вы создаете скрытую зависимость, когда используете что-то вроде GetCommandLine. Внезапно вместо простой семантики «передать значение» вы «волшебным образом берете свои входные данные откуда-то еще» — в сочетании с вышеупомянутым «значения могут измениться в любое время» это делает ваш код намного более хрупким, не говоря уже о невозможно проверить. И анализ аргументов командной строки, безусловно, является одним из случаев, когда автоматизированное тестирование весьма полезно. Если хотите, это глобальная переменная против подхода аргумента метода.

В C/C++, если main() не экспортирует их, то прямого доступа к ним нет; однако это не означает, что нет косвенного пути. Многие Posix-подобные системы используют формат elf, который передает argc, argv и envp в стек, чтобы быть инициализированным _start() и переданным в main() посредством обычного соглашения о вызовах. Обычно это делается на ассемблере (поскольку до сих пор нет переносимого способа получить указатель стека) и помещается в «стартовый файл», обычно с некоторым вариантом имени crt.o.

Если у вас нет доступа к main(), чтобы вы могли просто экспортировать символы, у вас, вероятно, не будет доступа к _start(). Так почему же я вообще упоминаю об этом? Из-за этого третьего параметра envp. Поскольку environ — это стандартная экспортируемая переменная, которая действительно устанавливается во время _start() с помощью envp. Во многих системах ELF, если вы возьмете базовый адрес environ и пройдете его в обратном направлении, используя отрицательные индексы массива, вы можете вывести параметры argc и argv. Первый должен быть NULL, за которым следует последний параметр argv, пока вы не дойдете до первого. Когда указанное значение, приведенное к long, равно отрицательному значению вашего отрицательного индекса, у вас есть argc, а следующим (на единицу больше, чем ваш отрицательный индекс) является argv/argv[0].

Мне известно несколько распространенных сценариев с функциями, требующими аргументов типа int argc, char *argv[]. Одним из таких очевидных примеров является GLUT, где его функция инициализации принимает эти аргументы от main(), что является своего рода «вложенным основным» сценарием. Это может быть или не быть вашим желаемым поведением. Если нет, так как не существует соглашения об именах этих аргументов, пока у вашей функции есть свой анализатор аргументов, и вы знаете, что делаете, вы можете делать все, что вам нужно, жестко запрограммировано:

int foo = 1;
char * bar[1] = {" "};

или читать из пользовательского ввода или генерировать иначе, насколько я знаю.

int myFunc( int foo, char *bar[]){
//argument parser
 {…   …}
return 0;
}

См. этот сообщение SO.

Наиболее переносимым способом было бы использование глобальной переменной для хранения параметров. Вы можете сделать это менее уродливым, используя Singleton (как ваш класс в вопросе, но синглтон, инициализированный main) или аналогичный Service Locator, который в основном такой же: создайте объект в main, статически передавайте и сохраняйте параметры и к ним обращается другой или тот же класс.

Непереносимые способы используют GetCommandLine в Windows, доступ к /proc/<pid>/cmdline или (/proc/self/cmdline) или использование специфичных для компилятора расширений, таких как __attribute__((constructor))

Обратите внимание, что получить функцию командной строки через эквивалент GetCommandLine невозможно (TLDR: Commandline не передается ядру, но уже анализируется и разделяется вызывающим процессом (например, оболочкой))

Похоже, вам нужна глобальная переменная; что вы должны сделать, это просто передать argc и argv в качестве параметров.