main_mainwindow - CSDN
精华内容
参与话题
  • main函数的参数

    万次阅读 多人点赞 2012-03-16 15:37:41
    main函数可以不带参数,也可以带参数,这个参数可以认为是 main函数的形式参数。C语言规定main函数的参数只能有两个,习惯上这两个参数写为argc和argv。因此,main函数的函数头可写为:  main (argc,argv) C语言...

    main函数可以不带参数,也可以带参数,这个参数可以认为是 main函数的形式参数。C语言规定main函数的参数只能有两个,习惯上这两个参数写为argc和argv。因此,main函数的函数头可写为:

        main (argc,argv)

    C语言还规定argc(第一个形参)必须是整型变量,argv( 第二个形参)必须是指向字符串的指针数组。加上形参说明后,main函数的函数头应写为:

        main (int argc,char *argv[])

        由于main函数不能被其它函数调用,因此不可能在程序内部取得实际值。那么,在何处把实参值赋予main函数的形参呢? 实际上,main函数的参数值是从操作系统命令行上获得的。当我们要运行一个可执行文件时,在DOS提示符下键入文件名,再输入实际参数即可把这些实参传送到main的形参中去。

    DOS提示符下命令行的一般形式为:

        C:\>可执行文件名  参数  参数……;  

        但是应该特别注意的是,main 的两个形参和命令行中的参数在位置上不是一一对应的。因为,main的形参只有二个,而命令行中的参数个数原则上未加限制。argc参数表示了命令行中参数的个数(注意:文件名本身也算一个参数),argc的值是在输入命令行时由系统按实际参数的个数自动赋予的。

    例如有命令行为:

        C:\>E24  BASIC  foxpro  FORTRAN

    由于文件名E24本身也算一个参数,所以共有4个参数,因此argc取得的值为4。argv参数是字符串指针数组,其各元素值为命令行中各字符串(参数均按字符串处理)的首地址。 指针数组的长度即为参数个数。数组元素初值由系统自动赋予。其表示如图所示:


     

    【例】

    main(int argc,char *argv){

      while(argc-->1)

          printf("%s",*++argv);

    }

    本例是显示命令行中输入的参数。如果上例的可执行文件名为e24.exe,存放在A驱动器的盘内。因此输入的命令行为:

        C:\>a:e24 BASIC foxpro FORTRAN 

    则运行结果为:

    BASIC

    foxpro

    FORTRAN

    该行共有4个参数,执行main时,argc的初值即为4。argv的4个元素分为4个字符串的首地址。执行while语句,每循环一次argv值减1,当argv等于1时停止循环,共循环三次,因此共可输出三个参数。在printf函数中,由于打印项*++argv是先加1再打印, 故第一次打印的是argv[1]所指的字符串BASIC。第二、三次循环分别打印后二个字符串。而参数e24是文件名,不必输出。


    展开全文
  • C语言main()函数详解

    万次阅读 2017-10-20 14:12:52
    main()函数称之为主函数,一个C程序总是从main()函数开始执行的。   一、main()函数的形式 在最新的 C99 标准中,只有以下两种定义方式是正确的: int main( void ) /* 无参数形式 */ {  ...  return 0; }...

    C的设计原则是把函数作为程序的构成模块。main()函数称之为主函数,一个C程序总是从main()函数开始执行的。

     


    一、main()函数的形式


    在最新的 C99 标准中,只有以下两种定义方式是正确的:

    int main( void )  /* 无参数形式 */
    {
        ...
        return 0;
    }
    int main( int argc, char *argv[] ) /* 带参数形式 */
    {
        ...
        return 0;
    }
    int指明了main()函数的返回类型 ,函数名后面的圆括号一般包含传递给函数的信息。void表示没有给函数传递参数。关于带参数的形式,我们等会讨论。

    浏览老版本的C代码,将会发现程序常常以。

    main()

    这种形式开始。C90标准允许这种形式,但是C99标准不允许。因此即使你当前的编译器允许,也不要这么写。

    你还可能看到过另一种形式。

    void main()

    有些编译器允许这种形式,但是还没有任何标准考虑接受它。C++ 之父 Bjarne Stroustrup 在他的主页上的 FAQ 中明确地表示:void main( ) 的定义从来就不存在于 C++ 或者 C 。所以,编译器不必接受这种形式,并且很多编译器也不允许这么写。

    坚持使用标准的意义在于:当你把程序从一个编译器移到另一个编译器时,照样能正常运行。

     


    二、main()函数的返回值


    从前面我们知道main()函数的返回值类型是int型的,而程序最后的 return 0; 正与之遥相呼应,0就是main()函数的返回值。那么这个0返回到那里呢?返回给操作系统,表示程序正常退出。因为return语句通常写在程序的最后,不管返回什么值,只要到达这一步,说明程序已经运行完毕。而return的作用不仅在于返回一个值,还在于结束函数。

    现在我们来做一个小试验(注意:本人的系统是Windows XP, 编译环境是TC)来观察main()函数的返回值。编写如下代码并编译运行:

    //a.c
    #include "stdio.h"
    int main(void)
    {
        printf("I love you.");
        return 0;
    }
    将这个文件保存为a.c,编译运行后会生成一个a.exe文件。现在打开命令提示符,在命令行里运行刚才编译好的可执行文件,然后输入   echo %ERRORLEVEL% ,回车,就可以看到程序返回 一个0 。如果把 return 0; 改为 return 99; ,那么很显然,再次执行上述步骤以后你可以看到程序返回99。要是你这样写 return 99.99; 那还是返回99,因为99.99被传给操作系统之前,被强制类型转换成整数类型了。

    现在,我们把a.c改回原来的代码,然后再编写另一个程序b.c:

    //b.c
    #include "stdio.h"
    int main(void)
    {
        printf("
    I’m too.");
        return 0;
    }
    编译运行后打开命令提示符,在命令行里输入a&&b 回车,这样你就可以看到《人鬼情未了》里面经典的爱情对白:

    I love you.

    I’m too.

    && 的含义是:如果 && 前面的程序正常退出,则继续执行 && 后面的程序,否则不执行所以,要是把a.c里面的 return 0; 删除或者改为 return 99; ,那么你只能看到 I love you. 。也就是说,程序b.c就不执行了。现在,大家该明白 return 0; 的作用了吧。

     


    三、main()函数的参数

     


    C编译器允许main()函数没有参数,或者有两个参数 (有些实现允许更多的参数,但这只是对标准的扩展)。这两个参数,一个是int类型,一个是字符串类型。第一个参数是命令行中的字符串数。按照惯例(但不是必须的),这个int参数被称为argc(argument count)。 大家或许现在才明白这个形参为什么要取这么个奇怪的名字吧,呵呵!至于英文的意思,自己查字典吧。第二个参数是一个指向字符串的指针数组。命令行中的每个字符串被存储到内存中,并且分配一个指针指向它。按照惯例,这个指针数组被称为argv(argument value)。系统使用空格把各个字符串格开。一般情况下,把程序本身的名字赋值给argv[0],接着,把最后的第一个字符串赋给argv[1] ,等等。

    现在我们来看一个例子:

    //c.c
    #include "stdio.h"
    int main(int argc, char *argv[])
    {
        int count;
        printf("The command line has %d arguments:
    ", argc - 1);
        for(count = 1; count < argc ; count++)
            printf("%d: %s
    ", count, argv[count] );
        return 0;
    }
    编译运行,在命令行输入c I love you 回车,下面是从命令行运行该程序的结果:

    The command line has 3 arguments:

    1:I


    2:love


    3:you


    从本例可以看出,程序从命令行中接受到4个字符串(包括程序名),并将它们存放在字符串数组中,其对应关系:

    argv[0]  ------>    c(程序名)

    argv[1]  ------>    I


    argv[2]  ------>    love


    argv[3]  ------>    you


    至于argc的值,也即是参数的个数,程序在运行时会自动统计,不必我们操心。

    这个例子中,每个字符串都时一个单词(字母),那既然是字符串,要把一句话当作参数赋给程序该怎么办?你可以在命令行里这样输入 c  "I love you."  "I’m too."。程序运行结果:

    The command line has 2 arguments:

    1:I love you.

    2:I’m too.

    其对应关系:

    argv[0]  ------>    c(程序名)

    argv[1]  ------>    I love you.

    argv[2]  ------>    I’m too.

    要注意的是,你在命令行的输入都将作为字符串形式存储于内存中。也就是说,如果你输入一个数字,那么要输出这个数字,你应该用%s格式而非%d或者其他。

    再来看一个例子:

    //d.c
    #include "stdio.h"
    int main(int argc, char *argv[])
    {
        FILE *fp;//FILE 是变量类型,实际上是C语言定义的标准数据结构,用于文件。 FILE *fp 是声明,声明fp是指针,用来指向FILE类型的对象。
        fp = fopen(argv[1], "w");
        fputs("I love you.", fp);
        fclose(fp);
        return 0;
    }
    编译运行,打开命令行并输入d love.txt 回车。这样,打开d.c文件所在的目录,你会发现多了一个名为 love.txt 的文件,打开后里面的内容正是世界上说的最多的那句话。

    当然,你可能会说我不需要使用命令行参数就可以做到这些。是的,你当然可以。使用命令行参数的理由或许就是练习命令行用法,以备以后需要编写基于命令行的程序。还有一个好处是,不需要C环境就可以运行已经编译好的程序。比如,你把上面那个程序编译后生成的d.exe发给你的女朋友,再告诉她怎么运行,这样,你的女朋友可以用另一种方式体会到你对她的浓情蜜意。

    展开全文
  • Java之主函数——main函数

    万次阅读 多人点赞 2016-11-25 15:08:19
    main函数特殊之处: 1 格式是固定的。 2 被jvm所识别和调用。 main函数关键字分析: 对于 public static void main(String[] args) public: 因为权限必须是最大的。 static: 不需要对象,直接用主函数所属类名调用...

    main函数特殊之处:

    1 格式是固定的。
    2 被jvm所识别和调用。

    main函数关键字分析:

    对于 public static void main(String[] args)
    public: 因为权限必须是最大的。
    static: 不需要对象,直接用主函数所属类名调用即可。
    void: 主函数没有具体的返回值。
    main:函数名,不是关键字,只是一个jvm识别的固定的名字。

    String[] arg: 这是主函数的参数列表,是一个数组类型的参数,而且元素都是字符串类型的。


    main函数的例子:MainDemo.java

    class MainDemo
    {
    	public static void main(String[] args)  
    	{
    		System.out.println(args); //[ljava.lang.string;@139a55  “[”代表数组, “l”代表long , "@139a55"代表哈希值
    		System.out.println(args.length);  //默认长度为0
    		for(int i = 0; i < args.length; i++)
    			System.out.println(args[i]); 
    	}
    }

    输出:

    分析:
    1 args是arguments的缩写,args名字可以随意改,不用担心。String[] args也可以写成 String args[]。
    2 默认Java虚拟机创建了new String[0]作为传入参数,长度为0。
    3 main函数为什么要传入字符串呢? 因为任何数据都可以通过字符串形式的数据进行转换。


    展开全文
  • 深入浅出 C++:main()

    千次阅读 2018-07-29 09:41:57
    main() 是 C/C++ 程序执行的进入点,操作系统执行程序时,首先会执行 Runtime Library 内的函数进行必要的初始化,接着才调用 main() 转移控制权,当 main() 返回时,再根据 main() 的返回值调用 exit() 结束程序。...

    main() 是 C/C++ 程序执行的进入点,操作系统执行程序时,首先会执行 Runtime Library 内的函数进行必要的初始化,接着才调用 main() 转移控制权,当 main() 返回时,再根据 main() 的返回值调用 exit() 结束程序。

    main() 的标准函数原型 (Function Prototype)

    第一种标准写法,是不带参数的:

    #include <cstdlib>
    
    int main()
    {
      return EXIT_SUCCESS;
    }

    main() 的返回值代表程序的结束状态。使用 cstdlib 是为了引入 EXIT_SUCCESS 这个 macro,回传它或 0 代表程序成功执行,而相对的,回传 EXIT_FAILURE 则代表由错误发生。C++ 标准并未定义 EXIT_SUCCESS 对应哪个整数。

    值得留意的是,C++ 严格规定,如果函数宣告时有返回值类型 (return type),就必须有代码明确给出返回值。但 main() 例外,它可以省略 return EXIT_SUCCESS 那一行,此时效果成功结束。

    第二种 main() 的写法带有两个参数 (parameter),允许用户在命令行模式运行程序时,指定一至数个引数 (argument):

    #include <cstdlib>
    #include <iostream>
    
    int main(int argc, char* argv[])
    {
      for (int i = 0 ; i < argc ; ++i)
        std::cout << "parameter " << i << " : " << argv[i] << std::endl;
    
      return EXIT_SUCCESS;
    }

    参数 argc 记录当程序执行时,传入的引数个数,argv 则是类型为 char** 的指针 (pointer),指向一个字符串数组 (string array),该数组长度为 argc + 1。argv[0] 至 argv[argc - 1] 为执行程序时传入的引数;argv[argc] 为 0,代表空字符串。语法上,第二个参数的宣告,也可以写成 char** argv,但较常见的写法仍是 char* argv[],因为它明确表达了 argv 指向一个字符串数组。

    上面程序执行结果如下:

    sora@sora-VirtualBox:~/cpp/c1$ clang++ -std=c++17 -stdlib=libc++ --pedantic-errors -pthread -o main main.cpp
    sora@sora-VirtualBox:~/cpp/c1$ ./main -s -t --version "test" \"test\" 'test' \'test\'
    Argument 0 : ./main
    Argument 1 : -s
    Argument 2 : -t
    Argument 3 : --version
    Argument 4 : test
    Argument 5 : "test"
    Argument 6 : test
    Argument 7 : 'test'
    

    有些程序员,认为 argv[0] 必为程序的名称,但实际上在 c++ 标准中,argv[0] 可能是程序名、也可能是空字符串。故撰写跨平台程序时,切勿犯此错误。

    如果你熟悉 C++11 的返回类型后置语法 (trailing return type),也可以装逼这么写:

    auto main(int argc, char* argv[]) -> int
    {
      // ...
    }

    Trailing return type 在 C++ template 开发有举足轻重的作用,但在 main() 这里,意义与效果与前面的版本完全相同,纯粹是换个写法。


    谁调用了 main()

    本文开头提到,main() 并非程序第一个执行的函数。我们可以用 gdb 探索究竟是誰调用了它。

    首先,我们沿用前面的 main.cpp,但在 compile 时,加上 -g 选项以包含 debug 信息:

    sora@sora-VirtualBox:~/cpp/c1$ clang++ -std=c++17 -g -stdlib=libc++ --pedantic-errors -pthread -o main main.cpp
    

    接着使用 gdb 调试:

    sora@sora-VirtualBox:~/cpp/c1$ gdb -q main
    Reading symbols from main...done.
    

    将中断点 (breakpoint) 设在程序的第 6 行,也就是 for 循环那里:

    (gdb) b 6
    Breakpoint 1 at 0x400e06: file main.cpp, line 6.
    

    运行程序后,就会显示停止在第 6 行:

    (gdb) r
    Starting program: /home/sora/cpp/c1/main 
    [Thread debugging using libthread_db enabled]
    Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
    
    Breakpoint 1, main (argc=1, argv=0x7fffffffdf58) at main.cpp:6
    6     for (int i = 0 ; i < argc ;++i)
    

    执行 where 指令,此时 gdb 默认会忽略 main() 之前的函数,所以看不到什么:

    (gdb) where
     #0  main (argc=1, argv=0x7fffffffdf58) at main.cpp:6
    

    输入以下指令,即可让 gdb 显示 main() 之前的函数:

    (gdb) set backtrace past-main
    

    再执行一次 where,即可让 gdb 显示 main() 之前的函数,可看到 C++ Runtime Library 先执行了 _start()、再调用到 __libc_start_main() 函数,最后才调用到 main():

    (gdb) where
     #0  main (argc=1, argv=0x7fffffffdf58) at main.cpp:6
     #1  0x00007ffff6d3cb97 in __libc_start_main (
        main=0x400df0 <main(int, char**)>, argc=1, argv=0x7fffffffdf58, 
        init=<optimized out>, fini=<optimized out>, rtld_fini=<optimized out>, 
        stack_end=0x7fffffffdf48) at ../csu/libc-start.c:310
     #2  0x0000000000400d2a in _start ()
    

    在 Unix-like 系统中,当 compile 后的程序与 glibc link 成 ELF 格式的可执行文件,_start 就是程序执行初始化的入口函数。在 ELF 格式中,.init 代表 main() 执行前需要被执行的代码,.fini 代表 main() 离开后、程序结束前需要执行的代码,这些都传入了 __libc_start_main() 函数,以下是删减过后的版本,省略了初始化其他部分的代码:

    // glibc/csu/libc-start.c
    
    STATIC int
    LIBC_START_MAIN (int (*main) (int, char **, char ** MAIN_AUXVEC_DECL),
                     int argc, char **argv,
    #ifdef LIBC_START_MAIN_AUXVEC_ARG
                     ElfW(auxv_t) *auxvec,
    #endif
                     __typeof (main) init,
                     void (*fini) (void),
                     void (*rtld_fini) (void), void *stack_end)
    {
      /* Result of the 'main' function.  */
      int result;
    
      /* Call the initializer of the program, if any.  */
      if (init)
        (*init) (argc, argv, __environ MAIN_AUXVEC_PARAM);
    
      /* Register the destructor of the dynamic linker if there is any.  */
      if (__glibc_likely (rtld_fini != NULL))
        __cxa_atexit ((void (*) (void *)) rtld_fini, NULL, NULL);
    
      /* Register the destructor of the program, if any.  */
      if (fini)
        __cxa_atexit ((void (*) (void *)) fini, NULL, NULL);
    
      result = main (argc, argv, __environ MAIN_AUXVEC_PARAM);
      exit (result);
    }

    .init 与 .fini 两个 section 对 C++ 至关重要,.init 帮 C++ 程序在 main() 执行之前,调用了所有 global object 的 constructor,而 .fini 则是执行他们的 destructor。

    最后执行 quit 指令离开调试,结束 gdb 运行:

    (gdb) quit
    A debugging session is active.
    
        Inferior 1 [process 25264] will be killed.
    
    Quit anyway? (y or n) y
    



    常见的非标准 main() 函数原型

    void main()
    {
    }

    这种返回值为 void 的写法,来自 Microsoft Visual C++,由于 Windows 平台上,许多 C++ 初学者选用 Visual C++ 当作入门的练习工具,所以常会误以为这种写法是标准所允许的。gcc 与 clang 都将这种写法视为错误。

    另一种非标准、但也很常见的形式为:

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

    这种非标准写法带有第三个参数 envp,用来接收目前系统的环境变量。下面程序可以打印出系统所有的环境变量:

    #include <iostream>
    
    int main(int argc, char* argv[], char* envp[])
    {
      for (std::size_t i = 0 ; envp[i] != nullptr ; ++i)
        std::cout << "envp[" << i << "] : " << envp[i] << std::endl;
    }

    以笔者运行的 Ubuntu 18.04 为例,执行结果如下,可看到 env 里每个字符串,其实是环境变量里 key、value 的对应:

    envp[0] : CLUTTER_IM_MODULE=xim
    envp[1] : LD_LIBRARY_PATH=:/home/sora/Temp/clang/build/lib
    ...
    envp[62] : OLDPWD=/home/sora/Temp/clang/llvm/projects
    envp[63] : _=./main_envp
    

    C++ 标准中,可以使用 <cstdlib> 的 getenv() 函数取得某个环境变量内容,这种方式,比借由 main() 传递第三个参数来的安全且标准:

    char* getenv(const char* env_var);

    以下是范例:

    #include <iostream>
    #include <cstdlib>
    
    int main()
    {
      if (const char* p = std::getenv("PATH"); p)
        std::cout << "PATH=" << p << std::endl;
    
      if (const char* p = std::getenv("TERM"); p)
        std::cout << "TERM=" << p << std::endl;
    }

    输出结果如下:

    sora@sora-VirtualBox:~/cpp/c1$ clang++ -std=c++17 -stdlib=libc++ --pedantic-errors -pthread -o getenv getenv.cpp
    sora@sora-VirtualBox:~/cpp/c1$ ./getenv
    PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin
    TERM=xterm-256color
    


    早期的 C 式 main()

    以下这两种 main() 函数,在早期的 C 代码还可见到。这些写法已无法通过目前 C++ compiler 的检查。列在本文里,纯粹是因为笔者的考古情怀。如果你有机会接触到这些古老的程序,记得瞻仰下先圣先贤。

    main()
    {
    }

    这种连返回值类型都没写的形式,是早期 C 所允许的。没写并不代表没有返回值,C compiler 会将这种情况视为 int main()。

    另一种古老的形式如下:

    int main()
      int    argc;
      char** argv;
    {
      return 0;
    }

    这种写法称为 K&R 形式。1978年,由 Brian Kernighan 与 Dennis Ritchie 合著的 The C Programming Language 第一版,书中即采用这种格式,由于这本书太出名了,计算机界以两位作者首字母缩写简称这本书为 K&R,而这个函数定义就称为 K&R 形式。随后美国国家标准化协会 (American National Standards Institute) 于 1989 年制定的 ANSI C 标准 (常称为 C89) 已不采用这种函数定义,而 1988 出版的 K&R 第二版亦以 ANSI C 格式改写。不过如果读者有幸接触一些二十几年钱的 C 程序,仍可看到这种写法。这种语法一样无法通过目前 gcc 与 clang 的检查。

    展开全文
  • __main() 和 main()

    万次阅读 2012-07-16 16:09:25
    __main() 和 main()(转载) 因为我们通常在BOOTLOADER中都已做好了比较细致的初始化工作,包括代码的搬运,所以我们最好别再调用库函数__main(),因为__main()作为ADS集成好的库函数,会对系统进行初始化设置,...
  • main

    2019-04-27 00:07:12
    main方法 main 方法是由jvm调用的,jvm也是一个程序 public :保证在任何情况下,jvm都对其方法可见 static:静态;可以使用类名调用,避免创建对象而且解决了创建对象参数传递的问题 void:没有返回值,即使有...
  • main和_main的区别

    千次阅读 2014-03-13 10:34:41
    具体介绍了main和_main的编译运行结果的区别 已经内在原因 可以很好的帮助理解系统的编译特点
  • 因为我们通常在BOOTLOADER中都已做好了比较细致的初始化工作,包括代码的搬运,所以我们最好别再调用库函数__main(),因为__main()作为ADS集成好的库函数,会对系统进行初始化设置,可能会与我们的初始化发生冲突,...
  • Java中main方法详解

    千次阅读 多人点赞 2019-03-18 09:22:18
    Java中的main方法,是一个java应用程序的入口,无论一个java的应用多么复杂庞大,或是多么的小,只要他是一个可以运行的java程序那么必然就要有一个main方法。main方法的定义格式通常固定如下: public class Demo ...
  • Java main方法

    万次阅读 2015-07-28 17:47:59
    public static void main(String[] args) {} 或者 public static void main(String args[]) {}main方法是我们学习Java语言学习的第一个方法,也是每个java使用者最熟悉的方法,每个Java应用程序都必须有且仅有一个...
  • //--------------------------------------------------标准的main函数格式为:int main(int argc, char *argv[]); /*即返回值为整型,带两个参数,argc为命令行参数的个数,argv为指针数组, 前argc个指针为参数...
  • 深度剖析c语言main函数---main函数的返回值

    万次阅读 多人点赞 2018-07-09 23:21:17
    在接下来的几篇博文中,我将对c语言的main函数进行深入的剖析,分别从函数返回值,函数参数,以及函数的执行顺序对main函数作一总结。本文主要聊聊main函数的返回值。 main函数的返回值  main函数的返回值用于...
  • pip升级后Import Error:cannot import name main解决方案

    万次阅读 多人点赞 2020-07-11 17:43:36
    在Ubuntu上安装软件,不小心升级了pip,导致使用时报错如下 后来发现是因为将pip更新为10.0.0后库里面的函数有所变动...from pip import main 改为 from pip._internal import main 方法二: sudo gedit ...
  • if __name__ == '__main__' 如何正确理解?

    万次阅读 多人点赞 2019-04-21 17:02:10
    在大多数编排得好一点的脚本或者程序里面都有这段if __name__ == 'main': ,虽然一直知道他的作用,但是一直比较模糊,收集资料详细理解之后与大家分享。 1、这段代码的功能 一个python的文件有两种使用的方法,第...
  • 引言 dockerfile本地打包失败 一个报错会有很多种问题,也有很多种解决办法 ...no main manifest attribute, in service/app.jar 错误解决方法 删除本地 target 文件夹 然后重新clean-> package 即可 ...
  • Exception in thread "main" java.lang.Error: Unresolved compilation problem: Syntax error, insert ";" to complete Statement at cn.com.infosec.test.Rsaa.main(Rsaa.java:157)(线程"主要的"java.lang.e...
  • Python中if __name__ == '__main__':的作用和原理

    万次阅读 多人点赞 2019-05-10 14:25:21
    if __name__ == '__main__':的作用 一个python文件通常有两种使用方法,第一是作为脚本直接执行,第二是 import 到其他的 python 脚本中被调用(模块重用)执行。因此if __name__ == 'main':的作用就是控制这两种...
  • python中的main函数

    万次阅读 多人点赞 2020-05-05 09:43:21
    python是一种解释型脚本语言,和C/C++语言不同,C/C++程序从main函数开始执行,python程序从开始到结尾顺序执行。先总结下python中的main函数的作用:让模块(函数)可以自己单独执行(调试),相当于构造了调用其它...
  • chrome控制台 提示禁告:Synchronous XMLHttpRequest on the main thread is deprecated because of its detrimental effects to the end user's experience. For more help, check http://xhr.spec.whatwg.org...
  • main" java.lang.Error: 无法解析的编译问题解决思路public class ClientLogin extends JFrame { }因为没有导入包,要在头文件导入该包,然后才可调用import javax.swing.JFrame; //继承JFrame的所有功能 ...
1 2 3 4 5 ... 20
收藏数 8,456,227
精华内容 3,382,490
关键字:

main