Jump to content

Main function: Difference between revisions

From Wikipedia, the free encyclopedia
Browse history interactively
← Previous edit
Content deleted Content added
VisualWikitext
 
(15 intermediate revisions by 12 users not shown)
Line 1: Line 1:
#REDIRECT [[Entry point]]
In many [[programming language]]s, the '''main function''' is [[entry point|where a program starts execution]]. It is responsible for the high-level organization of the program's functionality, and typically has access to the [[command-line argument|command arguments]] given to the program when it was executed.


{{Redirect category shell|1=
The main function is generally the first programmer-written [[subroutine|function]] run when a program starts, and is invoked directly from the system-specific initialization contained in [[crt0]] or equivalent. However, some languages can execute user-written functions before main runs, such as the constructors of [[C++]] global objects.
{{R from merge}}

}}
==Variants==

===C and C++===
In [[C (programming language)|C]] and [[C++]], the [[function prototype]] of the main function looks like one of the following:

<source lang="c">
int main(void);
int main();

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

The [[parameter (computer science)|parameter]]s <code>argc</code>, ''argument count'', and <code>argv</code>, ''argument vector'',<ref>argv: the vector term in this variable's name is used in traditional sense to refer to strings.</ref> respectively give the number and values of the program's [[command-line argument]]s. The names of <code>argc</code> and <code>argv</code> may be any valid identifier in C, but it is common convention to use these names. In C++, the names are to be taken literally, and the "void" in the parameter list is to be omitted, if strict conformance is desired.<ref>[http://groups.google.com/group/comp.std.c++/browse_thread/thread/a1e5504b499bc58f] - Parameter types and names of main.</ref> Other platform-dependent formats are also allowed by the C and C++ standards, except that in C++ the return type must always be <code>int</code>;<ref>Section 3.6.1.2, Standard C++ 2011 edition.</ref> for example, [[Unix]] (though not [[POSIX.1]]) and [[Microsoft Windows]] have a third argument giving the program's [[environment variable|environment]], otherwise accessible through <code>getenv</code> in <code>[[stdlib.h]]</code>:
<source lang="c">
int main(int argc, char **argv, char **envp);
</source>

[[Mac OS X]] and [[Darwin (operating system)|Darwin]] have a fourth parameter containing arbitrary OS-supplied information, such as the path to the executing binary:<ref>[http://unixjunkie.blogspot.com/2006/02/char-apple-argument-vector.html The <code>char *apple</code> Argument Vector]</ref>

<source lang="c">
int main(int argc, char **argv, char **envp, char **apple);
</source>

The value returned from the main function becomes the [[exit status]] of the process, though the C standard only ascribes specific meaning to two values: <code>EXIT_SUCCESS</code> (traditionally 0) and <code>EXIT_FAILURE</code>. The meaning of other possible return values is implementation-defined. In case a return value is not defined by the programmer, an implicit <code>return 0;</code> at the end of the <code>main()</code> function is inserted by the compiler; this behavior is required by the C++ standard.

It is guaranteed that <code>argc</code> is non-negative and that <code>argv[argc]</code> is a [[null pointer]]. By convention, the command-line arguments specified by <code>argc</code> and <code>argv</code> include the name of the program as the first element if <code>argc</code> is greater than 0; if a user types a command of "<code>rm file</code>", the [[shell (computing)|shell]] will initialise the <code>[[rm (Unix)|rm]]</code> process with <code>argc = 2</code> and <code>argv = ["rm", "file", NULL]</code>. As <code>argv[0]</code> is the name that processes appear under in <code>[[ps (Unix)|ps]]</code>, <code>[[top (Unix)|top]]</code> etc., some programs, such as [[Daemon (computer software)|daemon]]s or those running within an [[interpreter (computing)|interpreter]] or [[virtual machine]] (where <code>argv[0]</code> would be the name of the host executable), may choose to alter their argv to give a more descriptive <code>argv[0]</code>, usually by means of the <code>[[Exec (operating system)|exec]]</code> system call.

The <code>main()</code> function is special; normally every C and C++ program must define it exactly once.

If declared, <code>main()</code> must be declared as if it has external linkage; it cannot be declared <code>static<code> or <code>inline</code>.

In C++, <code>main()</code> must be in the global [[namespace]] (i.e. <code>::main</code>), cannot be overloaded, and cannot be a [[member function]], although the name is not otherwise reserved, and may be used for member functions, classes, enumerations, or non-member functions in other namespaces. In C++ (unlike C) <code>main()</code> cannot be called [[Recursion (computer science)|recursively]] and cannot have its address taken.

===Clean===
[[Clean (programming language)|Clean]] is a functional programming language based on graph rewriting. The initial node is called <code>Start</code> and is of type <code>*World -> *World</code> if it ''changes'' the world or some fixed type if the program only prints the result after [[graph rewriting|reducing]] <code>Start</code>.

Start :: *World -> *World
Start world = startIO ...

Or even simpler

Start :: String
Start = "Hello, world!"

One tells the compiler which option to use to generate the executable file.

===C#===
When executing a program written in [[C Sharp (programming language)|C#]], the [[Common Language Runtime|CLR]] searches for a static method marked with the <code>.entrypoint</code> IL directive, which takes either no arguments, or a single argument of type <code>string[]</code>, and has a return type of <code>void</code> or <code>int</code>, and executes it.<ref>http://msdn.microsoft.com/msdnmag/issues/04/02/NETConsoleApps/</ref>

<source lang="csharp">
static void Main();
static void Main(string[] args);
static int Main();
static int Main(string[] args);
</source>

Command-line arguments are passed in <code>args</code>, similar to how it is done in Java. For versions of <code>Main()</code> returning an integer, similar to both C and C++, it is passed back to the environment as the exit status of the process.

===D===

In [[D (programming language)|D]], the [[function prototype]] of the main function looks like one of the following:

<source lang="D">
void main();
void main(string[] args);
int main();
int main(string[] args);
</source>

Command-line arguments are passed in <code>args</code>, similar to how it is done in C# or Java. For versions of <code>main()</code> returning an integer, similar to both C and C++, it is passed back to the environment as the exit status of the process.

===Common Lisp===

ANSI Common Lisp does not define a main function. However, the following code will emulate a main function in CMUCL. It is easily adjusted to work in ECL, SBCL, and Clojure (CLISP not at all).

<source lang="lisp">
#!/usr/bin/env lisp -quiet -load

(defun hello-main ()
(format t "Hello World!~%")
(quit))

(if (member (pathname-name *load-truename*)
extensions:*command-line-strings*
:test #'(lambda (x y) (search x y :test #'equalp)))
(hello-main))
</source>

===FORTRAN===
[[FORTRAN]] does not have a main subroutine or function. Instead a <code>PROGRAM</code> statement as the first line can be used to specify that a program unit is a main program, as shown below. The <code>PROGRAM</code> statement cannot be used for recursive calls.<ref>XL FORTRAN for [[AIX]]. Language Reference. Third Edition, 1994. [[IBM]]</ref>

<source lang="fortran">
PROGRAM HELLO
PRINT *, "yawa!"
END PROGRAM HELLO
</source>

===GNAT===
Using [[GNAT]], the programmer is not required to write a function called <code>main</code>; a source file containing a single subprogram can be compiled to an executable. The binder will however create a package <code>ada_main</code>, which will contain and export a C-style main function.

===Go===
In [[Go (programming language)|Go]] programming language, program execution starts with the <code>main</code> function of the <code>package main</code>

<source lang="go">
package main

import "fmt"

func main() {
fmt.Println("Hello, World!")
}
</source>

===Haskell===
A [[Haskell (programming language)|Haskell]] program must contain a name called <code>main</code> bound to a value of type <code>IO t</code>, for some type <code>t</code>;<ref>http://www.haskell.org/onlinereport/modules.html</ref> which is usually <code>IO ()</code>. <code>IO</code> is a [[monads in functional programming|monad]], which organizes [[Side effect (computer science)|side-effects]] in terms of [[purely functional]] code.<ref>[http://geekrant.wordpress.com/2008/06/23/misconceptions/ Some Haskell Misconceptions: Idiomatic Code, Purity, Laziness, and IO] — on Haskell's monadic IO></ref> The <code>main</code> value represents the side-effects-ful computation done by the program. The result of the computation represented by <code>main</code> is discarded; that is why <code>main</code> usually has type <code>IO ()</code>, which indicates that the type of the result of the computation is <code>()</code>, the [[unit type]], which contains no information.

Command line arguments are not given to <code>main</code>; they must be fetched using another IO action, such as [http://haskell.org/ghc/docs/latest/html/libraries/base/System-Environment.html#v%3AgetArgs <code>System.Environment.getArgs</code>].

===Java===
[[Java (programming language)|Java]] programs start executing at the main [[method (computer science)|method]], which has the following [[method heading]]:

<source lang="java5">
public static void main(String[] args)
public static void main(String... args)
public static void main(String args[])
</source>

Command-line arguments are passed in <code>args</code>. As in C and C++, the name "<code>main()</code>" is special. Java's main methods do not return a value directly, but one can be passed by using the <code>System.exit()</code> method.

Unlike C, the name of the program is not included in <code>args</code>, because the name of the program is exactly the name of the class that contains the main method called, so it is already known. Also unlike C, the number of arguments need not be included, since the array class in Java has an attribute that keeps track of how many elements there are.

===OCaml===
[[OCaml]] has no <code>main</code> function. Programs are evaluated from top to bottom.

Command-line arguments are available in an array named <code>Sys.argv</code> and the exit status is 0 by default.

Example:
<source lang="ocaml">

print_endline "Hello World"

</source>

===Pascal===
In [[Pascal (programming language)|Pascal]], the main procedure is the only unnamed procedure in the program. Because Pascal programs have the procedures and functions in a more rigorous top-down order than C, C++ or Java programs, the main procedure is usually the last procedure in the program. Pascal does not have a special meaning for the name "<code>main</code>" or any similar name.

<source lang="pascal">
program Hello(Output);

procedure HelloWorld;
begin
writeln('Hello, world!');
end;

begin
HelloWorld;
end.
</source>

Command-line arguments are counted in <code>ParamCount</code> and accessible as strings by <code>ParamStr(n)</code>, with n between 0 and <code>ParamCount</code>.

Note that "unit" or "module" based versions of Pascal start the main module with the PROGRAM keyword, while other separately compiled modules start with UNIT (UCSD/Borland) or MODULE (ISO). The unnamed function in modules is often module initialization, and run before the main program starts.

===Perl===
In [[Perl]], there is no main function. Statements are executed from top to bottom.

Command-line arguments are available in the special array <code>@ARGV</code>. Unlike C, <code>@ARGV</code> does not contain the name of the program, which is <code>$0</code>.

===Pike===
In [[Pike (programming language)|Pike]] syntax is similar to that of C and C++. The execution begins at <code>main</code>. The "<code>argc</code>" variable keeps the number of [[Parameter (computer science)|arguments]] passed to the program. The "<code>argv</code>" variable holds the value associated with the arguments passed to the program.

Example:
int main(int argc, array(string) argv)

===Python===
In [[Python (programming language)|Python]] a function called <code>main</code> doesn't have any special significance. However, it is common practice to organize a program's main functionality in a function called <code>main</code> and call it with code similar to the following:

<source lang="python">
def main():
# the main code goes here

if __name__ == "__main__":
main()
</source>

When a Python program is executed directly (as opposed to being imported from another program), the special global variable <code>__name__</code> has the value "<code>__main__</code>".<ref>[http://www.artima.com/weblogs/viewpost.jsp?thread=4829 Python <code>main()</code> functions]</ref>

Some programmers use the following, giving a better look to exits:

<source lang="python">
import sys

def main(args):
try:
# program's main code here
except:
# error handling code here
return 1 # exit on error
else:
return 0 # exit errorlessly

if __name__ == '__main__':
sys.exit(main(sys.argv))
</source>

===REALbasic===
In [[REALbasic]], there are two different project types, each with a different main entry point. Desktop (GUI) applications start with the <code>App.Open</code> event of the project's <code>Application</code> object. Console applications start with the <code>App.Run</code> event of the project's <code>ConsoleApplication</code> object. In both instances, the main function is automatically generated, and cannot be removed from the project.

===Ruby===
In [[Ruby (programming language)|Ruby]], there is no distinct main function. The code written without additional "<code>class .. end</code>", "<code>module .. end</code>" enclosures is executed directly, step by step, in context of special "<code>main</code>" object. This object can be referenced using:

<source lang="ruby">
self # => main
</source>

and contain the following properties:

<source lang="ruby">
self.class # => Object
self.class.ancestors # => [Object, Kernel]
</source>

Methods defined without additional classes/modules are defined as private methods of the "<code>main</code>" object, and, consequentally, as private methods of almost any other object in Ruby:

<source lang="ruby">
def foo
42
end
foo # => 42
[].foo # => private method `foo' called for []:Array (NoMethodError)
false.foo # => private method `foo' called for false:FalseClass (NoMethodError)
</source>

Number and values of command-line arguments can be determined using the single <code>ARGV</code> constant array:

<source lang="ruby">
ARGV # => ["foo", "bar"]
ARGV.size # => 2
</source>

Note that first element of <code>ARGV</code>, <code>ARGV[0]</code>, contains the first command-line argument, not the name of program executed, as in C. The name of program is available using <code>$0</code> or <code>$PROGRAM_NAME</code>.<ref>[http://www.ruby-doc.org/docs/ProgrammingRuby/html/rubyworld.html#UB Programming Ruby: The Pragmatic Programmer's Guide, Ruby and Its World] — on Ruby <code>ARGV</code></ref>

Similar to Python, one could use:

<source lang="ruby">
if __FILE__ == $PROGRAM_NAME
# Put "main" code here
end
</source>

===Visual Basic===
In [[Visual Basic]], when a project contains no forms, the startup object may be the <code>Main()</code> procedure. The <code>Command$</code> function can be optionally used to access the argument portion of the command line used to launch the program:
<source lang="vb">
Sub Main()
Debug.Print "Hello World!"
MsgBox "Arguments if any are: " & Command$
End Sub
</source>

===LOGO===
In [[Logo (programming language)|FMSLogo]], the procedures when loaded do not execute. To make them execute, it is necessary to use this code:

to procname
... ; Startup commands (such as print [Welcome])
end

make "startup [procname]

Note that the variable <code>startup</code> is used for the startup list of actions, but the convention is that this calls another procedure that runs the actions. That procedure may be of any name.

===AHLSL===
In [[AIGE]]'s [[AHLSL]], the main function, by default, is defined as:

[main]

==References==
{{Reflist|2}}

==External links==
<!--Please see this URL before adding external links here: http://meta.wikimedia.org/wiki/When_should_I_link_externally -->
* [http://www.javaexperience.com/main-method-in-java/ How main method works in Java].
{{DEFAULTSORT:Main Function (Programming)}}
[[Category:Subroutines]]
[[Category:Programming language comparisons]]

Latest revision as of 00:05, 8 June 2017

Redirect to:

Retrieved from "https://en.wikipedia.org/enwiki/w/index.php?title=Main_function&oldid=784375384"