深刻理解main函数的命令行参数

深刻理解main函数的命令行参数
深刻理解main函数的命令行参数

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

一、main()函数的形式

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

(参阅ISO/IEC 9899:1999 (E) 5.1.2.2.1 Program startup)

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("/nI'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: /n",argc-1);

for(count=1;count

printf("%d: %s/n",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;

fp=fopen(argv[1],"w");

fputs("I love you.",fp);

fclose(fp);

return 0;

}

编译运行,打开命令行并输入d love.txt 回车。这样,打开d.c文件所在的目录,你会发现多了一个名为love.txt 的文件,打开后里面的内容正是世界上说的最多的那句话。

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

C程序最大的特点就是所有的程序都是用函数来装配的。main()称之为主函数,是所有程序运行的入口。其余函数分为有参或无参两种,均由main()函数或其它一般函数调用,若调用

的是有参函数,则参数在调用时传递。

main()

{

...

y1=f1(x1,x2);

...

}

f1(int a,int b)

{

....

Y2=f2(x3,x4);

....

}

f2(int m,int n)

{

....

.....

}

在前面课程的学习中,对main()函数始终作为主调函数处理,也就是说,允许main()调用其它函数并传递参数。事实上,main()函数既可以是无参函数,也可以是有参的函数。对于有

参的形式来说,就需要向其传递参数。但是其它任何函数均不能调用main()函数。当然也同样

无法向main()函数传递,只能由程序之外传递而来。这个具体的问题怎样解决呢?

我们先看一下main()函数的带参的形式:

main(argc,argv)

int argc,char *argv[];

{

.....

}

从函数参数的形式上看,包含一个整型和一个指针数组。当一个C的源程序经过编译、链接后,会生成扩展名为.EXE的可执行文件,这是可以在操作系统下直接运行的文件,换句话说,就是由系统来启动运行的。对main()函数既然不能由其它函数调用和传递参数,就只能由

系统在启动运行时传递参数了。

在操作系统环境下,一条完整的运行命令应包括两部分:命令与相应的参数。其格式为:命令参数1参数2....参数n?

此格式也称为命令行。命令行中的命令就是可执行文件的文件名,其后所跟参数需用空格分隔,并为对命令的进一步补充,也即是传递给main()函数的参数。

命令行与main()函数的参数存在如下的关系:

设命令行为:program str1 str2 str3 str4 str5

其中program为文件名,也就是一个由program.c经编译、链接后生成的可执行文件progr am.exe,其后各跟5个参数。对main()函数来说,它的参数argc记录了命令行中命令与参数的个数,共6个,指针数组的大小由参数argc的值决定,即为char*argv[6],指针数组的取值情况如图6-15所示。

数组的各指针分别指向一个字符串。应当引起注意的是接收到的指针数组的各指针是从命令行的开始接收的,首先接收到的是命令,其后

才是参数。

下面用实例来说明带参数的main()函数的正确使用。

[例6-29] 利用图形库函数绘制一个变化的环。它是把一个半径为R 1的圆周分成n份,然后以每个等分点为圆心,以R s为半径画n个圆(关于作图的详细理论本教材第9章第1节作了专

门介绍,这里只作简单分析)。利用m a i n ( )函数的带参数形式,我们可以从键盘以命令行的方

式输入R 1和R s及屏幕的背景色。

#include /*包含图形库函数的头文件* /

#include

#define pi 4.1415926

m a i n ( a r g c , a r g v )

int argc;char *argv[]; /* 定义带参数的m a i n ( ) * /

{

int x,y,r1,rs,color;

double a;

int gdriver=DETECT,gmode;

initgraph(&gdriver,&gmode,"..\\bgi ")启;/动*图形工作方式*/

r1=atoi(argv[1]);/*计算基础圆半径*/

rs=atoi(argv[2]);/*计算同心圆半径*/

color=atoi(argv[3]);/*背景色*/

cleardevice();/*清除图形屏幕*/

setbkcolor(color);/*设置背景色*/

setcolor(4);/*设置图形显示颜色*/

for(a=0;a<=2*pi;a+=pi/18)/*绘制同心圆*/

{

x=r1*cos(a)+320;

y=r1*sin(a)+240;

circle(x,y,rs);/*以圆心坐标为x、y,半径为rs画圆*/

}

getch();/*等待按键继续*/

close graph();/*关闭图形工作方式*/

}

若程序名为L6-29.c,经编译、连结生成可执行文件L6-29.exe。在操作系统的环境下运行程序,命令行方式为:

l6-29 40 20 3

则命令行与main()函数的参数有如图6-16所示的关

系。

图6-16中,argv[0]是程序名,argv[1]是r1的值,

argv[2]是rs的值,argv[3]是屏幕的背景色。

由于指针数组均存放字符串,所需的圆半径及背景

色彩通过atoi()函数转换为整型。

通过带参数的main()函数,我们可以为自己的程序设置口令,在运行程序的命令行中给出所需的口令,正确则继续,否则退出。程序图形输出如图6-17所示。

[例6-30]将上述程序作修改,在程序的入口处添置密码,若给定密码正确,则显示图形。

#include

#include

#define pi 4.1415926

m a i n ( a r g c , a r g v )

int argc;char *argv[];

{

int x,y,r1,rs,color;

double a;

int gdriver=DETECT,gmode;

if (strcmp(argv[1],"pass")!=0) 设/置* 口令的比较*/

{ printf("password error!\n");

e x i t ( 0 ) ;

}

initgraph(&gdriver,&gmode,"..\\bgi ");

r1=atoi(argv[2]);

rs=atoi(argv[3]);

color=atoi(argv[4]);

cleardevice();

setbkcolor(color);

setcolor(4);

for(a=0;a<=2*pi;a+=pi/18)

{

x=r1*cos(a)+320;

y=r1*sin(a)+240;

circle(x,y,rs);

}

getch();

closegraph();

}

在操作系统的环境下运行程序,命令行中增加口令“p a s s”,命令行方式为:

l6-30 pass 20 40 3

指针数组的存储字符串如图6-18所示。

若给定字符串argv[1]的值是pass,则程序正确运行,否则程序退出。口令正确的情况下,显示的图形为图6-17中的一个。

main函数的命令行参数

main函数的命令行参数 前面所用到的main函数都是不带参数的,即main()。其实main函数也可以有参数,只是它的参数之一是指针数组。 1.main函数中可以写两个形参,一般形式如下:main(int argc,char *argv[ ]); 2.说明:第一个形参argc是一个整型变量,第二个形参argv是一个指针数组,其元素指向字符型数据。 1 若以下程序所生成的可执行文件名为filel.exe ; 当输入以下命令行执行该程序 时,FILE1 CHINA BEIJING SHANGHAI程序的输出结果是()。 main( int argc,char *argv[]) { while(argc-->0) { ++argv; printf("%s",*argv);} } A)CHINA BEIJING SHANGHAI B)FILE1 CHINA BEIJING C)C B S D)F C B 2 假定下列程序的可执行文件名为prg.exe,则在该程序的子目录下输入命令行: main(int argc,char *argv[ ]) { int i; if(argc<=0) return; for(i=1;i后程序的输出结果是()。 A)hello good B)hg C)hel D)hellogood 3 假定以下程序经编译和连接后生成可执行文件PROG.EXE,如果在此可执行文件所在录的DOS提示符下键入:PROG ABCDEFGH IJKL<回车>,则输出结果为()。 main( int argc, char *argv[])) { while(--argc>0) printf("%s",argv[argc]); printf("\n"); } A) ABCDEFG B) IJHL C) ABCDEFGHIJKL D) IJKLABCDEFGH 4 不合法的main函数命令行参数表示形式是()。 A) main(int a,char *c[]) B) main(int arc,char **arv) C) main(int argc,char *argv) D) main(int argv,char *argc[]) 5 有以下程序:程序编译连接后生成的可执行文件是exl.exe,若运行时输入带参数的命令行是exl abcd efg 10<回车>则运行的结果是()。 #include main(int argc,char *argv[]) { int i,len=0; for (i=1; i,则运行结果为()。 main(int argc, char *argv[]) { int n,i=0; while(argv[1][i]!= '\0') { n=fun(); i++;} printf("%d\n",n*argc); } int fun() { static int s=0; s+=1; return s; } A)6 B)8 C)3 D)4

C语言编程实战-4-命令行参数(main函数)处理

命令行(main函数)参数处理 我们在执行某某命令的时候,经常会传入一些参数,告诉程序做不同的处理。如使用gcc编译程序时,我们经常会在后边指定c源码文件,如gcc test.c。我们自己写的程序,如何能够算其它命令一样,能够接收和处理不同的参数呢?答案是肯定的。我们今天来介绍自写程序对命令行参数的处理。 一个标准的C程序,其主函数通常是这样子定义的: int main(int argc,char *argv[]) { //用户代码 return xxx; } main函数有两个参数:argc与agv,前者是一个整数,表示命令行给程序参数的个数,后者是一个字符串数组,用于顺次存放命令行传给程序的参数,通过argc与argv,我们就能实现对命令行参数的处理。 对每一个程序而言,程序的名称总会作为命令行的第一个参数传给它的主函数,那怕命令行中并没有传任何参数。因此,主函数的参数argc最小值为1,argv[0]总是存放命令程序名。因此,假使test是我们程序的名字,如果执行: test 则main函数得到的参数是:argc = 1, argv = {“test”}; 如果执行: test arg1 arg2 则main函数得到的参数是:argc = 3, argv = {“test”, “arg1”, “arg2”}; 如此类推。 通过上面的讲解,我们不难在main函数中实现对命令行参数的代码。我们接下来做一个编程任务: 写一个程序,该程序接收两个参数,这两个参数都是整数,程序中需将这两个整数的和与差计算并输出到屏幕上。假设程序的名称为cal,在命令行执行: cal 10 15 则程序输出: 10 + 15 = 25 10 – 15 = -5 如果输入的参数不合法,则提示参数错误。 代码实现: #include

主函数main

①主函数main() ②保存单链表函数save() ③重载操作菜单函数load() ④显示单链表内容函数display () ⑤插入元素函数insert () ⑥删除元素函数decelt () ⑦修改元素函数modify() 各函数间关系如下: #include "stdafx.h" #include #include typedef char ElemType; struct LNode { ElemType data; struct LNode *next; }; //***********************************************************置空表setnull() void setnull(struct LNode **p) { *p=NULL; } //************************************************************求长度length() int length(struct LNode **p) { int n=0; struct LNode *q=*p; while (q!=NULL) { n++; q=q->next; }

return(n); } //*************************************************************取结点get() ElemType get(struct LNode **p,int i) { int j=1; struct LNode *q=*p; while (jnext;j++; } if (q!=NULL) /**//*找到了第i个结点*/ return(q->data); else { printf("位置参数不正确!\n"); return NULL; } } //************************************************************按值查找locate() int locate(struct LNode **p,ElemType x) { int n=0; struct LNode *q=*p; while (q!=NULL && q->data!=x) /**//*查找data域为x的第一个结点*/ { q=q->next; n++; } if (q==NULL) /**//*未找到data域等于x的结点*/ return(-1); else /**//*找到data域等于x的结点*/ return(n+1); }

带参数main函数

main函数也可以带参数。带参数main函数的定义格式如下: void main(int argc, char *argv[]) { ... ... } argc和argv是main函数的形式参数。这两个形式参数的类型是系统规定的。如果main函数要带参数,就是这两个类型的参数;否则main函数就没有参数。变量名称argc和argv 是常规的名称,当然也可以换成其他名称。 那么,实际参数是如何传递给main函数的argc和argv的呢?我们知道,C程序在编译和链接后,都生成一个exe文件,执行该exe文件时,可以直接执行;也可以在命令行下带参数执行,命令行执行的形式为: 可执行文件名称参数1 参数2 ... ... 参数n 执行文件名称和参数、参数之间均使用空格隔开。例如,在linux下运行程序./a.out 1 2 ,可执行文件名称为./a.out,参数1为字符串1,参数2为2。 如果按照这种方法执行,命令行字符串将作为实际参数传递给main函数。具体为: (1) 可执行文件名称和所有参数的个数之和传递给argc;所以上面的argc=3 (2) 可执行文件名称(包括路径名称)作为一个字符串,首地址被赋给argv[0],参数1也作为一个字符串,首地址被赋给argv[1],... ...依次类推。 本回答专业性由科学教育分类达人陶文认证 满意回答 运行方法: (假设你的程序为Untitled1.exe) 打开命令提示符: 转到你的Untitled1.exe的目录, 输入下列命令: Untitled1.exe a basdfsa 1314324 -k -f 回车就可以运行了。 这时,在Main函数里定义的 int main(int argc, char *args[]) 里的argc = 6,就是表示有六个参数, 对应的 args[0] = "Untitled1.exe"; args[1] = "a"; args[2] = "basdfsa"; args[3] = "1314324"; args[4] = "-k"; args[5] = "-f"; 就是这样子了。

int main参数详解

int main(int argc,char* argv[])详解 argc是命令行总的参数个数 argv[]是argc个参数,其中第0个参数是程序的全名,以后的参数 命令行后面跟的用户输入的参数,比如: int main(int argc, char* argv[]) { int i; for (i = 0; i>i; return 0; } 执行时敲入 F:\MYDOCU~1\TEMPCODE\D1\DEBUG\D1.EXE aaaa bbb ccc ddd 输出如下: F:\MYDOCU~1\TEMPCODE\D1\DEBUG\D1.EXE aaaa bbb ccc ddd -------------------------------------------------------------------- char *argv[]是一个字符数组,其大小是int argc,主要用于命令行参数argv[] 参数,数组里每个元素代表一个参数; 比如你输入 test a.c b.c t.c 则 argc = 4 argv[0] = "test" argv[1] = "a.c" argv[2] = "b.c" argv[3] = "t.c" -------------------------------------------------------------------------------------------- argc记录了用户在运行程序的命令行中输入的参数的个数。 arg[]指向的数组中至少有一个字符指针,即arg[0].他通常指向程序中的可执行文件的文件名。在有些版本的编译器中还包括程序 文件所在的路径。 ------------------------------------------------------------------------- 在调用一个可执行程序时,某些情况下需要向程序传递参数。如我们可以在控制台中键入notepad.exe, 回车后将执行记事本程序。如果我们希望在打开notepad时同时打开一个文本文件,可以在notepad.exe

关于main函数的(int argc,char argv[])

main(int argc,char *argv[ ]) argv为指针的指针 argc为整数 char **argv or: char *argv[] or: char argv[][] main()括号内是固定的写法。 下面给出一个例子来理解这两个参数的用法: 假设程序的名称为prog, 当只输入prog,则由操作系统传来的参数为: argc=1,表示只有一程序名称。 argc只有一个元素,argv[0]指向输入的程序路径及名称:./prog 当输入prog para_1,有一个参数,则由操作系统传来的参数为: argc=2,表示除了程序名外还有一个参数。 argv[0]指向输入的程序路径及名称。 argv[1]指向参数para_1字符串。 当输入prog para_1 para_2 有2个参数,则由操作系统传来的参数为: argc=3,表示除了程序名外还有2个参数。 argv[0]指向输入的程序路径及名称。 argv[1]指向参数para_1字符串。 argv[2]指向参数para_2字符串。 void main( int argc, char *argv[] ) char *argv[] : argv 是一个指针数组,他的元素个数是argc,存放的是指向每一个参数的指针, 他的第一个元素即argv[0]为编译生成的可执行文件名(包括路径eg:"F:\VC\Ex1\Debug\Ex1.exe"),从二个元素(argv[1])开始,是每一个参数int argc 表示argv的大小,是实际参数个数+1,其中+1是因为argv[0]是编译后的可执行文件名main()主函数 每一C 程序都必须有一main()函数, 可以根据自己的爱好把它放在程序的某个地方。有些程序员把它放在最前面, 而另一些程序员把它放在最后面, 无论放 在哪个地方, 以下几点说明都是适合的。 1. main() 参数 在Turbo C2.0启动过程中, 传递main()函数三个参数: argc, argv和env。 * argc: 整数, 为传给main()的命令行参数个数。 * argv: 字符串数组。 在DOS 3.X 版本中, argv[0] 为程序运行的全路径名; 对DOS 3.0 以下的版本, argv[0]为空串("") 。 argv[1] 为在DOS命令行中执行程序名后的第一个字符串; argv[2] 为执行程序名后的第二个字符串; ... argv[argc]为NULL。 *env: 安符串数组。env[] 的每一个元素都包含ENVV AR=value形式的字符串。其中ENVV AR为环境变量如PA TH或87。value 为ENVV AR的对应值如C:\DOS, C: \TURBOC(对于PA TH) 或YES(对于87)。 Turbo C2.0启动时总是把这三个参数传递给main()函数, 可以在用户程序中说明(或不说明)它们, 如果说明了部分(或全部)参数, 它们就成为main()子程序的局部变量。

c c++ main 函数命令行参数的使用 知识小结

c/c++ main 函数命令行参数的使用知识小结 2012-12-31 13:13:43 我来说两句作者:wu_lai_314 收藏我要投稿C程序最大的特点就是所有的程序都是用函数来装配的。main()称之为主函数,是所有程 序运行的入口。其余函数分为有参或无参两种,均由main()函数或其它一般函数调用,若调用 的是有参函数,则参数在调用时传递。 C/C++语言中的main函数,经常带有参数argc,argv,如下: int main(int argc, char** argv)int main(int argc, char* argv[])从函数参数的形式上看,包含一个整型和一个指针数组。当一个C/C++的源程序经过编译、链接后,会生成扩展名为.EXE的可执行文件,这是可以在操作系统下直接运行的文件,换句话说,就是由系统来启动运行的。对main()函数既然不能由其它函数调用和传递参数,就只能由 系统在启动运行时传递参数了。 在操作系统环境下,一条完整的运行命令应包括两部分:命令与相应的参数。其格式为: 命令参数1参数2....参数n? 此格式也称为命令行。命令行中的命令就是可执行文件的文件名,其后所跟参数需用空格分隔,并为对命令的进一步补充,也即是传递给main()函数的参数。 命令行与main()函数的参数存在如下的关系: 设命令行为:program str1 str2 str3 str4 str5 其中program为文件名,也就是一个由program.c经编译、链接后生成的可执行文件program.exe,其后各跟5个参数。对main()函数来说,它的参数argc记录了命令行中命令与参数的个数,共6个,指针数组的大小由参数argc的值决定,即为char*argv[6],指针数组的取值情况如图6-15所示。

Main函数参数argc,argv说明

Main函数参数argc,argv说明 C/C++语言中的main 函数,经常带有参数argc,argv,如下:int main(int argc, char** argv) int main(int argc, char* argv[]) 这两个参数的作用是什么呢?argc 是指命令行输入参数的个数,argv 存储了 所有的命令行参数。假如你的程序是hello.exe,如果在命令行运行该程序,(首 先应该在命令行下用cd 命令进入到hello.exe 文件所在目录)运行命令为:hello.exe Shiqi Yu 那么,argc 的值是3,argv[0]是”hello.exe”,argv[1]是”Shiqi”,argv[2]是”Yu”。 下面的程序演示argc 和argv 的使用: #include int main(int argc, char ** argv) { int i; for (i=0; i 假如上述代码编译 为hello.exe,那么运行 hello.exe a b c d e 将得到 Argument 0 is hello.exe. Argument 1 is a. Argument 2 is b. Argument 3 is c. Argument 4 is d. Argument 5 is e.运行 hello.exe lena.jpg 将得到 Argument 0 is hello.exe. Argument 1 is lena.jpg.================================#include #include #include int main(int argc ,char * argv[]){int i;char arg[6][15]={0};printf(“argc: %d /n”,argc);for(i=0;i{sprintf(arg[i],”%s” ,argv[i]);}//for(i=1;i//printf(“%s/n”,arg[i]);execlp(“/bin/mkdir”,”mkdir”,arg[1],NULL); return 1;}======================================清单 2. BusyBox 使 用argv[0] 来确定调用哪个应用程序// test.c #include int main( int argc, char

C语言主函数main的注意

# include main() { int i=50; while(i<=80) { szd-h: i += 10; if(i==80) goto szd-h cout<<"i is"<就行 第二,main 函数应该带上一个返回值int,这是出于兼容性的考虑,在前面的帖子中,有位兄弟找到了这样的一段话: 在 C 和C++ 中,不接收任何参数也不返回任何信息的函数原型为“void foo(void);”。可能正是因为这个,所以很多人都误认为如果不需要程序返回任何信息时可以把main 函数定义成void main(void) 。然而这是错误的!main 函数的返回值应该定义为int 类型,C 和C++ 标准中都是这样规定的。虽然在一些编译器中,void main 可以通过编译(如vc6),但并非所有编译器都支持void main ,因为标准中从来没有定义过void main 。g++3.2 中如果main 函数的返回值不是int 类型,就根本通不过编译。而gcc3.2 则会发出警告。所以,如果你想你的程序拥有很好的可移植性,请一定要用int main 。 有int main()后,就要加上return 0;当然,你不显示的写int 也就是说默认为int型,也要加上return 0;否则会有warning出现! 第三,标示符写错了,可能是作者的粗心所至,sxd_h,最好还是不要用这样的标示符,感觉没有什么可读性```` 第四,goto szd_h;后面要分号! 我稍微修改了一下,但是程序结构一点没变 # include using namespace std; int main() { int i=50; while(i<=80) { szd_h: i += 10; if(i==80)

main函数的参数

一、main函数的参数 我们经常用的main函数都是不带参数的。因此main 后的括号都是空括号。实际上,main函数可以带参数,这个参数可以认为是main函数的形式参数。C语言规定main函数的参数只能有两个,习惯上这两个参数写为argc和argv。因此,main函数的函数头可写为:main (argc,argv)C语言还规定argc(第一个形参)必须是整型变量,argv( 第二个形参)必须是指向字符串的指针数组。加上形参说明后,main函数的函数头应写为: main (argc,argv) int argv; char *argv[];或写成: main (int argc,char *argv[]) 由于main函数不能被其它函数调用,因此不可能在程序内部取得实际值。那么,在何处把实参值赋予main函数的形参呢? 实际上,main函数的参数值是从操作系统命令行上获得的。当我们要运行一个可执行文件时,在DOS提示符下键入文件名,再输入实际参数即可把这些实参传送到main的形参中去。 DOS提示符下命令行的一般形式为:C:\>可执行文件名参数参数……; 但是应该特别注意的是,main 的两个形参和命令行中的参数在 位置上不是一一对应的。因为,main的形参只有二个,而命令行中的参数个数原则上未加限制。argc参数表示了命令行中参数的个数(注意:文件名本身也算一个参数),argc的值是在输入命令行时由系统按实际参数的个数自动赋予的。例如有命令行为:C:\>E6 24 BASIC dbase FORTRAN由于文件名E6 24本身也算一个参数,所以共有4个参数,因此argc取得的值为4。argv参数是字符串指针数组,其各元素值为命令行中各字符串(参数均按字符串处理)的首地址。指针数组的长度即为参数个数。数组元素初值由系统自动赋予。其表示如图6.8所示:main(int argc,char *argv){ while(argc-->1) printf("%s\n",*++argv); } 本例是显示命令行中输入的参数如果上例的可执行文件名为e24.exe,存放在A 驱动器的盘内。 因此输入的命令行为:C:\>a:e24 BASIC dBASE FORTRAN 则运行结果为: BASIC dBASE FORTRAN 该行共有4个参数,执行main时,argc的初值即为4。argv的4个元素分为4个字符串的首地址。执行while语句,每循环一次argv值减1,当argv等于1时停止循环,共循环三次,因此共可输出三个参数。在printf函数中,由于打印项*++argv是先加1再打印,故第一次打印的是argv[1]所指的字符串BASIC。第二、三次循环分别打印后二个字符串。而参数e24是文件名,不必输出。

辨析主函数:main()void main()int main()int main(void)int main(int argc, char argv[])之间的区别

“void main与int main之间的区别是什么?”这是一个常见的问题。这个faq就是来探讨一下这个问题,并深入研究一些有关main()函数不同版本的更多的东西。 C与C++在main()函数方面的标准有所不同,所以我们要分开讨论。 对于C语言: 在C89标准中,main() 的形式是可以接受的,当然使用如下的C99标准更明智,因为在这个标准中只有如下格式才能被接受: int main ( void ) int main ( int argc, char *argv[] ) 我们可以对main函数做轻微的改变,比如我们可以用一个自定义的类型代替int(当然这个类型必须被定义为int型),还可以把*argv[]改为**argv,等等。 如果我们不想在命令行下对程序输入参数,可以选择第一种形式。 其实第二种形式的两个参数argc,argv的名称是可以改变的,但保持原样是更明智的选择。 main()函数的返回类型必须为int;返回的整形值作为传递给调用者的一个返回码。(this allows a return code to be passed to the invoker) 对于C++: 以下是可以接受的格式: int main ( int argc, char *argv[] ) int main () 第一种格式遵从C99标准;第二种格式在不需要通过命令行向程序传递参数时使用,与C99标准中规定的格式int main(void)效果相同。 (C)int main()与int main(void)之间的区别: 很多C程序员都曾搞错的一个概念,就是以为这样一个函数不接受任何参数: int foo();

linux下的C语言带参数的main函数

int main(int argc, char*argv[ ]) 等同于int main(int argc, char **argv) argc是命令行中的参数的个数 argv[]对应每一个参数 例如 ./uarttest /dev/tty0 /mnt/tt argc将会是3 其中 argv[0]是“./uarttest” argv[1]是“/dev/tty0” argv[2]是“/mnt/tt” 在命令行里用来传递参数用的. 比如你执行xxx.exe username password username password 就是两个参数, argc=3, argv=程序路径+ 那两个字符串 如果程序没有指定命令行参数, argc 就=1 ,argv只有程序路径 int main(int argc,char* argv[])详解 argc是命令行总的参数个数 argv[]是argc个参数,其中第0个参数是程序的全名,以后的参数 命令行后面跟的用户输入的参数,比如: int main(int argc, char* argv[]) { int i; for (i = 0; i>i; return 0; } 执行时敲入 F:\MYDOCU~1\TEMPCODE\D1\DEBUG\D1.EXE aaaa bbb ccc ddd 输出如下: F:\MYDOCU~1\TEMPCODE\D1\DEBUG\D1.EXE aaaa bbb ccc ddd

-------------------------------------------------------------------- char *argv[]是一个字符数组,其大小是int argc,主要用于命令行参数argv[] 参数,数组里每个元素代表一个参数; 比如你输入 test a.c b.c t.c 则 argc = 4 argv[0] = "test" argv[1] = "a.c" argv[2] = "b.c" argv[3] = "t.c" -------------------------------------------------------------------------------------------- argc记录了用户在运行程序的命令行中输入的参数的个数。 arg[]指向的数组中至少有一个字符指针,即arg[0].他通常指向程序中的可执行文件的文件名。在有些版本的编译器中还包括程序 文件所在的路径。 ------------------------------------------------------------------------- 在调用一个可执行程序时,某些情况下需要向程序传递参数。如我们可以在控制台中键入notepad.exe, 回车后将执行记事本程序。如果我们希望在打开notepad时同时打开一个文本文件,可以在notepad.exe 后面跟上文件的路径和名字,如notepad.exe example.txt(文件在当前路径)。 那么程序中如何能得到这些输入参数呢?这个工作是编译器帮我们完成的,编译器将输入参数的信息 放入main函数的参数列表中。 main函数的参数列表保存了输入参数的信息,第一个参数argc记录了输入参数的个数, 第二个参数是字符串数组的,字符串数组的每个单元是char*类型的,指向一个c风格字符串。 以notepad.exe example.txt为例 argc是2,就是说argv数组中有两个有效单元 第一单元指向的字符串是"notepad.exe" 第二单元指向的字符串是"example.txt" argv数组中的第一个单元指向的字符串总是可执行程序的名字,以后的单元指向的字符串依次是程序调用时的参数。 这个赋值过程是编译器完成的,我们只需要读出数据就可以了。 -----------------------------------------------------------------------------

C语言之Main函数返回值问题分析

C语言之Main函数返回值问题分析 C语言之Main函数返回值问题分析:很多人甚至市面上的一些书籍,都使用了void main( ) ,其实这是错误的。C/C++ 中从来没有定义过void main( ) 。C++ 之父 Bjarne Stroustrup 在他的主页上的 FAQ 中明确地写着 The definition void main( ) { /* ... */ } is not and never has been C++, nor has it even been C.( void main( ) 从来就不存在于 C++ 或者 C )。下面我分别说一下 C 和C++ 标准中对 main 函数的定义。 “The C programming Language(《C 程序设计语言》)用的就是main( )。”--- 这是因为第一版的C语言只有一种类型,那就是int,没有char,没有long,没有float,…………既然只有一种类型,那么就可以不写,后来的改进版为了兼容以前的代码于是规定:不明确标明返回值的,默认返回值为int,也就是说 main()等同于int main(),而不是等同于void main()。在C99中,标准要求编译器至少给 main() 这种用法来个警告。 1. C 在 C89 中,main( ) 是可以接受的。Brian W. Kernighan 和Dennis M. Ritchie 的经典巨著 The C programming Language 2e(《C 程序设计语言第二版》)用的就是 main( )。不过在最新的 C99 标准中,只有以下两种定义方式是正确的: int main( void ) int main( int argc, char *argv[] )

main函数的参数(argc,argv[ ])使用说明

main(int argc, char* argv[ ])的参数使用说明 argc是命令行总的参数个数 argv[]是argc个参数,其中第0个参数是程序的全名,以后的参数命令行后面跟的用户输入的参数,比如: int main(int argc, char* argv[]) { int i; for (i = 0; i>i; return 0; } 执行时敲入 F:\MYDOCU~1\TEMPCODE\D1\DEBUG\D1.EXE aaaa bbb ccc ddd 输出如下: F:\MYDOCU~1\TEMPCODE\D1\DEBUG\D1.EXE aaaa bbb ccc ddd -------------------------------------------------------------------- char *argv[]是一个字符数组,其大小是int argc,主要用于命令行参 数 argv[] 参数,数组里每个元素代表一个参数; 比如你输入 test a.c b.c t.c 则 argc = 4 argv[0] = "test" argv[1] = "a.c" argv[2] = "b.c" argv[3] = "t.c" -------------------------------------------------------------------------------------------- argc记录了用户在运行程序的命令行中输入的参数的个数。 arg[]指向的数组中至少有一个字符指针,即arg[0].他通常指向程序中的可执行文件的文件名。在有些版本的编译器中还包括程序 文件所在的路径。 ------------------------------------------------------------------------- 在调用一个可执行程序时,某些情况下需要向程序传递参数。如我们可以在控制台中键入notepad.exe, 回车后将执行记事本程序。如果我们希望在打开notepad时同时打开一个文本文

main函数的调用及其参数问题

main函数的调用及其参数问题 电子科技大学任道远 在学C的时候就知道main函数是可以有两个参数的,但因为不会经常用,所以就简单地看过去了,没有看懂到底是怎么回事就没管它了,直到看C++的时候才终于有了点头绪。 一、用code::blocks编译出现的一个错误 在VC上成功编译并运行的C++程序,到了code::blocks上编译就有错误“error:‘::main’ must return ‘int’”,奇怪,为什么会出现这种情况呢?难道是因为换了编译器?但是,我以前用code::blocks编C的时候,一直都用的void main(),我记得没有问题啊。于是,我又将一个C程序在code::blocks上试了一下,居然出现了同样的错误提示,但我明明记得以前没有这种情况的啊…… 在百度之后,才明白,好像正规的C/C++标准规定main函数要返回一个整型量0,以表示程序(main函数)运行正常。也就是说,在code::blocks中编译时,不仅要将“void main()”改为“int main()”,还要在主函数最后加上“return 0;”才是对的。试了一下,果然如此,C 和C++都是这样,(将改过的程序在VC上编译也可以通过哦)。原来,VC和code::blocks 对C/C++标准的实行是略有区别的。(另外,对于C++,在code::blocks中必须以 #include using namespace std; 开头,而在VC上可以#include 开头。更多不同之处期待你我的发现。)但是,返回的int量到哪里去了呢?又是怎么判断程序(main函数)运行正常的呢?请听下文分解。 至于为什么以前用code::blocks时没有出现问题,我想可能是因为,我现在和以前用的code::blocks虽然是在同一个地方下载的,但可能版本更新了,有所不同。但是,两次下载间隔也不久啊,不可能这么巧吧。所以具体原因还有待调查…… 二、对main函数的进一步了解 先从系统对main函数的调用开始说起。C/C++开篇第一讲就说到,main函数是所有函数的入口,程序是从main函数开始的,也是从这里结束的。但是,到底是怎么从main函数开始的,前述的返回的int量又到哪里去了呢? 原来,main函数是由于系统的调用才开始运行的,也就是说,main函数就像程序中的其它函数一样,也是函数,系统调用它,就如它自己调用程序中的其它函数一样自然。 所以,返回的int型的量,是返回到系统中去了,由系统来判断返回值是否为0,若为0,则运行正常,否则不正常,至于不正常又是怎么办的,那是系统的事了,也可以说基本上是专业程序员的事了,已超出讨论范围。 这样理解之后,main函数名后的括号里可以有两个形参也就不足为奇了,也就像其它函数有参数一样自然了。具体地说,一般习惯将其表示为:int main(int argc,char *argv[ ]),(当然,其中的argc和argv可以由用户自己另外命名),两个参数是命令行参数,关于命令行,读者可以百度一下。其中,argc的值是命令行中可执行文件名和所有参数的个数之和,argv[]指针数组的各指针分别指向命令行中可执行文件名和各个参数的字符串。 下面给出一个查看两参数值(说法欠妥)的C++程序: #include using namespace std;

Java中main()方法以及命令行参数的若干注意

Java中main()方法以及命令行参数的若干注意 2009-12-14 22:26 main方法的完整定义语法:public static void main(String[] args){} 命令行格式:java [命令参数] 文件名 [args[0](用户参数) args[1] ... 比如 java - cs AClass a b c 1. 关于main()方法中的修饰符public java虚拟机规范并没有要求main一定是public的,所以public可以省略,它只是为了main()方法可以从任意一个java运行环境中调用。不过没有public 虽然编译无错误,但是虚拟机无法启动应用程序。 2. 关于main()方法中的关键字static 静态方法不能访问实例字段。但可访问自身类中的静态字段。 main方法是且必须是一个静态方法,所以static 必须写。为了不需要构造类实例。如果没有static,运行时出错。 3 . main()方法的返回类型和返回值 main(String[] arg)如果不写void会有编译错误 如果不写static和[]会有运行错误 main()方法并不向操作系统返回“退出代码”。java中,如果main方法正常退出,Java程序的退出代码为0,表示成功地实行完毕程序。若要用不同的退出代码终止程序,则使用System.exit方法。 因为main()方法是可以重载的,所以返回类型可以void ,int ,boolean... 但如果从应用程序的入口main()方法的角度看,则只能用void返回。 4. main()方法及命令行参数相联系的若干注意 当缺少String[]args时,虽然编译可以通过,但是运行时无法获取有效的main方法,运行时候会报错。其中方法参数名字args可以改变。 要知道知道String数组长度,可以直接用args.length即可。 当没有用户参数的时候,如果进行args[0]等的访问,会抛出一个数组越界异常。

Java中的main()方法详解

Java中的main()方法详解 在Java中,main()方法是Java应用程序的入口方法,也就是说,程序在运行的时候,第一个执行的方法就是main()方法,这个方法和其他的方法有很大的不同,比如方法的名字必须是main,方法必须是public static void 类型的,方法必须接收一个字符串数组的参数等等。 在看Java中的main()方法之前,先看一个最简单的Java应用程序HelloWorld,我将通过这个例子说明Java类中main()方法的奥秘,程序的代码如下: /** * Java中的main()方法详解 */ public class HelloWorld { public static void main(String args[]) { System.out.println("Hello World!"); } } 一、先说类: HelloWorld 类中有main()方法,说明这是个java应用程序,通过JVM直接启动运行的程序。 既然是类,java允许类不加public关键字约束,当然类的定义只能限制为public或者无限制关键字(默认的)。 二、再说main()方法 这个main()方法的声明为:public static void main(String args[])。必须这么定义,这是Java的规范。 为什么要这么定义,和JVM的运行有关系。 当一个类中有main()方法,执行命令“java 类名”则会启动虚拟机执行该类中的main方法。

由于JVM在运行这个Java应用程序的时候,首先会调用main方法,调用时不实例化这个类的对象,而是通过类名直接调用因此需要是限制为public static。 对于java中的main方法,jvm有限制,不能有返回值,因此返回值类型为void。 main方法中还有一个输入参数,类型为String[],这个也是java的规范,main()方法中必须有一个入参,类细必须String[],至于字符串数组的名字,这个是可以自己设定的,根据习惯,这个字符串数组的名字一般和sun java规范范例中mian参数名保持一致,取名为args。 因此,main()方法定义必须是:“public static void main(String 字符串数组参数名[])”。 三、main()方法中可以throw Exception 因此main()方法中可以抛出异常,main()方法上也可以声明抛出异常。 比如,下面这个写法是正确的: public class TestMain { public static void main(String[] args) throws Exception { System.out.println("哈哈哈哈哈"); throw new Exception(""); } } 运行结果: 哈哈哈哈哈 Exception in thread "main" https://www.360docs.net/doc/259982362.html,ng.Exception: at maintest.TestMain.main(TestMain.java:11) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.jav a:39) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessor Impl.java:25) at https://www.360docs.net/doc/259982362.html,ng.reflect.Method.invoke(Method.java:585) at com.intellij.rt.execution.application.AppMain.main(AppMain.java:90) Process finished with exit code 1