Optional and named arguments
Optional Arguments
C# 4.0 introduces a new feature that improves the convenience of specifying arguments when calling a method. This tool is called optional arguments and allows you to define a default value for a method parameter. This value will be used by default if no corresponding argument is specified for the parameter when the method is called. Therefore, it is not necessary to specify an argument for such a parameter. Optional arguments make it easier to call methods, where default arguments are applied to some parameters. They can also be used as a "short" form of method overloading.
The main impetus for adding optional arguments was the need to simplify interaction with COM objects. In several Microsoft object models (for example, Microsoft Office) functionality is provided through COM objects, many of which were written long ago and designed to use optional parameters.
An example of using optional arguments is shown below:
Using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication1 ( class Program ( // Arguments b and c are optional when calling static int mySum(int a, int b = 5, int c = 10) ( return a + b + c; ) static void Main() ( int sum1 = mySum(3); int sum2 = mySum(3,12); Console.WriteLine("Sum1 = "+sum1); Console.WriteLine("Sum2 = "+sum2); Console.ReadLine(); ) ) )
It should be borne in mind that all optional arguments must necessarily be indicated to the right of the required ones. In addition to methods, optional arguments can be used in constructors, indexers, and delegates.
One advantage of optional arguments is that they make it easier for the programmer to deal with complex method and constructor calls. After all, it is often necessary to set more parameters in a method than is usually required. And in cases like this, some of these parameters can be made optional by careful use of the optional arguments. This means that you only need to pass the arguments that are important in the given specific case, not all arguments, which should otherwise be required. This approach allows us to rationalize the method and simplify the programmer's handling of it.
Named Arguments
One more functionality, which was added to C# with the release of .NET 4.0, is support for the so-called named arguments. As you know, when passing arguments to a method, the order in which they appear, as a rule, must match the order in which the parameters are defined in the method itself. In other words, the argument value is assigned to the parameter by its position in the argument list.
Named arguments are designed to overcome this limitation. A named argument allows you to specify the name of the parameter to which its value is assigned. And in this case, the order of the arguments no longer matters. Thus, named arguments are somewhat similar to the object initializers mentioned earlier, although they differ from them in their syntax. To specify an argument by name, use the following form of syntax:
parameter_name: value
Here parameter_name denotes the name of the parameter to which the value is passed. Of course, parameter_name must be the name of a valid parameter for the method being called.
It happens that data is transferred to the program from the command line when it is called. Such data is called command line arguments. It looks like this, for example:
./a.out test.txt ls -lt /home/peter/
This calls the programs a.out (from the current directory) and ls (from the same directory specified in the PATH environment variable). The first program from the command line receives one word - test.txt, the second - two: -lt and /home/peter/.
If the program is written in C, then when it starts, control is immediately transferred to the main() function, therefore, it is she who receives the command line arguments that are assigned to her variable parameters.
So far, we've defined the main() function as if it doesn't take any parameters and doesn't return anything. In fact, in C, any function by default (if nothing else is defined) returns an integer. This can be verified. If you write the code like this:
main() ( printf("Hi \n") ; return 0 ; )
Then no warning or error will occur during compilation. The same will happen if we write int main() . This proves that the default function returns an integer and not nothing (void). Although what the function returns can always be "overridden", for example, voidmain() or float main() .
When a program is called from the command line, a pair of data is always passed to it:
- integer, denoting the number of words (elements separated by spaces) on the command line when called,
- pointer to array of strings, where each line is a single word from the command line.
Note that the program name itself is also considered. For example, if the call looks like this:
./a.out 12 theme 2
Then the first argument of the program is 4, and the array of strings is defined as ("./a.out", "12", "theme", "2").
Pay attention to the terminology, there are only two program arguments (a number and an array), but as many command line arguments as you like. Command line arguments are "translated" into program arguments (into arguments to the main() function).
This data (number and pointer) is passed to the program even when it is simply called by name without passing anything to it: ./a.out. In this case, the first argument is 1, and the second argument points to an array of just one string (""./a.out").
The fact that data is passed to the program does not mean that the main() function should receive it. If the main() function is defined without parameters, then the command line arguments cannot be accessed. Although nothing prevents you from sending them. No error will occur.
To get access to the data passed to the program, they must be assigned to variables. Since the arguments are immediately passed to main() , its header should look like this:
main (int n, char *arr)
The first variable (n) contains the number of words, and the second variable contains a pointer to an array of strings. Often the second parameter is written as **arr . However, it is the same. Recall that the array of strings itself contains pointers to strings as its elements. And in the function we pass a pointer to the first element of the array. It turns out that we are passing a pointer to a pointer, i.e. **arr.
Exercise
Write a program like this:
#include
It prints the number of words on the command line when it is called, and each word with newline. Call it without command line arguments and with arguments.
In the program, we used the variable parameters argc and argv. It is customary to use just such names, but in fact they can be anything. It is better to adhere to this standard so that your programs are more understandable not only to you, but also to other programmers.
The Practical Importance of Passing Data to a Program
If you have experience with the GNU/Linux command line, you know that most commands have switches and arguments. For example, when viewing the contents of directories, copying, moving, objects are specified as arguments file system on which the command is executed. Features of its implementation are determined using keys. For example, in the command
Cp -r ../les_1 ../les_101
cp is the name of the command, -r is the switch, and ../les_1 and ../les_101 are the command arguments.
In general, most often, when programs are launched, file addresses and "modifiers" (these are keys) of the program execution process are transferred.
Let's write a program that opens the files specified by the user on the command line for writing or appending and writes (adds) there the same information that the user enters from the keyboard during the program execution:
#include
Explanations for the code:
- An array of five file pointers is created. Therefore, no more than five files can be opened at the same time. The file pointer of the first file will be stored in the array element f, the second - in f, and so on.
- The number of command line arguments is checked. There must be at least three of them, because. the first is the name of the program, the second is the file open mode, the third is the first or only file to be written to. Since the program only allows you to open five files, the total number of command line arguments cannot exceed seven. Therefore, if the number of arguments is less than 3 or more than 7, then the program ends, because The return statement causes the function to exit, even if there is more code after it. A function return value that is not equal to 0 can be interpreted by the parent process as a message that the program terminated with an error.
- The correctness of the second command line argument is checked. If it is neither "-w" nor "-a", then the conditional expression in the second if returns 1 (true). The strcmp() function allows you to compare strings and returns 0 if they are equal.
- IN for loop files are opened at the specified addresses that start with the third element of the argv array. That is why 2 is added to i to get the elements of the argv array, starting from the third. The expression argc-2 indicates the number of filenames passed; because argc stores the total number of command line arguments, the first two of which are not filenames.
- The expression argv+1 allows you to "cut" the substring "w" (or "a") from the string "-w" (or "-a"), because argv is essentially a pointer to the first element of the string. By adding one to the pointer, we shift it to the next element in the array.
- If the file cannot be opened, the fopen() function returns NULL. In this case, the program ends.
- Each character entered by the user from the keyboard is written to all open files.
- At the end, the files are closed.
When automatically creating a console application in the C++ programming language, a main function is automatically created that is very similar to this one:
int main(int argc, char * argv)
{…}
The function header contains the signature main function main() with arguments argc and argv .
If the program is run through the command line, then it is possible to transfer any information to this program. There are command line arguments argc and argv for this.
The argc parameter is of type int , and contains the number of parameters passed to the main function. Moreover, argc is always at least 1, even when no information is passed to the main function, since the name of the application is considered the first parameter.
The argv parameter is an array of pointers to strings. Only string type data can be passed through the command line.
When starting the program via command Windows string you can send some information to it. In this case, the command line will look like:
Drive:\path\name.exe argument1 argument2 ...
Command line arguments are separated by one or more spaces.
The argv argument contains the fully qualified application name:
#include
using namespace std;
cout<< argv << endl;
return 0;
}
Execution result
Example : calculating the product of two integers
The program uses the string to integer conversion function StrToInt() from here .
#include
using namespace std;
int StrToInt(char*s) (…)
int main(int argc, char * argv) (
Int a = 0, b=0;
If (argc > 1)
a = StrToInt(argv);
If (argc > 2)
b = StrToInt(argv);
cout<< a <<«*» << b << «= « << a*b << endl;
return 0;
}
The program is launched as
Execution result
Debugging a Program with Command Line Arguments
To pass command line arguments when debugging a program, you need to access the menu Properties project. 
On the tab Configuration Properties ->Debug choose Command arguments and set their values. 
When you run the program in debug mode, the entered arguments will be treated by the program as command line arguments.
Sometimes when starting a program it is useful to pass some information to it. Typically, this information is passed to the main() function via command-line arguments. Command line argument is information that is entered on the operating system command line following the program name. For example, to start compiling a program, you need to type the following on the command line after the prompt:
CC program_name
program_name is a command line argument that specifies the name of the program you are about to compile.
To accept command line arguments, two special built-in arguments are used: argc and argv . The argc parameter contains the number of arguments on the command line and is an integer, and it is always at least 1 because the first argument is the name of the program. And the argv parameter is a pointer to an array of pointers to strings. In this array, each element points to some command line argument. All command-line arguments are strings, so converting any numbers to the desired binary format must be provided in the program when it is developed.
Here is a simple example of using the command line argument. The screen displays the word Hello and your name, which must be specified as a command line argument.
#include
If you named this program name (name) and your name is Tom, then to run the program, enter name Tom at the command line. As a result of running the program, the message Hello, Tom will appear on the screen.
In many environments, all command-line arguments must be separated from each other by a space or tab. Commas, semicolons, and similar characters are not considered separators. For example,
Run Spot, run
consists of three character strings, while
Eric, Rick, Fred
is a single character string - commas are generally not considered delimiters.
If the string contains spaces, then in some environments the string can be enclosed in double quotes to prevent multiple arguments from being made. As a result, the entire string will be considered as one argument. To learn more about how command-line options are set on your operating system, see the documentation for that system.
It is very important to declare argv correctly. Here's how they do it most often:
Char *argv;
Empty square brackets indicate that the array has an indefinite length. You can now access individual arguments by indexing the argv array. For example, argv points to the first character string, which is always the program name; argv points to the first argument, and so on.
Another small example of using command line arguments is the countdown program below. This program counts down from some value (specified on the command line) and beeps when it reaches 0. Note that the first argument containing the initial value is converted to an integer value using the standard function atoi () . If the second argument of the command line (and if we take the name of the program as the third argument) is the string "display" (output to the screen), then the result of the countdown (in reverse order) will be displayed on the screen.
/* Program to count backwards. */ #include
Note that if command line arguments are not specified, an error message will be displayed. Programs with command-line arguments often do the following: when the user runs these programs without entering the required information, instructions are displayed on how to correctly specify the arguments.
To access a single character in one of the command line arguments, enter the second index into argv. For example, the following program prints character-by-character all the arguments with which it was called:
#include Remember, the first index of argv provides access to the string, and the second index provides access to its individual characters. Usually argc and argv are used to pass the initial commands to the program that it will need when it starts. For example, command-line arguments often specify information such as a filename, an option, or an alternate behavior. Using command line arguments gives your program a "professional look" and makes it easier to use in batch files. The names argc and argv are traditional but not required. You can name these two parameters in the main() function whatever you like. Also, some compilers may support -additional arguments for main(), so be sure to check the documentation for your compiler. When a program does not require command line parameters, it is most common to explicitly declare the main() function to have no parameters. In this case, the keyword void is used in the parameter list of this function. Borland C++ supports three main() arguments. The first two are traditional argc and argv. These are the only arguments to the main() function defined by the ANSI C standard. They allow command-line arguments to be passed to the program. Command line arguments are the information that follows the program name on the operating system command line. For example, when a program is compiled with the Borland inline compiler, bcc is typically typed program_name Where program_name is the program to be compiled. The program name is passed to the compiler as an argument. The argc parameter contains the number of command line arguments and is an integer. It is always at least 1 because the program name is qualified as the first argument. The argv parameter is a pointer to an array of character pointers. Each element of this array points to a command line argument. All command line arguments are strings. All numbers are converted by the program into an internal format. The following program prints "Hello" followed by the username if typed right after the program name: #include If you call this program name, and the username is Sergey, then to run the program you should type: Command line arguments must be separated by spaces or tabs. Commas, semicolons, and similar characters are not considered separators. For example: Consists of three lines, while Herb,Rick,Fred This is one line - commas are not delimiters. If you want to pass a string containing spaces or tabs as a single argument, enclose it in double quotes. For example, this is one argument: "this is a test" It is important to correctly declare argv. The most typical method is: The empty parentheses indicate that the array does not have a fixed length. You can access individual elements using argv indexing. For example, argv points to the first line, which always contains the name of the program. argv points to the next line, and so on. Below is a small example of using command line arguments. It counts down from the value specified on the command line and emits a signal when zero is reached. Note that the first argument contains a number converted to an integer using the standard atoi() function. If the string "display" is present as the second argument, then the counter itself will be displayed on the screen. /* counting program */ #include Note that if no arguments are specified, an error message appears. This is most typical of programs that use command line arguments to issue instructions if an attempt was made to run the program without the correct information. To access individual command line characters, add a second index to argv. For example, the following program prints all the arguments it was called with, one character at a time: #include It must be remembered that the first index is for accessing the string, and the second is for accessing the character of the string. Typically argc and argv are used to get source commands. Theoretically, you can have up to 32767 arguments, but most operating systems don't even allow you to get close to that. Typically, these arguments are used to specify a filename or options. Using command line arguments gives the program a professional look and allows the program to be used in batch files. If you include the WILDARGS.OBJ file supplied with Borland C++, you can use wildcards in *.EXE type arguments. (Borland C++ handles patterns automatically and increments argc accordingly.) For example, if you connect WILDARGS.OBJ to the following program, it will print out how many files match the name of the file specified on the command line: /* Link this program with WILDARGS.OBJ */ #include If we call this program WA, then run it as follows, we get the number of files that have the EXE extension, and a list of the names of these files: In addition to argc and argv, Borland C++ also provides a third command line argument -env. The env parameter allows the program to access information about the operating system environment. The env parameter must follow argc and argv and is declared like this: As you can see, env is declared in the same way as argv. Just like argv, this is a pointer to an array of strings. Each line is an environment string as defined by the operating system. The env parameter has no counterpart to the argc parameter, which tells how many environment lines there are. Instead, the last line of the environment is null. The following program prints all the environment strings currently defined in the operating system: /* this program prints all environment lines */ #include Note that although argc and argv are not used by the program, they must be present in the parameter list. C does not know the parameter names. Instead, their use is determined by the order in which the parameters are declared. In fact, you can call the parameter whatever you like. Because argc, argv, and env are traditional names, it's best to keep using them so that anyone reading the program can instantly recognize that these are arguments to the main() function. For programs, a typical task is to find the value defined in the environment string. For example, the contents of the PATH string allow programs to use search paths. The following program demonstrates how to find strings that declare standard search paths. It uses the standard library function strstr(), which has the following prototype: Char *strstr(const char *str1, const char *str2); The strstr() function looks for the string pointed to by str1 in the string pointed to by str2. If such a string is found, then a pointer to the first position is returned. If no match is found, the function returns NULL. /* the program searches the environment strings for a string containing PATH */ #include
{
if(argc!=2)
{
printf("You forgot to type your name\n");
return 1;
}
printf("Hello %s", argv);
return 0;
}
name Sergei.
As a result of the program will appear:
Hello Sergei.
#include
#include
int main(int argc, char *argv)
{
int disp, count;
if(argc<2)
{
printf("You must enter the length of the count\n");
printf("on the command line. Try again.\n");
return 1;
}
if (argc==3 && !strcmp(argv,"display")) disp = 1;
else disp = 0;
for(count=atoi(argv); count; -count)
if (disp) printf("%d", count);
printf("%c", "\a"); /* on most computers this is a call */
return 0;
}
int main(int argc, char *argv)
{
int t, i;
for(t=0; t
i = 0;
while(argv[t][i])
{
printf("%c", argv[t][i]);
}
printf(");
}
return 0;
}
int main(int argc, char *argv)
{
register int i;
printf("%d files match specified name\n", argc-1);
printf("They are: ");
for(i=1; i
return 0;
}
int main(int argc, char *argv, char *env)
{
int t;
for(t=0; env[t]/ t++)
printf("%s\n", env[t]);
return 0;
}
#include
int main (int argc, char *argv, char *env)
{
int t;
for(t=0; env[t]; t++)
{
if(strstr(env[t], "PATH"))
printf("%s\n", env[t]);
}
return 0;
}
Loading...