Linux下的C编程程序源代码

hobby!

#include <stdio.h>



int getinput(void);

void printmessage(int counter,int input);



int main(void){

          int counter;

        int input;



        for(counter=0;counter<=200;counter++){

                  input=getinput();

                if(input==-1) end(0);

        printmessage(counter,input);

           }

        return0;

}



int getinput(void){

          int input;



        printf(“Enter an integer,or use –1 to exit:”);

        scanf(“%d”,&input);

        return input;

}



void printmessage(int counter,int input){  

          static int lastnum=0;

          counter++;

  

          printf(“For number %d ,you entered %d (%d more than last time)\n”,

                counter,input,input-lastnum);

          lastnum=input;

}

hobby!

#include <stdio.h>

#include <stdlib.h>

#include <string.h>



typedef struct TAG_datastruct{

          char* string;

        int checksum;

}datastruct;



datastruct* gerinput(void);

void printmessage(datastruct* todisp);



int main(void){

        int counter;

        int maxval=0;

        datastruct* svalues[200];



        for(counter=0;counter<200;counter++){

                  svalues[counter]=getinput();

                  if(!svalues[counter]) break;

                  maxval=counter;

        }



        printmessage(svalues[maxval/2]);



        return 0;

}



datastruct* getinput(void){

          char input[80];

        datastruct* instruct;

        int counter;



        printf(“Enter a string,or leave blank when done:”);

        fgets(input,79,stdin);

        input[strlen(input)-1]=0;

        if(strlen(input)==0)

                  return NULL;

        instruct=malloc(sizeof(datastruct));

        instruct->string=strdup(input);

        instruct->checksum=0;

        for(counter=0;counter<strlen(instruct->string);counter++){

                  instruct->checksum + =instruct->string[counter];

        }

        return instruct;

}



void printmessage(datastruct* todisp){

          printf(“This structure has a checksum of %d.  Its string is:\n”,

                   todisp->checksum);

          puts(todisp->string);

}

hobby!

#include <stdio.h>



int main(void){

          int counter;

        for(counter=0;counter<30;counter++){

                  if(counter%2==0){

                            printf(“Counter:%d\n”,counter);

                  }

        }

}

hobby!

#include <stdio.h>

#include <stdlib.h>

#include <string.h>



typedef struct TAG_datastruct{

          char* string;

        int checksum;

}datastruct;



datastruct* gerinput(void);

void printmessage(datastruct* todisp);



int main(void){

          int counter;

        int maxval=-1;

        datastruct* svalues[200];



        for(counter=0;counter<200;counter++){

                  svalues[counter]=getinput();

                  if(!svalues[counter]) break;

                  maxval=counter;

        }



        printmessage(svalues[maxval/2]);



        return 0;

}



datastruct* getinput(void){

          char input[80];

        datastruct* instruct;

        int counter;



        printf(“Enter a string,or leave blank when done:”);

        fgets(input,79,stdin);

        input[strlen(input)-1]=0;

        if(strlen(input)==0)

                  return NULL;

        instruct=malloc(sizeof(datastruct));

        instruct->string=strdup(input);

        instruct->checksum=0;

        for(counter=0;counter<strlen(instruct->string);counter++){

                  instruct->checksum + =instruct->string[counter];

        }

        return instruct;

}



void printmessage(datastruct* todisp){

          printf(“This structure has a checksum of %d.  Its string is:\n”,

                   todisp->checksum);

          puts(todisp->string);

}

hobby!

#include <stdio.h>

#include <stdlib.h>

#include <string.h>



typedef struct TAG_datastruct{

          char* string;

          int checksum;

}datastruct;



datastruct* getinput(void);

void printmessage(datastruct* todisp);



int main(void){

          int counter;

          int maxval=0;

          datastruct* svalues[200];



        for(counter=0;counter<200;counter++){

                    svalues[counter]=getinput();

                    if(!svalues[counter]) break;

                    maxval=counter;

          }



          printmessage(svalues[maxval*2]);



          return 0;

}



datastruct* getinput(void){

          char input[80];

          datastruct* instruct;

          int counter;



          printf(“Enter a string,or leave blank when done:”);

          fgets(input,79,stdin);

          input[strlen(input)-1]=0;

          if(strlen(input)==0)

                    return NULL;

          instruct=malloc(sizeof(datastruct));

          instruct->string=strdup(input);

          instruct->checksum=0;

          for(counter=0;counter<strlen(instruct->string);counter++){

                    instruct->checksum+=instruct->string[counter];

          }

          return instruct;

}



void printmessage(datastruct* todisp){

          printf(“This structure has a checksum of %d. Its string is:\n”,

                   todisp->checksum);

          puts(todisp->string);

}

hobby!

#include <stdio.h>

#include <stdlib.h>

#define BIGNUM 5000



void index_to_the _moon(int ary[ ]);



int main(void)

{

        int intary[10];

        int j;



        index_to_the_moon(intary);

        exit(EXIT_SUCCESS);

}



void index_to_the_moon(int ary[ ])

{

        int j;

        for(j=0;j<BIGNUM;++1)

                ary[j]=j;

}

hobby!

/*compute.c源程序的代码*/



extern int somegrobal;



int computer(void){

           return 5*somegrobal;

}



/*源程序init.c的代码*/



#include <stdio.h>

#include “myprogram.h”



int somegrobal=11;



int main(void){

           foo();

           return 0;

}



/*源文件io.c的代码*/



#include <stdio.h>

#include “myprogram.h”



int foo(void){

           printf(“The value is:%d.\n”,computer());

           return 1;

}



/*头文件myprogram.h的代码*/



int computer(void);

int foo(void);

hobby!

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

int write_open(const char *pathname, mode_t mode)

{

            int retval;

            if((retval=open(pathname, O_WRONLY|O_CREAT|O_TRUNC, mode)==-1))

        {

                printf("ERROR, OPEN FILE FAILED!\n");

                exit(254);

            }

            return retval;

}

main()

{

        write_open("abc",O_CREAT);

}

hobby!

#include <sys/types.h>

#include <sys/stat.h>

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <errno.h>

#include <unistd.h>

#include <fcntl.h>



#define NEWFILE (O_WRONLY|O_CREAT|O_TRUNC)

#define SIZE 80



int write_buffer(int fd, char *buf, int count);



int main(void)

{

            int outfile;

            char filename[ ]={"test.dat"};

        char buffer[SIZE];



        if(outfile=open(filename, NEWFILE, 0640)==-1)

        {

                    printf("ERROR, OPEN FILE FAILED! \n");

                    exit(255);

        }



        while(!strcmp(buffer,"quit"))

        {

                gets(buffer);

                if(write_buffer(outfile, buffer, SIZE)==-1)

                {

                        printf("ERROR,WRITE FAILED: \n",sys_errlist[errno]);

                        exit(255);

                }

            }

            close(outfile);

            return 0;

}





int write_buffer(int fd, char *buf, int count)

{

            int i,n;

        char write_buf[SIZE];

        int write_offset=0;

            for(i=0; i<count; ++i)

            {

                write_buf[write_offset++]=*buf++;

                if(write_offset==SIZE)

                {

                            write_offset=0;

                            n=write(fd, write_buf, sizeof(write_buf));



                            if(n!=SIZE)

                                return -1;

                 }

            }

        return -1;

}

hobby!

#include <sys/types.h>

#include <sys/stat.h>

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <errno.h>

#include <unistd.h>

#include <fcntl.h>



#define NEWFILE (O_WRONLY|O_CREAT|O_TRUNC)

#define BUFSIZE 1024

#define size 1



int my_read(int fd, char *buf, size_t count);

int my_write(int fd, char *bur, size_t count);



static char read_buf[BUFSIZE];

static int read_offset=BUFSIZE;

static int read_max=BUFSIZE;

static char write_buf[BUFSIZE];

static int write_offset=0;



int main(void)

{

            char infile[ ]={"test.dat"};

            char outfile[ ]={"backup.dat"};

            char buf[size];

        int infd, outfd, count;



        if(infd=open(infile, O_RDONLY)==-1)

        {

                    printf("ERROR, OPEN READ FILE FAILED: \n", sys_errlist[errno]);

                    exit(255);

        }

        if(outfd=open(outfile, NEWFILE, 0600)==-1)

        {

                    printf("ERROR, OPEN WRITE FILE FAILED: \n", sys_errlist[errno]);

                    exit(255);

        }

        while(count=read(infd,buf,sizeof(buf))>0)

        {

                    if(write(outfd, buf, count)!=count)

                    {

                        printf("ERROR, WRITE FILE FAILED: \n", sys_errlist[errno]);

                        exit(255);

                }

            }

        if(count==-1)

        {

                printf("ERROR, READ FILE FAILED: \n", sys_errlist[errno]);

                exit(255);

        }

        close(infd);

        if(write_offset>0)

        {

                    write(outfd, write_buf, write_offset);

                   write_offset=0;

        }

        close(outfd);

}





int my_read(int fd, char *buf, size_t count)

{

            int i;



            for(i=0; i<count; ++i)

            {

                if(read_offset==read_max)

                {

                            read_offset=0;

                            read_max=read(fd, read_buf, sizeof(read_buf));



                            if(!read_max)

                        return i;

                }

                *buf++=read_buf[read_offset++];

        }

        return i;

}





int my_write(int fd, char *buf, size_t count)

{

            int i,n;

            for(i=0; i<count; ++i)

            {

                write_buf[write_offset++]=*buf++;

                if(write_offset==BUFSIZE)

                {

                            write_offset=0;

                            n=write(fd, write_buf, sizeof(write_buf));



                            if(n!=BUFSIZE)

                                return -1;

                 }

            }

        return -1;

}

hobby!

#include <sys/types.h>

#include <sys/stat.h>

#include <stdio.h>

#include <stdlib.h>

#include <fcntl.h>

#include <errno.h>



#define NEWFILE (O_WRONLY|O_CREAT|O_TRUNC)



int main(void)

{

            char buf1[ ]={"abcdefghij"};

            char buf2[ ]={"1234567890"};

        int fd;

        int length;



        if(fd=open("test.hole", NEWFILE, 0600)==-1)

        {

                    printf("ERROR, OPEN WRITE FILE FAILED: \n", sys_errlist[errno]);

                    exit(255);

        }



        length=strlen(buf1);

            if(write(fd, buf1,length)!=length)

            {

                    printf("ERROR, OPEN WRITE FILE FAILED: \n", sys_errlist[errno]);

                    exit(255);

        }



            if(lseek(fd, 50, SEEK_SET)==-1)

            {

                    printf("ERROR, LSEEK FAILED: \n", sys_errlist[errno]);

                exit(255);

            }



        length=strlen(buf2);

            if(write(fd, buf2,length)!=length)

            {

                    printf("ERROR, OPEN WRITE FILE FAILED: \n", sys_errlist[errno]);

                    exit(255);

        }



        return 0;

}

hobby!

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>



int main(void)

{

            int stat(const char *pathname,struct stat *sbuf);



            if(open("temfile", O_RDWR)<0)

            {

                printf("open error!\n");

                exit(1);

            }



            if(unlink("tempfile")<0)

            {

                printf("unlink error");

                exit(1);

            }

            printf("file unlinked.\n");



            sleep(15);

            printf("done\n");



           exit(0);

}

hobby!

#include <sys/types.h>

#include <sys/stat.h>

#include <unistd.h>



int main(int argc,char *argv[])

{

            char symname[ ]={"mysym"};

            char buf[80];



            if(argc<2)

                       return 0;



            if(symlink(argv[1], symname)==-1)

            {

                printf("symlink error!\n");

                exit(1);

            }



            if(!readlink(symname, buf, sizeof(buf)))

            {

                printf("readlink error!\n");

                exit(1);

            }

            printf("name of symbol link: %s.\n", buf);

   

            exit(0);

}

hobby!

/*无主函数，只是应用四个子函数*/

#include <sys/types.h>

#include <sys/stat.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <fcntl.h>

#include <malloc.h>

#include <malloc.h>

#include <signal.h>

#include <errno.h>

#include <stdarg.h>



int safeopen(const char *pathname, int flags, mode_t mode)

{

        int retval;

               

        if(retval=open(pathname, flags, mode)==-1)

                HandleError(errno, "open", "open %s failed", pathname);



        return retval;

}

int safewrite(int fd, const void *buf, size_t count)

{

        int retval;

       

        if(retval=write(fd, buf, count)==-1)

                HandleError(errno, "write", "write %d byets to fd %d failed", (int)count, fd);



        return retval;

}





int saferead(int fd, void *buf, size_t count)

{

        int retval;

       

        if(retval=read(fd, buf, count)==-1)

                HandleError(errno, "read", "read %d bytes to fd %d failed", (int)count,fd);



        return retval;

}





int safeclose(int fd)

{

        int retval;

       

        if(retval=close(fd)==-1)

                HandleError(errno, "close", "Possible serious problem: colse fd %d failed", fd);



        return retval;

}





void HandleError(int ecode, const char *const caller, const char *fmt, ...)

{

        va_list fmtargs;

        struct sigaction sastruct;

        FILE *of=(SafeLibErrorDest)?SafeLibErrorDest:stderr;



        SafeLibErrorLoc=caller;

        SafeLibErrorno=ecode;



        va_start(fmtargs, fmt);

        fprintf(of, "***Error in %s:", caller);

        vfprintf(of, fmt, fmtargs);

        va_end(fmtargs);

        fprintf(of, "\n");

        if(ecode)

        {

                fprintf(of, "*** Error cause:%s \n", strerror(ecode));

        }

       

        sigaction(SIGUSR1, NULL, &sastruct);

        if(sastruct.sa_handler!=SIG_DFL)

        {

                raise(SIGUSR1);

        }

        else

        {

                exit(254);

        }

}

hobby!

#include<stdio.h>



main()

{

              char key;

        FILE *stream;                          /*流的指针*/



        printf("Please input a letter.\n");

        key=getchar();                        /*读入一个字符*/



        if (stream =fopen("test","r")==(FILE*)0)   /*将流与一个文件联系起来,

        并判断是否成功*/

        {

                      fprintf(stderr,"Error opening file.\n");

                    exit(1);

        }



/*将缓冲区设定为行缓冲,并判断是否成功*/

        if(setlinebuf(stream))!=0)

        {

                fprintf (stderr,"Error setlinebuffer .\n");

                exit(1);

              }



/*将对应的缓冲区清空,并判断操作是否成功*/

        if(fpurge(stream))==EOF)

        {

                fprintf(stderr,"Error flush stream.\n");

                exit(1);

              }



/*对流的读写操作*/

        fprintf(stream,"The letter that you input is %c.\n",key);



/*在程序结束前关闭流,并判断操作是否成功*/

        if(fclose(stream))==EOF)

        {

                     fprintf(stderr,"Error closing file,\n");

                     exit(1);

        }

        exit(0);

}