Linux下的C编程

最新推荐文章于 2024-04-17 11:11:12 发布
最新推荐文章于 2024-04-17 11:11:12 发布
阅读量47 收藏
点赞数
文章标签： c/c++ 操作系统 shell

1、程序的编译、运行
2、进程
3、文件
4、时间
5、信号
6、消息
7、线程
8、网络

1、程序的编译、运行

简单的编译：gcc test.c

运行：./a.out


2、进程

复制代码 
#include <unistd.h>
#include <pwd.h>
#include <sys/types.h>
#include <stdio.h>
int main(int argc,char **argv) 
{ 
    pid_t my_pid,parent_pid; //进程id，进程的父进程id
    uid_t my_uid,my_euid;  //用户id，有效用户id
    gid_t my_gid,my_egid;  //组id，有效组id
    struct passwd *my_info;

    my_pid=getpid(); 
    parent_pid=getppid(); 
    my_uid=getuid(); 
    my_euid=geteuid(); 
    my_gid=getgid(); 
    my_egid=getegid(); 
    my_info=getpwuid(my_uid);

    printf("Process ID：%ld\n",my_pid); 
    printf("Parent ID ：%ld\n",parent_pid); 
    printf("User ID：%ld\n",my_uid); 
    printf("Effective User ID ：%ld\n",my_euid); 
    printf("Group ID ：%ld\n",my_gid); 
    printf("Effective Group ID ：%ld\n",my_egid)：

    if(my_info) 
    {
        printf("My Login Name：%s\n" ,my_info->pw_name); //登录名称
         printf("My Password：%s\n" ,my_info->pw_passwd); //登录口令
         printf("My User ID：%ld\n",my_info->pw_uid); //用户ID
        printf("My Group ID：%ld\n",my_info->pw_gid); //用户组ID
        printf("My Real Name：%s\n" ,my_info->pw_gecos); //用户的真名
         printf("My Home Dir：%s\n", my_info->pw_dir); //用户的目录
         printf("My Work Shell：%s\n", my_info->pw_shell); //用户的SHELL
    } 
}
复制代码

 

运行结果：

 

进程的创建

创建进程
#include <unistd.h>
pid_t fork();

阻塞进程
#include <sys/types.h>;
#include <sys/wait.h>;
pid_t wait(int *stat_loc);
pid_t waitpid(pid_t pid,int *stat_loc,int options);

新进程执行一个程序
#include <unistd.h>;
int execl(const char *path,const char *arg,...);
int execlp(const char *file,const char *arg,...);
int execle(const char *path,const char *arg,...);
int execv(const char *path,char *const argv[]);
int execvp(const char *file,char *const argv[]);

复制代码 
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <errno.h>
#include <math.h>
void main(void) 
{ 
    pid_t child; 
    int status; 
    printf("This will demostrate how to get child status\n"); 
    if((child=fork()) == -1) 
    { 
        printf("Fork Error：%s\n",strerror(errno)); 
        exit(1); 
    } 
    else if(child == 0) 
    { 
        int i; 
        printf("I am the child：%ld\n",getpid()); 
        for(i=0;i<1000000;i++) 
            sin(i); 
        i=5; 
        printf("I exit with %d\n",i); 
        exit(i); 
    } 
    while(((child=wait(&status)) == -1)&(errno == EINTR)); 
    if(child == -1) 
        printf("Wait Error：%s\n",strerror(errno)); 
    else if(!status) 
        printf("Child %ld terminated normally return status is zero\n", child); 
    else if(WIFEXITED(status)) 
        printf("Child %ld terminated normally return status is %d\n", child,WEXITSTATUS(status)); 
    else if(WIFSIGNALED(status))
        printf("Child %ld terminated due to signal %d znot caught\n", child,WTERMSIG(status));  
}
复制代码

 

后台进程

父进程创建一个子进程，子进程杀死父进程，信号处理所有的工作由子进程处理

复制代码 
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>

#define MAIL "/var/spool/mail/hoyt"  /* Linux  的默任个人的邮箱地址是 /var/spool/mail/用户的登录名 */
#define SLEEP_TIME 10 /* 睡眠 10 秒钟 */

main(void) 
{ 
    pid_t child; 
    if((child=fork())==-1) 
    { 
        printf("Fork Error：%s\n",strerror(errno)); 
        exit(1); 
    } 
    else if(child>0) 
    while(1); 
    if(kill(getppid(),SIGTERM)==-1) 
    { 
        printf("Kill Parent Error：%s\n",strerror(errno)); 
        exit(1);
    }
    { 
        int mailfd; 
        while(1) 
        { 
            if((mailfd=open(MAIL,O_RDONLY))!=-1) 
            { 
                fprintf(stderr,"%s","\007"); 
                close(mailfd); 
            }  
            sleep(SLEEP_TIME); 
        } 
    } 
}
复制代码

 

 

3、文件

 

文件的创建和读写

复制代码 
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <string.h>

#define BUFFER_SIZE 1024 
int main(int argc,char **argv) 
{ 
    int from_fd,to_fd; 
    int bytes_read,bytes_write; 
    char buffer[BUFFER_SIZE]; 
    char *ptr; 
    if(argc!=3) 
    { 
        fprintf(stderr,"Usage：%s fromfile tofile\n\a",argv[0]); 
        exit(1); 
    }
    /* 打开源文件 */ 
    if((from_fd=open(argv[1],O_RDONLY))==-1) 
    { 
        fprintf(stderr,"Open %s Error ：%s\n",argv[1],strerror(errno)); 
        exit(1); 
    } 
    /* 创建目的文件 */ 
    if((to_fd=open(argv[2],O_WRONLY|O _CREAT,S_IRUSR|S_IWUSR))==-1) 
    { 
        fprintf(stderr,"Open %s Error ：%s\n",argv[2],strerror(errno)); 
        exit(1); 
    } 
    /* 以下代码是一个经典的拷贝文件的代码 */ 
    while(bytes_read=read(from_fd,buffer,BUFFER_SIZE)) 
    { 
        /* 一个致命的错误发生了 */ 
        if((bytes_read==-1)&&(errno!=EINTR)) break; 
        else if(bytes_read>;0) 
        { 
            ptr=buffer; 
            while(bytes_write=write(to_fd,ptr,bytes_read)) 
            { 
                /* 一个致命错误发生了 */ 
                if((bytes_write==-1)&&(errno!=EINTR))break; 
                /* 写完了所有读的字节 */ 
                else if(bytes_write==bytes_read) break; 
                /* 只写了一部分,继续写 */ 
                else if(bytes_write>;0) 
                { 
                    ptr+=bytes_write; 
                    bytes_read-=bytes_write; 
                } 
            } 
            /* 写的时候发生的致命错误 */ 
            if(bytes_write==-1)break; 
        } 
    } 
    close(from_fd); 
    close(to_fd); 
    exit(0); 
}
复制代码

 

文件的属性

复制代码 
#include <unistd.h>int access(const char *pathname,int mode); 

#include <sys/stat.h> 
#include <unistd.h>int stat(const char *file_name,struct stat *buf); 
int fstat(int filedes,struct stat *buf); 
struct stat { 
    dev_t st_dev; /*  设备 */ 
    ino_t st_ino; /*  节点 */  
    mode_t st_mode; /* 模式 */ 
    nlink_t st_nlink; /*  硬连接 */ 
    uid_t st_uid; /*  用户ID */ 
    gid_t st_gid; /*  组ID */ 
    dev_t st_rdev; /*  设备类型 */ 
    off_t st_off; /* 文件字节数 */ 
    unsigned long st_blksize; /* 块大小 */ 
    unsigned long st_blocks; /*  块数 */ 
    time_t st_atime; /*  最后一次访问时间 */ 
    time_t st_mtime; /* 最后一次修改时间 */ 
    time_t st_ctime; /*  最后一次改变时间(指属性) */ 
};
复制代码

 

目录文件

头文件及库函数

复制代码 
#include <unistd.h>
char *getcwd(char *buffer,size_t size);

#include <dirent.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
int mkdir(const char *path,mode_t mode); 
DIR *opendir(const char *path); 
struct dirent *readdir(DIR *dir); 
void rewinddir(DIR *dir); 
off_t telldir(DIR *dir); 
void seekdir(DIR *dir,off_t off); 
int closedir(DIR *dir); 
struct dirent { 
long d_ino; 
off_t d_off; 
unsigned short d_reclen; 
char d_name[NAME_MAX+1]; /*  文件名称 */
复制代码
复制代码 
//举例
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <time.h>

static int get_file_size_time(const char *filename)
{ 
    struct stat statbuf; 
    if(stat(filename,&statbuf)==-1) 
    { 
        printf("Get stat on %s Error：%s\n", filename,strerror(errno)); 
        return(-1); 
    } 
    if(S_ISDIR(statbuf.st_mode))
        return(1); 
    if(S_ISREG(statbuf.st_mode)) 
        printf("%s size ：%ld bytes\tmodified at %s", filename,statbuf.st_size,ctime(&statbuf.st_mtime));  
    return(0); 
} 

int main(int argc,char **argv) 
{ 
    DIR *dirp; 
    struct dirent *direntp; 
    int stats; 
    if(argc!=2) 
    { 
        printf("Usage：%s filename\n\a",argv[0]); 
        exit(1); 
    } 
    if(((stats=get_file_size_time(argv[1]))==0)||(stats==-1))exit(1); 
    if((dirp=opendir(argv[1]))==NULL) 
    { 
        printf("Open Directory %s Error ：%s\n", argv[1],strerror(errno)); 
        exit(1); 
    } 
    while((direntp=readdir(dirp))!=NULL) 
        if(get_file_size_time(direntp-<d_name)==-1)break; 
    closedir(dirp); 
    exit(1); 
}
复制代码

 

管道文件

管道pipe

复制代码 
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/wait.h>

#define BUFFER 255 

int main(int argc,char **argv) 
{ 
    char buffer[BUFFER+1]; 
    int fd[2]; 
    if(argc!=2) 
    { 
        fprintf(stderr,"Usage：%s string\n\a",argv[0]); 
        exit(1); 
    } 
    if(pipe(fd)!=0) 
    { 
        fprintf(stderr,"Pipe Error ：%s\n\a",strerror(errno)); 
        exit(1); 
    } 
    if(fork()==0) 
    { 
        close(fd[0]); 
        printf("Child[%d] Write to pipe\n\a",getpid()); 
        snprintf(buffer,BUFFER,"%s",argv[1]); 
        write(fd[1],buffer,strlen(buffer)); 
        printf("Child[%d] Quit\n\a",getpid()); 
        exit(0); 
    } 
    else 
    { 
        close(fd[1]); 
        printf("Parent[%d] Read from pipe\n\a",getpid());
        memset(buffer,'\0',BUFFER+1); 
        read(fd[0],buffer,BUFFER); 
        printf("Parent[%d] Read：%s\n",getpid(),buffer); 
        exit(1); 
    } 
}
复制代码

重定向dup2

复制代码 
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>

#define BUFFER_SIZE 1024 

int main(int argc,char **argv) 
{ 
    int fd; 
    char buffer[BUFFER_SIZE]; 
    if(argc!=2) 
    { 
        fprintf(stderr,"Usage：%s outfilename\n\a",argv[0]); 
        exit(1); 
    } 
    if((fd=open(argv[1],O_WRONLY|O_CREAT|O_TRUNC,S_IRUSR|S_IWUSR))==-1) 
    { 
        fprintf(stderr,"Open %s Error ：%s\n\a",argv[1],strerror(errno)); 
        exit(1); 
    } 
    if(dup2(fd,STDOUT_FILENO)==-1) 
    { 
        fprintf(stderr,"Redirect Standard Out Error ：%s\n\a",strerror(errno)); 
        exit(1); 
    } 
    fprintf(stderr,"Now,please input string"); 
    fprintf(stderr,"(To quit use CTRL+D)\n"); 
    while(1)
    { 
        fgets(buffer,BUFFER_SIZE,stdin); 
        if(feof(stdin))break; 
        write(STDOUT_FILENO,buffer,strlen(buffer)); 
    } 
    exit(0); 
}
复制代码

 

4、时间

 

时间的表示

#include <time.h> 
time_t time(time_t *tloc); 
char *ctime(const time_t *clock);

时间的测量

复制代码 
#include <sys/time.h> 
#include <stdio.h>
#include <math.h>

void function() 
{ 
    unsigned int i,j; 
    double y; 
    for(i=0;i<1000;i++) 
        for(j=0;j<1000;j++) 
            y=sin((double)i); 
} 

main()
{ 
    struct timeval tpstart,tpend; 
    float timeuse; 
    gettimeofday(&tpstart,NULL); 
    function(); 
    gettimeofday(&tpend,NULL); 
    timeuse=1000000*(tpend.tv_sec-tpstart.tv_sec)+ 
    tpend.tv_usec-tpstart.tv_usec; 
    timeuse/=1000000; 
    printf("Used Time：%f\n",timeuse); 
    exit(0); 
}
复制代码

计时器

复制代码 
#include <sys/time.h>
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>

#define PROMPT " 时间已经过去了两秒钟\n\a"

char *prompt=PROMPT; 
unsigned int len; 

void prompt_info(int signo) 
{ 
    write(STDERR_FILENO,prompt,len); 
} 

void init_sigaction(void) 
{ 
    struct sigaction act; 
    act.sa_handler=prompt_info; 
    act.sa_flags=0; 
    sigemptyset(&act.sa_mask); 
    sigaction(SIGPROF,&act,NULL); 
}
 
void init_time() 
{ 
    struct itimerval value; 
    value.it_value.tv_sec=2; 
    value.it_value.tv_usec=0; 
    value.it_interval=value.it_value; 
    setitimer(ITIMER_PROF,&value,NULL); 
} 

int main() 
{ 
    len=strlen(prompt); 
    init_sigaction(); 
    init_time(); 
    while(1); 
    exit(0); 
}
复制代码

 

5、信号

#include <sys/types.h>
#include <signal.h>
#include <unistd.h>

int kill(pid_t pid,int sig);
kill系统调用负责向进程发送信号sig.
如果pid是正数,那么向信号sig被发送到进程pid.
如果pid等于 0, 那么信号sig被发送到所以和pid进程在同一个进程组的进程
如果pid等于-1,那么信号发给所有的进程表中的进程,除了最大的哪个进程号.
如果pid由于-1,和0 一样,只是发送进程组是-pid

int raise(int sig);
raise 系统调用向自己发送一个sig信号

unisigned int alarm(unsigned int seconds);
alarm 函数可以在seconds秒后向自己发送一个SIGALRM 信号

复制代码 
//常用的信号屏蔽函数
#include <signal.h>
int sigemptyset(sigset_t *set); 
int sigfillset(sigset_t *set); 
int sigaddset(sigset_t *set,int signo); 
int sigdelset(sigset_t *set,int signo); 
int sigismember(sigset_t *set,int signo); 
int sigprocmask(int how,const sigset_t *set,sigset_t *oset);
复制代码
复制代码 
#include <signal.h>
#include <stdio.h>
#include <math.h>
#include <stdlib.h>

int main(int argc,char **argv) 
{ 
    double y; 
    sigset_t intmask; 
    int i,repeat_factor; 
    if(argc!=2) 
    { 
        fprintf(stderr,"Usage：%s repeat_factor\n\a",argv[0]); 
        exit(1); 
    } 
    if((repeat_factor=atoi(argv[1]))<1)repeat_factor=10; 
    sigemptyset(&intmask); /*  将信号集合设置为空 */
    sigaddset(&intmask,SIGINT); /* 加入中断 Ctrl+C  信号*/ 
    while(1) 
    { 
        /* 阻塞信号,我们不希望保存原来的集合所以参数为NULL*/ 
        sigprocmask(SIG_BLOCK,&intmask,NULL); 
        fprintf(stderr,"SIGINT signal blocked\n"); 
        for(i=0;i<repeat_factor;i++)
            y=sin((double)i); 
        fprintf(stderr,"Blocked calculation is finished\n"); 
        /* 取消阻塞 */ 
        sigprocmask(SIG_UNBLOCK,&intmask,NULL); 
        fprintf(stderr,"SIGINT signal unblocked\n"); 
        for(i=0;i<repeat_factor;i++)
            y=sin((double)i); 
        fprintf(stderr,"Unblocked calculation is finished\n"); 
    } 
    exit(0); 
}
复制代码

sigaction 函数

复制代码 
#include <signal.h>; 
 
int sigaction(int signo,const struct sigaction *act,struct sigaction *oact); 
struct sigaction { 
    (*sa_handler)(int signo); 
    void (*sa_sigaction)(int siginfo_t *info,void *act); 
    sigset_t sa_mask; 
    int sa_flags; 
    void (*sa_restore)(void); 
}
复制代码
复制代码 
#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>

#define PROMPT " 你想终止程序吗?" 
char *prompt=PROMPT; 

void ctrl_c_op(int signo) 
{ 
    write(STDERR_FILENO,prompt,strlen(prompt)); 
} 

int main() 
{ 
    struct sigaction act; 
    act.sa_handler=ctrl_c_op; 
    sigemptyset(&act.sa_mask); 
    act.sa_flags=0; 
    if(sigaction(SIGINT,&act,NULL)<0) 
    { 
        fprintf(stderr,"Install Signal Action Error ：%s\n\a",strerror(errno)); 
        exit(1); 
    } 
    while(1); 
}
复制代码

 其他信号函数

复制代码 
#include <unistd.h>
#include <signal.h>
int pause(void); 
int sigsuspend(const sigset_t *sigmask); 

#include <sigsetjmp>
int sigsetjmp(sigjmp_buf  env,int val); 
void siglongjmp(sigjmp_buf  env,int val);
复制代码

实例

复制代码 
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <string.h>
#include <pwd.h>
#include <sys/types.h>
#include <sys/stat.h>

/* Linux  的默任个人的邮箱地址是 /var/spool/mail/ */ 
#define MAIL_DIR "/var/spool/mail/" 
/* 睡眠 10 秒钟 */ 
#define SLEEP_TIME 10 
#define MAX_FILENAME 255 
unsigned char notifyflag=1; 

long get_file_size(const char *filename) 
{ 
    struct stat buf; 
    if(stat(filename,&;buf)==-1) 
    { 
        if(errno==ENOENT) return 0; 
        else return -1; 
    } 
    return (long)buf.st_size;
}
 
void send_mail_notify(void) 
{ 
    fprintf(stderr,"New mail has arrived\007\n"); 
} 

void turn_on_notify(int signo) 
{ 
    notifyflag=1; 
} 

void turn_off_notify(int signo) 
{ 
    notifyflag=0; 
} 

int check_mail(const char *filename) 
{ 
    long old_mail_size,new_mail_size; 
    sigset_t blockset,emptyset; 
    sigemptyset(&;blockset); 
    sigemptyset(&;emptyset); 
    sigaddset(&;blockset,SIGUSR1); 
    sigaddset(&;blockset,SIGUSR2); 
    old_mail_size=get_file_size(filename); 
    if(old_mail_size<0)return 1; 
    if(old_mail_size>0) send_mail_notify(); 
    sleep(SLEEP_TIME); 
    while(1) 
    { 
        if(sigprocmask(SIG_BLOCK,&;blockset,NULL)<0) return 1; 
        while(notifyflag==0)
            sigsuspend(&;emptyset); 
        if(sigprocmask(SIG_SETMASK,&;emptyset,NULL)<0) return 1; 
        new_mail_size=get_file_size(filename); 
        if(new_mail_size>old_ma il_size) send_mail_notify(); 
        old_mail_size=new_mail_size; 
        sleep(SLEEP_TIME); 
    } 
} 

int main(void) 
{ 
    char mailfile[MAX_FILENAME]; 
    struct sigaction newact; 
    struct passwd *pw; 
    if((pw=getpwuid(getuid()))==NULL) 
    { 
        fprintf(stderr,"Get Login Name Error ：%s\n\a",strerror(errno)); 
        exit(1); 
    } 
    strcpy(mailfile,MAIL_DIR); 
    strcat(mailfile,pw->pw_name); 
    newact.sa_handler=turn_on_notify; 
    newact.sa_flags=0; 
    sigemptyset(&;newact.sa_mask); 
    sigaddset(&;newact.sa_mask,SIGUSR1); 
    sigaddset(&;newact.sa_mask,SIGUSR2); 
    if(sigaction(SIGUSR1,&;newact,NULL)<0) 
        fprintf(stderr,"Turn On Error ：%s\n\a",strerror(errno)); 
    newact.sa_handler=turn_off_notify; 
    if(sigaction(SIGUSR1,&;newact,NULL)<0) 
        fprintf(stderr,"Turn Off  Error ：%s\n\a",strerror(errno)); 
    check_mail(mailfile); 
    exit(0); 
}
复制代码

 

6、消息

POSIX 无名信号量函数：
#include <semaphore.h>
int sem_init(sem_t *sem,int pshared,unsigned int value);
int sem_destroy(sem_t *sem);
int sem_wait(sem_t *sem);
int sem_trywait(sem_t *sem);
int sem_post(sem_t *sem);
int sem_getvalue(sem_t *sem);

 

System V信号量

信号量的主要用途是保护临界资源(在一个时刻只被一个进程所拥有)

复制代码 
#include <stdio.h> 
#include <unistd.h> 
#include <limits.h> 
#include <errno.h> 
#include <string.h> 
#include <stdlib.h> 
#include <sys/stat.h> 
#include <sys/wait.h> 
#include <sys/ipc.h> 
#include <sys/sem.h> 

#define PERMS S_IRUSR|S_IWUSR 

void init_semaphore_struct(struct sembuf  *sem,int semnum, int semop,int semflg) 
{ 
    /* 初始话信号量结构 */
    sem->sem_num=semnum; 
    sem->sem_op=semop; 
    sem->sem_flg=semflg; 
} 

int del_semaphore(int semid) 
{ 
    /* 信号量并不随程序的结束而被删除,如果我们没删除的话(将1 改为0) 可以用ipcs 命令查看到信号量,用ipcrm 可以删除信号量的 */ 
    #if  1 
        return semctl(semid,0,IPC_RMID); 
    #endif 
}
 
int main(int argc,char **argv) 
{ 
    char buffer[MAX_CANON],*c; 
    int i,n; 
    int semid,semop_ret,status; 
    pid_t childpid; 
    struct sembuf  semwait,semsignal; 
    if((argc!=2)||((n=atoi(argv[1]))<1)) 
    { 
        fprintf(stderr,"Usage：%s number\n\a",argv[0]); 
        exit(1); 
    } 
    /* 使用 IPC_PRIVATE  表示由系统选择一个关键字来创建 */ 
    /* 创建以后信号量的初始值为 0 */ 
    if((semid=semget(IPC_PRIVATE,1,PERMS))==-1) 
    { 
        fprintf(stderr,"[%d] ：Acess Semaphore Error：%s\n\a",getpid(),strerror(errno)); 
        exit(1); 
    } 
    /* semwait 是要求资源的操作(-1) */ 
    init_semaphore_struct(&semwait,0,-1,0); 
    /* semsignal 是释放资源的操作(+1) */ 
    init_semaphore_struct(&semsignal,0,1,0); 
    /* 开始的时候有一个系统资源(一个标准错误输出) */ 
    if(semop(semid,&semsignal,1)==-1) 
    { 
        fprintf(stderr,"[%d] ：Increment Semaphore Error：%s\n\a",getpid(),strerror(errno)); 
        if(del_semaphore(semid)==-1) 
        fprintf(stderr,"[%d] ：Destroy Semaphore Error：%s\n\a",getpid(),strerror(errno)); 
        exit(1); 
    } 
    /* 创建一个进程链 */ 
    for(i=0;i<n;i++) 
        if(childpid=fork()) break; 
    sprintf(buffer,"[i=%d]-->[Process=%d]-->[Parent=%d]-->[Child=%d]\n",i,getpid(),getppid(),childpid); 
    c=buffer; 
    /* 这里要求资源,进入原子操作 */ 
    while(((semop_ret=semop(semid,&semwait,1))==-1)&&(errno==EINTR)); 
    if(semop_ret==-1) 
    { 
        fprintf(stderr,"[%d] ：Decrement Semaphore Error：%s\n\a", getpid(),strerror(errno)); 
    } 
    else 
    { 
        while(*c!='\0')fputc(*c++,stderr); 
        /* 原子操作完成,赶快释放资源 */ 
        while(((semop_ret=semop(semid,&semsignal,1))==-1)&&(errno==EINTR)); 
        if(semop_ret==-1) 
            fprintf(stderr,"[%d] ：Increment Semaphore Error：%s\n\a",getpid(),strerror(errno)); 
    } 
    /* 不能够在其他进程反问信号量的时候,我们删除了信号量 */ 
    while((wait(&status)==-1)&&(errno==EINTR)); 
    /* 信号量只能够被删除一次的 */ 
    if(i==1) 
        if(del_semaphore(semid)==-1) 
            fprintf(stderr,"[%d] ：Destroy Semaphore Error：%s\n\a", getpid(),strerror(errno)); 
    exit(0); 
}
复制代码

 

System V消息队列

复制代码 
//服务端 server.c 
#include <stdio.h> 
#include <string.h> 
#include <stdlib.h> 
#include <errno.h> 
#include <unistd.h> 
#include <sys/types.h> 
#include <sys/ipc.h> 
#include <sys/stat.h> 
#include <sys/msg.h> 

#define MSG_FILE "server.c" 
#define BUFFER 255 
#define PERM S_IRUSR|S_IWUSR 

struct msgtype { 
    long mtype; 
    char buffer[BUFFER+1]; 
}; 

int main() 
{ 
    struct msgtype msg; 
    key_t key; 
    int msgid;
    if((key=ftok(MSG_FILE,'a'))==-1) 
    { 
        fprintf(stderr,"Creat Key Error：%s\a\n",strerror(errno)); 
        exit(1); 
    } 
    if((msgid=msgget(key,PERM|IPC_CREAT|IPC_EXCL))==-1) 
    { 
        fprintf(stderr,"Creat Message Error ：%s\a\n",strerror(errno)); 
        exit(1); 
    } 
    while(1) 
    { 
        msgrcv(msgid,&msg,sizeof(struct msgtype),1,0); 
        fprintf(stderr,"Server Receive ：%s\n",msg.buffer); 
        msg.mtype=2; 
        msgsnd(msgid,&msg,sizeof(struct msgtype),0); 
    } 
    exit(0); 
}  


//客户端(client.c) 
#include <stdio.h> 
#include <string.h> 
#include <stdlib.h> 
#include <errno.h> 
#include <sys/types.h> 
#include <sys/ipc.h> 
#include <sys/msg.h> 
#include <sys/stat.h> 

#define MSG_FILE "server.c" 
#define BUFFER 255 
#define PERM S_IRUSR|S_IWUSR 

struct msgtype { 
    long mtype; 
    char buffer[BUFFER+1]; 
};
 
int main(int argc,char **argv) 
{ 
    struct msgtype msg; 
    key_t key; 
    int msgid; 
    if(argc!=2) 
    { 
        fprintf(stderr,"Usage：%s string\n\a",argv[0]); 
        exit(1); 
    } 
    if((key=ftok(MSG_FILE,'a'))==-1) 
    { 
        fprintf(stderr,"Creat Key Error：%s\a\n",strerror(errno)); 
        exit(1); 
    } 
    if((msgid=msgget(key,PERM))==-1) 
    { 
        fprintf(stderr,"Creat Message Error ：%s\a\n",strerror(errno)); 
        exit(1); 
    } 
    msg.mtype=1; 
    strncpy(msg.buffer,argv[1],BUFFER); 
    msgsnd(msgid,&msg,sizeof(struct msgtype),0); 
    memset(&msg,'\0',sizeof(struct msgtype)); 
    msgrcv(msgid,&msg,sizeof(struct msgtype),2,0); 
    fprintf(stderr,"Client receive ：%s\n",msg.buffer); 
    exit(0); 
}
复制代码

 System V共享内存

实现共享内存的几个函数：
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
int shmget(key_t key,int size,int shmflg);
void *shmat(int shmid,const void *shmaddr,int shmflg);
int shmdt(const void *shmaddr);
int shmctl(int shmid,int cm d,struct shmid_ds *buf);

复制代码 
#include <stdio.h> 
#include <string.h> 
#include <errno.h>
#include <unistd.h> 
#include <sys/stat.h> 
#include <sys/types.h> 
#include <sys/ipc.h> 
#include <sys/shm.h> 

#define PERM S_IRUSR|S_IWUSR 

int main(int argc,char **argv) 
{ 
    int shmid; 
    char *p_addr,*c_addr; 
    if(argc!=2) 
    { 
        fprintf(stderr,"Usage：%s\n\a",argv[0]); 
        exit(1); 
    } 
    if((shmid=shmget(IPC_PRIVATE,1024,PERM))==-1) 
    { 
        fprintf(stderr,"Create Share Memory Error ：%s\n\a",strerror(errno)); 
        exit(1); 
    } 
    if(fork()) 
    { 
        p_addr=shmat(shmid,0,0); 
        memset(p_addr,'\0',1024); 
        strncpy(p_addr,argv[1],1024); 
        exit(0); 
    } 
    else 
    { 
        c_addr=shmat(shmid,0,0); 
        printf("Client get %s",c_addr); 
        exit(0); 
    } 
}
复制代码

 

7、线程

线程相关处理函数：
#include <pthread.h>
int pthread_create(pthread_t *thread,pthread_attr_t *attr, void *(*start_routine)(void *),void *arg);
void pthread_exit(void *retval);
int pthread_join(pthread *thread,void **thread_return);

复制代码 
#include <stdio.h> 
#include <unistd.h> 
#include <stdlib.h> 
#include <string.h> 
#include <errno.h> 
#include <pthread.h> 
#include <dirent.h> 
#include <fcntl.h> 
#include <sys/types.h> 
#include <sys/stat.h> 
#include <sys/time.h> 

#define BUFFER 512 

struct copy_file { 
    int infile; 
    int outfile; 
}; 

void *copy(void *arg) 
{ 
    int infile,outfile; 
    int bytes_read,bytes_write,*bytes_copy_p; 
    char buffer[BUFFER],*buffer_p; 
    struct copy_file *file=(struct copy_file *)arg; 
    infile=file->infile; 
    outfile=file->outfile; 
    /* 因为线程退出时,所有的变量空间都要被释放,所以我们只好自己分配内存了 */
    if((bytes_copy_p=(int *)malloc(sizeof(int)))==NULL) 
        pthread_exit(NULL); 
    bytes_read=bytes_write=0; 
    *bytes_copy_p=0; 
    /* 还记得怎么拷贝文件吗 */ 
    while((bytes_read=read(infile,buffer,BUFFER))!=0) 
    { 
        if((bytes_read==-1)&&(errno!=EINTR))break; 
        else if(bytes_read>0) 
        { 
            buffer_p=buffer; 
            while((bytes_write=write(outfile,buffer_p,bytes_read))!=0) 
            { 
                if((bytes_write==-1)&&(errno!=EINTR))break; 
                else if(bytes_write==bytes_read)break; 
                else if(bytes_write>0) 
                { 
                    buffer_p+=bytes_write; 
                    bytes_read-=bytes_write; 
                } 
            } 
            if(bytes_write==-1)break; 
            *bytes_copy_p+=bytes_read; 
        } 
    }  
    close(infile); 
    close(outfile); 
    pthread_exit(bytes_copy_p); 
}
 
int main(int argc,char **argv) 
{ 
    pthread_t *thread; 
    struct copy_file *file; 
    int byte_copy,*byte_copy_p,num,i,j; 
    char filename[BUFFER]; 
    struct dirent **namelist; 
    struct stat filestat; 
    /* 得到当前路径下面所有的文件(包含目录)的个数 */ 
    if((num=scandir(".",&namelist,0,alphasort))<0) 
    { 
        fprintf(stderr,"Get File Num Error ：%s\n\a",strerror(errno)); 
        exit(1); 
    } 
    /* 给线程分配空间,其实没有必要这么多的 */ 
    if(((thread=(pthread_t *)malloc(sizeof(pthread_t)*num))==NULL)||((file=(struct copy_file *)malloc(sizeof(struct copy_file)*num))==NULL)) 
    { 
        fprintf(stderr,"Out Of  Memory!\n\a"); 
        exit(1); 
    }  
 
    for(i=0,j=0;i<num;i++) 
    { 
        memset(filename,'\0',BUFFER); 
        strcpy(filename,namelist->d_name); 
        if(stat(filename,&filestat)==-1) 
        { 
            fprintf(stderr,"Get File Information ：%s\n\a",strerror(errno)); 
            exit(1); 
        } 
        /* 我们忽略目录 */ 
        if(!S_ISREG(filestat.st_mode))continue; 
        if((file[j].infile=open(filename,O_RDONLY))<0) 
        { 
            fprintf(stderr,"Open %s Error ：%s\n\a",filename,strerror(errno)); 
            continue; 
        } 
        strcat(filename,".bak"); 
        if((file[j].outfile=open(filename,O_W RONLY|O_CREAT,S_IRUSR|S_IWUSR))<0) 
        { 
            fprintf(stderr,"Creat %s Error ：%s\n\a",filename,strerror(errno)); 
            continue; 
        } 
        /* 创建线程,进行文件拷贝 */ 
        if(pthread_create(&thread[j],NULL,copy,(void *)&file[j])!=0) 
            fprintf(stderr,"Create Thread[%d] Error ：%s\n\a",i,strerror(errno)); 
        j++; 
    }  
    byte_copy=0; 
    for(i=0;i<j;i++) 
    { 
        /* 等待线程结束 */ 
        if(pthread_join(thread,(void **)&byte_copy_p)!=0) 
        fprintf(stderr,"Thread[%d] Join Error ：%s\n\a",i,strerror(errno)); 
        else
        { 
            if(bytes_copy_p==NULL)continue; 
            printf("Thread[%d] Copy %d bytes\n\a",i,*byte_copy_p); 
            byte_copy+=*byte_copy_p; 
            /* 释放我们在 copy 函数里面创建的内存 */  
            free(byte_copy_p);  
        } 
    } 
    printf("Total Copy Bytes %d\n\a",byte_copy); 
    free(thread); 
    free(file); 
    exit(0); 
}
复制代码

 

8、网络

复制代码 
/*******  服务器程序 (server.c) ************/ 
#include <stdlib.h> 
#include <stdio.h> 
#include <errno.h> 
#include <string.h> 
#include <netdb.h> 
#include <sys/types.h> 
#include <netinet/in.h> 
#include <sys/socket.h>
 
int main(int argc, char *argv[]) 
{ 
    int sockfd,new_fd; 
    struct sockaddr_in server_addr; 
    struct sockaddr_in client_addr; 
    int sin_size,portnumber; 
    char hello[]="Hello! Are You Fine?\n"; 
    if(argc!=2) 
    { 
        fprintf(stderr,"Usage：%s portnumber\a\n",argv[0]); 
        exit(1); 
    } 
    if((portnumber=atoi(argv[1]))<0) 
    { 
        fprintf(stderr,"Usage：%s portnumber\a\n",argv[0]); 
        exit(1); 
    } 
    /* 服务器端开始建立 socket 描述符 */ 
    if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1) 
    { 
        fprintf(stderr,"Socket error ：%s\n\a",strerror(errno)); 
        exit(1); 
    } 
    /* 服务器端填充 sockaddr 结构 */ 
    bzero(&server_addr,sizeof(struct sockaddr_in)); 
    server_addr.sin_family=AF_INET; 
    server_addr.sin_addr.s_addr=htonl(INADDR_ANY); 
    server_addr.sin_port=htons(portnumber); 
    /* 捆绑 sockfd 描述符 */ 
    if(bind(sockfd,(struct sockaddr *)(& server_addr),sizeof(struct sockaddr))== -1) 
    { 
        fprintf(stderr,"Bind error ：%s\n\a",strerror(errno)); 
        exit(1); 
    } 
    /* 监听 sockfd 描述符 */ 
    if(listen(sockfd,5)==-1) 
    { 
        fprintf(stderr,"Listen error：%s\n\a",strerror(errno)); 
        exit(1); 
    } 
    while(1) 
    { 
        /* 服务器阻塞,直到客户程序建立连接 */ 
        sin_size=sizeof(struct sockaddr_in); 
        if((new_fd=accept(sockfd,(struct so ckaddr *)(&client_addr),&sin_size))==-1) 
        { 
            fprintf(stderr,"Accept error ：%s\n\a",strerror(errno)); 
            exit(1); 
        } 
        fprintf(stderr,"Server get connection from %s\n", inet_ntoa(client_addr.sin_addr)); 
        if(write(new_fd,hello,strlen(hello))==-1) 
        { 
            fprintf(stderr,"Write Error：%s\n",strerror(errno)); 
            exit(1); 
        } 
        /* 这个通讯已经结束 */ 
        close(new_fd); 
        /* 循环下一个 */ 
    } 
    close(sockfd); 
    exit(0); 
} 


/*******  客户端程序 client.c ************/ 
#include <stdlib.h> 
#include <stdio.h> 
#include <errno.h> 
#include <string.h> 
#include <netdb.h> 
#include <sys/types.h> 
#include <netinet/in.h> 
#include <sys/socket.h> 

int main(int argc, char *argv[]) 
{ 
    int sockfd; 
    char buffer[1024]; 
    struct sockaddr_in server_addr; 
    struct hostent *host; 
    int portnumber,nbytes; 
    if(argc!=3) 
    { 
        fprintf(stderr,"Usage：%s hostname portnumber\a\n",argv[0]); 
        exit(1); 
    } 
    if((host=gethostbyname(argv[1]))==NULL) 
    { 
        fprintf(stderr,"Gethostname error\n"); 
        exit(1); 
    } 
    if((portnumber=atoi(argv[2]))<0) 
    { 
        fprintf(stderr,"Usage：%s hostname portnumber\a\n",argv[0]); 
        exit(1); 
    } 
    /* 客户程序开始建立 sockfd描述符 */ 
    if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1) 
    { 
        fprintf(stderr,"Socket Error ：%s\a\n",strerror(errno)); 
        exit(1); 
    } 
    /* 客户程序填充服务端的资料 */ 
    bzero(&server_addr,sizeof(server_addr)); 
    server_addr.sin_family=AF_INET; 
    server_addr.sin_port=htons(portnumber); 
    server_addr.sin_addr=*((struct in_addr *)host->h_addr); 
    /* 客户程序发起连接请求 */ 
    if(connect(sockfd,(struct sockaddr *)(& server_addr),sizeof(struct sockaddr))==-1) 
    { 
        fprintf(stderr,"Connect Error ：%s\a\n",strerror(errno)); 
        exit(1); 
    } 
    /* 连接成功了 */
    if((nbytes=read(sockfd,buffer,1024))==-1) 
    { 
        fprintf(stderr,"Read Error：%s\n",strerror(errno)); 
        exit(1); 
    } 
    buffer[nbytes]='\0'; 
    printf("I have received ：%s\n",buffer); 
    /* 结束通讯 */ 
    close(sockfd); 
    exit(0); 
}
复制代码

 

完整版请参考： Linux操作系统下C语言编程入门

 

来源：http://www.cnblogs.com/JCSU/articles/3102260.html#a8

weixin_33834075
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Linux下C语言编程概述
01-19
Linux下的C语言程序设计与在其他环境中的C程序设计一样，主要涉及到编辑器、编译链接器、调试器及项目管理工具。 （1）编辑器 　Linux下的编辑器就如Windows下的word、记事本等一样，完成对所录入文字的编辑...
linux下c语言编程.doc
11-29
linux下c语言编程.doc
Linux下C编程
12-17
Linux下的C语言编程，可以当作参考文档看看，对初学或者工作一段时间的人有一定帮助。
Linux下c语言编程实验讲义.docx
12-19
Linux下c语言编程实验讲义.docx
Linux下C语言编程——时间概念.rar_Linux下C语言编程_c 计时器
09-24
Linux下C语言编程--时间概念，包括时间表示，时间测量，计时器的使用三部分内容。仅供参考。
C语言 | Leetcode C语言题解之第27题移除元素
m0_59237910的博客
04-14 422
C语言 | Leetcode C语言题解之第27题移除元素
lesson01:c++入门
2401_82494141的博客
04-11 945
定义命名空间，需使用namespace关键字，后面更着的是命名空间的名字（自定义的），然后接{}，花括号里写命名空间的成员（如变量，函数，类，甚至可以嵌套命名空间）。现在用命名空间解决一下上面的问题：原理：一个命名空间就定义了一个作用域，叫做命名空间域，命名空间中的内容都局限与命名空间中，与命名空间外的内容互不影响。
第十四届蓝桥杯c++b组
m0_74087709的博客
04-12 695
这里我们删除一个元素时，需要将它左右两边的元素都加上它的值，但是我们无法在优先队列随意修改元素，所以这里有一个技巧，先记录下来下标为x的元素更新后的值，先不急着更新优先队列，类似于线段树的懒标记，等到用到了才更新优先队列，当队头的值是最新的值的时候，那么说明更新过了，那么执行删除操作，否则，需要在优先队列中更新它的值。将字符为c1的位置都存储下来，然后枚举到字符为c2时，二分到最大的满足以c2结尾，c1开头的长度大于等于k的位置，然后该位置以及前面的c1都满足，作为对答案的贡献。
C++三大特性（1）——继承
mastershooter的博客
04-12 797
1.基类的private成员无论以什么方式继承，在派生类中都是不可见的，这里的不可见是指基类的私有成员虽然被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。2.基类的private成员在派生类中是不能被访问的，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就需要定义为protected，由此可以看出，protected限定符是因继承才出现的。
解决Dev-C++编译时不支持C++11特性的办法
Beau_Will的博客
04-11 160
Dev-C++的最新的编译器只能支持到C++14，如果想要使用C++17,C++20,C++2a，必须安装一个新的编译器，然后在Dev-C++中重新选择编译器，再按如下操作（只希望使用C++11或者C++14的也按如下操作）：
算法设计与分析实验报告c++实现(生命游戏、带锁的门、三壶谜题、串匹配问题、交替放置的碟子)
Obliviate的博客
04-11 669
1、 编写一个生命游戏： 规则如下：（或者网上找到更详细的规则） 一个人可以有8个邻居； 一个人若只有一个邻居，在下一代会孤独的死去； 若有2或3个邻居，在下一代依然活着； 若有4个或以上邻居，在下一代会因拥挤而死； 死去的人若有3个邻居，在下一代会复活； 所有的死去或复活都在下一代变化时同时发生。 2、 带锁的门： 在走廊上有n个带锁的门，从1到n依次编号。最初所有的门都是关着的。我们从门前经过n次，每次都从1号门开始。在第i次经过时（i = 1,2，..., n)我们改变i的整数倍号锁的状态；如果门是关
C++ //练习 12.14 编写你自己版本的用shared_ptr管理connection的函数。
Made in Code
04-17 175
【代码】C++ //练习 12.14 编写你自己版本的用shared_ptr管理connection的函数。
C++Book对象数组初始化
Ct314的博客
04-11 535
定义含5个Book对象的数组b，定义同时将b[0]~b[3]分别初始化为(1,10),(3,30),(5,50),(8,80)；void set(int _qu) //_qu赋值给qu，price为qu的10倍。//_qu赋值给qu，price为qu的10倍。已声明Book类，要求完成类中函数的定义，并编写main函数完成如下的功能。逆序输出对象数据成员qu * price的值，每个数据后带一个空格。根据输入的数据给b[4]的成员赋值；/* 请在这里填写答案 */
C++类和对象（四）——类的实现、const、explicit、static
m0_63596031的博客
04-13 487
将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。 也就是说，该操作是对this的改变，因为this是隐式传递的，如果不加const便可直接调用函数，有改变this的风险，属于权限放大，这是不被允许的，加了const后属于权限的平移
C++类和对象注意事项（上）（类的对象大小计算和this指针）
qq_45755259的博客
04-16 830
this指针存放位置：堆是malloc出来的，静态区存放静态数据和全局数据，常量区存放常量，栈存放形参，形参和局部变量都存在栈上，函数调用，建立栈帧，this指针是形参一般是存放在栈上，有些地方会直接放在寄存器里面，因为寄存器访问特别块，一般情况是栈。类实例化的每个对象中的成员变量是不同的，但是调用同一份函数，调用的成员函数地址都是一样的，如果每个对象内部都放一份，会造成大大的浪费。小端（存储）模式：是指数据的低位字节内容保存在内存的低地址处，而数据的高位字节内容，保存在内存的高地址处。
小梦C嘎嘎——启航篇】C++ priority_queue 手撕模拟实现
小梦的博客
04-14 621
C++有关priority_queue(优先级队列)的手撕模拟实现和使用分享~
【C++】stack与queue（相关接口介绍、容器适配器、deque、模拟实现）
最新发布
m0_74910646的博客
04-17 761
stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行 元素的插入与提取操作。stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定 的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部(即栈顶)被压入和弹出。
如何使用Jetbrain全家桶？图文视频教程
weixin_45700531的博客
04-14 712
PhpStorm 2024.1WebStorm 2024.1Clion 2024.1PyCharm 2024.1IntelliJ IDEA 2024.1Golandpycharm ： https://www.bilibili.com/video/BV1UE421u7j8/Clion ： https://www.bilibili.com/video/BV1st421E7Wk/IDEA ： https://www.bilibili.com/video/BV1PZ421q7Fb/
C++高级特性：重新理解左值、右值、左值引用与右值引用详解（四）
weixin_43808717的博客
04-11 1089
另外还有引用初始化的问题，引用只能在定义的时候初始化（定义的时候必须指定一个类型）。定义完毕无法初始化和修改指向，虽然无法修改指向但是可以修改值。b = y：实际上是将y的右值给了b当右值，不是把y的左值给了b当右值。int&b = x;b = y;/* 输出*/左值引用不是引用不了一个临时变量值吗，那右值引用来引用临时变量（东厂管不了的西厂管）右值引用却无法引用一个存在地址的左值（有实际地址）// 报错int t = 10;int& a = t;// 报错。
linux下c语言编程
09-16
Linux操作系统提供了完善的C语言开发工具链，包括编译器、调试工具、开发库等，因此在Linux下进行C语言编程是非常方便和高效的。 首先，Linux下最常用的C语言编译器是GNU编译器套装（GCC）。GCC是一个开源的编译器...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值