曾经学习C语言使用过的代码，方便以后使用

最新推荐文章于 2024-05-07 10:26:13 发布
最新推荐文章于 2024-05-07 10:26:13 发布
阅读量125 收藏
点赞数
文章标签： c语言 学习 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yanzaixu12/article/details/134144191
版权

进程

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdlib.h>

void fun(int a,int b)
{
    printf("china\n");
    printf("a+b=%d",a+b);
    exit(0);//不刷新缓冲区，结束进程
    return;
}

int main(int argc, char const *argv[])
{
    //创建父子进程
    pid_t pid = fork();
    if(pid < 0)
    {
        printf("fork err");
        return -1;
    }
    else if(pid == 0)//返回0是子进程
    {
        printf("hello\n");
        fun(3,4);
        sleep(1);
        printf("hahahaha\n");
    }
    else//否则一率是父进程
    {
        printf("world\n");
        waitpid(pid,NULL,0);//阻塞回收指定子进程
        printf("ni hao\n");
    }
    return 0;
}

线程

#include <stdio.h>
#include <pthread.h>

void *handler(void *arg)
{
    printf("in pthread\n");
    return NULL;
}

int main(int argc, char const *argv[])
{
    pthread_t tid;
    //创建线程
    if(pthread_create(&tid,NULL,handler,NULL)!=0)
    {
        perror("create err");
        return -1;
    }
    printf("in mian\n");
    while(1);//让进程不结束
    return 0;
}

信号量同步

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>
#include <semaphore.h>

char buf[32] = {0};
sem_t sem;

void *myprint(void *arg)
{
    //循环输出到终端
    while(1)
    {
        sem_wait(&sem);//-1
        if(!strcmp(buf,"quit"))
            break;
        printf("buf:%s\n",buf);
    }
    pthread_exit(0);
}

int main(int argc, char const *argv[])
{
    pthread_t tid;
    //1.初始化信号量
    if(sem_init(&sem,0,0))
    {
        perror("init err");
        return -1;
    }
    //创建线程
    if(pthread_create(&tid,NULL,myprint,NULL)!=0)
    {
        perror("create err");
        return -1;
    }
    //从终端获取
    while(1)
    {
        fgets(buf,32,stdin);
        //处理\n
        if(buf[strlen(buf) -1] == '\n')
            buf[strlen(buf) -1] = '\0';
        sem_post(&sem);//+1
        if(!strcmp(buf,"quit"))
            break;
    }
    //回收线程
    pthread_join(tid,NULL);
    return 0;
}

互斥锁互斥

#include <stdio.h>
#include <semaphore.h>
#include <pthread.h>
#include <string.h>
#include <unistd.h>

pthread_mutex_t lock;
pthread_cond_t cond;
int a[10] = {0,1,2,3,4,5,6,7,8,9};

void *inver(void *arg)
{
    int temp;
    while(1)
    {
        sleep(1);//让打印先抢到锁
        pthread_mutex_lock(&lock);
        //倒置
        for(int i = 0;i < 5;i++)
        {
            temp = a[i];
            a[i] = a[9 - i];
            a[9 - i] = temp;
        }
        pthread_cond_signal(&cond);//产生条件变量
        pthread_mutex_unlock(&lock);
    }
}

void *myprint (void *arg)
{
    while(1)
    {
        pthread_mutex_lock(&lock);//上锁
        pthread_cond_wait(&cond,&lock);//如果没有条件产生时，解锁，当等待到条件产生时，上锁
        //打印
        for(int i = 0;i < 10; i++)
            printf("%d ",a[i]);
        putchar(10);
        pthread_mutex_unlock(&lock);//解锁
    }
}

int main(int argc, char const *argv[])
{
    pthread_t tid1,tid2;
    //初始化锁
    pthread_mutex_init(&lock,NULL);
    //初始化条件变量
    pthread_cond_init(&cond,NULL);
    //创建线程
    if(pthread_create(&tid1,NULL,inver,NULL))
    {
        perror("tid1 err");
        return -1;
    }
    if(pthread_create(&tid2,NULL,myprint,NULL))
    {
        perror("tid2 err");
        return -1;
    }
    //阻塞回收进程
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    //销毁
    pthread_mutex_destroy(&lock);
    pthread_cond_destroy(&cond);
    return 0;
}

信号

#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include <stdlib.h>
#include <sys/wait.h>

pid_t pid;

void saler(int sig)
{
    if(sig == SIGINT)
        kill(getppid(),SIGUSR1);
    else if(sig == SIGQUIT)
        kill(getppid(),SIGUSR2);
    else if(sig == SIGUSR1)
    {
        printf("please get off the bus\n");
        exit(0);
    }
}
void driver(int sig)
{
    if(sig == SIGUSR1)
        printf("gogogo\n");
    else if(sig == SIGUSR2)
        printf("stop the bus\n");
    else if(sig == SIGTSTP)
    {
        kill(pid,SIGUSR1);
        wait(NULL);
        exit(0);
    }
}

int main(int argc, char const *argv[])
{
    if((pid = fork()) < 0)
    {
        perror("fork err");
        return -1;
    }
    else if(pid == 0)
    {
        //子进程管理员
        signal(SIGTSTP,SIG_IGN);
        signal(SIGINT,saler);
        signal(SIGQUIT,saler);
        signal(SIGUSR1,saler);
    }
    else
    {
        signal(SIGINT,SIG_IGN);
        signal(SIGQUIT,SIG_IGN);
        signal(SIGUSR1,driver);
        signal(SIGUSR2,driver);
        signal(SIGTSTP,driver);
    }
    while(1)
        pause();
    
    return 0;
}

守护进程

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main(int argc, char const *argv[])
{
    //1.创建子进程，父进程退出
    pid_t pid = fork();
    if(pid < 0)
    {
        perror("fork err");
        return -1;
    }
    else if(pid == 0)
    {
        //2. 在子进程里创建新会话，让子进程成为会话组长
        setsid();
        //3.改变运行目录为跟目录
        chdir("/");
        //4.重设文件权限掩码
        umask(0);
        //5.关闭文件描述符
        for (int i = 0; i < 2; i++)
        {
            close(i);
        }
        //打开文件
        int fd = open("./test.txt",O_RDWR | O_CREAT | O_TRUNC,0666);
        if(fd < 0)
        {
            perror("open err");
            return -1;
        }
        while(1)
        {
            write(fd,"hello\n",6);
            sleep(1);
        }
    }
    else
    {
        exit(0);
    }
    
    return 0;
}

共享内存

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <errno.h>

typedef struct
{
    int flag;
    char buf[32];
}SHM;

int main(int argc, char const *argv[])
{
    key_t key = 1;
    //创建或打开共享内存
    int shmid;
    shmid = shmget(key,128,IPC_CREAT | IPC_EXCL | 0666);
    if(shmid < 0)
    {
        if(errno == 17)
            //重新打开共享内存
            shmid = shmget(key,128,0666);
        else
        {
            perror("shmget err");
            return -1;
        }
    }
    printf("shmid:%d\n",shmid);
    //映射共享内存
    SHM *p = shmat(shmid,NULL,0);
    if(p == (SHM *)-1)
    {
        perror("shmat err");
        return -1;
    }
    fgets(p->buf,32,stdin);
    printf("buf:%s\n",p->buf);
    //取消映射
    shmdt(p);
    //删除共享内存
    shmctl(shmid,IPC_RMID,NULL);
    return 0;
}

消息队列

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <errno.h>
#include <string.h>

struct msgbuf
{
    long mtype;
    char name[32];
    int age;
    float score;
};

int main(int argc, char const *argv[])
{
    //创建key
    key_t key = ftok(".",'b');
    if(key < 0)
    {
        perror("ftok err");
        return -1;
    }
    printf("key:%d\n",key);
    //创建或打开消息队列
    int msgid = msgget(key,IPC_CREAT | IPC_EXCL | 0666);
    if(msgid <= 0)
    {
        if(errno == 17)
            msgid = msgget(key,0666);
        else
        {
            perror("msgget err");
            return -1;
        }
    }
    printf("msgid:%d\n",msgid);
    //按照类型添加/读取消息
    struct msgbuf msg;
    msg.mtype = 1;
    strcpy(msg.name,"lihua");
    msg.age = 18;
    msg.score = 69.9;
    msgsnd(msgid,&msg,sizeof(msg) - sizeof(long),0);

    /
    msg.mtype = 3;
    strcpy(msg.name,"lihu");
    msg.age = 8;
    msg.score = 99.99;
    msgsnd(msgid,&msg,sizeof(msg) - sizeof(long),0);
    //读取消息
    struct msgbuf buf;
    msgrcv(msgid,&buf,sizeof(buf) - sizeof(long),2,0);
    printf("name:%s\n",buf.name);
    printf("age:%d\n",buf.age);
    printf("score:%.2f\n",buf.score);
    //再读一次
    struct msgbuf buf;
    msgrcv(msgid,&buf,sizeof(buf) - sizeof(long),1,0);
    printf("name:%s\n",buf.name);
    printf("age:%d\n",buf.age);
    printf("score:%.2f\n",buf.score);
        
    return 0;
}

TCP多进程服务器

#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/wait.h>
#include <string.h>
#include <stdlib.h>
#include <signal.h>
//分别打印错误信息，函数名和行号到标准错误流中
#define ERR_MSG(msg) do{\
    fprintf(stderr,"__%s__ __%s__ __%d__",__FILE__,__func__,__LINE__);\
    perror(msg);\
}while(0)//循环只是为了去括号，无任何意义
#define IP "192.168.50.149"  //ifconfig

int do_cil_msg(int newfd,struct sockaddr_in cin);
void headler(int sig);

int main(int argc, char const *argv[])
{
    //创建流式套接字
    int sfd = socket(AF_INET,SOCK_STREAM,0);
    if(sfd < 0)
    {
        ERR_MSG("socket");
        return -1;
    }
    printf("sock success sfd=%d\n",sfd);

    //允许端口快速被覆盖重用。
    int reuse = 1;
    if(setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) < 0)
    {
        ERR_MSG("setsockopt");
        return -1;                                                              
    }
    printf("允许端口快速被覆盖重用成功\n");

    //填充地址信息结构体，真实的地址信息结构体AF_INET:man 7 IP
    struct sockaddr_in sin;//定义结构体变量，引出成员并填充地址
    sin.sin_family      = AF_INET;  //这里填ipv4协议
    sin.sin_port        = htons(6666);//端口号的网络字节序1024～49151,将端口号转换成网络字节序
    sin.sin_addr.s_addr = inet_addr(IP);//将ip地址的点分十进制转换成网络字节序，并存到sin下的sin_addr下的s_addr中

    if(bind(sfd,(struct sockaddr*)&sin,sizeof(sin)) < 0)
    {
        ERR_MSG("bind");
        return -1;
    }
    printf("bind success __%d__\n",__LINE__);//输出当前行号

    //将套接字设置为被动监听状态
    if(listen(sfd,128) < 0)
    {//将sfd套接字设置为被监听状态，允许同时有128个客户端未完成链接
        ERR_MSG("listen");
        return -1;
    }
    printf("listen success __%d__\n",__LINE__);//链接成功后输出行号

    struct sockaddr_in cin;//存储客户端信息，定义存储地址信息结构体变量
    socklen_t addrlen = sizeof(cin);//定义结构体类型存取结构体长度

    //生成新的文件描述符与客户端通信
    //int newfd = -1;
    pid_t cpid = 0;//定义结构体变量，用来开启进程
    while(1)
    {
        int newfd = accept(sfd,(struct sockaddr*)&cin,&addrlen);
    
        if(newfd < 0)
        {
            ERR_MSG("accept");
            return -1;
        }
        printf("[%s:%d] newfd=%d 客户端链接成功 __%d__\n",\
                inet_ntoa(cin.sin_addr),ntohs(cin.sin_port),newfd,__LINE__);
        cpid = fork();//客户端链接成功后开启进程
        
        if(cpid == 0)
        {
            close(sfd);
            do_cil_msg(newfd,cin);
            close(newfd);
            exit(0);
        }
        else if(cpid > 0)
        {
            close(newfd);
            if(signal(17,headler) == SIG_ERR)
            {
                perror("signal");
                return -1;
            }
        }
        else
        {
            ERR_MSG("fork");
            return -1;
        }
    }
    //关闭
    if(close(sfd) < 0)//关闭sfd套接字
    {
        ERR_MSG("close");
        return -1;
    }
    return 0;
}
int do_cil_msg(int newfd,struct sockaddr_in cin)
{
    char buf[128] = "";//定义字符型数组存取数据
    ssize_t res = 0;//定义结构提变量接收返回值
    while(1)
        {
            bzero(buf,sizeof(buf));//将buf数组清零
            //接收
            res = recv(newfd,buf,sizeof(buf),0);//从得到accept返回值的newfd套接字中
            
            if(res <0)//返回值小于0,读取失败
            {
                ERR_MSG("recv");
                return -1;
            }
            else if(0 == res)//返回值等于0,客户端下线
            {
                printf("[%s:%d] newfd=%d 客户端下线__%d__\n",\
                    inet_ntoa(cin.sin_addr),ntohs(cin.sin_port),newfd,__LINE__);
                    //输出转换后的ip地址和主机字节序，和新的文件描述符
                break;
            }

            printf("[%s:%d] newfd=%d : %s __%d__\n",\
                inet_ntoa(cin.sin_addr),ntohs(cin.sin_port),newfd,buf,__LINE__);
                //输出ip地址和主机字节序，新的文件描述符和buf中的内容
            //发送
            strcat(buf,"*_*");//在buf数组的末尾追加*_*，证明服务器以收到数据

            if(send(newfd,buf,sizeof(buf),0) < 0)//如果返回值小于0,发送失败
            {
                ERR_MSG("send");
                return -1;
            }
            printf("send success __%d__\n",__LINE__);//发送成功后显示数据
        }
    return 0;
}
void headler(int sig)
{
    //若成功回收到僵尸进程再收一次
    //直到没有收到僵尸进程，解除循环
    //==0,有子进程，没有僵尸进程
    //==-1,没有子进程，也没有僵尸进程
    while(waitpid(-1,NULL,WNOHANG) > 0);
    return;
}

TCP多线程服务器

#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string.h>
#include <pthread.h>
//分别打印错误信息，函数名和行号到标准错误流中
#define ERR_MSG(msg) do{\
    fprintf(stderr,"__%s__ __%s__ __%d__",__FILE__,__func__,__LINE__);\
    perror(msg);\
}while(0)//循环只是为了去括号，无任何意义

//需要传入线程中的参数
struct msg
{
    int newfd;
    struct sockaddr_in cin;
};

void* deal_cil_msg(void* arg);

#define IP "192.168.50.149"  //ifconfig

int main(int argc, char const *argv[])
{
    //创建流式套接字
    int sfd = socket(AF_INET,SOCK_STREAM,0);
    if(sfd < 0)
    {
        ERR_MSG("socket");
        return -1;
    }
    printf("sock success sfd=%d\n",sfd);

    //允许端口快速被覆盖重用。
    int reuse = 1;
    if(setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) < 0)
    {
        ERR_MSG("setsockopt");
        return -1;                                                              
    }
    printf("允许端口快速被覆盖重用成功\n");

    //填充地址信息结构体，真实的地址信息结构体AF_INET:man 7 IP
    struct sockaddr_in sin;//定义结构体变量，引出成员并填充地址
    sin.sin_family      = AF_INET;  //这里填ipv4协议
    sin.sin_port        = htons(6666);//端口号的网络字节序1024～49151,将端口号转换成网络字节序
    sin.sin_addr.s_addr = inet_addr(IP);//将ip地址的点分十进制转换成网络字节序，并存到sin下的sin_addr下的s_addr中

    if(bind(sfd,(struct sockaddr*)&sin,sizeof(sin)) < 0)
    {
        ERR_MSG("bind");
        return -1;
    }
    printf("bind success __%d__\n",__LINE__);//输出当前行号

    //将套接字设置为被动监听状态
    if(listen(sfd,128) < 0)
    {//将sfd套接字设置为被监听状态，允许同时有128个客户端未完成链接
        ERR_MSG("listen");
        return -1;
    }
    printf("listen success __%d__\n",__LINE__);//链接成功后输出行号

    struct sockaddr_in cin;//存储客户端信息，定义存储地址信息结构体变量
    socklen_t addrlen = sizeof(cin);//定义结构体类型存取结构体长度

    //生成新的文件描述符与客户端通信
    //int newfd = -1;
    pthread_t tid;//定义结构体变量，用来开启线程
    struct msg info;
    while(1)
    {
        int newfd = accept(sfd,(struct sockaddr*)&cin,&addrlen);
    
        if(newfd < 0)
        {
            ERR_MSG("accept");
            return -1;
        }
        printf("[%s:%d] newfd=%d 客户端链接成功 __%d__\n",\
                inet_ntoa(cin.sin_addr),ntohs(cin.sin_port),newfd,__LINE__);

        info.newfd = newfd;
        info.cin = cin;
        
        if(pthread_create(&tid,NULL,deal_cil_msg,&info) != 0)
        {//出错会执行以下语句
            fprintf(stderr,"pthread_create failed __%d__\n",__LINE__);
        }
        pthread_detach(tid);//分离线程，线程退出后由内核自动回收
    }
    //关闭
    if(close(sfd) < 0)//关闭sfd套接字
    {
        ERR_MSG("close");
        return -1;
    }
    return 0;
}
void* deal_cil_msg(void* arg)
{
    int newfd = ((struct msg*)arg)->newfd;
    struct sockaddr_in cin = ((struct msg*)arg)->cin;

    char buf[128] = "";//定义字符型数组存取数据
    ssize_t res = 0;//定义结构提变量接收返回值
    while(1)
        {
            bzero(buf,sizeof(buf));//将buf数组清零
            //接收
            res = recv(newfd,buf,sizeof(buf),0);//从得到accept返回值的newfd套接字中
            
            if(res <0)//返回值小于0,读取失败
            {
                ERR_MSG("recv");
                break;
            }
            else if(0 == res)//返回值等于0,客户端下线
            {
                printf("[%s:%d] newfd=%d 客户端下线__%d__\n",\
                    inet_ntoa(cin.sin_addr),ntohs(cin.sin_port),newfd,__LINE__);
                    //输出转换后的ip地址和主机字节序，和新的文件描述符
                break;
            }

            printf("[%s:%d] newfd=%d : %s __%d__\n",\
                inet_ntoa(cin.sin_addr),ntohs(cin.sin_port),newfd,buf,__LINE__);
                //输出ip地址和主机字节序，新的文件描述符和buf中的内容
            //发送
            strcat(buf,"*_*");//在buf数组的末尾追加*_*，证明服务器以收到数据

            if(send(newfd,buf,sizeof(buf),0) < 0)//如果返回值小于0,发送失败
            {
                ERR_MSG("send");
                break;
            }
            printf("send success __%d__\n",__LINE__);//发送成功后显示数据
        }
        //关闭
        if(close(newfd) < 0)
        {
            ERR_MSG("close");
        }
        pthread_exit(NULL);
    return 0;
}

selectTCP(多路复用)

#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <string.h>
#include <netinet/in.h>
#include <sys/time.h>
#include <sys/select.h>

#define ERR_MSG(msg) do{\
  fprintf(stderr,"__%s__ __%s__ __%d__",__FILE__,__func__,__LINE__);\
  perror(msg);\
}while(0)

#define IP "192.168.50.149"  //ifconfig
#define PORT 6666 //端口号 1024～49151

int main(int argc, char const *argv[])
{
  //创建流式套接字
  int sfd = socket(AF_INET,SOCK_STREAM,0);
  //定义整形变量接收socket函数返回的文件描述副
  if(sfd < 0)
  {
      ERR_MSG("socket");
      return -1;
  }
  printf("create socket success cfd=%d __%d__\n",sfd,__LINE__);

  int reuse = 1;
  if(setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) < 0)
  {
      ERR_MSG("setsockopt");
      return -1;                                                              
  }
  printf("允许端口快速被覆盖重用成功\n");

  struct sockaddr_in sin;
  sin.sin_family      = AF_INET;  //这里填ipv4协议
  sin.sin_port        = htons(PORT);//端口号的网络字节序1024～49151,将端口号转换成网络字节序
  sin.sin_addr.s_addr = inet_addr(IP);//将ip地址的点分十进制转换成网络字节序，并存到sin下的sin_addr下的s_addr中

  if(bind(sfd,(struct sockaddr*)&sin,sizeof(sin)) < 0)
  {//将sin中得地址信息绑定到sfd套接字文件中(因为sin的变量类型不一样
  //需要强制类型转换),最后可以使用sizeof直接算出sin结构体变量的大小
      ERR_MSG("bind");
      return -1;
  }
  printf("bind success __%d__\n",__LINE__);//输出当前行号

  //将套接字设置为被动监听状态
  if(listen(sfd,128) < 0)
  {//将sfd套接字设置为被监听状态，允许同时有128个客户端未完成链接
      ERR_MSG("listen");
      return -1;
  }
  printf("listen success __%d__\n",__LINE__);//链接成功后输出行号

  //创建一个集合
  fd_set readfds,tempfds;
  //清空结构体，完成初始化
  FD_ZERO(&readfds);
  FD_ZERO(&tempfds);

  FD_SET(0,&readfds);//将0添加到集合中
  FD_SET(sfd,&readfds);//将sfd添加到集合中

  int maxfd = sfd;
  
  int s_res = 0;
  struct sockaddr_in cin;//存储客户地址信息
  socklen_t addrlen = sizeof(cin);

  struct sockaddr_in savecin[1024-3];

  int newfd = -1;
  char buf[128] = "";
  ssize_t res = 0;
while(1)
{
  tempfds = readfds;
  //调用select函数，让内核检测集合中的文件描述符
  s_res = select(maxfd+1,&tempfds,NULL,NULL,NULL);
  if(s_res <0)
  {
    ERR_MSG("select");
    return -1;
  }
  else if(0 == s_res)
  {
    printf("time out...\n");
    break;
  }
  printf("__%d__",__LINE__);

  for(int i=0;i<=maxfd;i++)
  {
    if(!FD_ISSET(i,&tempfds))
    //能运行到当前位置，则说明i代表的文件描述符在集合中
      continue;
    if(0 == i)
    {
      printf("触发输入事件\n");
      fgets(buf,sizeof(buf),stdin);
      buf[strlen(buf)-1] = 0;
      printf("%s\n",buf);
    }
    else if(sfd == i)
    {
      printf("触发客户端链接事件\n");
      newfd = accept(sfd,(struct sockaddr*)&cin,&addrlen);
      if(newfd < 0)
      {
          ERR_MSG("accept");
          return -1;
      }
      printf("[%s:%d] newfd=%d 客户端链接成功 __%d__\n",\
              inet_ntoa(cin.sin_addr),ntohs(cin.sin_port),newfd,__LINE__);
      savecin[newfd-3] = cin;//将cin通过newfd另存到数组中
      //将newfd添加到读集合中
      FD_SET(newfd,&readfds);

      maxfd = maxfd>newfd?maxfd:newfd;
    }
    else
    {
      bzero(buf,sizeof(buf));
      printf("触发客户端交互事件\n");
      res = recv(i,buf,sizeof(buf),0);
      if(res <0)//返回值小于0,读取失败
      {
          ERR_MSG("recv");
          return -1;
      }
      else if(0 == res)//返回值等于0,客户端下线
      {
          printf("[%s:%d] newfd=%d 客户端下线__%d__\n",\
              inet_ntoa(savecin[i-3].sin_addr),ntohs(savecin[i-3].sin_port),newfd,__LINE__);
              //输出转换后的ip地址和主机字节序，和新的文件描述符
          //关闭文件描述符
          close(i);
          //将文件描述符从集合中移除
          FD_CLR(i,&readfds);
          //更新maxfd从最大maxfd往小便利，
          //若该文件描述符在集合中，则该文件描述符就是最大的
          int j = maxfd;
          while(!FD_ISSET(j,&readfds) && j-->=0);
          maxfd = j;
          continue;
      }

      printf("[%s:%d] newfd=%d : %s __%d__\n",\
          inet_ntoa(savecin[i-3].sin_addr),ntohs(savecin[i-3].sin_port),newfd,buf,__LINE__);

      strcat(buf,"*_*");//在buf数组的末尾追加*_*，证明服务器以收到数据

      if(send(i,buf,sizeof(buf),0) < 0)//如果返回值小于0,发送失败
      {
          ERR_MSG("send");
          return -1;
      }
      printf("send success __%d__\n",__LINE__);//发送成功后显示数据
    }
  }
    
}
  //关闭
  if(close(sfd) < 0)//关闭cfd套接字文件描述符
  {
      ERR_MSG("close");
      return -1;
  }
  return 0;
}

TCP_unix(进程之间通信服务器)

#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <string.h>
#include <netinet/in.h>
#include <sys/un.h>
//分别打印错误信息，函数名和行号到标准错误流中
#define ERR_MSG(msg) do{\
    fprintf(stderr,"__%s__ __%s__ __%d__",__FILE__,__func__,__LINE__);\
    perror(msg);\
}while(0)//循环只是为了去括号，无任何意义


int main(int argc, char const *argv[])
{
    //创建流式套接字
    int sfd = socket(AF_UNIX,SOCK_STREAM,0);
    if(sfd < 0)
    {
        ERR_MSG("socket");
        return -1;
    }
    printf("sock success sfd=%d\n",sfd);

    //判断文件是否存在
    if(access("./unix",F_OK) == 0)
    {
        //若存在删除
        if(unlink("./unix") < 0)
        {
            ERR_MSG("unlink");
            return -1;
        }
    }

    //填充地址信息结构体，真实的地址信息结构体AF_INET:man 7 IP
    struct sockaddr_un sun;//定义结构体变量，引出成员并填充地址
    sun.sun_family      = AF_UNIX; 
    strcpy(sun.sun_path,"./unix");

    if(bind(sfd,(struct sockaddr*)&sun,sizeof(sun)) < 0)
    {//将sin中得地址信息绑定到sfd套接字文件中(因为sin的变量类型不一样
    //需要强制类型转换),最后可以使用sizeof直接算出sin结构体变量的大小
        ERR_MSG("bind");
        return -1;
    }
    printf("bind success __%d__\n",__LINE__);//输出当前行号

    if(listen(sfd,128) < 0)
    {//将sfd套接字设置为被监听状态，允许同时有128个客户端未完成链接
        ERR_MSG("listen");
        return -1;
    }
    printf("listen success __%d__\n",__LINE__);//链接成功后输出行号

    struct sockaddr_in cun;//存储客户端信息，定义存储地址信息结构体变量
    socklen_t addrlen = sizeof(cun);//定义结构体类型存取结构体长度

    //生成新的文件描述符与客户端通信
    int newfd = accept(sfd,(struct sockaddr*)&cun,&addrlen);
    if(newfd < 0)
    {
        ERR_MSG("accept");
        return -1;
    }
    printf("[] newfd=%d 客户端链接成功 __%d__\n",newfd,__LINE__);
    //客户端链接成功后输出，转换后的ip地址和转换后的主机字节序，和行号
    char buf[128] = "";//定义字符型数组存取数据
    ssize_t res = 0;//定义结构提变量接收返回值
    while(1)
    {
        bzero(buf,sizeof(buf));//将buf数组清零
        //接收
        res = recv(newfd,buf,sizeof(buf),0);//从得到accept返回值的newfd套接字中
        //接收缓冲区的数据，并存储在数组中，用sizeof算出指定读取字节最后用0表示以阻塞方式
        //读取
        if(res <0)//返回值小于0,读取失败
        {
            ERR_MSG("recv");
            return -1;
        }
        else if(0 == res)//返回值等于0,客户端下线
        {
            printf("[] newfd=%d 客户端下线__%d__\n",newfd,__LINE__);
                //输出转换后的ip地址和主机字节序，和新的文件描述符
            break;
        }

        printf("[] newfd=%d : %s __%d__\n",newfd,buf,__LINE__);
            //输出ip地址和主机字节序，新的文件描述符和buf中的内容
        //发送
        strcat(buf,"*_*");//在buf数组的末尾追加*_*，证明服务器以收到数据

        if(send(newfd,buf,sizeof(buf),0) < 0)//如果返回值小于0,发送失败
        {//send函数可以将but数组中的数据发送给accept函数中得到的文件描述符，
         //第三项是大小，第四项0是阻塞发送
            ERR_MSG("send");
            return -1;
        }
        printf("send success __%d__\n",__LINE__);//发送成功后显示数据
    }
    //关闭
    if(close(newfd) < 0)//关闭newfd套接字
    {
        ERR_MSG("close");//关闭失败返回-1,并输出错误内容
        return -1;
    }
    if(close(sfd) < 0)//关闭sfd套接字
    {
        ERR_MSG("close");
        return -1;
    }
    return 0;
}

TCP进程之间通信客户端

#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <string.h>
#include <netinet/in.h>
#include <sys/un.h>

#define ERR_MSG(msg) do{\
    fprintf(stderr,"__%s__ __%s__ __%d__",__FILE__,__func__,__LINE__);\
    perror(msg);\
}while(0)


int main(int argc, char const *argv[])
{
    //创建流式套接字
    int cfd = socket(AF_UNIX,SOCK_STREAM,0);
    //定义整形变量接收socket函数返回的文件描述副
    if(cfd < 0)
    {
        ERR_MSG("socket");
        return -1;
    }
    printf("create socket success cfd=%d __%d__\n",cfd,__LINE__);

    //绑定客户端自身的地址信息结构体---》非必须绑定
    //若客户端没有绑定地址信息，
    //测操作系统会自动帮客户端绑定本机IP，以及49151～65535内的随机端口

    //填充服务器的地址信息结构体，给connect函数使用
    //要链接哪个服务器，就填哪个服务器的地址信息
    struct sockaddr_un sun;
    sun.sun_family      = AF_UNIX;  
    strcpy(sun.sun_path,"./unix");
    
    //链接服务器
    if(connect(cfd,(struct sockaddr*)&sun,sizeof(sun)) < 0)//当返回值小于0，失败
    {//通过connect函数链接服务器：将指定要链接的文件描述符绑定sun的结构体变量链接服务器，
        ERR_MSG("connect");
        return -1;
    }
    printf("connect success __%d__\n",__LINE__);
    //成功后返回行号

    char buf[128] = "";//定义字符型数组
    ssize_t res = 0;//定义结构体变量，接收返回值
    while(1)
    {
        //从终端获取数据
        printf("请输入>>> ");
        fgets(buf,sizeof(buf),stdin);//从标准输入流中读取数据，存入到buf数组中
        buf[strlen(buf)-1] = 0;//将buf的最后一位‘\n’改为0

        //发送
        if(send(cfd,buf,sizeof(buf),0) < 0)//返回值小于0,发送失败
        {//通过cfd套接字文件描述符向缓冲区发送buf中的数据
            ERR_MSG("send");
            return -1;
        }
        printf("send success __%d__\n",__LINE__);//成功输出行号

        //接收
        bzero(buf,sizeof(buf));//将buf数组清零
        res = recv(cfd,buf,sizeof(buf),0);
        //通过该函数从该套接字文件描述符中接收数据，并存入buf数组中
        if(res < 0)//如果返回值小于0
        {
            ERR_MSG("recv");//接收失败
            return -1;
        }
        else if(0 == res)//返回之等于0，断线
        {
            printf("服务器离线\n");
            break;
        }
        printf("%s __%d__\n",buf,__LINE__);//接收成功输出buf数组中的内容和行号
        
    }
    //关闭
    if(close(cfd) < 0)//关闭cfd套接字文件描述符
    {
        ERR_MSG("close");
        return -1;
    }
    return 0;
}

UDP组播服务器

#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string.h>

#define ERR_MSG(msg)  do{\
    fprintf(stderr, "__%s__ __%s__  __%d__ ", __FILE__, __func__, __LINE__);\
    perror(msg);\
}while(0)

#define PORT 6666               //1024~49151
#define GRP_IP  "224.1.2.3"        //组播IP
#define LOL_IP  "192.168.50.149"   //本机IP


int main(int argc, const char *argv[])
{
    //创建报式套接字
    int sfd = socket(AF_INET, SOCK_DGRAM, 0);
    if(sfd < 0)
    {
        ERR_MSG("socket");
        return -1;
    }
    printf("sfd = %d __%d__\n", sfd, __LINE__);
    
    //加入多播组
    struct ip_mreqn mq;
    mq.imr_multiaddr.s_addr = inet_addr(GRP_IP);
    mq.imr_address.s_addr   = inet_addr(LOL_IP);
    mq.imr_ifindex          = 2; //0 网卡设备的索引号

    if(setsockopt(sfd,IPPROTO_IP,IP_ADD_MEMBERSHIP,&mq,sizeof(mq)) < 0)
    {
        ERR_MSG("setsockopt");
        return -1;
    }
    printf("加入多播组 %s : %d 成功\n",GRP_IP,PORT);

    //填充服务器的地址信息结构体， AF_INET: man 7 ip
    struct sockaddr_in sin;
    sin.sin_family      = AF_INET;
    sin.sin_port        = htons(PORT);      //1024~49151
    sin.sin_addr.s_addr = inet_addr(GRP_IP);    //ifconfig

    //绑定服务器自身的地址信息
    if(bind(sfd, (struct sockaddr*)&sin, sizeof(sin)) < 0)
    {
        ERR_MSG("bind");
        return -1;
    }
    printf("bind success __%d__\n", __LINE__);

    char buf[128] = "";
    struct sockaddr_in cin;     //存储客户端的地址信息
    socklen_t addrlen = sizeof(cin);

    ssize_t res = 0;
    while(1)
    {
        bzero(buf, sizeof(buf));
        //接收
        res = recvfrom(sfd, buf, sizeof(buf), 0, (struct sockaddr*)&cin, &addrlen);
        if(res < 0)
        {
            ERR_MSG("recvfrom");
            return -1;
        }                                                                             
        printf("[%s:%d] : %s __%d__\n", \
                inet_ntoa(cin.sin_addr), ntohs(cin.sin_port), buf, __LINE__);

    }

    //关闭
    if(close(sfd) < 0)
    {
        ERR_MSG("close");
        return -1;
    }
    return 0;
}

UDP组播客户端

#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string.h>

#define ERR_MSG(msg)  do{\
    fprintf(stderr, "__%s__ __%s__  __%d__ ", __FILE__, __func__, __LINE__);\
    perror(msg);\
}while(0)

#define PORT 6666               //1024~49151
#define IP  "224.1.2.3"         //组播IP224.0.0.0-239.255.255.255


int main(int argc, const char *argv[])
{
    //创建报式套接字
    int cfd = socket(AF_INET, SOCK_DGRAM, 0);
    if(cfd < 0)
    {
        ERR_MSG("socket");
        return -1;
    }
    printf("cfd = %d __%d__\n", cfd, __LINE__);

    //绑定客户端自身的地址信息---》非必须绑定
    //若不绑定则操作系统会自动给客户端绑定上一个可用IP以及随机端口。

    //填充服务器的地址信息结构体，给sendto函数使用
    struct sockaddr_in sin;
    sin.sin_family      = AF_INET;
    sin.sin_port        = htons(PORT);      //服务器的端口
    sin.sin_addr.s_addr = inet_addr(IP);    //服务器的IP



    char buf[128] = "";
    ssize_t res = 0;
    while(1)
    {
        bzero(buf, sizeof(buf));
        printf("请输入>>> ");
        fgets(buf, sizeof(buf), stdin);
        buf[strlen(buf)-1] = 0;

        if(sendto(cfd, buf, sizeof(buf), 0, (struct sockaddr*)&sin, sizeof(sin)) < 0)
        {
            ERR_MSG("sendto");
            return -1;
        }
        printf("sendto success __%d__\n", __LINE__);
                                                                                       
    }

    //关闭
    if(close(cfd) < 0)
    {
        ERR_MSG("close");
        return -1;
    }
    return 0;
}

UDP广播

#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <string.h>
#define ERR_MSG(msg) do{\
    fprintf(stderr,"__%s__ __%s__ __%d__",__FILE__,__func__,__LINE__);\
    perror(msg);\
}while(0)

#define IP "192.168.50.255"  //ifconfig
#define PORT 6666 //端口号 1024～49151

int main(int argc, char const *argv[])
{
    //创建套接字
    int cfd = socket(AF_INET,SOCK_DGRAM,0);
    if(cfd < 0)
    {
        ERR_MSG("socket");
        return -1;
    }
    printf("std = %d __%d__\n",cfd,__LINE__);
    //设置允许广播
    int broad = 1;
    if(setsockopt(cfd, SOL_SOCKET, SO_BROADCAST, &broad, sizeof(broad)) < 0)
    {
        ERR_MSG("setsockopt");
        return -1;
    }
    printf("设置广播成功\n");
    //绑定ip地址
    struct sockaddr_in sin;
    sin.sin_family      = AF_INET;
    sin.sin_port        = htons(PORT);
    sin.sin_addr.s_addr = inet_addr(IP);

    //接收对方数据
    char buf[128]="";
    struct sockaddr_in dstAddr;
    socklen_t addrlen = sizeof(dstAddr);

    ssize_t res = 0;
    while(1)
    {
        bzero(buf,sizeof(buf));
        printf("请输入>>> ");
        fgets(buf,sizeof(buf),stdin);
        buf[strlen(buf)-1] = 0;
        //发送
        if(sendto(cfd,buf,sizeof(buf),0,(struct sockaddr*)&sin,sizeof(sin)) < 0)
        {
            ERR_MSG("sendto");
            return -1;
        }
        printf("sendto success __%d__\n",__LINE__);
    }
    if(close(cfd) < 0)
    {
        ERR_MSG("close");
        return -1;
    }
    return 0;
}

哲学大怪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C语言图书借阅管理系统课程设计报告.doc
05-29
课 程 设 计 报 告 课程名称 C语言程序设计 课题名称图书借阅管理系统 专 业机械设计 班 级 15机械二班 学 号2015030220 姓 名 指导教师 2016年 6 月 14日 理工大学高科学院 课 程 设 计 任 务 书 课程名称 C语言程序设计 课 题 图书借阅管理系统 专业班级 网络工程1002班 学生XX 学 号 4 指导教师 唐北平、淑红、谭小兰 审 批 任务书下达日期 2011 年 6 月20 日 任务完成日期 2011 年 7 月 03 日 一、设计容与设计要求 1．设计容：对一个有N本图书的图书馆，通过该系统实现对该班级学生的根本信息 进展录入、显示、修改、删除、保存等操作的管理。 〔1〕、本系统采用一个包含N个数据的构造体数组，每个数据的构造应当包括：书号 、书名、作者、、出版日期、单价、是否借出等。 〔2〕、本系统显示这样的菜单： a. 图书根本信息录入 b. 图书根本信息显示 c. 图书根本信息删除 d. 图书根本信息修改 e. 图书根本信息查询〔按书号查询、书名等〕 g. 退出系统 〔3〕、执行一个具体的功能之后，程序将重新显示菜单。 2．设计要求：掌握构造化程序设计的主体思想，以自顶向下逐步求精的方法编制程 序解决一些实际的问题，为将来编写软件积累一些典型的案例处理经历。 1. 设计正确，方案合理。 2. 界面友好，使用方便。 3. 程序精炼，构造清晰。 4. 设计报告5000字以上，含程序设计说明，用户使用说明，源程序清单及程序框图。 5. 上机演示。 6. 按学号顺序选课题号，并在规定的时间单独完成相关课题的C源程序编写、调整和运行 。源程序及编译生成各文件均保存在软盘中； 7. 按本任务书的要求，按附录的要求编写?课程设计报告?〔Word文档格式〕。并用A4的复 印纸打印并装订； 二、进度安排 第 十八 周 星期1 8时00分——11时30分 星期2 14时00分——18时15分 星期3 8时00分——11时30分 星期4 8时00分——11时30分 第 十九 周 星期1 8时00分——11时30分 星期2 14时00分——18时15分 三、课程设计报告 1.程序设计准备 做系统前，首先，自己详细看了?C程序设计?〔教科书〕，根本自学会了文件的相关 容，理解了相关函数的用法和作用；另，上网查询了很多相关资料，还有找了很多相关 的系统，都详细的看了一遍，加深了对C的理解以及对文件的相关容进一步理解。学习了 C语言的容，图书信息管理系统有助于C语言学习的进一步稳固，在本系统可以增强对指 针、文件、函数、构造体变量等根本知识的进一步理解。另外图书信息管理系统也是学 校常用的根本系统之一，它有助于学校对图书馆书籍的根本管理。 2.程序设计说明 根据题目要求，应当把图书信息用构造体形式输入，再定义一个全局变量和文件指针 进展整个程序的运行，然后把图书信息送到文件中去，所以应该提供下个构造体和文件 的输入等操作：在程序中需要实现图书信息录入，浏览，查询，删除和修改等功能的操 作，所以需要建立相应的模块来实现：另外还需提供选择菜单实现功能，在运行时到达 所要求的目的。 3.程序的主要功能 图书管理在生活中运用非常广泛，因此需要用许多的程序来对它们进展管理。图书借 阅管理系统是对图书信息的根本管理，它包括：图书信息的录入、图书信息的显示、图 书信息的删除、图书信息的修改、图书信息的查询。 通过编译一个C语言函数，其中包含一个主函数，多个子函数，主函数调用其余的子 函数实现人们能够简易、快捷的了解并找到自己所学要的信息的功能。 1、图书根本信息录入：对新到图书馆的图书的信息〔编号、书名、、作者、价格〕 进展录入。 2、图书根本信息显示：显示已被录入图书的所有信息。 3、图书根本信息删除：通过输入书名，判断此图书是否存在，假设存在， 那么删除该图书所有信息，假设不存在那么提示用户重新输入图书书名。 4、图书根本信息修改：通过输入书名，判断此图书是否存在，假设不存在那么提示 用户重新输入图书书名，假设存在，那么可对图书各项信息进展修改。 5、图书根本信息查询：将所有图书信息包括编号、书名、、作者、价格等显示在屏 幕上。 6、退出系统：即退出图书借阅管理系统。 使用模块化编程的方法每项功能有一个或多个函数组合来完成，其中菜单项选择项模 块对应如下： 图书根本信息录入==> void insert() 图书根本信息显示==> void print() 图书根本信息删除==> void del() 图书根本信息修改==> void modify() 图书根本信息查询==> void find() 这份代码中各个变量的定义如下： num 图书编号 name 书名 author 作者 pub where 出版日期
（谭浩强）c语言学习书
12-16
C语言教程 1 C语言概述 1.1 Ｃ语言的发展过程 Ｃ语言是在 70 年代初问世的。一九七八年由美国电话电报公司(AT&T)贝尔实验室正式发表了Ｃ语言。同时由B.W.Kernighan和D.M.Ritchit合著了著名的“THE C PROGRAMMING LANGUAGE”一书。通常简称为《K&R》，也有人称之为《K&R》标准。但是，在《K&R》中并没有定义一个完整的标准C 语言，后来由美国国家标准协会（American National Standards Institute）在此基础上制定了一个C 语言标准，于一九八三年发表。通常称之为ANSI C。 1.2 当代最优秀的程序设计语言 早期的C 语言主要是用于UNIX系统。由于Ｃ语言的强大功能和各方面的优点逐渐为人们认识，到了八十年代，C开始进入其它操作系统，并很快在各类大、中、小和微型计算机上得到了广泛的使用，成为当代最优秀的程序设计语言之一。 1.3 Ｃ语言版本 目前最流行的Ｃ语言有以下几种： •Microsoft C 或称 MS C •Borland Turbo C 或称 Turbo C •AT&T C 这些Ｃ语言版本不仅实现了ANSI C标准，而且在此基础上各自作了一些扩充，使之更加方便、完美。 1.4 Ｃ语言的特点 1•C语言简洁、紧凑，使用方便、灵活。ANSI C一共只有32个关键字: auto break case char const continue default do double else enum extern float for goto if int long register return short signed static sizof struct switch typedef union unsigned void volatile while 9种控制语句，程序书写自由，主要用小写字母表示，压缩了一切不必要的成分。 Turbo C扩充了11个关键字： asm _cs _ds _es _ss cdecl far huge interrupt near pascal 注意：在C语言中，关键字都是小写的。 2•运算符丰富。共有34种。C把括号、赋值、逗号等都作为运算符处理。从而使C的运算类型极为丰富，可以实现其他高级语言难以实现的运算。 3•数据结构类型丰富。 4•具有结构化的控制语句。 5•语法限制不太严格，程序设计自由度大。 6•C语言允许直接访问物理地址，能进行位（bit）操作，能实现汇编语言的大部分功能，可以直接对硬件进行操作。因此有人把它称为中级语言。 7•生成目标代码质量高，程序执行效率高。 8•与汇编语言相比，用C语言写的程序可移植性好。 但是，C语言对程序员要求也高，程序员用C写程序会感到限制少、灵活性大，功能强，但较其他高级语言在学习上要困难一些。 1.5 面向对象的程序设计语言 在C的基础上，一九八三年又由贝尔实验室的Bjarne Strou-strup推出了C++。 C++进一步扩充和完善了Ｃ语言，成为一种面向对象的程序设计语言。C++目前流行的最新版本是Borland C++, Symantec C++和Microsoft VisualC++。 C++提出了一些更为深入的概念，它所支持的这些面向对象的概念容易将问题空间直接地映射到程序空间，为程序员提供了一种与传统结构程序设计不同的思维方式和编程方法。因而也增加了整个语言的复杂性，掌握起来有一定难度。 1.6 Ｃ和Ｃ＋＋ 但是，C是C++的基础，C++语言和Ｃ语言在很多方面是兼容的。因此，掌握了Ｃ语言，再进一步学习C++就能以一种熟悉的语法来学习面向对象的语言，从而达到事半功倍的目的。 1.7 简单的Ｃ程序介绍 为了说明Ｃ语言源程序结构的特点，先看以下几个程序。这几个程序由简到难，表现了Ｃ语言源程序在组成结构上的特点。虽然有关内容还未介绍，但可从这些例子中了解到组成一个C源程序的基本部分和书写格式。 【例1.1】 main() { printf("世界，您好！\n"); }  main是主函数的函数名，表示这是一个主函数。  每一个C源程序都必须有，且只能有一个主函数(main函数)。  函数调用语句，printf函数的功能是把要输出的内容送到显示器去显示。  printf函数是一个由系统定义的标准函数，可在程序中直接调用。 【例1.2】 #include<math.h> #include<stdio.h> main() { double x,s; printf("input number:\n"); scanf("%lf",&x); s=sin(x); printf("sine of %lf is %lf\n",x,s); }  include称为文件包含命令  扩展名为.h的文件称为头文件  定义两个实数变量，以被后面程序使用  显示提示信息  从键盘获得一个实数x  求x的正弦,并把它赋给变量s  显示程序运算结果  main函数结束 程序的功能是从键盘输入一个数x，求x的正弦值，然后输出结果。在main()之前的两行称为预处理命令(详见后面)。预处理命令还有其它几种，这里的include 称为文件包含命令，其意义是把尖括号<>或引号""内指定的文件包含到本程序来，成为本程序的一部分。被包含的文件通常是由系统提供的，其扩展名为.h。因此也称为头文件或首部文件。Ｃ语言的头文件中包括了各个标准库函数的函数原型。因此，凡是在程序中调用一个库函数时，都必须包含该函数原型所在的头文件。在本例中，使用了三个库函数：输入函数scanf，正弦函数sin,输出函数printf。sin函数是数学函数，其头文件为math.h文件，因此在程序的主函数前用include命令包含了math.h。scanf和printf是标准输入输出函数，其头文件为stdio.h，在主函数前也用include命令包含了stdio.h文件。 需要说明的是，C语言规定对scanf和printf这两个函数可以省去对其头文件的包含命令。所以在本例中也可以删去第二行的包含命令#include<stdio.h>。 同样，在例1.1中使用了printf函数，也省略了包含命令。 在例题中的主函数体中又分为两部分，一部分为说明部分，另一部为分执行部分。说明是指变量的类型说明。例题1.1中未使用任何变量，因此无说明部分。Ｃ语言规定，源程序中所有用到的变量都必须先说明，后使用，否则将会出错。这一点是编译型高级程序设计语言的一个特点，与解释型的BASIC语言是不同的。说明部分是C源程序结构中很重要的组成部分。本例中使用了两个变量x，s，用来表示输入的自变量和sin函数值。由于sin函数要求这两个量必须是双精度浮点型，故用类型说明符double来说明这两个变量。说明部分后的四行为执行部分或称为执行语句部分，用以完成程序的功能。执行部分的第一行是输出语句，调用printf函数在显示器上输出提示字符串，请操作人员输入自变量x的值。第二行为输入语句，调用scanf函数，接受键盘上输入的数并存入变量x中。第三行是调用sin函数并把函数值送到变量s中。第四行是用printf 函数输出变量s的值，即x的正弦值。程序结束。 运行本程序时，首先在显示器屏幕上给出提示串input number，这是由执行部分的第一行完成的。用户在提示下从键盘上键入某一数，如5，按下回车键，接着在屏幕上给出计算结果。 1.8 输入和输出函数 在前两个例子中用到了输入和输出函数scanf和 printf，在以后要详细介绍。这里我们先简单介绍一下它们的格式，以便下面使用。 scanf和 printf这两个函数分别称为格式输入函数和格式输出函数。其意义是按指定的格式输入输出值。因此，这两个函数在括号中的参数表都由以下两部分组成： “格式控制串”，参数表 格式控制串是一个字符串，必须用双引号括起来，它表示了输入输出量的数据类型。各种类型的格式表示法可参阅第三章。在printf函数中还可以在格式控制串内出现非格式控制字符，这时在显示屏幕上将原文照印。参数表中给出了输入或输出的量。当有多个量时，用 逗号间隔。例如： printf("sine of %lf is %lf\n",x,s); 其中%lf为格式字符，表示按双精度浮点数处理。它在格式串中两次现，对应了x和s两个变量。其余字符为非格式字符则照原样输出在屏幕上。 【例1.3】 int max(int a,int b); /*函数说明*/ main() /*主函数*/ { int x,y,z; /*变量说明*/ int max(int a,int b); /*函数说明*/ printf("input two numbers:\n"); scanf("%d%d",&x,&y); /*输入x,y值*/ z=max(x,y); /*调用max函数*/ printf("maxmum=%d",z); /*输出*/ } int max(int a,int b) /*定义max函数*/ { if(a>b)return a;else return b; /*把结果返回主调函数*/ } 上面例中程序的功能是由用户输入两个整数，程序执行后输出其中较大的数。本程序由两个函数组成，主函数和max 函数。函数之间是并列关系。可从主函数中调用其它函数。max 函数的功能是比较两个数，然后把较大的数返回给主函数。max 函数是一个用户自定义函数。因此在主函数中要给出说明(程序第三行)。可见，在程序的说明部分中，不仅可以有变量说明，还可以有函数说明。关于函数的详细内容将在以后第五章介绍。在程序的每行后用/*和*/括起来的内容为注释部分，程序不执行注释部分。 上例中程序的执行过程是，首先在屏幕上显示提示串，请用户输入两个数，回车后由scanf函数语句接收这两个数送入变量x,y中，然后调用max函数，并把x,y 的值传送给max函数的参数a,b。在max函数中比较a,b的大小，把大者返回给主函数的变量z，最后在屏幕上输出z的值。 1.9 Ｃ源程序的结构特点 1.一个Ｃ语言源程序可以由一个或多个源文件组成。 2.每个源文件可由一个或多个函数组成。 3.一个源程序不论由多少个文件组成，都有一个且只能有一个main函数，即主函数。 4.源程序中可以有预处理命令(include 命令仅为其中的一种)，预处理命令通常应放在源文件或源程序的最前面。 5.每一个说明，每一个语句都必须以分号结尾。但预处理命令，函数头和花括号“}”之后不能加分号。 6.标识符，关键字之间必须至少加一个空格以示间隔。若已有明显的间隔符，也可不再加空格来间隔。 1.10 书写程序时应遵循的规则 从书写清晰，便于阅读，理解，维护的角度出发，在书写程序时应遵循以下规则： 1.一个说明或一个语句占一行。 2.用{} 括起来的部分，通常表示了程序的某一层次结构。{}一般与该结构语句的第一个字母对齐，并单独占一行。 3.低一层次的语句或说明可比高一层次的语句或说明缩进若干格后书写。以便看起来更加清晰，增加程序的可读性。 在编程时应力求遵循这些规则，以养成良好的编程风格。 1.11 Ｃ语言的字符集 字符是组成语言的最基本的元素。Ｃ语言字符集由字母，数字，空格，标点和特殊字符组成。在字符常量，字符串常量和注释中还可以使用汉字或其它可表示的图形符号。 1.字母 小写字母a～z共26个 大写字母A～Z共26个 2.数字 0～9共10个 3.空白符 空格符、制表符、换行符等统称为空白符。空白符只在字符常量和字符串常量中起作用。在其它地方出现时，只起间隔作用，编译程序对它们忽略不计。因此在程序中使用空白符与否，对程序的编译不发生影响，但在程序中适当的地方使用空白符将增加程序的清晰性和可读性。 4.标点和特殊字符
c语言学生成绩管理系统
05-31
c学生成绩管理系统.rar<br>这次的课程设计和以往写的程序比起来，无论是在篇幅和复杂度上都提高了不少，我在写这个程序的过程中，遇到了不少的困难，也积累了不少的知识和经验，特别是在以前的时候我倍感头疼的文件部分，我也有了一定的了解，我想这对我今后的学习和工作是十分有益的。在这里我特意将在我在写程序过程中的体验和要注意的问题总结如下：<br>一． 基础知识一定要牢固。<br>在调试程序的过程中，有时候程序出了错误，找了半天找不到在哪里。这个时候往往会感觉十分不耐烦，但往往越是一些很小的小错误，越是往往容易被人疏漏，诸如“print”啦，注释引号括号不成对出现，遗漏scanf函数中的&符号等等，而这些却可能导致整个程序不运行，从而浪费了不少的时间。等到发现时，只会郁闷不已。因此，对于一个合格的程序员来说，牢固的基础知识是十分重要的。我们虽然没有必要达到那么高的要求，但牢固的基础知识对于程序的熟练编写和时间的节省也是大有裨益的。<br>二．调试程序的过程中，经验的积累和技巧的掌握是必要的。<br>在这次的课程设计中，由于要编写的程序的篇幅较大，因此不可避免地出现了相当多的错误，调试程序花了我不少的时间。我发现调试程序是有规律和技巧可寻的。/**/注释符号的灵活运用提供了较大的空间。通过程序的分块屏蔽可以很容易地找出错误的所在。函数的运用也是很自然的。因为有时一个临时的功能函数可以让我们很直观地知道一段程序是否正确。当然，有时，错误提示信息可以直接提供错误的所在，但是C语言自动查找错误的功能毕竟是有限的，大多数情况之下，我们还是必须要依靠自己。这时，经验就显的很重要了，我们在平时编写程序时，应多注意有意识地积累一些，会有好处的。<br>三．务求简单<br>我在编写程序的过程中发现，在某一个功能多个算法可以实现的时候，最好采用最简单的方案，这样可以减少出错的几率，也可以省去不少的麻烦。在我的程序中，有一个例子，可以很好地说明这个问题：在编写score_research()函数的时候，有一个地方可以用排序算法实现，也可以用一个标志变量加101然后在函数的末尾处再减101，这样大大地简化了程序，但是运算量也明显地加大了。然而计算机硬件已经发展到今天这个地步，对于我们写的这种小程序，计算速度已经不是问题，因此，务求简单，减少出错率才是正确的选择。<br>四．函数的运用和程序的模块化。<br> 在这次课程设计里，我终于体会到了模块化带来的方便和优越。通过模块化处理，将最初的程序的功能构想以函数的形式划分成几个模块，模块下再设子模块，一层一层直到程序的功能实现为止。这样，不仅程序易于编写，还易于维护。最重要的是，如果程序出错，还易于查找和修改。<br>以上是我在程序的编写过程中的一点心得和体会，虽然很肤浅，但毕竟是通过自己的亲身实践得来的，感受较深。<br><br>另外，在程序的操作中还有一些需要注意的问题，主要有以下几点：<br>一．输入数据时，也就是在执行input()和input_2（）函数的时候，一定要注意按照程序提供的输入顺序输入数据，否则极有可能导致文件的输入错误；还有，由于学生基本情况文件和成绩文件是由input()和input_2（）两个函数先后完成的，所以在输入时一定要注意前后相同学生的姓名一定要相应地一致。如果输入了不同的姓名，虽然不会导致程序出错，但对于程序的结果来说，却是逻辑上的一个大大的错误。<br>二．为了使程序的操作更加简便，人性，我在程序中有加进了一个view_two()函数，目的是为了使程序每执行完一项功能之后，都能出现菜单以供选择，可以非常方便地执行下一个功能。另外，在view_two()函数和view()函数中，我还设置了exit()子函数。执行这个函数，便可以直接返回原代码界面。操作者若是在操作中注意到了这些，将会使操作简单不少。<br>三．当然，不可避免地，由于我的程序大部分是在机房编写和调试完成，时间相对较紧张，再加上我本来就对C语言没有精深的钻研和琢磨，因此程序写得相当粗糙，在有些功能的实现上，只是将其功能大致完成，并未考虑到操作的简便化等问题。例如在input()和input_2（）函数的执行中，本来每个学生的基本情况和成绩应该是在一起输入的，这样才符合一般人的正常思路，但由于学生的基本情况和成绩是由两个函数分别执行完成的，姓名需要输入两次才能将学生的姓名输入到两个结构体中，因为姓名是存储在字符数组里面的，所以用一般的赋值语句是解决不了的。我只好采用了一个原始的办法，把两个结构体里的姓名分别用两个输入语句实现。但这样又导致了另外一个问题，即两次姓名的输入如果不相同时所导致的错误，而且这个问题在学生的数量越多即两次输入离得越远时表现得越突出，但我也想不出更好的办法来解决这个问题了。<br><br>通过这次做课程设计，我感觉我学到了不少的东西，尤其是耐心的培养和在宏观上组织问题的能力让我受益非浅。这不仅是设计程序所必需的，也是今后的学习和工作所不可缺少的。希望我能在这次课程设计的基础上，继续学习更多的C语言的知识，使自己的编程能力更上一层楼。<br>
C语言如何利用异或进行两个值的交换详解
08-29
最近在工作中遇到了两个值交换的需求，发现自己对异或有些忘记，所以索性写出来，方便以后需要的时候参考学习，下面这篇文章主要给大家介绍了关于C语言如何利用异或进行两个值的交换的相关资料，需要的朋友可以参考下。
c语言使用系统,使用C语言入门
weixin_35711852的博客
05-20 906
全部展开逐步学习任何知识始终是最好的方法. 不幸的是，许都知道这个道理，但总是想走所谓的捷径. 如果您是刚刚开始学习编程的中学生，或者是刚刚进入计算机e68a84e8a2ade799bee5baa6e79fa5e9819331333236373234大学的本科生，或者您是决心在计算机领域取得一些成就的初学者，则您必须渴望知道学习计算机技术，我应该从哪里开始.我的建议是: 数学，英语，C语言.我不再...
大一新生应该如何学习C语言，书上代码看不懂理解不了怎么办？
沉默王二
11-09 8万+
大家好，我是二哥呀！ 昨天有个读者问我要 C语言的学习路线，他今年刚上大一，书上的代码完全看不懂。 讲真，大一新生，一般都是零基础的纯小白，看不懂书上的代码很正常，除非是小学、初中、高中就开始卷计算机的硬核少年；或者是因为教材选的有问题。 那刚好二哥之前整理过一些学习 C语言的资料和学习方法，今天趁这个机会就再做个汇总和梳理。 推荐一本书，两门视频课，若干学习建议，看完后如果还看不懂、理解不了C语言，过来骂我、捶我，只要不要打脸就行。 01）阮一峰老师的 C语言入门教程 这个教程是开源的，采用知识共享许可
c语言使用CodeBlocks软件,使用CodeBlocks学习C语言
weixin_42350411的博客
05-20 2844
目录正文一、C语言的优缺点C语言是面向过程的程序设计语言，一门“死而不僵”的语言，优点是稳定、可靠、通用性极强，但是对大型程序来说面向过程的语言使用起来会比较麻烦。1.从命令行获取输入内容使用函数scanf("XX0XX1...",&YY0,&YY1,...)。其中&表示获得数据的地址，获取数据后放到这个地址中，XX是一般的数据类型比如%d、%o等，YY是要赋值的对象。使用...
c语言 函数 的简单使用和学习
qq_63228370的博客
10-28 803
函数是什么 为什么要用函数 怎么样使用函数 使用函数注意什么
c语言常用基础代码大全,C语言基础入门必读
weixin_39954698的博客
05-17 4070
C语言一经出现就以其功能丰富、表达能力强、灵活方便、应用面广等特点迅速在全世界普及和推广。C语言不但执行效率高而且可移植性好，可以用来开发应用软件、驱动、操作系统等。C语言也是其它众多高级语言的鼻祖语言，所以说学习C语言是进入编程世界的必修课。下面我来分享我学习的c语言的一些收获。一、include是一个宏，用来导入头文件1.为什么要导入头文件？因为在这个头文件的库里包含了很多方法，方便我们在工程...
C语言基础知识入门大全
热门推荐
weixin_55305220的博客
05-11 58万+
C语言一经出现就以其功能丰富、表达能力强、灵活方便、应用面广等特点迅速在全世界普及和推广。C语言不但执行效率高而且可移植性好，可以用来开发应用软件、驱动、操作系统等。C语言也是其它众多高级语言的鼻祖语言，所以说学习C语言是进入编程世界的必修课！简单来说，一个C程序就是由若干和组成。就是一条预处理命令, 它的作用是通知C语言编译系统在对C程序进行正式编译之前需做一些预处理工作。就是实现代码逻辑的一个小的单元。一个C程序有且只有一个主函数，即main函数。注释是写给程序员看的，不是写给电脑看的。C语言注释方法有
c语言基础学习笔记 zip
10-16
本次学习笔记以纯文本形式记录，都是一些提纲挈领的内容，方便以后大家的复习和回顾。今后在回顾的过程中看到这些要点部分自己能够独立写出测试代码才算是彻底掌握了C语言的基础语法部分。另外若是遇见感觉模糊的...
学习C语言经验
weixin_50977929的博客
10-12 297
C语言写的代码叫做程序，而程序是计算机能够识别的一组有序的指令，指令则是计算机能够识别的操作。当你写了一组指令之后，计算机会先编译，然后再去执行。而C语言写的代码仅仅是皮肉，作为骨骼存在的是算法（算法是解决一个实际问题的思路），在有了算法之后去根据算法的每一步的目的来编写每一部分的代码，最终便写成了程序。
C语言 | Leetcode C语言题解之第64题最小路径和
m0_59237910的博客
05-02 169
C语言 | Leetcode C语言题解之第64题最小路径和
LeetCode //C - 60. Permutation Sequence
Made in Code
05-03 902
【代码】LeetCode //C - 60. Permutation Sequence。
JAVA 学习·泛型（二）——通配泛型
wr114514的博客
05-02 1102
介绍了Java泛型中的重要知识点——通配泛型及其应用。
STM32CubeMX学习笔记30---FreeRTOS内存管理
H2z1220的博客
05-06 855
FreeRTOS 操作系统将内核与内存管理分开实现，操作系统内核仅规定了必要的内存管理函数原型，而不关心这些内存管理函数是如何实现的，所以在 FreeRTOS 中提供了多种内存分配算法（分配策略），但是上层接口（API）却是统一的。这样做可以增加系统的灵活性：用户可以选择对自己更有利的内存管理策略，在不同的应用场合使用不同的内存分配策略。
Java---类和方法的再学习
m0_74012211的博客
05-05 1141
Java类与对象
场景文本检测&识别学习 day08（无监督的Loss Function、代理任务、特征金字塔）
丿罗小黑的博客
05-03 473
无监督的Loss Function（无监督的目标函数） 根据有无标签，可以将模型的学习方法分为：无监督、有监督两种。而自监督是无监督的一种 无监督的目标函数可以分为以下几种： 生成式网络的做法，衡量模型的输出和固定的目标之间的差距，主要考虑输入数据是怎么分布的，即 “给定Y，如何生成X”。如auto-encoder：输入一张干扰过的图，通过编码器-解码器，然后得出一张还原后的图，通过对比原图和生成的还原后的图之间的差异 判别式网络的做法，衡量模型的输出和固定的目标之间的差异，主要考虑输入和输出的映射关系
力扣数据库题库学习（5.7日）--1757. 可回收且低脂的产品
最新发布
Jesse_Kyrie的博客
05-07 382
这个问题要求的筛选条件很简单，只需要简单的WHERE语句即可 **WHERE low_fats = "Y" AND recyclable="Y";** 太简单了，简直侮辱我的智商。。扛不住😕😕😕
c语言程序设计学习指导pdf
07-07
### 回答1： C语言程序设计学习指导PDF是一份有关于C语言编程学习的指导资料，主要用于帮助初学者掌握C语言的基本知识和编程技巧。 首先，这份指导PDF会从C语言的基础语法开始介绍，包括变量、数据类型、运算符等基本概念。通过理论知识的讲解和示例代码的演示，读者可以逐步了解C语言的基本语法和表达方式。 其次，指导PDF还会介绍C语言中的控制语句，如条件语句、循环语句和选择语句等。这些控制语句是编写程序时非常重要的部分，能够使程序具有逻辑性和灵活性。通过对这些语句的学习和练习，读者可以进一步提高编程能力。 此外，指导PDF还会介绍C语言中的函数和数组等重要内容。函数是C语言中的重要组成部分，能够方便地组织和管理代码。而数组则可以用来存储大量数据，并进行相应的处理和操作。通过对函数和数组的学习，读者可以更好地理解C语言的编程思想和实践技巧。 最后，指导PDF还会提供一些编程实例和练习题，帮助读者巩固所学的知识并提高解决问题的能力。这些实例和练习题涵盖了各个方面的内容，旨在让读者通过实际练习掌握C语言编程的技巧和经验。 综上所述，C语言程序设计学习指导PDF是一份很有价值的教材，通过系统地介绍C语言的基本知识和编程技巧，能够帮助初学者快速入门，并为进一步学习和应用C语言奠定良好的基础。 ### 回答2： 《C语言程序设计学习指导PDF》是一本针对C语言程序设计学习的电子书，提供了全面而系统的学习指导。本书主要包括以下内容： 首先，本书介绍了C语言的基本语法和特性。它从简单的变量定义和基本的运算符开始，逐步深入讲解了循环、条件语句、数组和指针等重要概念。通过这些内容的讲解，读者可以了解C语言的基本结构和用法。 其次，本书通过大量的实例演示了C语言的实际应用。这些实例包括从简单的计算器程序到复杂的图形界面设计等各种各样的应用场景。通过实例的学习，读者可以进一步掌握C语言的应用技巧和工程开发方法。 此外，本书还提供了一些实用的学习辅助工具。包括编程环境的安装和配置、调试技巧的介绍、常见问题的解答等。这些工具和技巧的介绍可以帮助读者更好地进行学习和实践。 最后，本书还提供了一些进阶的内容和扩展知识。包括C语言标准库的使用、文件操作、动态内存管理等。这些内容对于想要深入学习和应用C语言的读者来说是非常有用的。 总之，《C语言程序设计学习指导PDF》是一本系统全面的学习资料，它通过详细的介绍和实例演示，帮助读者理解和掌握C语言的基本知识和应用技巧。阅读本书可以帮助读者快速入门C语言程序设计，并为进一步深入学习和应用提供了基础。 ### 回答3： C语言程序设计是计算机科学中一门基础性的编程语言，学习C语言对于初学者来说是非常重要的。学习C语言可以帮助我们了解计算机的工作原理，培养良好的编程习惯，并为以后学习其他高级编程语言打下坚实的基础。 关于C语言程序设计的学习指导PDF，这是一本教材，提供了系统的学习方法和基础知识。它通常包含以下内容： 1. 介绍：有关C语言的发展历程、特点和重要性的介绍，以激发学习兴趣。 2. 基础知识：从C语言的语法规则开始，逐步介绍变量、数据类型、运算符、控制语句等基础知识。 3. 函数：详细介绍了函数的定义、调用和参数传递等内容，让学习者能够掌握函数的使用和编写。 4. 数组和指针：介绍了数组和指针的概念及其应用，这些是C语言中非常重要的概念，对于学习和理解其他高级数据结构和算法也非常有帮助。 5. 输入输出：详细介绍了C语言中各种输入输出函数的使用方法，让学习者能够灵活运用，实现程序的输入和输出。 6. 文件处理：介绍了如何使用C语言处理文件，包括读取和写入文件的操作，以及文件指针的使用。 7. 综合练习：提供了一些练习题和项目，以帮助学习者巩固所学知识，并培养实际编程的能力。 总的来说，C语言程序设计学习指导PDF是一种很好的学习资源，可以帮助初学者系统地学习C语言的基础知识和编程技巧。通过研读这本教材，学习者能够逐步掌握C语言的编程思想和实践技巧，为以后的学习和工作打下坚实的基础。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值