What does int argc, char *argv[] mean?
argv
and argc
are how command line arguments are passed to main()
in C and C++.
argc
will be the number of strings pointed to by argv
. This will (in practice) be 1 plus the number of arguments, as virtually all implementations will prepend the name of the program to the array.
The variables are named argc
(argument count) and argv
(argument vector) by convention, but they can be given any valid identifier: int main(int num_args, char** arg_strings)
is equally valid.
They can also be omitted entirely, yielding int main()
, if you do not intend to process command line arguments.
Try the following program:
#include <iostream>
int main(int argc, char** argv) {
std::cout << "Have " << argc << " arguments:" << std::endl;
for (int i = 0; i < argc; ++i) {
std::cout << argv[i] << std::endl;
}
}
Running it with ./test a1 b2 c3
will output
Have 4 arguments:
./test
a1
b2
c3
int main(int argc, char **argv) [duplicate]
If you are running from Visual Studio, you can add arguments in the Project Properties. Right click the project that is running, select Properties. In the Debug tab, there is a input box for Command Line Arguments. Enter them there.
For codeblocks, see here.
Regarding 'main(int argc, char *argv[])' [duplicate]
The arguments argc
and argv
of main
is used as a way to send arguments to a program, the possibly most familiar way is to use the good ol' terminal where an user could type cat file
. Here the word cat
is a program that takes a file and outputs it to standard output (stdout
).
The program receives the number of arguments in argc
and the vector of arguments in argv
, in the above the argument count would be two (The program name counts as the first argument) and the argument vector would contain [cat
,file
,null]. While the last element being a null-pointer.
Commonly, you would write it like this:
int // Specifies that type of variable the function returns.
// main() must return an integer
main ( int argc, char **argv ) {
// code
return 0; // Indicates that everything went well.
}
If your program does not require any arguments, it is equally valid to write a main
-function in the following fashion:
int main() {
// code
return 0; // Zero indicates success, while any
// Non-Zero value indicates a failure/error
}
In the early versions of the C language, there was no int
before main
as this was implied. Today, this is considered to be an error.
On POSIX-compliant systems (and Windows), there exists the possibility to use a third parameter char **envp
which contains a vector of the programs environment variables. Further variations of the argument list of the main
function exists, but I will not detail it here since it is non-standard.
Also, the naming of the variables is a convention and has no actual meaning. It is always a good idea to adhere to this so that you do not confuse others, but it would be equally valid to define main
as
int main(int c, char **v, char **e) {
// code
return 0;
}
And for your second question, there are several ways to send arguments to a program. I would recommend you to look at the exec*()
family of functions which is POSIX-standard, but it is probably easier to just use system
("command arg1 arg2")
, but the use of system()
is usually frowned upon as it is not guaranteed to work on every system. I have not tested it myself; but if there is no bash
,zsh
, or other shell installed on a *NIX-system, system()
will fail.
int main(int argc, char** argv) [duplicate]
The argc
parameter is the number of command line options specified, including the executable name, when the executable was invoked. The individual command line options are found in the argv
array, which is NULL
terminated (the name and path used to invoke the executable is in argv[0]
).
The difference between the two versions is simply if you want to parse command line arguments or not - if you are not interested in them then you can ignore them using the second form.
What does char * argv[] means?
The parameter char * argv[]
decays to a pointer, char ** argv
. You can equally well write the function signature for main()
as:
int main(int argc, char ** argv)
You can do what you like with the pointer argv
within main()
, so argv++
for example just bumps argv
to point at argv[1]
rather than argv[0]
.
argv ---> argv[0] ---> "program"
argv[1] ---> "arg1"
argv[2] ---> "arg2"
... ...
argv[argc] == NULL
char** in int main(int argc, char** argv)
That is one of the allowable function signatures for the designated start of the program.
It is a requirement of a C++ executable that it contain one and only one of:
int main()
int main(int argc, char** argv)
(This function signature ofmain
is allowed to take additional parameters.)
You can find more information about main
here: http://en.cppreference.com/w/cpp/language/main_function
To specifically quote the definition of argv
:
Pointer to the first element of an array of pointers to null-terminated multibyte strings that represent the arguments passed to the program from the execution environment (
argv[0]
throughargv[argc-1]
). The value ofargv[argc]
is guaranteed to be 0.
For a more detailed documentation of how Microsoft populates argv
you can see here: https://msdn.microsoft.com/en-us/library/17w5ykft.aspx
The parameter argv in the function main(int argc, char *argv[])
The correct answer is E, none of the above. Although the parameter declaration looks like an array of pointer to char
, the rules of C adjust it to pointer to pointer to char
, and so do the rules of C++.
Either your instructor mistakenly intended choice C or your instructor designed a question inappropriately tricky for an introductory class, unless it is extra credit.
Related Topics
Vector of Structs Initialization
Checking the Neighbour Values of Arrays
Method That Converts Uint8_T to String
Writing a Sequence of Numbers Like: 1 22 333 4444 55555
How to Read in User Entered Comma Separated Integers
Derived Template-Class Access to Base-Class Member-Data
Finding Current Executable'S Path Without /Proc/Self/Exe
If You Shouldn't Throw Exceptions in a Destructor, How to Handle Errors in It
Thou Shalt Not Inherit from Std::Vector
Post-Increment and Pre-Increment Concept
What Are the Barriers to Understanding Pointers and What Can Be Done to Overcome Them
How to Initialize Private Static Members in C++
What Does "Dereferencing" a Pointer Mean
How to Convert a Std::String to Const Char* or Char*
Function Pointer to Member Function
What Are the Rules For Calling the Base Class Constructor