void main 和 int main的区别

void main 和int main的区别就是有无返回值啊

在int main 可以出现非int 类型的东西

我们在写代码时，一个函数要么有返回值，要么没有返回值，没有返回值就用void来表示。main函数同样的，在没有返回值时加个void 。

有的编译器必须main要有返回值int ，那就写成int main 。

至于什么时候需要哪种写法，不必有这种顾虑，你可以一律都写成int main ，然后在方法体中最后加个return 0 ；就行了，这样写法没有哪个编译器不通过的吧。

void main 和int main 在作用上其实没什么区别啊，只是有的严谨的编译器必须要main有int 返回值而已，这两种写法跟自定义的函数没任何关系。

一句话，以后楼主就写成int main 就行了

!函数返回值

函数返回值 int Count() { int i,j; i=100; j=200; return i+j; } 测试函数: void Test() { int k=Count(); printf("\n k[%d]\n"); } C/C++的函数返回值一般是放在寄存器eax里的，而不是在栈里。 你的这一句int k = Count()的汇编语句就是这样： mov [esp - 4], eax //eax里是300，esp - 4是局部变量k的位置 你可以在vc里做个实验： int add(int a, int b) { __asm { mov eax,a // 把参数1存入eax add eax,b // eax += 参数2, 结果在eax里 } } int main() { printf("%d\n", add(3, 4)); return 0; } 楼主需要了解下寄存器这一概念，我就不把C/C++函数的汇编代码给发出来了。 还有在汇编层面来看，函数的返回值根本就没有定论，函数可以通过多种方式返回。保存返回值在eax里只是C/C++的一个约定而已。

返回值可以放在栈里，但你在C的语言层面上可能做不到，其实随着函数的结束，mov esp, ebp这条指令过后，函数内部的局部变量就报废了。如果你之后没改变过栈的内容，你可以用栈来存返回值，但比起用寄存器来存储，存储和读取要慢的多。 自己突发奇想在vc下试了下用栈“返回”值，写了段代码： #include void __declspec(naked) __stdcall return_a_value() { int local; local = 1990; // 栈空间 __asm ret } int main() { int local = 1; return_a_value(); // 用栈返回值 printf("%d\n", local); return 0; } 汇编看c之一，简单函数调用 简单的函数调用，通过简单的函数调用反汇编可以清楚了解如下 1.栈到底是什么，如何操纵栈的？ 2.参数和临时变量是以什么形式在哪存放？ 3.如何传递返回值？ 举例： #include

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

C#多线程函数如何传参数和返回值

C#多线程函数如何传参数和返回值 提起多线程,不得不提起委托(delegates)这个概念. 我理解的委托就是具有同样参数和返回值的函数的集合. 比如 public delegate void MyDelegate(int arg); 就是这种形式的函数 void Myfuntion(int i); 的集合. 如何将一个函数加入委托的集合? MyDelegate dele = new MyDelegate(Myfuntion1); 再增加一个 dele += new MyDelegate(Myfuntion2); ... 委托函数 dele 就是具有整数参数和空返回值的函数 Myfuntion1,2的集合. 调用这个委托函数 dele(1); 就是逐个调用 Myfuntion1,2,... 一般线程函数的声明和启动 Thread t = new Thread(new ThreadStart(MyFunction)); t.Start(); 正是调用了没有参数和返回值的委托函数 ThreadStart 其中的参数MyFunction 是这个委托函数中的一员. 很明显这样无法传参数和返回值,那我们该怎么办? 答案就在委托的BeginInvoke() 方法上, BeginInvoke() 也是(异步)启动一个新线程. 例如 MyDelegate dele = new MyDelegate (MyFunction); dele.BeginInvoke(10,"abcd"); void MyFunction(int count, string str); 可以实现参数的传递. 如何收集线程函数的返回值? 与BeginInvoke 对应有个 EndInvoke 方法,而且运行完毕返回 IAsyncResult 类型的返回值.这样我们可以这样收集线程函数的返回值 MyDelegate dele = new MyDelegate (MyFunction); IAsyncResult ref = dele.BeginInvoke(10,"abcd"); ...

主函数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"; 就是这样子了。

函数的参数

如果把函数比喻成一台机器，那么参数就是原材料，返回值就是最终产品；函数的作用就是根据不同的参数产生不同的返回值。 函数的参数 在函数定义中出现的参数可以看做是一个占位符，它没有数据，只能等到函数被调用时接收传递进来的数据，所以称为形式参数，简称形参。 函数被调用时给出的参数包含了实实在在的数据，会被函数内部的代码使用，所以称为实际参数，简称实参。 形参和实参的功能是作数据传送，发生函数调用时，实参的值会传送给形参。 形参和实参有以下几个特点： 1) 形参变量只有在函数被调用时才会分配内存，调用结束后，立刻释放内存，所以形参变量只有在函数内部有效，不能在函数外部使用。 2) 实参可以是常量、变量、表达式、函数等，无论实参是何种类型的数据，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参，所以应该提前用赋值、输入等办法使实参获得确定值。 3) 实参和形参在数量上、类型上、顺序上必须严格一致，否则会发生“类型不匹配”的错误。

函数调用中发生的数据传送是单向的，只能把实参的值传送给形参，而不能把形参的值反向地传送给实参。因此在函数调用过程中，形参的值发生改变，而实参中的值不会变化。 【示例】计算1+2+3+...+(n-1)+n 的值。 1.#include 2.int sum(int n){ // 有参函数 3.int i; 4.for(i=n-1; i>=1; i--){ 5. n+=i; 6.} 7.printf("The inner n = %d\n",n); 8.return n; 9.} 10.int main(){ // 无参函数 11.int m, total; 12.printf("Input a number: "); 13.scanf("%d",&m); 14. total =sum(m); 15.printf("The outer m = %d \n", m); 16.printf("1+2+3+...+%d+%d = %d\n", m-1, m, total); 17.return0; 18.} 运行结果： Input a number: 100↙ The inner n = 5050 The outer m = 100

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

函数参数返回值总结

函数的参数、返回值总结 （一）参数 ◆函数分： 有参函数：函数名（实参列表） 无参函数：函数名（） ◆有参函数调用语句中的实参应与被调函数中的形参在个数、类型、顺序上一致。 ◆参数传递时，实参向形参一一对应进行单向的值传递。值：可是数值（变量或数 组元素）或数值的地址值（指针或数组名）。 （二）返回值 函数的返回值即为函数调用后的结果，可有如下返回结果的方法： （1）通过return语句返回一个值； （2）利用地址做参数返回一个或多个值； （3）利用全局变量返回一个或多个值。 （三）例 1、170页实验内容（1）：打印由正三角和倒三角组成的图形。 有一个参数，无返回值。实参向形参传递一个数值。 #include /* 有一个参数，无返回值的函数，打印正三角 */ void f1(int n) /* 形参只能是变量，用来接收实参传来的数值 */ { int i,j,k; for(k=1;k<=n;k++) {for(i=1;i<=10-k;i++) printf(" "); for(j=1;j<=k;j++) printf(" *"); printf("\n");} } /* 有一个参数，无返回值的函数，打印倒三角*/ void f2(int n) {int i,j,k; for(k=n;k>=1;k--) {for(i=1;i<=10-k;i++) printf(" "); for(j=1;j<=k;j++) printf(" *"); /*双引号内应为“空格加半角星号”*/ printf("\n");} } main() { int n; scanf("%d",&n);

关于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所示。

C语言函数说明与返回值

C语言函数说明与返回值 在学习C语言函数以前，我们需要了解什么是模块化程序设计方法。 人们在求解一个复杂问题时，通常采用的是逐步分解、分而治之的方法，也就是把一个大问题分解成若干个比较容易求解的小问题，然后分别求解。程序员在设计一个复杂的应用程序时，往往也是把整个程序划分为若干功能较为单一的程序模块，然后分别予以实现，最后再把所有的程序模块像搭积木一样装配起来，这种在程序设计中分而治之的策略，被称为模块化程序设计方法。 在C语言中，函数是程序的基本组成单位，因此可以很方便地用函数作为程序模块来实现C语言程序。 利用函数，不仅可以实现程序的模块化，程序设计得简单和直观，提高了程序的易读性和可维护性，而且还可以把程序中普通用到的一些计算或操作编成通用的函数，以供随时调用，这样可以大大地减轻程序员的代码工作量。 函数是C语言的基本构件，是所有程序活动的舞台。函数的一般形式是: type-specifier function_name(parameter list) parameter declarations { body of the function } 类型说明符定义了函数中return语句返回值的类型，该返回值可以是任何有效类型。如果没有类型说明符出现，函数返回一个整型值。参数表是一个用逗号分隔的变量表，当函数被调用时这些变量接收调用参数的值。一个函数可以没有参数，这时函数表是空的。但即使没有参数，括号仍然是必须要有的。参数说明段定义了其中参数的类型。

当一个函数没有明确说明类型时， C语言的编译程序自动将整型( i n t)作为这个函数的缺省类型，缺省类型适用于很大一部分函数。当有必要返回其它类型数据时，需要分两步处理: 首先，必须给函数以明确的类型说明符;其次，函数类型的说明必须处于对它的首次调用之前。只有这样，C编译程序才能为返回非整型的值的函数生成正确代码。 4.1.1 函数的类型说明 可将函数说明为返回任何一种合法的C语言数据类型。 类型说明符告诉编译程序它返回什么类型的数据。这个信息对于程序能否正确运行关系极大，因为不同的数据有不同的长度和内部表示。 返回非整型数据的函数被使用之前，必须把它的类型向程序的其余部分说明。若不这样做，C语言的编译程序就认为函数是返回整型数据的函数，调用点又在函数类型说明之前，编译程序就会对调用生成错误代码。为了防止上述问题的出现，必须使用一个特别的说明语句，通知编译程序这个函数返回什么值。下例示出了这种方法。 第一个函数的类型说明sum()函数返回浮点类型的数据。这个说明使编译程序能够对sum( ) 的调用产生正确代码。 函数类型说明语句的一般形式是: type_specifier function_name (; ) 即使函数使用形参，也不要将其写入说明句。若未使用类型说明语句，函数返回的数据类型可能与调用者所要求的不一致，其结果是难以预料的。如果两者同处于一个文件中，编译程序可以发现该错误并停止编译。如果不在同一个文件中，编译程序无法发现这种错误。类型检查仅在编译中进行，链接和运行时均不检查。因此，必须十分细心以确保绝不发生上

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函数的参数只能有两个，习惯上这两个参数写为argc和argv。因此，main函数的函数头可写为：main (argc,argv)Ｃ语言还规定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语言入门教程10(函数参数的传递和值的返回)

前面我们说的都是无参数无返回值的函数，实际程序中，我们经常使用到带参数有返回值的函数。 一、函数参数传递 1.形式参数和实际参数 函数的调用值把一些表达式作为参数传递给函数。函数定义中的参数是形式参数，函数的调用者提供给函数的参数叫实际参数。在函数调用之前，实际参数的值将被拷贝到这些形式参数中。 2.参数传递 先看一个例子： void a(int); /*注意函数声明的形式*/ main() { int num; scanf(%d,&num); a(num); /*注意调用形式*/ } void a(int num_back) /*注意定义形式*/ { printf(%d\n,num_back); } 在主函数中，先定义一个变量，然后输入一个值，在a()这个函数中输出。当程序运行a(num);这一步时，把num的值赋值给num_back，在运行程序过程中，把实际参数的值传给形式参数，这就是函数参数的传递。 形参和实参可能不只一个，如果多于一个时，函数声明、调用、定义的形式都要一一对应，不仅个数要对应，参数的数据类型也要对应。 void a(int,float); main() { int num1; float num2; scanf(%d,&num1); scanf(%f,&num2); a(num1,num2); } void a(int num1_back,float num2_back) { printf(%d,%f\n,num1_back,num2_back);

} 上面的例子中，函数有两个参数，一个是整型，一个是浮点型，那么在声明、调用、定义的时候，不仅个数要一样，类型也要对应。如果不对应，有可能使的编译错误，即使没错误，也有可能让数据传递过程中出现错误。 再看一个例子： void a(int); main() { int num; scanf(%d,&num); a(num); } void a(int num) { printf(%d\n,num); } 看上面的例子，形式参数和实际参数的标识符都是num，程序把实际参数num的值传递给形式参数num。有些人可能就不明白了，既然两个都是num，为什么还要传递呢？干脆这样不就行了吗： void a(); main() { int num; scanf(%d,&num); a(); } void a() { printf(%d\n,num); } 其实不然，这就要涉及到标识符作用域的问题。作用域的意思就是说，哪些变量在哪些范围内有效。一个标识符在一个语句块中声明，那么这个标识符仅在当前和更低的语句块中可见，在函数外部的其实地方不可见，其他地方同名的标识符不受影响，后面我们会系统讲解作用域的问题。在这儿你就要知道两个同名的变量在不同的函数中是互不干扰的。