What does this do?

    if __name__ == &quot;__main__&quot;:
        print(&quot;Hello world!&quot;)


What does if __name__ == &quot;__main__&quot;: do?

I want to test a few functions that are included in my main package, but my tests don&#39;t appear to be able to access those functions.

My sample main.go file looks like:

    package main
    
    import (
    	&quot;log&quot;
    )
    
    func main() {
    	log.Printf(foo())
    }
    
    func foo() string {
    	return &quot;Foo&quot;
    }

and my main_test.go file looks like:

    package main
    
    import (
    	&quot;testing&quot;
    )
    
    func Foo(t testing.T) {
    	t.Error(foo())
    }

when I run `go test main_test.go` I get

    # command-line-arguments
    .\main_test.go:8: undefined: foo
    FAIL    command-line-arguments [build failed]

As I understand, even if I moved the test file elsewhere and tried importing from the main.go file, I couldn&#39;t import it, since it&#39;s `package main`.

What is the correct way of structuring such tests? Should I just remove everything from the `main` package asides a simple main function to run everything and then test the functions in their own package, or is there a way for me to call those functions from the main file during testing?

How to test the main package functions in golang?

I have installed an application, when I try to run it (it&#39;s an executable jar) nothing happens. When I run it from the commandline with: 
&gt;java -jar &quot;app.jar&quot;

I get the following message:
&gt;no main manifest attribute, in &quot;app.jar&quot;

Normally, if I had created the program myself, I would have added a main class attribute to the manifest file. But in this case, since the file is from an application, i cannot do that. I also tried extracting the jar to see if I could find the main class, but there are to many classes and none of them has the word &quot;main&quot; in it&#39;s name. There must be a way to fix this because the program runs fine on other systems.


Can&#39;t execute jar- file: &quot;no main manifest attribute&quot;

After having some trouble setting up SDL, I found out that SDL defines a macro that replaces main:

    #define main SDL_main

    // And then
    extern C_LINKAGE int SDL_main(int argc, char *argv[]);

This can also create compilation errors, if the main function doesn&#39;t have the `argc` and `argv` parameters defined.

This macro gives me headaches just when I see it... Why does SDL need to redefine main? After some more searching, I found that some people `#undef main`, and use it the normal way.

**So this is the question:** *why does SDL need to redefine main, what does it do? Are there any side effects to undefining it?*

One thing I noticed is that SDL redirects standard output and error to files (and I don&#39;t want this behavior), and this behavior stops if I undefine main.

Why SDL defines main macro?

How can you explain very well, to a **beginner**, the meaning of `String args[]` and the use of `static` in the following excerpt?

    class FirstApp {
        public static void main(String[] args) {
            ...
        }
    }

Explanation of &#39;String args[]&#39; and static in &#39;public static void main(String[] args)&#39;

One of my kids is taking Java in high school and had this on one of his tests:

&gt; Which of the following is a valid identifier in Java?
&gt;
&gt; a.  `123java`  
    b.  `main`  
    c.  `java1234`  
    d.  `{abce`  
    e.  `)whoot`  

He answered **b** and got it wrong.  

I looked at the question and argued that `main` *is* a valid identifier and that it should have been right.  

We took a look at the Java [spec][1] for identifiers and it reinforced that point.  We also wrote a sample program that had a variable called `main`, as well as a method.  He created a written rebuttal that included the Java documentation reference, the test program and the teacher ignored it and says the answer is still incorrect.

Is `main` a valid identifier?  



  [1]: https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html

Is main a valid Java identifier?

I am porting an application from Solaris to Linux

The object files which are linked do not have a main() defined. But compilation and linking is done properly in Solaris and executable is generated. In Linux I get this error 

        /usr/lib/gcc/x86_64-redhat-linux/4.1.2/../../../../lib64/crt1.o: In function `_start&#39;:
    (.text+0x20): undefined reference to `main&#39; 

My problem is, I cannot include new .c/.o files since its a huge application and has been running for years. How can I get rid of this error?

Code extractes of makefile:

    RPCAPPN = api
    LINK = cc 

        $(RPCAPPN)_server: $(RPCAPIOBJ)
                $(LINK) -g $(RPCAPIOBJ) -o $(RPCAPPN)_server $(IDALIBS) $(LIBS) $(ORALIBS) $(COMMONLIB) $(LIBAPI) $(CCLIB) $(THREADLIB) $(DBSERVERLIB) $(ENCLIB)



crt1.o: In function `_start&#39;: - undefined reference to `main&#39; in Linux

What is the correct (most efficient) way to define the `main()` function in C and C++ — `int main()` or `void main()` — and why? And how about the arguments?
If `int main()` then `return 1` or `return 0`?

&lt;hr&gt;

_There are numerous duplicates of this question, including:_

* [What are the valid signatures for C&#39;s `main()` function?](https://stackoverflow.com/questions/2108192/what-are-the-valid-signatures-for-cs-main-function/)
* [The return type of `main()` function](https://stackoverflow.com/questions/17715008/the-return-type-of-main-function/)
* [Difference between `void main()` and `int main()`?](https://stackoverflow.com/questions/636829/difference-between-void-main-and-int-main)
* [`main()`&#39;s signature in C++](https://stackoverflow.com/questions/1621574/mains-signature-in-c)
* [What is the proper declaration of `main()`?](https://stackoverflow.com/questions/4207134/what-is-the-proper-declaration-of-main) — For C++, with a very good answer indeed.
* [Styles of `main()` functions in C](https://stackoverflow.com/questions/8692120/styles-of-main-functions-in-c)
* [Return type of `main()` method in C](https://stackoverflow.com/questions/10915713/return-type-of-main-method-in-c)
* [`int main()` vs `void main()` in C](https://stackoverflow.com/questions/9356510/int-main-vs-void-main-in-c)

Related:

* [C++ — `int main(int argc, char **argv)`](https://stackoverflow.com/questions/5191965/c-int-mainint-argc-char-argv)
* [C++ — `int main(int argc, char *argv[])`](https://stackoverflow.com/questions/5217395/c-int-mainint-argc-char-argv)
* [Is `char *envp[]` as a third argument to `main()` portable?](https://stackoverflow.com/questions/10321435/is-char-envp-as-a-third-argument-to-main-portable)
* [Must the `int main()` function return a value in all compilers?](https://stackoverflow.com/questions/18402853/must-the-int-main-function-return-a-value-in-all-compilers)
* [Why is the type of the `main()` function in C and C++ left to the user to define?](https://stackoverflow.com/questions/5296163/why-is-the-type-of-the-main-function-in-c-and-c-left-to-the-user-to-define)
* [Why does `int main(){}` compile?](https://stackoverflow.com/questions/22239/why-does-int-main-compile)
* [Legal definitions of `main()` in C++14?](https://stackoverflow.com/questions/26470912/legal-definitions-of-main-in-c14)


What should main() return in C and C++?

## Questions ##

- What is the proper signature of the `main` function in C++? 

- What is the correct return type, and what does it mean to return a value from `main`? 

- What are the allowed parameter types, and what are their meanings? 

- Is this system-specific?

-  Have those rules changed over time? 

- What happens if I violate them?

What is the proper declaration of main in C++?

It&#39;s a simple question, but I keep seeing conflicting answers: should the main routine of a C++ program return `0` or `EXIT_SUCCESS`?

    #include &lt;cstdlib&gt;
    int main(){return EXIT_SUCCESS;}

or

    int main(){return 0;}

Are they the exact same thing? Should `EXIT_SUCCESS` only be used with `exit()`?  

I thought `EXIT_SUCCESS` would be a better option because other software may want to deem zero as failure, but I also heard that if you return `0`, the compiler is capable of changing it to a different value anyway.

Should I return EXIT_SUCCESS or 0 from main()?

I am a beginner when it comes to programming but I was sure that one of the universal rules was that a program starts with Main(). I do not see one when I create a WPF project. Is Main() simply named something differently in WPF?

No Main() in WPF?

I recently had to type in a small C test program and, in the process, I made a spelling mistake in the main function by accidentally using `vooid` instead of `void`.

And yet it still worked.

Reducing it down to its smallest complete version, I ended up with:

    int main (vooid) {
        return 42;
    }

This does _indeed_ compile (`gcc -Wall -o myprog myprog.c`) and, when run, it returns 42.

How exactly is this valid code?

---

Here&#39;s a transcript cut and pasted from my `bash` shell to show what I&#39;m doing:

    pax$ cat qq.c
    int main (vooid) {
        return 42;
    }
    
    pax$ rm qq ; gcc -Wall -o qq qq.c ; ./qq
    
    pax$ echo $?
    42


&quot;int main (vooid)&quot;? How does that work?

The section $3.6.1/1 from the C++ Standard reads,

&gt; A program shall contain a global
&gt; function called **main**, which is the
&gt; designated **start** of the program.

Now consider this code,

    int square(int i) { return i*i; }
    int user_main()
    { 
        for ( int i = 0 ; i &lt; 10 ; ++i )
               std::cout &lt;&lt; square(i) &lt;&lt; endl;
        return 0;
    }
    int main_ret= user_main();
    int main() 
    {
            return main_ret;
    }

This sample code does what I intend it to do, i.e printing the square of integers from 0 to 9, **before** entering into the `main()` function which is supposed to be the &quot;start&quot; of the program.

I also compiled it with `-pedantic` option, GCC 4.5.0. It gives no error, not even warning!

So my question is, 

**Is this code really Standard conformant?**

If it&#39;s standard conformant, then does it not invalidate what the Standard says? `main()` is not start of this program! `user_main()` executed before the `main()`. 

I understand that to initialize the global variable `main_ret`, the `use_main()` executes first but that is a different thing altogether; the point is that, it **does** invalidate the quoted statement $3.6.1/1 from the Standard, as `main()` is NOT the *start* of the program; it is in fact the **end** of *this* program!

---

EDIT:

## How do you define the  word &#39;start&#39;?

It boils down to the definition of the phrase *&quot;start of the program&quot;*. So how exactly do you define it?


Is main() really start of a C++ program?

It seems that the `argv[argc]` is always `NULL`, so I think we can traverse the argument list without `argc`. A single `while` loop will do this.

If there is always a `NULL` at the end of `argv`, why do we need an `argc`?


Why do we need argc while there is always a null at the end of argv?

I was just reading 

**ISO/IEC 9899:201x  Committee Draft — April 12, 2011**
 
in which i found  under 5.1.2.2.3 Program termination

    ..reaching the } that terminates the main function returns a value of 0. 

 
it means if you don&#39;t specify any return statement in `main()`, and if the program runs successfully, then at the closing brace } of main will return 0.

But in the following code i don&#39;t specify any return statement, yet it does not return 0 

    #include&lt;stdio.h&gt;
    int sum(int a,int b)
    {
    return (a + b);
    }
    
    int main()
    {
        int a=10;
        int b=5;
        int ans;    
        ans=sum(a,b);
        printf(&quot;sum is %d&quot;,ans);
    }

   

compile 

    gcc test.c  
    ./a.out
    sum is 15
    echo $?
    9          // here it should be 0 but it shows 9 why?

Why main does not return 0 here?

I ask because my compiler seems to think so, even though I don’t.

`echo &#39;int main;&#39; | cc -x c - -Wall`  
`echo &#39;int main;&#39; | c++ -x c++ - -Wall`

Clang issues no warning or error with this, and gcc issues only the meek warning: `&#39;main&#39; is usually a function [-Wmain]`, but only when compiled as C. Specifying a `-std=` doesn’t seem to matter.

Otherwise, it compiles and links fine. But on execution, it terminates immediately with `SIGBUS` (for me). 

Reading through the (excellent) answers at https://stackoverflow.com/questions/204476/what-should-main-return-in-c-and-c and a quick grep through the language specs, it would certainly **seem** to me that a main _function_ is required. But the verbiage from gcc’s `-Wmain` (‘main’ is **_usually_** a function) (and the dearth of errors here) seems to possibly suggest otherwise.

But why? Is there some strange edge-case or “historical” use for this? Anyone know what gives?

My point, I suppose, is that I really think this should be an **error** in a hosted environment, eh?

Is ‘int main;’ a valid C/C++ program?

In Python I have a **module** myModule.py where I define a few functions and a **main()**, which takes a few command line arguments. 

I usually call this main() from a bash script. Now, I would like to put everything into a small **package**, so I thought that maybe I could turn my simple bash script into a Python script and put it in the package.

So, how do I actually **call the main()** function of myModule.py **from the main() function** of MyFormerBashScript.py? Can I even do that? How do I pass any **arguments** to it?



In Python, can I call the main() of an imported module?

I am new to Ruby.  I&#39;m looking to import functions from a module that contains a tool I want to continue using separately.  In Python I would simply do this:

    def a():
        ...
    def b():
        ...
    if __name__ == &#39;__main__&#39;:
        a()
        b()

This allows me to run the program or import it as a module to use `a()` and/or `b()` separately.  What&#39;s the equivalent paradigm in Ruby?

`if __name__ == &#39;__main__&#39;` equivalent in Ruby

The method signature of a Java `main`method is:

    public static void main(String[] args) {
        ...
    }

**Is there a reason why this method must be static?**


Why is the Java main method static?

    int main( const int argc , const char[] const argv)

As [Effective C++][1] Item#3 states &quot;Use const whenever possible&quot;, I start thinking &quot;why not make these &#39;constant&#39; parameters `const`&quot;?.

Is there any scenario in which the value of `argc` is modified in a program?

  [1]: https://rads.stackoverflow.com/amzn/click/0321334876

Why is argc not a constant?

Consider following program:

    #include &lt;iostream&gt;
    int main = ( std::cout &lt;&lt; &quot;C++ is excellent!\n&quot;, 195 ); 

Using g++ 4.8.1 (mingw64) on Windows 7 OS, the program compiles and runs fine, printing:

&gt;C++ is excellent!

to the console. `main` appears to be a global variable rather than a function; how can this program execute without the function `main()`? Does this code conform to the C++ standard? Is the behavior of the program is well defined? I have also used the **`-pedantic-errors`** option but the program still compiles and runs. 

How can a program with a global variable called main instead of a main function work?

I know a cool shortcut for `System.out.println()`: sysout &lt;kbd&gt;Ctrl&lt;/kbd&gt; + &lt;kbd&gt;Space&lt;/kbd&gt;.

Is there something similar for `public static void main(String args[])`?

What is the Eclipse shortcut for &quot;public static void main(String args[])&quot;?

A lot of programs use standard names for a number of arguments and arrays of strings. The prototype of main function looks like: `int main(int argc, char *argv[]);`. But would I break something if I choose custom names for these variables? 

E.g. `int main(int n_of_args, char *args[]);`

In the context of the compiler, everything is fine. These variables are local for main function, so they may have any names. And the simple code builds and runs perfectly. But these names may be used by preprocessor. So is it safe to rename these arguments?

**PS** Personally I find these names bad, because they look very similar and differ in only one letter. But EVERYONE uses them for some kind of reason.

Is it safe to rename argc and argv in main function?

Given the standard definition for the main program:

    int main(int argc, char *argv[]) {
       ...
    }

Under which circumstances can `argc` be zero on a POSIX system?

Can argc be zero on a POSIX system?

I&#39;m trying to compile and run following program without `main()` function in `C`. I have compiled my program using the following command.

    gcc -nostartfiles nomain.c
And compiler gives warning

    /usr/bin/ld: warning: cannot find entry symbol _start; defaulting to 0000000000400340

Ok, No problem. then, I have run executable file(a.out), both `printf` statements print successfully, and then get **segmentation fault**. 

So, my question is, **Why segmentation fault after successfully execute print statements?**

my code:

    #include &lt;stdio.h&gt;

    void nomain()
    {
            printf(&quot;Hello World...\n&quot;);
            printf(&quot;Successfully run without main...\n&quot;);
    }

**output:**

&lt;!-- language: lang-none --&gt;

    Hello World...
    Successfully run without main...
    Segmentation fault (core dumped)

**Note:** 

Here, `-nostartfiles` gcc flag prevents the compiler from using standard startup files when linking


Compile and run program without main() in C

A common problem that new Java developers experience is that their programs fail to run with the error message:  `Could not find or load main class ...`

What does this mean, what causes it, and how should you fix it?

What does &quot;Could not find or load main class&quot; mean?

In order to get an environment variable in a `C` program, one could use the following:

 - `getenv()`  
 - `extern char **environ;`

But other than the above mentioned, is using `char *envp[]` as a third argument to `main()` to get the environment variables considered part of the standard?

    #include &lt;stdio.h&gt;
    
    int main(int argc, char *argv[], char *envp[])
    {
        while(*envp)
            printf(&quot;%s\n&quot;,*envp++);
    }

Is `char *envp[]` portable?


Is char *envp[] as a third argument to main() portable

Right, I have looked at this post: https://stackoverflow.com/questions/416739/difference-between-winmain-main-and-dllmain-in-c

I now know that `WINMAIN` is used for window applications and `main()` for consoles. But reading the post doesn&#39;t really tell me why exactly what is the difference.

I mean what&#39;s the point of having separating different mains functions to start of a program? Is it due to performance issues? Or what is it?


WINMAIN and main() in C++ (Extended)

Here is my code:

    public class Main {
    
        public static void main(String[] args) {
            Main p = new Main();
            p.start(args);
        }
	
        @Autowired
        private MyBean myBean;
        private void start(String[] args) {
            ApplicationContext context = 
                new ClassPathXmlApplicationContext(&quot;META-INF/config.xml&quot;);
            System.out.println(&quot;my beans method: &quot; + myBean.getStr());
        }
    }

    @Service 
    public class MyBean {
        public String getStr() {
            return &quot;string&quot;;
        }
    }

---
    &lt;beans xmlns=&quot;http://www.springframework.org/schema/beans&quot;
     xmlns:xsi=&quot;http://www.w3.org/2001/XMLSchema-instance&quot;
     xmlns:context=&quot;http://www.springframework.org/schema/context&quot;
     xsi:schemaLocation=&quot;http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context-3.0.xsd&quot;&gt; 
        &lt;context:annotation-config /&gt; 
        &lt;context:component-scan base-package=&quot;mypackage&quot;/&gt;
    &lt;/beans&gt;


Why doesn&#39;t this work? I get `NullPointerException`. Is it possible to use autowiring in a standalone application?

Using Spring 3 autowire in a standalone Java application

How do I access a variable that was declared/init in my main.go in a different .go package/file? Keeps telling me that the variable is undefined (I know that global variables are bad but this is just to be used as a timestamp)

in main.go

    var StartTime = time.Now()
    func main(){...}

trying to access StartTime in a different .go file
but keep getting StartTime undefined

How to access global variables

2 valid versions of `main()` exist in `C++`:

    int main()  // version 1
    int main(int argc, char **argv)  // version 2

But both overloads cannot coexist at the same time. Why not? (Potential use case: while running the program from the terminal, if no arguments are passed the first version is called, otherwise the second version is.)

Does the compiler perform a special check to allow just one version per binary? 


Is main() overloaded in C++?

I was reading the C++ FAQs and I noticed one sentence.

&gt;main() cannot be inline. 

Why is this?


Why main() in C++ cannot be inlined?

I&#39;m a bit new at this so bear with me. I&#39;m currently learning C# and Java and one of their similarities is that the main function needs to be encapsulated within a class. For example

    public class HelloWorld {
    	public static void main(String[] args) {
    		// Some Code
    	}
    }

Now I understand that main is often the &quot;entry point&quot; when you run the program. So basically, your program will start executing wherever the main function is. But I believe in both languages you can have multiple main functions within multiple classes. So when I compile a project with multiple main functions, where is the &quot;entry point&quot;? How does the compiler know where to start?


Multiple Main Functions

I&#39;m just beginning to write programs in Java. What does the following Java code mean?

    public static void main(String[] args)

* What is `String[] args`? 

* When would you use these `args`?

Source code and/or examples are preferred over abstract explanations

What is &quot;String args[]&quot;? parameter in main method Java

I was taught that functions need declarations to be called. To illustrate, the following example would give me an error as there is no declaration for the function `sum`:

    #include &lt;iostream&gt;
    
    int main() {
      std::cout &lt;&lt; &quot;The result is &quot; &lt;&lt; sum(1, 2);
      return 0;
    }
    
    int sum(int x, int y) {
      return x + y;
    }

    // main.cpp:4:36: error: use of undeclared identifier &#39;sum&#39;
    //  std::cout &lt;&lt; &quot;The result is &quot; &lt;&lt; sum(1, 2);
    //                                   ^
    // 1 error generated.


To fix this, I&#39;d add the declaration:

    #include &lt;iostream&gt;
    
    int sum(int x, int y); // declaration
    
    int main() {
      std::cout &lt;&lt; &quot;The result is &quot; &lt;&lt; sum(1, 2);
      return 0;
    }
    
    int sum(int x, int y) {
      return x + y;
    }

Why the `main` function doesn&#39;t need the declaration, as other functions like `sum` need? 

Does int main() need a declaration on C++?

Today, while working with one custom library, I found a strange behavior.
A static library code contained a debug `main()` function. It wasn&#39;t inside a `#define` flag. So it is present in library also. And it is used link to another program which contained the real `main()`.  
When both of them are linked together, the linker didn&#39;t throw a multiple declaration error for `main()`. I was wondering how this could happen.

To make it simple, I have created a sample program which simulated the same behavior:

    $ cat prog.c
    #include &lt;stdio.h&gt;
    int main()
    {
            printf(&quot;Main in prog.c\n&quot;);
    }

    $ cat static.c
    #include &lt;stdio.h&gt;
    int main()
    {
            printf(&quot;Main in static.c\n&quot;);
    }

    $ gcc -c static.c
    $ ar rcs libstatic.a static.o
    $ gcc prog.c -L. -lstatic -o 2main
    $ gcc -L. -lstatic -o 1main

    $ ./2main
    Main in prog.c
    $ ./1main
    Main in static.c

How does the &quot;2main&quot; binary find which `main` to execute?

But compiling both of them together gives a multiple declaration error:

    $ gcc prog.c static.o
    static.o: In function `main&#39;:
    static.c:(.text+0x0): multiple definition of `main&#39;
    /tmp/ccrFqgkh.o:prog.c:(.text+0x0): first defined here
    collect2: ld returned 1 exit status

Can anyone please explain this behavior?



How does this C program compile and run with two main functions?

What does the following mean : 

    int main(void) {...} 

VS

    int main() {...}

?


I think that `int main() {...}` means that main doesn&#39;t receive any parameters (from command line) , however:

    int main(int argc, char *argv[])

does.

But, what does `int main(void) {...}`  mean? And, what does **void** stand for ?

I&#39;ve looked [here][1] but it&#39;s somehow a different question . 



  [1]: https://stackoverflow.com/questions/636829/difference-between-void-main-and-int-main


Difference between int main() and int main(void)?

In C/C++, the main function receives parameters which are of type `char*`.

    int main(int argc, char* argv[]){
      return 0;
    }

`argv` is an array of `char*`, and points to strings. Where are these string located? Are they on the heap, stack, or somewhere else?

Where are C/C++ main function&#39;s parameters?

&lt;!-- language-all: lang-none --&gt;

New Java programmers often encounter messages like the following when they attempt to run a Java program.  (Different Java tools, IDEs and so on give a variety of diagnostics for this problem.)

----

    Error: Main method not found in class MyClass, please define the main method as:
       public static void main(String[] args)
    or a JavaFX application class must extend javafx.application.Application

----

    Error: Main method not found in the file, please define the main method as: 
       public static void main(String[] args)

----

    Error: Main method is not static in class MyClass, please define the main method as:
       public static void main(String[] args)

----

    Error: Main method must return a value of type void in class MyClass, please
    define the main method as:
       public static void main(String[] args)

----

    java.lang.NoSuchMethodError: main
    Exception in thread &quot;main&quot;

----

What does this mean, what can cause it, and what should one do to fix it?

&quot;Error: Main method not found in class MyClass, please define the main method as...&quot;

I&#39;m trying to load a jar using

    @echo off
    java -jar Test.jar
    pause

With the manifest of 

    Manifest-Version: 1.0
    Main-Class: classes.TestClass

In the Jar directory, I can clearly see a classes\TestClass file when I extract it.

Edit: `classes.TestClass` does have a `public static void main(String[] args)`. 

Package Deceleration in `classes.TestClass` is `package classes;`

But I still keep getting the error message 

    Could not find or load main class classes.TestClass

I&#39;ve been through everything I&#39;ve been able to find with this problem, and none of it seems to help.

I&#39;ve tried editing the classpath, redoing the manifest, installing the new JRE. 

What else should I be doing? 

Could not find or load main class with a Jar File

I saw [a snippet of code on CodeGolf][1] that&#39;s intended as a compiler bomb, where `main` is declared as a huge array. I tried the following (non-bomb) version:

    int main[1] = { 0 };

It seems to compile fine under Clang and with only a warning under GCC:

&gt; warning: &#39;main&#39; is usually a function [-Wmain]

The resulting binary is, of course, garbage.

But why does it compile at all? Is it even allowed by the C specification? The section that I think is relevant says:

&gt; 5.1.2.2.1 Program startup
&gt; 
&gt; The function called at program startup is named main. The implementation declares no prototype for this function. It shall be defined with a return type of int and with no parameters [...] or with two parameters [...] or in some other implementation-defined manner.

Does &quot;some other implementation-defined manner&quot; include a global array? (It seems to me that the spec still refers to a *function*.)

If not, is it a compiler extension? Or a feature of the toolchains, that serves some other purpose and they decided to make it available through the frontend?

  [1]: https://codegolf.stackexchange.com/a/69193/13441

Why does declaring main as an array compile?

What is the difference between `char** argv` and `char* argv[]`? in `int main(int argc, char** argv)` and `int main(int argc, char* argv[])`?

Are they the same? Especially that the first part does not have `[]`.

C++ - char** argv vs. char* argv[]

I am trying to get familiar with Kotlin to use in my android apps. So first I want to try out some simple kotlin examples, just to get familiar with syntax of kotlin.

I made a class named `Main.kt` in my android project with just main method.

    fun main(args: Array&lt;String&gt;) {
    println(&quot;Hello World&quot;); }

Android studio shows me a kotlin icon to left of main method and when I click on this icon, It shows me below three option:

1) Run Mainkt

2) Debug Mainkt

3) Run Mainkt with coverage

I chose first one but it throws me 

    Exception in thread &quot;main&quot; java.lang.ClassNotFoundException: com.vikalp.kotlin.MainKt
	at java.net.URLClassLoader.findClass(URLClassLoader.java:381)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
	at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:331)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
	at java.lang.Class.forName0(Native Method)
	at java.lang.Class.forName(Class.java:264)
	at com.intellij.rt.execution.application.AppMainV2.main(AppMainV2.java:107)



I am stuck with such a small problem. Let me know if anyone of you have faced problem like this and what is the solution.


Run single kotlin class with main function in android studio

Does it matter which way I declare the `main` function in a C++ (or C) program? 

All Main Solutions on Gang of Coders

Total of 44 Main Solutions