Here is example that converts command line arguments to single string:

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[]) {
    if (argc < 1)
        return 0;

    int i;
    int strsize = 0;
    for (i=1; i<argc; i++) {
        strsize += strlen(argv[i]);
        if (argc > i+1)
            strsize++;
    }

    printf("strsize: %d\n", strsize);

    char *cmdstring;
    cmdstring = malloc(strsize);
    cmdstring[0] = '\0';

    for (i=1; i<argc; i++) {
        strcat(cmdstring, argv[i]);
        if (argc > i+1)
            strcat(cmdstring, " ");
    }

    printf("cmdstring: %s\n", cmdstring);

    return 0;
}

Imagine it this way

*main() is also a function which is called by something else (like another FunctioN)

*the arguments to it is decided by the FunctioN

*the second argument is an array of strings

*the first argument is a number representing the number of strings

*do something with the strings

Maybe a example program woluld help.

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

    printf("you entered in reverse order:\n");

    while(argc--)
    {
        printf("%s\n",argv[argc]);
    }

return 0;
}

it just prints everything you enter as args in reverse order but YOU should make new programs that do something more useful.

compile it (as say hello) run it from the terminal with the arguments like

./hello am i here

then try to modify it so that it tries to check if two strings are reverses of each other or not then you will need to check if argc parameter is exactly three if anything else print an error

if(argc!=3)/*3 because even the executables name string is on argc*/
{
    printf("unexpected number of arguments\n");
    return -1;
}

then check if argv[2] is the reverse of argv[1] and print the result

./hello asdf fdsa

should output

they are exact reverses of each other

the best example is a file copy program try it it's like cp

cp file1 file2

cp is the first argument (argv[0] not argv[1]) and mostly you should ignore the first argument unless you need to reference or something

if you made the cp program you understood the main args really...

This is not the sole province of "old" console (command line) applications. Every running program has a "command line" that points at the executable image and includes any command line parameters. Plenty of GUI apps take arguments that alter either their initialization behavior or runtime behavior or both.

Most languages do let you specify an entry-point function that takes no arguments. But virtually all of them also allow you to pass arguments. This args array is simply an ordered collection of whatever is passed on the command line after the name of the executable file when the program is executed. EDIT: And of course in the case of the C language (as one example), the first argument (index 0) is actually the name of the program.

For example, imagine a pointless little program that displays a message in a message box, and lets you specify the message and the title for the window on the command line, like this:

myprogram.exe -title Foo -message Bar

Your args array in this case will look like this, presuming a language like C# which does not include the program name in the args array:

args[ 0 ] = "-title"
args[ 1 ] = "Foo"
args[ 2 ] = "-message"
args[ 3 ] = "Bar"

Making sense of the order of the arguments, and which ones are valid or not, is totally up to your own application code.

Those are for command-line arguments in Java.

In other words, if you run

java MyProgram one two

Then args contains:

[ "one", "two" ]

public static void main(String [] args) {
    String one = args[0]; //=="one"
    String two = args[1]; //=="two"
}

The reason for this is to configure your application to run a particular way or provide it with some piece of information it needs.

If you are new to Java, I highly recommend reading through the official Oracle's Java™ Tutorials.

Further to everyone else's answer, you should note that the parameters are optional in C# if your application does not use command line arguments.

This code is perfectly valid:

internal static Program
{
    private static void Main()
    {
        // Get on with it, without any arguments...
    }
}

A feature of String[] vs String... is that the "String..." does not need to be part of the call.

public void test(String... args){ 
   if(args.length > 0){
      for( String text : args){
         System.out.println(text);
      }
   }else{
      System.out.println("No args defined.");
   }
}

public void callerTest(){
     test();
     System.out.println();

     test("tree");
     System.out.println();

     test("dog", "cat", "pigeon");
}

Then if you call callerTest(); the Output will be:

No args defined.

tree

dog
cat
pigeon

• Trust the promise. argc is the Argument Count:

  int size = 0;
  while(argv[size]) { // gets the amount of arguments besides the first argument
      size++;
  }
  

  At this point you may assert(size == argc);

• Here be arguments:

      int v = strlen(argv[1]) + strlen(argv[2]); // for allocating memroy
  

  We checked argv[1]. However argv[2] may not be there.

      int v = strlen(argv[1]) + strlen(argv[2]); // for allocating memroy
  
      char *str = (char *)malloc(v);
      strcat(str, argv[1]); // putting the string together
      strcat(str, " ");
      strcat(str, argv[2]);
      strcat(str, " ");
  

  v doesn't have enough space to accomodate both strings and two spaces and a terminating 0.

      str = (char *)realloc(str, (v + strlen(argv[i]))); // reallocates enough memory
  

  It doesn't reallocate enough. The subsequent strcat(str, " ") is not accounted for.