C передать параметры программе

Метод Main() . Способы объявления. Передача аргументов в функцию Main() . Метод GetCommandLineArgs() класса Environment

Поиск на других ресурсах:

1. Назначение метода Main() . Особенности применения

Функция Main() – это специальная функция, которая предназначена для начала выполнения любой программы и имеет следующие особенности применения:

• функция Main() есть точкой входа в любую программу на языке C#. Термин «точка входа» означает, что выполнение программы начинается из функции Main() ;
• функция Main() считается главной функцией в программе, которая может вызывать другие функции, реализованные в программе;
• функция Main() может получать параметры. С помощью этих параметров другая программа может передавать некоторую информацию (данные) в текущую программу;
• функция Main() может возвращать целочисленное значение, которое будет сигнализировать о результате выполнения программы. Это необходимо в случаях, если программа вызывается из другой программы (процесса). Чаще всего процессом, который вызывает функцию Main() есть операционная система;
• в программе функция с именем Main() может быть только одна. Иными словами, функция Main() не может быть перегружена;
• функция Main() есть статической, то есть в начале объявления содержит модификатор static . Это означает, что функция вызывается без создания экземпляра класса. Статичность функции необходима, так как при первом запуске еще не создано никаких экземпляров классов. Существуют только статические методы и переменные. Эти методы и переменные инициализируются автоматически при первом обращении к ним.

2. Способы объявления функции Main()

Функция Main() может быть объявлена одним из четырех возможных способов, перечисленных ниже.

Язык Си с нуля — Урок 54 — аргументы командной строки.

Способ 1. Функция не возвращает значения и не получает параметров. Общая форма функции Main() в этом случае следующая:

static void Main() < // действия, операторы // . >

Способ 2. Функция возвращает целочисленное значение и не получает параметров. В этом случае общая форма функции следующая

static int Main() < // действия, операторы // . return value; >

Здесь value – некоторое целочисленное значение, которое есть результатом возврата из программы. Другие процессы, запускающие текущую программу, могут использовать этот результат. Например, если функция Main() возвращает -1, то это может означать внутреннюю ошибку. И, наоборот, если функция возвращает 0, то это может означать корректное выполнение программы.

Способ 3. Функция не возвращает значения, но получает параметры. Параметрами функции Main() может быть массив строк. В этом случае общая форма функции следующая:

static void Main(string[] args) < // действия, операторы // . >

• args – массив строк, который передается в функцию Main() из других процессов.

Способ 4. Функция возвращает целочисленное значение и получает параметры. Общая форма объявления функции следующая

Передача параметров в функцию по ссылке. Разница между ссылкой и указателем. Урок #51

static void Main(string[] args) < // действия, операторы // . return value; >

• args – массив строк, который передается в функцию Main() из других процессов;
• value – значение типа int , которое передается в процесс, который вызвал текущую программу.

3. Модификаторы доступа, которые могут применяться с функцией Main()

Функция Main() может быть объявлена с двумя модификаторами доступа:

• private – в этом случае функция Main() не может вызываться из других сборок непосредственно;
• public – функция Main() есть общедоступной из других сборок.

4. Зачем в качестве параметров в функцию Main() передается массив строк?

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

Например. Пусть сделан вызов программы с именем Project1.exe следующим образом:

Project1.exe param1 param2 file1.txt

то функция Main() программы Project1.exe получит следующий массив входных параметров

param1 param2 file1.txt

то есть, для следующего объявления функции

void Main(string[] args) < // . >

значения переменной args будут следующими:

args.Length = 3 args[0] = «param1» args[1] = «param2» args[2] = «file1.txt»

5. Пример, который демонстрирует применение параметров в функции Main()

В примере продемонстрирован вывод массива параметров на экран. Программа создана по шаблону Console Application.

using System; namespace ConsoleApp1 < class Program < static void Main(string[] args) < // Пример вывода массива параметров args на экран Console.WriteLine(«args.Length = «, args.Length); for (int i = 0; i < args.Length; i++) < Console.WriteLine(«args[] = «, i, args[i]); > > > >

Результат выполнения программы ConsoleApp1.exe для строки

ConsoleApp1 param1 param2 file1.txt

имеет следующий вид

args.Length = 3 args[0] = param1 args[1] = param2 args[2] = file1.txt

6. Установка параметров, которые передаются в функцию Main() , средствами Microsoft Visual Studio 2019

В системе Microsoft Visual Studio любой версии можно задавать параметры, которые передаются в функцию Main() . Эти параметры еще называются аргументы командной строки.

Чтобы задать аргументы командной строки используется команда Properties… из меню Project .

Например, если создано консольное приложение с именем решения ConsoleApp1 , то вызвать окно настройки параметров можно с помощью команды

Project -> ConsoleApp1 Properties.

как показано на рисунке 1.

Рисунок 1. Команда вызова свойств проекта

В результате откроется окно «ConsoleApp1» , в котором нужно активировать элемент Debug (рисунок 2). В левой части окна в поле «Application arguments» нужно ввести аргументы командной строки. Эти аргументы будут передаваться в функцию Main() . Таким образом, можно протестировать вызов текущей программы из других процессов передавая программе различные варианты аргументов.

Рисунок 2. Установка аргументов командной строки

7. Каким образом в функцию Main() передать строку, которая содержит пробелы?

Бывают случаи, когда в функцию Main() нужно передать строку как один параметр. Но эта строка может содержать пробелы. В этом случае строку нужно заключить в двойные кавычки. Все что размещается между двойными кавычками не разбивается по параметрам.

Например. Пусть в функцию Main() для приложения с именем ConsoleApp1.exe нужно передать два параметра-строки:

• «This is a parameter»;
• «Second parameter».

В этом случае, вызов ConsoleApp1.exe из другого процесса (например, из командной строки) будет следующим:

ConsoleApp1.exe «This is a parameter» «Second parameter»

В этом случае в функцию Main() будут переданы следующие значения массива args :

args.Length = 2 args[0] = «This is a parameter» args[1] = «Second parameter»

8. Получение параметров с помощью метода GetCommandLineArgs() класса Environment . Пример

Получить параметры командной строки можно с помощью метода GetCommandLineArgs() класса Environment . Этот метод есть статическим, а потому не нужно создавать экземпляр класса Environment . Метод возвращает массив аргументов типа string[] .

Важно помнить, что метод GetCommandLineArgs() возвращает массив параметров на один больше. Первым параметром, который возвращает метод (под индексом 0) идет полное имя к текущему выполняемому файлу.

Пример. Вывод на экран списка параметров, передаваемых в функцию Main() .

using System; namespace ConsoleApp1 < class Program < static void Main(string[] args) < // Вывести список параметров с помощью метода GetCommandLineArgs() // класса Environment string[] parameters = Environment.GetCommandLineArgs(); Console.WriteLine(«Parameters:»); foreach (string s in parameters) < Console.WriteLine(s); > Console.ReadKey(); > > >

9. Определение полного имени файла выполняемой программы

Полное имя файла выполняемой программы можно определить с помощью статического метода GetCommandLineArgs() класса Environment. Как известно, метод используется для определения параметров текущей программы в виде массива строк типа string[] . При вызове метода, параметр, который возвращается, с индексом 0 содержит полное имя файла текущей программы.

Нижеследующий фрагмент кода демонстрирует вывод полного имени файла текущей программы

// Вывести полный путь к файлу текущей программы string path = Environment.GetCommandLineArgs()[0]; Console.WriteLine(«Full path = «, path);

Связанные темы

• Понятие метода. Примеры методов в классах. Возврат из метода. Оператор return . Методы без параметров. Ключевое слово void
• Передача параметров в метод. Аргументы и формальные параметры. Примеры. Передача ссылки на объект класса в метод

Источник: www.bestprog.net

C передать параметры программе

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

Вы наверняка знаете, что передача параметров в программу на C/C++ осуществляется через массив функции main(). Так повелось, что он называется argv (от arguments values — значения аргументов), но в принципе его можно назвать и по другому. Количество этих параметров передается через переменную argc (от arguments counter — счетчик аргументов).

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

int main(int argc, char *argv[]) >; int main(int argc, char **argv) >;

Давайте напишем маленькую программку, которая выводит значения переданных параметров:

// программа test.c #include int main(int argc, char *argv[]) int i = 0; for (i = 0; i argc; i++) printf(«Argument %d: %sn», i, argv[i]); >; >;

Сохраняем в файл test.c и компилируем:

dron:~# gcc test.c -o test

После этого попробуем запустить программу:

dron:~# ./test Argument 0: ./test

Передадим несколько параметров:

dron:~# ./test qwe sdf fgh hjk kl 123 —help Argument 0: ./test Argument 1: qwe Argument 2: sdf Argument 3: fgh Argument 4: hjk Argument 5: kl Argument 6: 123 Argument 7: —help

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

Но моя цель не говорить о том, как передаются параметры, а как с ними работать. Для начала надо вспомнить, что в системе Linux существует два вида параметров: короткие и длинные. Короткие параметры начинаются с одного дефиса и имеют длину в один символ, их просто и быстро набирать в командной строке. Длинные параметры начинаются с двух дефисов и могут иметь длинное имя, которое целесообразно использовать в скриптах (чтобы потом можно было вспомнить, что и как происходит). Кроме этого любой параметр может иметь значение, а может и не иметь. Приведу для примера несколько параметров:

-h — короткий параметр —help — длинный параметр -s 10 — параметры со значениями —size 10 —size=10

• int getopt(. ) — Обрабатывает короткие параметры
• int getopt_long(. ) — Обрабатывает короткие и длинные параметры
• int getopt_long_only(. ) — Обрабатывает параметры только как длинные

Давайте разберемся с работой первой функции — getopt(. ). Ее определение выглядит следующим образом:

#include int getopt(int argc, char * const argv[], const char *optstring); extern char *optarg; extern int optind, opterr, optopt;

Эта функция последовательно перебирает переданные параметры в программу.

Для работы в функцию передается количество параметров argc, массив параметров argv[] и специальная строка optstring, в которой перечисляются названия коротких параметров и признаки того, что параметры должны иметь значение. Например, если программа должна воспринимать три параметра a, b, F , то такая строка бы выглядела как «abF».

Если параметр должен иметь значение, то после буквы параметра ставится двоеточие, например параметр F и d имеют значения, а параметры e, a и b не имеют, тогда эта строка могла бы выглядеть как «eF:ad:b». Если параметр может иметь (т.е. может и не иметь) значение, то тогда ставится два знака двоеточия, например «a::» (это специальное расширение GNU). Если optstring содержит «W:», то тогда параметр -W opt переданный в программу, будет восприниматься как длинный параметр —opt. Это связано с тем, что параметр W зарезервирован в POSIX.2 для расширения возможностей.

Для перебора параметров функцию getopt() надо вызывать в цикле. В качестве результата возвращется буква названия параметра, если же параметры кончились, то функция возвращает -1. Индекс текущего параметра хранится в optind, а значение параметра помещается в optarg (указатель просто указывает на элемент массива argv[]). Если функция находит параметр не перечисленный в списке, то выводится сообщение об ошибке в stderr и код ошибки сохраняется в opterr, при этом в качестве значения возврящается «?». Вывод ошибки можно запретить, если установить opterr в 0.

#include #include int main(int argc, char *argv[]) int rez = 0; // opterr = 0; while ( (rez = getopt(argc, argv, «ab:C::d»)) != -1) switch (rez) case ‘a’: printf(«found argument «a».n»); break; case ‘b’: printf(«found argument «b = %s».n», optarg); break; case ‘C’: printf(«found argument «C = %s».n», optarg); break; case ‘d’: printf(«found argument «d»n»); break; case ‘?’: printf(«Error found !n»); break; > // switch > // while > // main

Попробуем скомпилировать данную программку и запустить:

dron:~# gcc test.c -o test dron:~# ./test -a -b -d -C found argument «a». found argument «b = -d». found argument «C = (null)». dron:~# ./test -a -b -C -d found argument «a». found argument «b = -C». found argument «d» dron:~# ./test -a -b1 -C -d found argument «a». found argument «b = 1». found argument «C = (null)». found argument «d» dron:~# ./test -b1 -b2 -b 15 found argument «b = 1». found argument «b = 2». found argument «b = 15».

Давайте посмотрим, как функция getopt вылавливает ошибки. Попробуем задать параметр, которого нет в списке:

dron:~# ./test -h -a ./test: invalid option — h Error found ! found argument «a».

Как я и говорил, функция вывела сообщение об ошибке в stderr. Давайте выключим вывод сообщений, для этого надо где-то в программе перед вызовом функции вставить opterr=0;. Компилируем и запускаем:

dron:~# ./test -h -a Error found ! found argument «a».

Теперь, как видите, сообщение больше не выдается, зато как и раньше можно обработать ошибку самому.

Источник: firststeps.ru

C передать параметры программе

Параметры методов

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

Большая часть программистов сталкивается с необходимостью изучения данной темы, когда приходится изменять параметры, передаваемые в методы (не использовать их значения для вычисления чего-либо, а именно изменять значения, так, чтобы эти изменения сохранились после выполнения метода). И существует ряд нюансов, которые совсем не очевидны для начинающего программиста.

По умолчанию, в языке программирования C#, аргументы в методы передаются по значению! Но, Вы должны помнить, что большинство типов, используемых программистами, являются всё-таки ссылочными типами, и в результате, в метод попадает, так сказать, копия ссылки, так что, Вы можете изменять объект, на который ссылается эта копия (т.е. тот же объект, на который ссылает и оригинал ссылки), но не можете заставить оригинальную ссылку указывать на другой объект. А вот при использовании типов значений, ситуация иная, и проблемы могут всплыть сразу же!

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

//Принимает два целых числа, и меняет их местами static void Swap(int aFirstArg, int aSecondArg) < //Сохраняем значение первого аргумента во временной переменной int tmpParam = aFirstArg; //Присваиваем значение второго аргумента первому aFirstArg = aSecondArg; //Присваиваем сохраненное значение первого аргумента второму aSecondArg = tmpParam; >

Казалось бы, ничего проще нет, но на практике, такой метод работать не будет! Если мы напишем код подобный следующему:

//Использования метода Swap int a = 5; int b = 10; Console.WriteLine(«До вызова Swap: ta = » + a + «; b = » + b); //Поменять значения a и b местами Swap(a, b); Console.WriteLine(«После вызова Swap: ta = » + a + «; b = » + b);

То мы увидим примерно такой результат работы приложения:

Результат работы метода Swap

Такой результат работы является следствием того, что аргументы передаются по значению, т.е. в метод передается копия аргумента, и сколько бы мы её не изменяли, за пределами метода, оригинал останется неизменным. Но ситуацию, можно исправить очень просто! Нужно указать при объявлении метода, что параметры должны передаваться по ссылке. Для этого в C# существует ключевое слово ref, которое указывается перед аргументом при объявлении и при вызове метода. На практике, доработанный метод «Swap» это выглядит так:

//Принимает по ссылке два целых числа, и меняет их местами static void Swap(ref int aFirstArg, ref int aSecondArg) < //Сохраняем значение первого аргумента во временной переменной int tmpParam = aFirstArg; //Присваиваем значение второго аргумента первому aFirstArg = aSecondArg; //Присваиваем сохраненное значение первого аргумента второму aSecondArg = tmpParam; >

А вызов метода «Swap» будет таким:

//Поменять значения a и b местами Swap(ref a, ref b);

И тогда, результат работы метода, будет таким:

Результат работы доработанного метода Swap

Как видите, подобные проблемы решаются передачи параметров в методы решаются довольно просто, даже не пришлось переписывать «логику» метода. Но есть одна особенность, объект, который передается в качестве ref-параметра метода, должен быть инициализирован перед вызовом метода. Т.е. подобный код, компилироваться не будет:

//Использования метода Swap int a; //Переменная не инициализирована. int b = 10; //Поменять значения a и b местами Swap(a, b);

Но бывают такие ситуации, когда перед передаче объекта в метод, который должен изменить его значение, мы не знаем чем инициализировать данный объект (можно конечно инициализировать его чем попало, но это это довольно коряво), в таких случаях можно передать параметр в метод не как ссылочный, как чисто выходной параметр. Делается это просто, ключевое слово ref, заменяется на ключевое слово out.

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

//Принимает выходной параметр, из устанавливает ему случайное значение static void SetValue(out int aParam) < //Создаем объект, генерирующий случайные числа Random rnd = new Random(); //Генерируем число aParam = rnd.Next(); >

Использовать метод можно так:

//Создает не инициализированную переменную int a; //Вызываем метод, задающей ей значение SetValue(out a);

Пример, конечно надуманный, можно было бы не работать с выходными параметрами, а просто возвращать случайное значение методом «SetValue», но в реальной практике, можно столкнуться с ситуацией, что метод уже возвращает какое-то значение, или нужно заполнить несколько выходных параметров.

А теперь вернемся к ссылочным типам! С ними всё немножко иначе, в метод попадает копия ссылки, это значит, что изменять состояние объекта, на который указывает ссылка мы можем, в отличии от типов значений. Но вот поменять местами два объекта, даже ссылочного типа, в «лоб» не получится, всё равно придется прибегать к использованию ссылочных параметров, но это и проблема! Правда?

Источник: plssite.ru