精华内容
下载资源
问答
  • 其实在主函数中输入时,空格后还可以输入被调用函数中的参数*//*这样就避免了很多输出的麻烦,而且看着也比较的舒服:-)例如新建立一文件,就可以直接输入mf a.txt(注意,中间空格)就可以建立一文本文件了*/#...
    /*调用函数中的scanf前没有提示,其实在主函数中输入时,空格后还可以输入被调用函数中的参数*/
    /*这样就避免了很多输出的麻烦,而且看着也比较的舒服:-)例如新建立一个文件,就可以直接输入mf a.txt(注意,中间有空格)就可以建立一个文本文件了*/
    #include<stdio.h>
    #include<dir.h>
    #include<string.h>
    #include<conio.h>
    #include<errno.h>
    #include<dos.h>
    #include<io.h>
    #include<process.h>
    #define PRF printf
    char buffer[MAXPATH], str1[12];
    char file[MAXPATH];
    /*buffer用来存储工作目录, 定义为全局变量,在用cd..和cd命令有用*/
    makefile()/*建立一个新文件*/
    {
            int handle;
            scanf("%s", file);
            if(strcmp(file, "/?") == 0)
                    PRF("  mf newfilename");
            else
            {
                    handle = creatnew(file, 0);
                    if(handle == -1)
                            PRF("%s already exists./n", file);
                    else
                            PRF("%s successfully created./n", file);
            }
    }
    dir()/*列出当前的工作目录中的文件和目录*/
    {
            char para[6];
            scanf("%s", para);
            if(strcmp(para, "/?") == 0)
                    PRF("  dir [/b][/m][/p][|more]/n");
            else
                    if(strcmp(para, "/w") == 0)system("dir/w");
                    else if(strcmp(para, "/b") == 0)system("dir/b");
                    else if(strcmp(para, "|more") == 0)system("dir|more");
                    else if(strcmp(para, "/b|more") == 0)system("dir/b|more");
                    else if(strcmp(para, "/w|more") == 0)system("dir/w|more");
                    else if(strcmp(para, "/p") == 0)system("dir/p");
                    else PRF("'dir' have no '%s' parameter", para);
    }
    del()/*删除文件*/
    {
            struct ffblk ffblk; /*定义一个搜索文件的结构体*/
            int done, flag=0, i;
            scanf("%s", file);
            for(i=0; i<strlen(file); i++)
            if(file[i] == '?' || file[i] == '*')
            {
                    flag=1;
                    break;
            }
            if(strcmp(file, "/?") == 0)
                    PRF("  del filename    del *.extendname");
            else if(flag)/*删除一特定文件*/
            {
                    done=findfirst(file, &ffblk, 0);
                    while(!done)
                    {
                            remove(ffblk.ff_name); /*删除找到符合条件的文件*/
                            done=findnext(&ffblk);
                    }
                    PRF("All files that accord to your conditions were deleted!/n");
            }
            else
            {
                    if(remove(file) == 0)
                            PRF("Removed %s successfully!/n", file);
                    else
                            perror("remove"); /*perror()是c语言里的错误处理函数*/
            }
    }
    cd()/*进入选定目录*/
    {
            char dirname[MAXPATH];
            scanf("%s", dirname);
            if(strcmp(dirname, "/?") == 0)
                    PRF("  cd directoryname");
            else
            {
                    strcpy(buffer, dirname); /*将输入的目录名赋给buffer*/
                    if(chdir(buffer))/*更改工作目录*/
                            perror("chdir()");
                    getcwd(buffer, MAXPATH); /*用函数chdir()更改目录后,重新给buffer赋值,使其为当前目录*/
            }
    }
    cdup()/*返回到上层目录, 有点小问题拉*/
    {
            char str_1[MAXPATH], *p;
            int n;
            strcpy(str_1, buffer);
            n=strlen(str_1); /*n存储工作目录buffer字符串的长度*/
            p=str_1+n; /*使指针指向字符串的最后一个字符*/
            while((*p) != '//')
            p--;
            *p='/0'; /*在指针指向str_1的地方重新赋值*/
            strcpy(buffer, str_1);
            if(chdir(buffer))/*更改工作目录*/
                    perror("chdir()");
            getcwd(buffer, MAXPATH); /*用函数chdir()更改目录后,重新给buffer赋值,使其为当前目录*/
    }
    cls()/*清屏*/
    {
            clrscr();
    }
    ver()/*版本信息,纯属好玩:)*/
    {
            PRF("This programme is created by mabiqiang!/nVersion 1.0   2004-4-14");
    }
    type()/*显示文件内容*/
    {
            FILE *fp;
            struct ftime ft; /*文件被最后修改的时间日期信息*/
            char ch;
            int y; /*定义屏幕上横坐标x和纵坐标y*/
            scanf("%s", file);
            if(strcmp(file, "/?") == 0)
                    PRF("  type filename(include extend name)");
            else
            {
                    if((fp=fopen(file, "r")) == NULL)
                            PRF("cannot open %s", file);
                    while(!feof(fp))
                    {
                            ch=fgetc(fp);
                            PRF("%c", ch);
                            y=wherey(); /*取得当前的纵坐标值*/
                            if(y == 25)/*屏幕的高度是25行*/
                            {
                                    printf("/n--------more--------");
                                    /*当满屏显示后就暂停,直到用户按下任意键后,再继续显示以下的内容*/
                                    getch();
                                    clrscr();
                            }
                    }
                    PRF("/n/n   This file was modified at ");
                    getftime(fileno(fp), &ft); /*取得文件最后修改的时间日期信息*/
                    PRF("%u:%u:%u   ", ft.ft_hour, ft.ft_min, ft.ft_tsec*2);
                    PRF("%u/%u/%u/n", ft.ft_month, ft.ft_day, ft.ft_year+1980);
                    fclose(fp);
            }
    }
    edit()/*编辑一已存在的文件(其实不存在也没关系), 有一点小问题就是不能够修改,只能增加数据*/
    {
            FILE *fp;
            char ch1, ch2;
            scanf("%s", file);
            if(strcmp(file, "/?") == 0)
                    PRF("  edit filename(include extend name)");
            else
            {
                    if((fp=fopen(file, "a+")) == NULL)
                            PRF("cannot open %s", file);
                    while(!feof(fp))
                    {
                            ch1=fgetc(fp);
                            PRF("%c", ch1);
                    }
                    getchar(); /*清除缓存中的回车字符*/
                    ch2=getchar();
                    while(ch2 != '$')
                    {
                            fputc(ch2, fp);
                            ch2=getchar();
                    }
                    fclose(fp);
            }
    }
    copy()/*复制文件*/
    {
            FILE *in, *out;
            char ch, infile[MAXPATH], outfile[MAXPATH];
            scanf("%s", infile);
            scanf("%s", outfile);
            if((in=fopen(infile, "r")) == NULL)
                    PRF("cannot open %s", infile);
            if((out=fopen(outfile, "w+")) == NULL)
                    PRF("cannot open %s", outfile);
            while(!feof(in))
            fputc(fgetc(in), out);
            fclose(in);
            fclose(out);
            PRF("   1 files was copied!");
    }
    ren()/*改文件名*/
    {
            char oldname[MAXPATH], newname[MAXPATH];
            scanf("%s", oldname); /*原文件名*/
            scanf("%s", newname); /*新文件名*/
            if(rename(oldname, newname) == 0)
                    PRF("Renamed %s to %s successfully!/n", oldname, newname);
            else
                    perror("rename");
    }
    mdir()/*建立目录*/
    {
            int status;
            char dirname[MAXPATH];
            scanf("%s", dirname);
            if(strcmp(dirname, "/?") == 0)
                    PRF("  md directoryname/n");
            else
            {
                    status = mkdir(dirname);
                    (!status)?(PRF("Directory created successfully!/n")):(PRF("Unable to create directory/n"));
            }
    }
    rdir()/*删除目录*/
    {
            int status;
            char dirname[MAXPATH];
            scanf("%s", dirname);
            if(strcmp(dirname, "/?") == 0)
                    PRF("  rd directoryname/n");
            else
            {
                    status = rmdir(dirname);
                    (!status)?(PRF("Directory deleted successfully!/n")):(perror("Unable to delete directory"));
            }
    }
    date()/*打印当日的日期*/
    {
            struct date d;
            getdate(&d);
            PRF("   Today is %d-%d-%d", d.da_year, d.da_mon, d.da_day);
    }
    time()/*获取当前的时间*/
    {
            struct time t;
            gettime(&t);
            PRF("   The current time is:%2d:%02d:%02d", t.ti_hour, t.ti_min, t.ti_sec);
    }
    find()/*在当前目录下搜索指定的文件*/
    {
            char *p;
            struct ffblk ffblk;
            int done;
            scanf("%s", file);
            if(strcmp(file, "/?") == 0)
                    PRF("   find filename");
            else
            {
                    PRF("Directory listing of %s:/n", file);
                    done=findfirst(file, &ffblk, 0);
                    while(!done)
                    {
                            PRF("  %s/n", ffblk.ff_name);
                            done=findnext(&ffblk);
                    }
            }
    }
    change()/*更改驱动盘*/
    {
            int disk;
            switch(str1[0])/*将输入字符的第一个字符赋给disk,代表驱动盘*/
            {
            case 'a':
            case 'A':disk=0; break;
            case 'c':
            case 'C':disk=2; break;
            case 'd':
            case 'D':disk=3; break;
            case 'e':
            case 'E':disk=4; break;
            case 'f':
            case 'F':disk=5; break;
            case 'g':
            case 'G':disk=6; break;
            case 'h':
            case 'H':disk=7; break;
            }
            setdisk(disk); /*设置输入的为当前驱动盘*/
            getcwd(buffer, MAXPATH); /*获取当前驱动盘的目录*/
    }
    call()/*调用子程序并运行*/
    {
            int result;
            scanf("%s", file);
            result=spawnl(P_WAIT, file, NULL);
            if(result == -1)/*当调用错误的时候就终止程序*/
            {
                    perror("Error from spawnl");
                    exit(1);
            }
    }
    color()/*设置当前文本颜色*/
    {
            int txtcol;
            scanf("%d", &txtcol); ;
            textcolor(txtcol); /*设置文本颜色*/
            clrscr(); /*清屏后才能看到效果*/
    }
    link()/*将一个文件接到另一个文件的后面*/
    {
            FILE *fp1, *fp2;
            char ch1, ch2, file1[MAXPATH], file2[MAXPATH];
            scanf("%s", file1);
            scanf("%s", file2);
            if((fp1=fopen(file1, "r")) == NULL)
                    PRF("cannot open %s", file1);
            /*以a方式打开文件file2时,文件指针已经指向该文件的末尾,可以增加数据*/
            if((fp2=fopen(file2, "a")) == NULL)
                    PRF("cannot open %s", file2);
            while(!feof(fp1))
            fputc(fgetc(fp1), fp2);
            fclose(fp1);
            fclose(fp2);
            PRF("   Link %s to %s successfully!", file1, file2);
    }
    fc()/*比较两个文件*/
    {
            FILE *fp1, *fp2;
            char ch1, ch2, file1[MAXPATH], file2[MAXPATH];
            int flag=0;
            scanf("%s", file1);
            scanf("%s", file2);
            if((fp1=fopen(file1, "r")) == NULL)
                    PRF("cannot open %s", file1);
            if((fp2=fopen(file2, "r")) == NULL)
                    PRF("cannot open %s", file2);
            while(!feof(fp1) || !feof(fp2))/*当文件都没有结束的时候,依次比较,若有不同,则退出*/
            {
                    ch1=fgetc(fp1);
                    ch2=fgetc(fp2);
                    if(ch1 != ch2)
                    {
                            flag=1;
                            break;
                    }
            }
            fclose(fp1);
            fclose(fp2);
            (flag)?PRF("   Two fils are different!"):PRF("   Two fils are the same!");
    }
    /*这里可以写自己编写的命令函数*/
    help()/*帮助文件*/
    {
            PRF("   mf    used to creat a new text file/n");
            PRF("   dir   used to show all the files of current directory/n");
            PRF("   del   used to delete a already exist file/n");
            PRF("   cd    used to go to a new directory/n");
            PRF("   cd..  used to go to the directory upon this one/n");
            PRF("   cls   used to clean the screen/n");
            PRF("   ver   used to show the version of this programme/n");
            PRF("   type  used to show contents of a already exist file/n");
            PRF("   edit  used to edit a file and end with character '$'/n");
            PRF("   copy  used to copy a already exist file to another place/n");
            PRF("   ren   used to rename a already exist file/n");
            PRF("   md    used to make a new directory/n");
            PRF("   rd    used to delete a already exist and empty directory/n");
            PRF("   date  used to show today's date/n");
            PRF("   time  used to show today's time/n");
            PRF("   find  used to find a file's in current directory/n");
            PRF("   call  used to call a already exist programme and run it/n");
            PRF("   color used to change the text's color/n");
            PRF("   fc    used to compete two files/n");
            PRF("   link  used to copy a file's contents to another file/n");
            PRF("All orders can input with file's or directory's name without cls cd.. and ver/n");
            PRF("You can enter like this 'orders /?' for help/n");
    }
    main()
    {
            int flag; /*用于判断输入字符串和命令是否相等, 相等则返回零*/
            PRF("Copyright by MaBiQiang!2004-4-14/nYou can E-mail to me:mxbgq@sohu.com./n");
            getcwd(buffer, MAXPATH); /*取得当前工作目录*/
            PRF("%s>", buffer);
            while(strcmp(str1, "exit") != 0)
            {
                    scanf("%s", str1);
                    if(strcmp(str1, "?") == 0 || strcmp(str1, "help") == 0)
                            help();
                    else
                            if(strcmp(str1, "mf") == 0)flag=1; /*给flag赋不同的值,就执行不同的命令*/
                            else if(strcmp(str1, "dir") == 0)flag=2;
                            else if(strcmp(str1, "del") == 0)flag=3;
                            else if(strcmp(str1, "cd") == 0)flag=4;
                            else if(strcmp(str1, "cd..") == 0)flag=5;
                            else if(strcmp(str1, "cls") == 0)flag=6;
                            else if(strcmp(str1, "ver") == 0)flag=7;
                            else if(strcmp(str1, "type") == 0)flag=8;
                            else if(strcmp(str1, "edit") == 0)flag=9;
                            else if(strcmp(str1, "copy") == 0)flag=10;
                            else if(strcmp(str1, "ren") == 0)flag=11;
                            else if(strcmp(str1, "md") == 0)flag=12;
                            else if(strcmp(str1, "rd") == 0)flag=13;
                            else if(strcmp(str1, "date") == 0)flag=14;
                            else if(strcmp(str1, "time") == 0)flag=15;
                            else if(strcmp(str1, "find") == 0)flag=16;
                            else if(strcmp(str1, "A:") == 0 || strcmp(str1, "a:") == 0)flag=17;
                            else if(strcmp(str1, "C:") == 0 || strcmp(str1, "c:") == 0)flag=18;
                            else if(strcmp(str1, "D:") == 0 || strcmp(str1, "d:") == 0)flag=19;
                            else if(strcmp(str1, "E:") == 0 || strcmp(str1, "e:") == 0)flag=20;
                            else if(strcmp(str1, "F:") == 0 || strcmp(str1, "f:") == 0)flag=21;
                            else if(strcmp(str1, "G:") == 0 || strcmp(str1, "g:") == 0)flag=22;
                            else if(strcmp(str1, "H:") == 0 || strcmp(str1, "h:") == 0)flag=23;
                            else if(strcmp(str1, "call") == 0)flag=24;
                            else if(strcmp(str1, "color") == 0)flag=25;
                            else if(strcmp(str1, "fc") == 0)flag=26;
                            else if(strcmp(str1, "link") == 0)flag=27;
                            else if(strcmp(str1, "exit") == 0)break;
                            /*这里可以加入想要增加的命令,同上*/
                    else PRF("'%s' is not a effect order of this programme!/n", str1);
                           
                    switch(flag)/*根据输入调用命令行*/
                    {
                    case 1:makefile(); flag=0; break;
                    case 2:dir(); flag=0; break;
                    case 3:del(); flag=0; break;
                    case 4:cd(); flag=0; break;
                    case 5:cdup(); flag=0; break;
                    case 6:cls(); flag=0; break;
                    case 7:ver(); flag=0; break;
                    case 8:type(); flag=0; break;
                    case 9:edit(); flag=0; break;
                    case 10:copy(); flag=0; break;
                    case 11:ren(); flag=0; break;
                    case 12:mdir(); flag=0; break;
                    case 13:rdir(); flag=0; break;
                    case 14:date(); flag=0; break;
                    case 15:time(); flag=0; break;
                    case 16:find(); flag=0; break;
                    case 17:
                    case 18:
                    case 19:
                    case 20:
                    case 21:
                    case 22:
                    case 23:change(); flag=0; break;
                    case 24:call(); flag=0; break;
                    case 25:color(); flag=0; break;
                    case 26:fc(); flag=0; break;
                    case 27:link(); flag=0; break;
                            /*这里可以加入想要增加的命令的调用函数,同上*/
                    }
                    PRF("/n%s>", buffer);
            }
    }

    转载于:https://www.cnblogs.com/carekee/articles/2569779.html

    展开全文
  • 从学习C语言开始就一直写函数,那么你知道它的标准写法什么什么样吗?main函数,又称主函数,是程序执行的起点,我们平时写的main函数是什么样呢?所以说,其他的写法并不符合标准,...

    从学习C语言开始就一直写个一个函数,那么你知道它的标准写法什么什么样吗?

    main函数,又称主函数,是程序执行的起点,我们平时写的main函数是什么样呢?

    所以说,其他的写法并不符合标准,有些算是历史遗留有些算是编译器的扩展,还有些不知道从哪里生出来的。

    所以说了这么多,为了代码的通用可移植性,建议采用标准提供的形式,还是推荐使用标准文档中规定的这两种写法。如果一个函数确定无需传入任何参数,那么用void限定是一个不错的选择。

    所以说,你明白要怎么写main函数了吗?

    来源:C语言Plus

    展开全文
  • 其实在主函数中输入时,空格后还可以输入被调用函数中的参数*//*这样就避免了很多输出的麻烦,而且看着也比较的舒服:-)例如新建立一文件,就可以直接输入mf a.txt(注意,中间空格)就可以建立一文本文件了*/#...
    /*调用函数中的scanf前没有提示,其实在主函数中输入时,空格后还可以输入被调用函数中的参数*/
    /*这样就避免了很多输出的麻烦,而且看着也比较的舒服:-)例如新建立一个文件,就可以直接输入mf a.txt(注意,中间有空格)就可以建立一个文本文件了*/
    #include<stdio.h>
    #include<dir.h>
    #include<string.h>
    #include<conio.h>
    #include<errno.h>
    #include<dos.h>
    #include<io.h>
    #include<process.h>
    #define PRF printf
    char buffer[MAXPATH], str1[12];
    char file[MAXPATH];
    /*buffer用来存储工作目录, 定义为全局变量,在用cd..和cd命令有用*/
    makefile()/*建立一个新文件*/
    {
            int handle;
            scanf("%s", file);
            if(strcmp(file, "/?") == 0)
                    PRF("  mf newfilename");
            else
            {
                    handle = creatnew(file, 0);
                    if(handle == -1)
                            PRF("%s already exists./n", file);
                    else
                            PRF("%s successfully created./n", file);
            }
    }
    dir()/*列出当前的工作目录中的文件和目录*/
    {
            char para[6];
            scanf("%s", para);
            if(strcmp(para, "/?") == 0)
                    PRF("  dir [/b][/m][/p][|more]/n");
            else
                    if(strcmp(para, "/w") == 0)system("dir/w");
                    else if(strcmp(para, "/b") == 0)system("dir/b");
                    else if(strcmp(para, "|more") == 0)system("dir|more");
                    else if(strcmp(para, "/b|more") == 0)system("dir/b|more");
                    else if(strcmp(para, "/w|more") == 0)system("dir/w|more");
                    else if(strcmp(para, "/p") == 0)system("dir/p");
                    else PRF("'dir' have no '%s' parameter", para);
    }
    del()/*删除文件*/
    {
            struct ffblk ffblk; /*定义一个搜索文件的结构体*/
            int done, flag=0, i;
            scanf("%s", file);
            for(i=0; i<strlen(file); i++)
            if(file[i] == '?' || file[i] == '*')
            {
                    flag=1;
                    break;
            }
            if(strcmp(file, "/?") == 0)
                    PRF("  del filename    del *.extendname");
            else if(flag)/*删除一特定文件*/
            {
                    done=findfirst(file, &ffblk, 0);
                    while(!done)
                    {
                            remove(ffblk.ff_name); /*删除找到符合条件的文件*/
                            done=findnext(&ffblk);
                    }
                    PRF("All files that accord to your conditions were deleted!/n");
            }
            else
            {
                    if(remove(file) == 0)
                            PRF("Removed %s successfully!/n", file);
                    else
                            perror("remove"); /*perror()是c语言里的错误处理函数*/
            }
    }
    cd()/*进入选定目录*/
    {
            char dirname[MAXPATH];
            scanf("%s", dirname);
            if(strcmp(dirname, "/?") == 0)
                    PRF("  cd directoryname");
            else
            {
                    strcpy(buffer, dirname); /*将输入的目录名赋给buffer*/
                    if(chdir(buffer))/*更改工作目录*/
                            perror("chdir()");
                    getcwd(buffer, MAXPATH); /*用函数chdir()更改目录后,重新给buffer赋值,使其为当前目录*/
            }
    }
    cdup()/*返回到上层目录, 有点小问题拉*/
    {
            char str_1[MAXPATH], *p;
            int n;
            strcpy(str_1, buffer);
            n=strlen(str_1); /*n存储工作目录buffer字符串的长度*/
            p=str_1+n; /*使指针指向字符串的最后一个字符*/
            while((*p) != '//')
            p--;
            *p='/0'; /*在指针指向str_1的地方重新赋值*/
            strcpy(buffer, str_1);
            if(chdir(buffer))/*更改工作目录*/
                    perror("chdir()");
            getcwd(buffer, MAXPATH); /*用函数chdir()更改目录后,重新给buffer赋值,使其为当前目录*/
    }
    cls()/*清屏*/
    {
            clrscr();
    }
    ver()/*版本信息,纯属好玩:)*/
    {
            PRF("This programme is created by mabiqiang!/nVersion 1.0   2004-4-14");
    }
    type()/*显示文件内容*/
    {
            FILE *fp;
            struct ftime ft; /*文件被最后修改的时间日期信息*/
            char ch;
            int y; /*定义屏幕上横坐标x和纵坐标y*/
            scanf("%s", file);
            if(strcmp(file, "/?") == 0)
                    PRF("  type filename(include extend name)");
            else
            {
                    if((fp=fopen(file, "r")) == NULL)
                            PRF("cannot open %s", file);
                    while(!feof(fp))
                    {
                            ch=fgetc(fp);
                            PRF("%c", ch);
                            y=wherey(); /*取得当前的纵坐标值*/
                            if(y == 25)/*屏幕的高度是25行*/
                            {
                                    printf("/n--------more--------");
                                    /*当满屏显示后就暂停,直到用户按下任意键后,再继续显示以下的内容*/
                                    getch();
                                    clrscr();
                            }
                    }
                    PRF("/n/n   This file was modified at ");
                    getftime(fileno(fp), &ft); /*取得文件最后修改的时间日期信息*/
                    PRF("%u:%u:%u   ", ft.ft_hour, ft.ft_min, ft.ft_tsec*2);
                    PRF("%u/%u/%u/n", ft.ft_month, ft.ft_day, ft.ft_year+1980);
                    fclose(fp);
            }
    }
    edit()/*编辑一已存在的文件(其实不存在也没关系), 有一点小问题就是不能够修改,只能增加数据*/
    {
            FILE *fp;
            char ch1, ch2;
            scanf("%s", file);
            if(strcmp(file, "/?") == 0)
                    PRF("  edit filename(include extend name)");
            else
            {
                    if((fp=fopen(file, "a+")) == NULL)
                            PRF("cannot open %s", file);
                    while(!feof(fp))
                    {
                            ch1=fgetc(fp);
                            PRF("%c", ch1);
                    }
                    getchar(); /*清除缓存中的回车字符*/
                    ch2=getchar();
                    while(ch2 != '$')
                    {
                            fputc(ch2, fp);
                            ch2=getchar();
                    }
                    fclose(fp);
            }
    }
    copy()/*复制文件*/
    {
            FILE *in, *out;
            char ch, infile[MAXPATH], outfile[MAXPATH];
            scanf("%s", infile);
            scanf("%s", outfile);
            if((in=fopen(infile, "r")) == NULL)
                    PRF("cannot open %s", infile);
            if((out=fopen(outfile, "w+")) == NULL)
                    PRF("cannot open %s", outfile);
            while(!feof(in))
            fputc(fgetc(in), out);
            fclose(in);
            fclose(out);
            PRF("   1 files was copied!");
    }
    ren()/*改文件名*/
    {
            char oldname[MAXPATH], newname[MAXPATH];
            scanf("%s", oldname); /*原文件名*/
            scanf("%s", newname); /*新文件名*/
            if(rename(oldname, newname) == 0)
                    PRF("Renamed %s to %s successfully!/n", oldname, newname);
            else
                    perror("rename");
    }
    mdir()/*建立目录*/
    {
            int status;
            char dirname[MAXPATH];
            scanf("%s", dirname);
            if(strcmp(dirname, "/?") == 0)
                    PRF("  md directoryname/n");
            else
            {
                    status = mkdir(dirname);
                    (!status)?(PRF("Directory created successfully!/n")):(PRF("Unable to create directory/n"));
            }
    }
    rdir()/*删除目录*/
    {
            int status;
            char dirname[MAXPATH];
            scanf("%s", dirname);
            if(strcmp(dirname, "/?") == 0)
                    PRF("  rd directoryname/n");
            else
            {
                    status = rmdir(dirname);
                    (!status)?(PRF("Directory deleted successfully!/n")):(perror("Unable to delete directory"));
            }
    }
    date()/*打印当日的日期*/
    {
            struct date d;
            getdate(&d);
            PRF("   Today is %d-%d-%d", d.da_year, d.da_mon, d.da_day);
    }
    time()/*获取当前的时间*/
    {
            struct time t;
            gettime(&t);
            PRF("   The current time is:%2d:%02d:%02d", t.ti_hour, t.ti_min, t.ti_sec);
    }
    find()/*在当前目录下搜索指定的文件*/
    {
            char *p;
            struct ffblk ffblk;
            int done;
            scanf("%s", file);
            if(strcmp(file, "/?") == 0)
                    PRF("   find filename");
            else
            {
                    PRF("Directory listing of %s:/n", file);
                    done=findfirst(file, &ffblk, 0);
                    while(!done)
                    {
                            PRF("  %s/n", ffblk.ff_name);
                            done=findnext(&ffblk);
                    }
            }
    }
    change()/*更改驱动盘*/
    {
            int disk;
            switch(str1[0])/*将输入字符的第一个字符赋给disk,代表驱动盘*/
            {
            case 'a':
            case 'A':disk=0; break;
            case 'c':
            case 'C':disk=2; break;
            case 'd':
            case 'D':disk=3; break;
            case 'e':
            case 'E':disk=4; break;
            case 'f':
            case 'F':disk=5; break;
            case 'g':
            case 'G':disk=6; break;
            case 'h':
            case 'H':disk=7; break;
            }
            setdisk(disk); /*设置输入的为当前驱动盘*/
            getcwd(buffer, MAXPATH); /*获取当前驱动盘的目录*/
    }
    call()/*调用子程序并运行*/
    {
            int result;
            scanf("%s", file);
            result=spawnl(P_WAIT, file, NULL);
            if(result == -1)/*当调用错误的时候就终止程序*/
            {
                    perror("Error from spawnl");
                    exit(1);
            }
    }
    color()/*设置当前文本颜色*/
    {
            int txtcol;
            scanf("%d", &txtcol); ;
            textcolor(txtcol); /*设置文本颜色*/
            clrscr(); /*清屏后才能看到效果*/
    }
    link()/*将一个文件接到另一个文件的后面*/
    {
            FILE *fp1, *fp2;
            char ch1, ch2, file1[MAXPATH], file2[MAXPATH];
            scanf("%s", file1);
            scanf("%s", file2);
            if((fp1=fopen(file1, "r")) == NULL)
                    PRF("cannot open %s", file1);
            /*以a方式打开文件file2时,文件指针已经指向该文件的末尾,可以增加数据*/
            if((fp2=fopen(file2, "a")) == NULL)
                    PRF("cannot open %s", file2);
            while(!feof(fp1))
            fputc(fgetc(fp1), fp2);
            fclose(fp1);
            fclose(fp2);
            PRF("   Link %s to %s successfully!", file1, file2);
    }
    fc()/*比较两个文件*/
    {
            FILE *fp1, *fp2;
            char ch1, ch2, file1[MAXPATH], file2[MAXPATH];
            int flag=0;
            scanf("%s", file1);
            scanf("%s", file2);
            if((fp1=fopen(file1, "r")) == NULL)
                    PRF("cannot open %s", file1);
            if((fp2=fopen(file2, "r")) == NULL)
                    PRF("cannot open %s", file2);
            while(!feof(fp1) || !feof(fp2))/*当文件都没有结束的时候,依次比较,若有不同,则退出*/
            {
                    ch1=fgetc(fp1);
                    ch2=fgetc(fp2);
                    if(ch1 != ch2)
                    {
                            flag=1;
                            break;
                    }
            }
            fclose(fp1);
            fclose(fp2);
            (flag)?PRF("   Two fils are different!"):PRF("   Two fils are the same!");
    }
    /*这里可以写自己编写的命令函数*/
    help()/*帮助文件*/
    {
            PRF("   mf    used to creat a new text file/n");
            PRF("   dir   used to show all the files of current directory/n");
            PRF("   del   used to delete a already exist file/n");
            PRF("   cd    used to go to a new directory/n");
            PRF("   cd..  used to go to the directory upon this one/n");
            PRF("   cls   used to clean the screen/n");
            PRF("   ver   used to show the version of this programme/n");
            PRF("   type  used to show contents of a already exist file/n");
            PRF("   edit  used to edit a file and end with character '$'/n");
            PRF("   copy  used to copy a already exist file to another place/n");
            PRF("   ren   used to rename a already exist file/n");
            PRF("   md    used to make a new directory/n");
            PRF("   rd    used to delete a already exist and empty directory/n");
            PRF("   date  used to show today's date/n");
            PRF("   time  used to show today's time/n");
            PRF("   find  used to find a file's in current directory/n");
            PRF("   call  used to call a already exist programme and run it/n");
            PRF("   color used to change the text's color/n");
            PRF("   fc    used to compete two files/n");
            PRF("   link  used to copy a file's contents to another file/n");
            PRF("All orders can input with file's or directory's name without cls cd.. and ver/n");
            PRF("You can enter like this 'orders /?' for help/n");
    }
    main()
    {
            int flag; /*用于判断输入字符串和命令是否相等, 相等则返回零*/
            PRF("Copyright by MaBiQiang!2004-4-14/nYou can E-mail to me:mxbgq@sohu.com./n");
            getcwd(buffer, MAXPATH); /*取得当前工作目录*/
            PRF("%s>", buffer);
            while(strcmp(str1, "exit") != 0)
            {
                    scanf("%s", str1);
                    if(strcmp(str1, "?") == 0 || strcmp(str1, "help") == 0)
                            help();
                    else
                            if(strcmp(str1, "mf") == 0)flag=1; /*给flag赋不同的值,就执行不同的命令*/
                            else if(strcmp(str1, "dir") == 0)flag=2;
                            else if(strcmp(str1, "del") == 0)flag=3;
                            else if(strcmp(str1, "cd") == 0)flag=4;
                            else if(strcmp(str1, "cd..") == 0)flag=5;
                            else if(strcmp(str1, "cls") == 0)flag=6;
                            else if(strcmp(str1, "ver") == 0)flag=7;
                            else if(strcmp(str1, "type") == 0)flag=8;
                            else if(strcmp(str1, "edit") == 0)flag=9;
                            else if(strcmp(str1, "copy") == 0)flag=10;
                            else if(strcmp(str1, "ren") == 0)flag=11;
                            else if(strcmp(str1, "md") == 0)flag=12;
                            else if(strcmp(str1, "rd") == 0)flag=13;
                            else if(strcmp(str1, "date") == 0)flag=14;
                            else if(strcmp(str1, "time") == 0)flag=15;
                            else if(strcmp(str1, "find") == 0)flag=16;
                            else if(strcmp(str1, "A:") == 0 || strcmp(str1, "a:") == 0)flag=17;
                            else if(strcmp(str1, "C:") == 0 || strcmp(str1, "c:") == 0)flag=18;
                            else if(strcmp(str1, "D:") == 0 || strcmp(str1, "d:") == 0)flag=19;
                            else if(strcmp(str1, "E:") == 0 || strcmp(str1, "e:") == 0)flag=20;
                            else if(strcmp(str1, "F:") == 0 || strcmp(str1, "f:") == 0)flag=21;
                            else if(strcmp(str1, "G:") == 0 || strcmp(str1, "g:") == 0)flag=22;
                            else if(strcmp(str1, "H:") == 0 || strcmp(str1, "h:") == 0)flag=23;
                            else if(strcmp(str1, "call") == 0)flag=24;
                            else if(strcmp(str1, "color") == 0)flag=25;
                            else if(strcmp(str1, "fc") == 0)flag=26;
                            else if(strcmp(str1, "link") == 0)flag=27;
                            else if(strcmp(str1, "exit") == 0)break;
                            /*这里可以加入想要增加的命令,同上*/
                    else PRF("'%s' is not a effect order of this programme!/n", str1);
                           
                    switch(flag)/*根据输入调用命令行*/
                    {
                    case 1:makefile(); flag=0; break;
                    case 2:dir(); flag=0; break;
                    case 3:del(); flag=0; break;
                    case 4:cd(); flag=0; break;
                    case 5:cdup(); flag=0; break;
                    case 6:cls(); flag=0; break;
                    case 7:ver(); flag=0; break;
                    case 8:type(); flag=0; break;
                    case 9:edit(); flag=0; break;
                    case 10:copy(); flag=0; break;
                    case 11:ren(); flag=0; break;
                    case 12:mdir(); flag=0; break;
                    case 13:rdir(); flag=0; break;
                    case 14:date(); flag=0; break;
                    case 15:time(); flag=0; break;
                    case 16:find(); flag=0; break;
                    case 17:
                    case 18:
                    case 19:
                    case 20:
                    case 21:
                    case 22:
                    case 23:change(); flag=0; break;
                    case 24:call(); flag=0; break;
                    case 25:color(); flag=0; break;
                    case 26:fc(); flag=0; break;
                    case 27:link(); flag=0; break;
                            /*这里可以加入想要增加的命令的调用函数,同上*/
                    }
                    PRF("/n%s>", buffer);
            }
    }
     
    展开全文
  • C语言入门

    2017-02-08 12:33:35
    C语言入门一个C程序只有一个主函数,即main函数 函数体内的语句要明显缩进,通常以按一下Tab键为一个缩进 代码中所有符号均为英文半角符号标识符 C 语言规定,标识符可以是字母(A~Z,a~z)、数字(0~9)、...

    C语言入门

    一个C程序只有一个主函数,即main函数
    函数体内的语句要有明显缩进,通常以按一下Tab键为一个缩进
    代码中所有符号均为英文半角符号

    标识符
    C 语言规定,标识符可以是字母(A~Z,a~z)、数字(0~9)、下划线_组成的字符串,并且第一个字符必须是字母或下划线。在使用标识符时还有注意以下几点:
    (1)标识符的长度最好不要超过8位,因为在某些版本的C中规定标识符前8位有效,当两个标识符前8位相同时,则被认为是同一个标识符。
    (2)标识符是严格区分大小写的。例如Imooc和imooc 是两个不同的标识符。
    (3)标识符最好选择有意义的英文单词组成做到”见名知意”,不要使用中文。
    (4)标识符不能是C语言的关键字。想了解更多C语言关键字的知识,请查阅WIKI

    变量及赋值
    在定义中不允许连续赋值,如int a=b=c=5;是不合法的。

    基本数据类型

    格式化输出语句
    将各种类型的数据按照格式化后的类型及指定的位置从计算机上显示。
    printf(“输出格式符”,输出项)

    常量 值不发生改变的量称为常量
    C语言的常量可以分为直接常量和符号常量。
    直接常量也称为字面量,是可以直接拿来使用,无需说明的量,比如:
    • 整型常量:13、0、-13;
    • 实型常量:13.33、-24.4;
    • 字符常量:‘a’、‘M’
    • 字符串常量:”I love imooc!”
    下面的代码分别打印这四种直接常量:

    在C语言中,可以用一个标识符来表示一个常量,称之为符号常量。符号常量在使用之前必须先定义,其一般形式为:
    #define 标识符 常量值
    符号常量的标示符一般习惯使用大写字母,变量的标示符一般习惯使用小写字母,加以区分。下面是一个使用符号常量的小例子:

    运算结果为: 圆周率:3.140000
    注意:常量是不可改变的

    自动类型转化

    自动转换发生在不同数据类型运算时,在编译的时候自动完成。
    字节小的可以向字节大的自动转换,但字节大的不能向字节小的自动转换

    强制类型转化
    强制类型转换是通过定义类型转换运算来实现的。其一般形式为:
    (数据类型) (表达式)
    其作用是把表达式的运算结果强制转换成类型说明符所表示的类型,例如:

    输入结果:

    1、数据类型和表达式都必须加括号,如把(int)(x/2+y)写成(int)x/2+y则成了把x转换成int型之后再除2再与y相加了。
    2、转换后不会改变原数据的类型及变量值,只在本次运算中临时性转换。
    3、强制转换后的运算结果不遵循四舍五入原则

    算术运算符

    如果相除的两个数都是整数的话,则结果也为整数,小数部分省略,如8/3 = 2;而两数中有一个为小数,结果则为小数,如:9.0/2 = 4.500000。
    该运算只适合用两个整数进行取余运算,如:10%3 = 1;而10.0%3则是错误的;运算后的符号取决于被模数的符号,如(-10)%3 = -1;而10%(-3) = 1。
    自加与自减
    自增运算符为“++”,其功能是使变量的值自增1;自减运算符为“–”,其功能是使变量值自减1。
    复合赋值运算符
    在简单赋值符“=”之前加上其它运算符构成,例如+=、-=、*=、/=、%=。
    定义整型变量a并赋值为3,a += 5;这个算式就等价于a = a+5; 将变量a和5相加之后再赋值给a
    关系运算符

    逻辑运算符

    三目运算符
    表达式1 ? 表达式2 : 表达式3;
    运算符优先级比较

    分之结构 if语句

    if else 语句

    多支结构之多重if else 语句

    当某一条件为真的时候,则不会向下执行该分支结构的其他语句。
    分支结构之嵌套if else 语句

    循环结构之while循环

    其中表达式表示循环条件,执行代码块为循环体。while语句的语义是:计算表达式的值,当值为真(非0)时, 执行循环体代码块。
    使用while语句应注意以下几点:
    1、while语句中的表达式一般是关系表达或逻辑表达式,当表达式的值为假时不执行循环体,反之则循环体一直执行。
    2、一定要记着在循环体中改变循环变量的值,否则会出现死循环(无休止的执行)。
    3、循环体如果包括有一个以上的语句,则必须用{}括起来,组成复合语句。
    循环结构之do while 循环

    do-while循环语句的语义是:它先执行循环中的执行代码块,然后再判断while中表达式是否为真,如果为真则继续循环;如果为假,则终止循环。
    循环结构之for循环

    它的执行过程如下:
    第一步:执行表达式1,对循环变量做初始化;
    第二步:判断表达式2,若其值为真(非0),则执行for循环体中执行代码块,然后向下执行;若其值为假(0),则结束循环;
    第三步:执行表达式3;
    第四步:执行for循环中执行代码块后执行第二步;
    第五步:循环结束,程序继续向下执行。

    在for循环中,表达式1是一个或多个赋值语句,它用来控制变量的初始值;表达式2是一个关系表达式,它决定什么时候退出循环;表达式3是循环变量的步进值,定义控制循环变量每循环一次后按什么方式变化。这三部分之间用分号(;)分开。
    使用for语句应该注意:
    1、for循环中的“表达式1、2、3”均可可以缺省,但分号(;)不能缺省。
    2、省略“表达式1(循环变量赋初值)”,表示不对循环变量赋初始值。如:

    使用for语句应该注意:
    1、for循环中的“表达式1、2、3”均可可以缺省,但分号(;)不能缺省。
    2、省略“表达式1(循环变量赋初值)”,表示不对循环变量赋初始值。如:

    3、省略“表达式2(循环条件)”,不做其它处理,循环一直执行(死循环)。如:

    4、省略“表达式3(循环变量增量)”,不做其他处理,循环一直执行(死循环)。如:

    注:死循环可以使用后面即将讲到的break解决
    5、表达式1可以是设置循环变量的初值的赋值表达式,也可以是其他表达式。如:

    6、表达式1和表达式3可以是一个简单表达式也可以是多个表达式以逗号分割。如:

    运行结果为
    7、表达式2一般是关系表达式或逻辑表达式,但也可是数值表达式或字符表达式,只要其值非零,就执行循环体。

    8、各表达式中的变量一定要在for循环之前定义。如:

    输出所有水仙花数字。
    所谓“水仙花数”是指一个三位数,其各位数字立方和等于该数,如:153就是一个水仙花数,153=1*1*1+5*5*5+3*3*3。

    while do while for三种循环比较
    while、do-while和for三种循环在具体的使用场合上是有区别的,如下:
    1、在知道循环次数的情况下更适合使用for循环;
    2、在不知道循环次数的情况下适合使用while或者do-while循环,如果有可能一次都不循环应考虑使用while循环,如果至少循环一次应考虑使用do-while循环。

    循环结构之多重循环

    使用for循环打印99乘法表

    结束语句之break语句

    1、在没有循环结构的情况下,break不能用在单独的if-else语句中。
    2、在多层循环中,一个break语句只跳出当前循环
    结束语句之continue语句

    运行结果:

    continue语句的作用是结束本次循环开始执行下一次循环。
    break语句与continue语句的区别是:break是跳出当前整个循环,continue结束本次循环开始下一次循环
    分支结构之switch语句

    在使用switch语句时还应注意以下几点:
    1、在case后的各常量表达式的值不能相同,否则会出现错误。
    2、在case子句后如果没有break;会一直往后执行一直到遇到break;才会跳出switch语句。

    运行结果: 学英语学C语言好好休息
    3、switch后面的表达式语句只能是整型或者字符类型。
    4、在case后,允许有多个语句,可以不用{}括起来。
    5、各case和default子句的先后顺序可以变动,而不会影响程序执行结果。
    6、default子句可以省略不用

    goto语句 无条件分支语句
    goto 语句标号
    其中语句标号是一个标识符,该标识符一般用英文大写并遵守标识符命名规则,这个标识符加上一个“:”一起出现在函数内某处,执行goto语句后,程序将跳转到该标号处并执行其后的语句。
    goto语句通常不用,主要因为它将使程序层次不清,且不易读,但在特定情况下,可以使用goto语句来提高程序的执行速度,所以还是少用为妙。

    自创函数

    注意:
    1、[]包含的内容可以省略,数据类型说明省略,默认是int类型函数;参数省略表示该函数是无参函数,参数不省略表示该函数是有参函数;
    2、函数名称遵循标识符命名规范;
    3、自定义函数尽量放在main函数之前,如果要放在main函数后面的话,需要在main函数之前先声明自定义函数,声明格式为:[数据类型说明] 函数名称([参数]);

    函数调用
    函数名(参数)
    1、对无参函数调用的时候可以将[]包含的省略。
    2、[]中可以是常数,变量或其它构造类型数据及表达式,个参数之间用逗号分隔。

    有参与无参函数

    在该例子中,我们不难发现有参函数更为灵活,输出的图形可以随着n的改变而随意变动,只要在main函数中传递一个参数就可以了;而在无参函数中输出的相对就比较固定,当需要改动的时候还需要到自定义的方法内改变循环变量的值
    形参与实参
    形参是在定义函数名和函数体的时候使用的参数,目的是用来接收调用该函数时传入的参数,实参是在调用时传递该函数的参数
    形参只有在被调用时才分配内存单元,在调用结束时,即刻释放所分配的内存单元。因此,形参只有在函数内部有效。函数调用结束返回主调函数后则不能再使用该形参变量。
    实参可以是常量、变量、表达式、函数等,无论实参是何种类型的量,在进行函数调用时,它们都必须具有确定的值,以便把这些值传送给形参。因此应预先用赋值等办法使实参获得确定值。
    在参数传递时,实参和形参在数量上,类型上,顺序上应严格一致,否则会发生类型不匹配”的错误。

    函数的返回值
    函数被调用之后,执行函数体中的程序段所取得的并返回给主调函数的值
    函数的返回值要注意以下几点:
    1. 函数的值只能通过return语句返回主调函数。return语句的一般形式为:
    return 表达式 或者为: return (表达式);
    2. 函数值的类型和函数定义中函数的类型应保持一致。如果两者不一致,则以函数返回类型为准,自动进行类型转换。
    就如小刚说选A,那么就返回一个字符型数据,用代码表示就是:

    小刚说值为100,那么就返回一个整型数据,用代码表示就是:

    1. 没有返回值的函数,返回类型为void。如果小刚算了一会没有返回结果的话,那么用代码表示就是:

    注意:void函数中可以有执行代码块,但是不能有返回值,另void函数中如果有return语句,该语句只能起到结束函数运行的功能。其格式为:return;
    递归函数
    递归就是一个函数在它的函数体内调用它自身。执行递归函数将反复调用其自身,每调用一次就进入新的一层

    递归函数特点:
    1. 每一级函数调用时都有自己的变量,但是函数代码并不会得到复制,如计算5的阶乘时每递推一次变量都不同;
    2. 每次调用都会有一次返回,如计算5的阶乘时每递推一次都返回进行下一次;
    3. 递归函数中,位于递归调用前的语句和各级被调用函数具有相同的执行顺序;
    4. 递归函数中,位于递归调用后的语句的执行顺序和各个被调用函数的顺序相反;
    5. 递归函数中必须有终止语句。
    一句话总结递归:自我调用且有完成状态
    局部变量与全局变量

    变量储存类别
    静态存储方式:是指在程序运行期间分配固定的存储空间的方式。静态存储区中存放了在整个程序执行过程中都存在的变量,如全局变量。
    动态存储方式:是指在程序运行期间根据需要进行动态的分配存储空间的方式。动态存储区中存放的变量是根据程序运行的需要而建立和释放的,通常包括:函数形式参数;自动变量;函数调用时的现场保护和返回地址等。
    C语言中存储类别又分为四类:自动(auto)、静态(static)、寄存器的(register)和外部的(extern)。
    1、用关键字auto定义的变量为自动变量,auto可以省略,auto不写则隐含定为“自动存储类别”,属于动态存储方式。如:

    2、用static修饰的为静态变量,如果定义在函数内部的,称之为静态局部变量;如果定义在函数外部,称之为静态外部变量。如下为静态局部变量:

    注意:静态局部变量属于静态存储类别,在静态存储区内分配存储单元,在程序整个运行期间都不释放;静态局部变量在编译时赋初值,即只赋初值一次;如果在定义局部变量时不赋初值的话,则对静态局部变量来说,编译时自动赋初值0(对数值型变量)或空字符(对字符变量)。
    3、为了提高效率,C语言允许将局部变量得值放在CPU中的寄存器中,这种变量叫“寄存器变量”,用关键字register作声明。例如:

    注意:只有局部自动变量和形式参数可以作为寄存器变量;一个计算机系统中的寄存器数目有限,不能定义任意多个寄存器变量;局部静态变量不能定义为寄存器变量。
    4、用extern声明的的变量是外部变量,外部变量的意义是某函数可以调用在该函数之后定义的变量。如:

    内部函数与外部函数
    在C语言中不能被其他源文件调用的函数称谓内部函数 ,内部函数由static关键字来定义,因此又被称谓静态函数,形式为:
    static [数据类型] 函数名([参数])
    这里的static是对函数的作用范围的一个限定,限定该函数只能在其所处的源文件中使用,因此在不同文件中出现相同的函数名称的内部函数是没有问题的。
    在C语言中能被其他源文件调用的函数称谓外部函数 ,外部函数由extern关键字来定义,形式为:
    extern [数据类型] 函数名([参数])
    C语言规定,在没有指定函数的作用范围时,系统会默认认为是外部函数,因此当需要定义外部函数时extern也可以省略。
    数组
    一块连续的,大小固定并且里面的数据类型一致的内存空间叫数组。
    如何声明一个数组
    数据类型 数组名称[长度];
    数组只声明也不行啊,看一下数组是如何初始化的。说到初始化,C语言中的数组初始化是有三种形式的,分别是:
    1、 数据类型 数组名称[长度n] = {元素1,元素2…元素n};
    2、 数据类型 数组名称[] = {元素1,元素2…元素n};
    3、 数据类型 数组名称[长度n]; 数组名称[0] = 元素1; 数组名称[1] = 元素2; 数组名称[n] = 元素n+1;
    我们将数据放到数组中之后又如何获取数组中的元素呢?
    获取数组元素时: 数组名称[元素所对应下标];
    如:初始化一个数组 int arr[3] = {1,2,3}; 那么arr[0]就是元素1。
    注意:
    1、数组的下标均以0开始;
    2、数组在初始化的时候,数组内元素的个数不能大于声明的数组长度;
    3、如果采用第一种初始化方式,元素个数小于数组的长度时,多余的数组元素初始化为0;
    数组遍历时要注意以下几点:
    1、最好避免出现数组越界访问,循环变量最好不要超出数组的长度,比如:

    2、C语言的数组长度一经声明,长度就是固定,无法改变,并且C语言并不提供计算数组长度的方法。
    由于C语言是没有检查数组长度改变或者数组越界的这个机制,可能会在编辑器中编译并通过,但是结果就不能肯定了,因此还是不要越界或者改变数组的长度

    4、在声明数组后没有进行初始化的时候,静态(static)和外部(extern)类型的数组元素初始化元素为0,自动(auto)类型的数组的元素初始化值不确定
    数组的遍历
    用for循环遍历一个数组:

    数组遍历时要注意以下几点:
    1、最好避免出现数组越界访问,循环变量最好不要超出数组的长度,比如:

    2、C语言的数组长度一经声明,长度就是固定,无法改变,并且C语言并不提供计算数组长度的方法。
    由于C语言是没有检查数组长度改变或者数组越界的这个机制,可能会在编辑器中编译并通过,但是结果就不能肯定了,因此还是不要越界或者改变数组的长度
    数组作为函数参数
    数组可以由整个数组当作函数的参数,也可以由数组中的某个元素当作函数的参数:
    1、整个数组当作函数参数,即把数组名称传入函数中,例如:

    2、数组中的元素当作函数参数,即把数组中的参数传入函数中,例如:

    数组作为函数参数时注意以下事项:
    1、数组名作为函数实参传递时,函数定义处作为接收参数的数组类型形参既可以指定长度也可以不指定长度。
    2、数组元素作为函数实参传递时,数组元素类型必须与形参数据类型一致。
    数组排序 冒泡排序
    相邻元素两两比较,将较大的数字放在后面,直到将所有数字全部排序。

    数组的查找功能 通过遍历
    比如以下程序实现在指定数组中查找指定元素的功能,如果找到该元素返回该元素的下标,否则返回-1:

    字符串与数组
    字符串就是由多个字符组合而成的一段话。
    在C语言中,是没有办法直接定义字符串数据类型的,但是我们可以使用数组来定义我们所要的字符串。一般有以下两种格式:
    1、char 字符串名称[长度] = “字符串值”;
    2、char 字符串名称[长度] = {‘字符1’,’字符2’,…,’字符n’,’\0’};
    注意:
    1、[]中的长度是可以省略不写的;
    2、采用第2种方式的时候最后一个元素必须是’\0’,’\0’表示字符串的结束标志;
    3、采用第2种方式的时候在数组中不能写中文。
    在输出字符串的时候要使用:printf(“%s”,字符数组名字);或者puts(字符数组名字);。例如:

    运行结果为

    字符串函数
    常用的字符串函数如下:

    使用字符串函数注意以下事项:
    1、strlen()获取字符串的长度,在字符串长度中是不包括‘\0’而且汉字和字母的长度是不一样的。比如:

    2、strcmp()在比较的时候会把字符串先转换成ASCII码再进行比较,返回的结果为0表示s1和s2的ASCII码相等,返回结果为1表示s1比s2的ASCII码大,返回结果为-1表示s1比s2的ASCII码小,例如:

    3、strcpy()拷贝之后会覆盖原来字符串且不能对字符串常量进行拷贝,比如:

    4、strcat在使用时s1与s2指的内存空间不能重叠,且s1要有足够的空间来容纳要复制的字符串,如:

    多维数组
    多维数组的定义格式是:
    数据类型 数组名称[常量表达式1][常量表达式2]…[常量表达式n];
    例如: 这样定义了一个名称为num,数据类型为int的二维数组。其中第一个[3]表示第一维下标的长度,就像购物时分类存放的购物;第二个[3]表示第二维下标的长度,就像每个购物袋中的元素。
    我们可以把上面的数组看作一个3×3的矩阵,如下图:

    多维数组的初始化与一维数组的初始化类似也是分两种:
    1、数据类型 数组名称[常量表达式1][常量表达式2]…[常量表达式n] = {{值1,..,值n},{值1,..,值n},…,{值1,..,值n}};
    2、数据类型 数组名称[常量表达式1][常量表达式2]…[常量表达式n]; 数组名称[下标1][下标2]…[下标n] = 值;
    多维数组初始化要注意以下事项:
    1、采用第一种始化时数组声明必须指定列的维数。因为系统会根据数组中元素的总个数来分配空间,当知道元素总个数以及列的维数后,会直接计算出行的维数;
    2、采用第二种初始化时数组声明必须同时指定行和列的维数。
    二维数组定义的时候,可以不指定行的数量,但是必须指定列的数量
    多维数组的遍历
    多维数组也是存在遍历的,和一维数组遍历一样,也是需要用到循环。不一样的就是多维数组需要采用嵌套循环,如:遍历输出int num[3][3] = {{1,2,3},{4,5,6},{7,8,9}};

    注意:多维数组的每一维下标均不能越界

    展开全文
  • C语言书写规范

    2014-04-19 20:42:57
    所有C语言程序中必须叫做 main 的顶级大括号 被称为...C语言中指定英文单词作为关键字,它们各自各自的用途。 return 就是一关键字,它可以用来指定遗留数字。 return 关键字的另一作用是立刻结束
  • C语言中返回字符串函数,或者通过一函数改变主函数中某个字符串变量的值四种方式: 1。使用堆空间,返回申请的堆地址,注意释放 2。函数参数传递指针,返回该指针 3。返回函数内定义的静态变量(共享) 4。...
  • 通过前面的几个例子我们总结出了C语言程序的几个特点 一个C语言源程序可以由一个或多个源文件组成 每个源文件可由一个或多个函数组成 一个源程序不论由多少个文件组成都一个且只能一个main函数即主函数 ...
  •  目前最流行的C语言有以下种:  ?Microsoft C 或称 MS C  ?Borland Turbo C 或称 Turbo C  ?AT&T C  这些C语言版本不仅实现了ANSI C标准,而且在此基础上各自作了一些扩充,使之更加方便、完美。 面向对象...
  • C语言程序结构和语法规则一、C语言程序的基本结构下面通过几个简单的示例,介绍C语言程序的基本构成和书写格式,使读者对C语言程序一个基本的了解。在此基础上,再进一步了解C语言程序的语法和书写规则。【例1.1】...
  • C语言小知识2

    2019-12-07 23:54:50
    转眼几个月就过去了,学习C语言有几个月了,大一的第一个·学期也到了尾声,马上就要期末考试了,现在来作一些知识点的复习,希望期末能考一个好成绩。 一。函数 1,局部变量和全局变量。 在一个函数内部定义的...
  • C语言浙大教程

    2018-12-27 19:00:52
    为了让读者对 C 语言一个感性认识,我们首先看一下用 C 语言编写的几个简单程序。 例1-1 在屏幕上显示一个短句“Programming is fun!”。 源程序: 运行结果如下: 程序中的 main 被称为“主函数”,任何一个C...
  • C语言程序的结构特点

    2017-08-04 10:58:02
    通过前面的几个例子,我们总结出了C语言程序的几个特点: 一个C语言源程序可以由一个或多个源文件组成。 每个源文件可由一个或多个函数组成。 一个源程序不论由多少个文件组成,都一个且只能一个main函数,...
  • 我们经常在做“分而治之”的事情(多个.c文件): 1.main()里的代码太长了适合分成几个...有个主函数main.c,另外一个函数max.c(求最大值) #include&lt;stdio.h&gt; int max(int a,int b); int main(){ ...
  • 我的目的是想做一个判断一个数组里有几个负数的函数,按我的想法是这样的: ``` int isNegative(double *C_Z) { int i; int index=0; for(i=0;i;i++) { if(C_Z) { index++; } } ...
  • 5.判断当前位置是否有地雷,没有则出现数字(表示周围格子中有几个地雷) 6.打印新的地图 7.重复3~6步骤,直到踩雷游戏结束,或胜利。 8重新继续游戏或退出! 代码 主函数及游戏选择菜单 #include #include #...
  • C语言如何设计随机数

    千次阅读 2020-02-05 11:51:19
    有几个需要注意的点 用到了随机函数所以在头文件里加上 #include<math.h> c语言随机函数是伪随机数并不能真正的随机 在头文件加上 #include<time.h> 再在主函数里加上 srand(time(0)) 就可...
  • C语言程序设计习题

    2020-09-26 16:26:51
    3. 编写一print函数,输出一学生的成绩数组,该数组中5学生的数据记录,每记录包括num,name,score[3],用主函数输入这些记录,用print函数输出这些记录。4.在第3题的基础上,编写一input函数,用来输入5...
  • C语言-扫雷

    2020-02-04 15:18:49
    判断当前位置是否有地雷,没有则出现数字(表示周围格子中有几个地雷) 打印新的地图 重复3~6步骤,直到踩雷游戏结束,或胜利。 重新继续游戏或退出! 代码 主函数及游戏选择菜单 #include<...
  • C语言函数集(十二)

    千次阅读 2013-11-12 15:26:53
    main()主函数 每一C 程序都必须一main()函数, 可以根据自己的爱好把它放在程序的某个地方。有些程序员把它放在最前面, 而另一些程序员把它放在最后面, 无论放在哪个地方, 以下点说明都是适合的。 1. main() ...
  • C 语言程序的结构特点 通过前面的几个例子我们总结出了 C 语言程序的几个特点 一个 C 语言源程序可以由一个或多个源文件组成 每个源文件可由一个或多个函数组成 一个源程序不论由多少个文件组成都一个且只能一个...
  • 目前最流行的C语言有以下种: •Microsoft C 或称 MS C •Borland Turbo C 或称 Turbo C •AT&T C 这些C语言版本不仅实现了ANSI C标准,而且在此基础上各自作了一些扩充,使之更加方便、完美。 1.4 C语言的...
  • C语言学习笔记 - 函数

    2018-04-03 16:27:50
    在C程序中至少函数,即主函数main()。 函数声明告诉编译器函数的名称、返回类型和参数。函数定义提供了函数的实际主体。 定义函数 在C语言中,函数由函数头和函数体组成。主要是返回类型、函数名称、参数...
  • c语言关于在函数返回值的问题,在函数中的局部变量主要是在栈上开辟的,出了函数变量就被回收了,针对函数返回值得问题,给出下面几个比较具体的例子来说明:函数返回值是在函数中定义的局部变量这类型的返回值...
  • 随便点一个格子,会有一块,上面的数字就代表数字周围八个格子会有几个雷,是1他周围就只有1个雷,2就有两个雷,以此类推,直到找出全部没有雷的格子就算玩家赢。只要点到一个有雷的格子就判定玩家输。 了解了 机制...
  • 3.编写一函数print,打印一学生的成绩数组,该数组中5学生的数据记录,每记录包括num,name,score[3],用主函数输人这些记录,用print函数输出这些记录。4.在第3题的基础上,编写一函数input,用来输人5学生...
  • 卷积神经网络的C语言实现

    千次阅读 2020-01-10 22:45:19
    卷积神经网络的C语言实现 代码实现环境是vs2019,po主使用这个代码实现了lenet-5模型的向前传播过程。不过可以通过改变主函数中的参数来实现其他...第一部分是在python上做的分为以下几个步骤。 1.搭建模型以及训练...

空空如也

空空如也

1 2 3 4 5
收藏数 99
精华内容 39
关键字:

c语言有几个主函数

c语言 订阅