8/5作业

最新推荐文章于 2024-08-07 11:15:21 发布
最新推荐文章于 2024-08-07 11:15:21 发布
阅读量785 收藏 20
点赞数 21
文章标签： java 服务器 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yyzzhd/article/details/140935867
版权

三、进程间通信（IPC）

3.1进程间通信的引入

1> 对于多个线程之间通信，我们可以使用临界资源来完成，通过一个线程任务对临界资源进行修改，另一个线程也可以使用已经修改过的临界资源，但是要注意使用同步互斥机制完成对临界资源的保护

2> 多个进程之间能否使用全局变量来进行进程间通信？

答：不能，多个进程之间的用户空间是相互独立的，每个进程的全局变量是各个进程独立拥有的，更改一个进程的全局变量，另一个进程不会受到影响，故而不能使用全局变量来完成通信

3> 有同学说：使用文件来完成进程间通信？

答：可行，但是要求写进程先完成向文件中写入数据，然后读进程才能读取数据，必须要加入进程的同步操作

4> 多个进程之间内核空间是共享的，我们可以通过将数据放入到内核空间，来完成两个进程之间信息的交流

5> 进程间通信方式：

1、内核提供的原始通信方式
        无名管道
        有名管道
        信号
2、system V提供三种
        消息队列
        共享内存
        信号量集

3.2 无名管道

1> 顾名思义就是没有名字的管道文件，所以只能适用于亲缘进程间的通信

2> 原理：通过内核，在内存中创建出一个管道文件，存放在内存空间，并不在文件系统中真实存在。当打开该文件时，会返回该文件的两个文件描述符，分别对应读端和写端。可以通过读端从管道中读取数据，从写端向管道中写入数据。当该文件的读写两端全部被关闭后，该管道文件会在内存中消失

3> 注意：由于打开管道时返回的是文件描述符，所以，对该文件的操作，只能使用文件IO

对于存入管道中的数据的读取是一次性的，当数据读取结束后，数据就不存在于管道文件中了

4> 无名管道的API接口函数

       #include <unistd.h>

       int pipe(int pipefd[2]);
       功能：在通过内核在内存中创建一个无名管道，并通过参数将该管道文件的两个文件描述符返回
       参数：接收文件描述符的数组，pipefd[0]表示管道文件的读端，pipefd[1]表示管道的写端
       返回值：成功返回0，失败返回-1并置位错误码

#include<myhead.h>

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

    //创建用于通信的管道文件，并返回该文件对应的文件描述符
    int pipefd[2] ;
    if(pipe(pipefd)==-1)
    {
        perror("pipe error");
        return -1;
    }


    //创建父子进程
    pid_t pid = fork();
    if(pid < 0)
    {
        perror("fork error");
        return -1;
    }else if(pid  == 0)
    {
        //子进程
        close(pipefd[1]);          //关闭写端
    
        //接受父进程发来的消息
        char rbuf[128] = "";

        while(1)
        {
            bzero(rbuf, sizeof(rbuf));

            //从管道中读取数据
            read(pipefd[0], rbuf, sizeof(rbuf));

            if(strcmp(rbuf, "quit")==0)
            {
                break;
            }

            //输出数据
            printf("收到父进程的来信：%s\n", rbuf);
        }

        //关闭读段
        close(pipefd[0]);


        //退出进程
        exit(EXIT_SUCCESS);
    }

    //父进程
    char sbuf[128] = "";
     //关闭读端
    close(pipefd[0]);
    while(1)
    {        

        usleep(10);
        printf("父进程中输入>>>");
        fgets(sbuf, sizeof(sbuf), stdin);          //从终端获取字符串
        sbuf[strlen(sbuf)-1] = 0;

        //发送给子进程,将数据通过写端写入管道 pipefd[1]
        write(pipefd[1], sbuf, strlen(sbuf));

        //判断终端获取的数据
        if(strcmp(sbuf, "quit") == 0)
        {
            break;
        }

        //关闭写端
        close(pipefd[1]);
    }

    

    //回收子进程资源
    wait(NULL);

    return 0;
}

5> 总结管道通信的特点

1、管道通信是半双工的通信方式
    单工：任意时刻只能A向B发送消息，B不能向A发送消息
    半双工：同一时刻，只能A向B发送消息或者B向A发消息
    全双工：任意时刻，AB可以互相发送消息
2、无名管道只适用于亲缘进程间通信
3、无名管道也能完成自己跟自己的通信
4、无名管道文件的大小：64KB

6> 管道的读写特点（笔试面试）

1、当管道读端存在时，写管道有多少写多少，直到写满64K为止
2、当管道读端不存在时，写管道写入数据时，会出现管道破裂，此时内核空间会向用户空间发送一个SIGPIPE信号
3、当写端存在时，读管道有多少读多少，没有数据会在read处阻塞
4、当写端不存在时，读管道有多少读多少，没有数据也不会在read处阻塞

#include<myhead.h>

int main(int argc, const char *argv[])
{
    //创建一个五名管道
    int fds[2];

    if(pipe(fds) == -1)
    {
        perror("pipe error");
        return -1;
    }

    //向管道中写入数据
    char buf = 'A';
    int count = 0;       //记录写入的大小
    while(1)
    {
        write(fds[1], &buf, 1);
        count ++;
        printf("count = %d\n", count);
        //关闭读端
        close(fds[0]);
    }


    while(1);

    return 0;
}
#include<myhead.h>

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

    //创建用于通信的管道文件，并返回该文件对应的文件描述符
    int pipefd[2] ;
    if(pipe(pipefd)==-1)
    {
        perror("pipe error");
        return -1;
    }


    //创建父子进程
    pid_t pid = fork();
    if(pid < 0)
    {
        perror("fork error");
        return -1;
    }else if(pid  == 0)
    {
        //子进程
        close(pipefd[1]);          //关闭写端
    
        //接受父进程发来的消息
        char rbuf[128] = "";

        while(1)
        {
            bzero(rbuf, sizeof(rbuf));

            //从管道中读取数据
            read(pipefd[0], rbuf, sizeof(rbuf));

            if(strcmp(rbuf, "quit")==0)
            {
                break;
            }

            //输出数据
            printf("收到父进程的来信：%s\n", rbuf);
        }

        //关闭读段
        close(pipefd[0]);


        //退出进程
        exit(EXIT_SUCCESS);
    }

    //父进程
    char sbuf[128] = "";
    //关闭读端
    close(pipefd[0]);
    while(1)
    {


        usleep(10);
        printf("父进程中输入>>>");
        fgets(sbuf, sizeof(sbuf), stdin);          //从终端获取字符串
        sbuf[strlen(sbuf)-1] = 0;

        //发送给子进程,将数据通过写端写入管道 pipefd[1]
        write(pipefd[1], sbuf, strlen(sbuf));

        //判断终端获取的数据
        if(strcmp(sbuf, "quit") == 0)
        {
            break;
        }

        //关闭写端
        close(pipefd[1]);


    }

    //关闭写端
    close(pipefd[1]);

    //回收子进程资源
    wait(NULL);

    return 0;
}

3.3 有名管道

1> 顾名思义就是有名字的管道文件，会在文件系统中创建一个有名字的管道文件

2> 可以用于亲缘进程间的通信，也可以用于非亲缘进程间的通信

3> 有名管道的API函数

       #include <sys/types.h>
       #include <sys/stat.h>

       int mkfifo(const char *pathname, mode_t mode);
    功能：在文件系统中创建一个有名管道，但是并没有打开该文件
    参数1：有名管道的名称
    参数2：管道文件的权限
    返回值：成功返回0，失败返回-1并置位错误码

create.c

#include<myhead.h>

int main(int argc, const char *argv[])
{
    //创建一个有名管道文件
    if(mkfifo("./linux", 0664)==-1)
    {
        perror("mkfifo error");
        return -1;
    }

    getchar();

    system("rm linux");
    
    return 0;
}

snd.c

#include<myhead.h>

int main(int argc, const char *argv[])
{
    //以写的形式打开管道文件
    int wfd = open("./linux", O_WRONLY);
    if(wfd == -1)
    {
        perror("open error");
        return -1;
    }
    printf("管道文件已经打开\n");

    //发送数据
    char wbuf[128] = "";
    while(1)
    {
        printf("请输入>>>>");
        fgets(wbuf, sizeof(wbuf), stdin);
        wbuf[strlen(wbuf)-1] = 0;

        //将数据发送给到管道中
        write(wfd, wbuf, strlen(wbuf));

        //判断数据
        if(strcmp(wbuf, "quit") == 0)
        {
            break;
        }
    }

    //关闭文件描述符
    close(wfd);

    
    return 0;
}

recv.c

#include<myhead.h>

int main(int argc, const char *argv[])
{
    //以读的形式打开文件
    int rfd = open("./linux", O_RDONLY);
    if(rfd == -1)
    {
        perror("open error");
        return -1;
    }
    printf("管道文件读端打开\n");

    //定义接受容器
    char rbuf[128] = "";
    while(1)
    {
        bzero(rbuf, sizeof(rbuf));
        //读取数据
        read(rfd, rbuf, sizeof(rbuf));
        if(strcmp(rbuf, "quit") == 0)
        {
            break;
        }
        printf("收到消息为：%s\n", rbuf);
    }

    //关闭文件描述符
    close(rfd);
    
    return 0;
}

3.4 信号通信

1> 信号通信原理图：两个异步通信的进程之间，通过发送相关信号，完成任务间的通信

2> 信号是linux中软件模拟硬件的“中断”的一种方式。信号是软件部分的名词，中断是硬件部分的名词

3> 能够发送的信号可以通过指令：kill -l进行查看

 1) SIGHUP     2) SIGINT     3) SIGQUIT     4) SIGILL     5) SIGTRAP
 6) SIGABRT     7) SIGBUS     8) SIGFPE     9) SIGKILL    10) SIGUSR1
11) SIGSEGV    12) SIGUSR2    13) SIGPIPE    14) SIGALRM    15) SIGTERM
16) SIGSTKFLT    17) SIGCHLD    18) SIGCONT    19) SIGSTOP    20) SIGTSTP
21) SIGTTIN    22) SIGTTOU    23) SIGURG    24) SIGXCPU    25) SIGXFSZ
26) SIGVTALRM    27) SIGPROF    28) SIGWINCH    29) SIGIO    30) SIGPWR
31) SIGSYS    34) SIGRTMIN    35) SIGRTMIN+1    36) SIGRTMIN+2    37) SIGRTMIN+3
38) SIGRTMIN+4    39) SIGRTMIN+5    40) SIGRTMIN+6    41) SIGRTMIN+7    42) SIGRTMIN+8
43) SIGRTMIN+9    44) SIGRTMIN+10    45) SIGRTMIN+11    46) SIGRTMIN+12    47) SIGRTMIN+13
48) SIGRTMIN+14    49) SIGRTMIN+15    50) SIGRTMAX-14    51) SIGRTMAX-13    52) SIGRTMAX-12
53) SIGRTMAX-11    54) SIGRTMAX-10    55) SIGRTMAX-9    56) SIGRTMAX-8    57) SIGRTMAX-7
58) SIGRTMAX-6    59) SIGRTMAX-5    60) SIGRTMAX-4    61) SIGRTMAX-3    62) SIGRTMAX-2
63) SIGRTMAX-1    64) SIGRTMAX  

4> 对于信号的处理方式有三种：默认、捕获、忽略

有两个信号既不能被捕获，也不能被忽略：SIGKILL、SIGSTOP

5> 上面的信号触发条件以及默认处理方式可以通过指令 man 7 signal进行查看

  Signal     Value     Action   Comment
       ──────────────────────────────────────────────────────────────────────
       SIGHUP        1       Term    Hangup detected on controlling terminal
                                     or death of controlling process
       SIGINT        2       Term    Interrupt from keyboard
       SIGQUIT       3       Core    Quit from keyboard
       SIGILL        4       Core    Illegal Instruction
       SIGABRT       6       Core    Abort signal from abort(3)
       SIGFPE        8       Core    Floating-point exception
       SIGKILL       9       Term    Kill signal
       SIGSEGV      11       Core    Invalid memory reference
       SIGPIPE      13       Term    Broken pipe: write to pipe with no
                                     readers; see pipe(7)
       SIGALRM      14       Term    Timer signal from alarm(2)
       SIGTERM      15       Term    Termination signal
       SIGUSR1   30,10,16    Term    User-defined signal 1
       SIGUSR2   31,12,17    Term    User-defined signal 2
       SIGCHLD   20,17,18    Ign     Child stopped or terminated
       SIGCONT   19,18,25    Cont    Continue if stopped
       SIGSTOP   17,19,23    Stop    Stop process
       SIGTSTP   18,20,24    Stop    Stop typed at terminal
       SIGTTIN   21,21,26    Stop    Terminal input for background process
       SIGTTOU   22,22,27    Stop    Terminal output for background process
 

6> 信号的发送者可以是内核、其他进程、用户自己

7> 将信号与信号处理方式连接函数

       #include <signal.h>

       typedef void (*sighandler_t)(int);

       sighandler_t signal(int signum, sighandler_t handler);
       功能：将信号与信号处理函数绑定到一起
       参数1：要绑定的信号
       参数2：信号处理函数
               SIG_IGN：表示忽略信号
               SIG_DFL：表示默认处理
               填自定义函数的入口地址
        返回值：成功返回处理方式的起始地址，失败返回 SIG_ERR
 

#include<myhead.h>
//自定义处理信号的函数
void handler(int signo)
{
    //判断传过来的信号是哪个
    if(signo == SIGINT)
    {
        printf("当前进程收到了ctrl + c，但是就是关不掉\n");
    }

    //判断是否为SIGKILL到位
    if(signo == SIGKILL)
    {
        printf("捕获了SIGKILL\n");
    }
    
}


/**************************主程序*******************/
int main(int argc, const char *argv[])
{

    //将2号信号与对应的信号处理函数进行绑定
    /*尝试忽略2号信号
    if(signal(2, SIG_IGN) == SIG_ERR)
    {
        perror("signal error");
        return -1;
    }
    */

    //尝试捕获2号信号
    if(signal(2, handler) == SIG_ERR)
    {
        perror("signal error");
        return -1;
    }

    /*尝试忽略SIGKILL信号：报错，参数不合法
        if(signal(SIGKILL, handler) == SIG_ERR)
    {
        perror("signal error");
        return -1;
    }*/

    /*尝试捕获SIGKILL信号：报错，参数不合法
        if(signal(SIGKILL, handler) == SIG_ERR)
    {
        perror("signal error");
        return -1;
    }
    */

    /*尝试默认处理:报错，参数不合法
    if(signal(SIGKILL, SIG_DFL) == SIG_ERR)
    {
        perror("signal error");
        return -1;
    }*/


    while(1)
    {
        printf("啦啦啦啦，我是卖报的小行家\n");
        sleep(1);
    }
    

    return 0;
}

3.5 特殊的信号处理

1> SIGCHLD信号：以非阻塞的形式回收僵尸进程

#include<myhead.h>

//自定义信号处理函数
void handler(int signo)
{
    if(signo == SIGCHLD)
    {
        while(1)
        {
            //判断是否将僵尸进程全部回收了
            if(waitpid(-1, NULL, WNOHANG) == 0)
            {
                break;
            }
        }
    }
}

/******************主程序**********************/
int main(int argc, const char *argv[])
{
    //将SIGCHLD信号与信号处理函数绑定到一起
    if(signal(SIGCHLD, handler) == SIG_ERR)
    {
        perror("signal error");
        return -1;
    }


    for(int i=0; i<10; i++)
    {
        if(fork() == 0)
        {
            exit(EXIT_SUCCESS);
        }
    
    }

    while(1);

    /*
    for(;;)
    {
        printf("我是小妖怪，逍遥游自在\n");
        sleep(1);
    }*/

    return 0;
}

2> SIGALRM：定时器信号

程序允许启动一个定时器，当所定的时间到位后，会发送一个SIGALRM信号，我们可以将该信号绑定到对应的信号处理函数中，从而导致，给定时间后，处理自定义函数。该信号需要使用一个函数来发送超时信号：alarm闹钟函数

 #include <unistd.h>

       unsigned alarm(unsigned seconds);
    功能：给进程设置一个定时器，以秒为单位，当定时器到位后，后向该进程发送一个SIGALRM的信号
    参数：秒数，如果参数设置成0，表示删除定时器
    返回值：>0:表示返回的上一个定时器剩余的秒数，并且重置上一个定时器
            0：表示之前没有设置定时器

作业

1> 使用有名管道实现，一个进程用于给另一个进程发消息，另一个进程收到消息后，展示到终端上，并且将消息保存到文件上一份

create.c

#include<myhead.h>

int main(int argc, char const *argv[])
{
    if (mkfifo("./1",0664)==-1)
    {
        perror("mkfifo error");
        return -1;
    }
    getchar();
    system("rm 1");
    return 0;
}

read.c

#include<myhead.h>

int main(int argc, char const *argv[])
{
    int rfd=open("./1",O_RDONLY);
    if (rfd==-1)
    {
        perror("open error");
        return -1;
    }
    
    char rbuf[128]="";
    

    int wfd=open("./file.txt",O_WRONLY|O_CREAT|O_TRUNC,0664);
    if (wfd==-1)
    {
        perror("open file error");
        return -1;
    }
    printf("读取管道已经打开\n");
    while (1)
    {
        bzero(rbuf,sizeof(rbuf));
        read(rfd,rbuf,sizeof(rbuf));
        if (strcmp(rbuf,"quit")==0)
        {
            break;
        }
        printf("%s\n",rbuf);
        
        write(wfd,rbuf,strlen(rbuf));
    }
    

    return 0;
}

snd.c

#include <myhead.h>

int main(int argc, char const *argv[])
{
    int wfd = open("./1", O_WRONLY);
    if (wfd == -1)
    {
        perror("open error");
        return -1;
    }
    printf("管道已经打开\n");
    char wbuf[128] = "";
    while (1)
    {
        usleep(10);
        printf("写入进程输入>>>");
        fgets(wbuf, sizeof(wbuf), stdin); // 从终端获取字符
        wbuf[strlen(wbuf) - 1] = 0;
        write(wfd, wbuf, strlen(wbuf));
        if (strcmp(wbuf, "quit") == 0)
        {
            break;
        }
    }
    return 0;
}

2> 使用有名管道实现两个进程间相互通信

create.c

#include <myhead.h>

int main(int argc, char const *argv[])
{
    int wfd = open("./1", O_WRONLY);
    if (wfd == -1)
    {
        perror("open error");
        return -1;
    }
    printf("管道已经打开\n");
    char wbuf[128] = "";
    while (1)
    {
        usleep(10);
        printf("写入进程输入>>>");
        fgets(wbuf, sizeof(wbuf), stdin); // 从终端获取字符
        wbuf[strlen(wbuf) - 1] = 0;
        write(wfd, wbuf, strlen(wbuf));
        if (strcmp(wbuf, "quit") == 0)
        {
            break;
        }
    }
    return 0;
}

02.c

#include <myhead.h>
void *task1()
{
    int wfd = open("./1", O_WRONLY);
    if (wfd == -1)
    {
        perror("open error");
        
        pthread_exit(NULL);
    }
    printf("管道已经打开\n");
    char wbuf[128] = "";
    while (1)
    {
        usleep(10);
        printf("写入进程输入>>>");
        fgets(wbuf, sizeof(wbuf), stdin); // 从终端获取字符
        wbuf[strlen(wbuf) - 1] = 0;
        write(wfd, wbuf, strlen(wbuf));
        if (strcmp(wbuf, "quit") == 0)
        {
            
            break;
        }
    }
}

void *task2()
{
    int rfd = open("./2", O_RDONLY);
    if (rfd == -1)
    {
        perror("open error");
        pthread_exit(NULL);
    }

    printf("管道文件读端打开\n");
    char rbuf[128] = "";
    while (1)
    {
        bzero(rbuf, sizeof(rbuf));
        read(rfd, rbuf, sizeof(rbuf));
        if (strcmp(rbuf, "quit") == 0)
        {
            printf("对方已经关闭输入通道\n");
            break;
        }
        printf("收到消息为:%s\n", rbuf);
    }

}

int main(int argc, char const *argv[])
{
    pthread_t tid1, tid2;
    if (pthread_create(&tid1, NULL, task1, NULL) != 0)
    {
        perror("pthread error");
        return -1;
    }
    if (pthread_create(&tid2, NULL, task2, NULL) != 0)
    {
        perror("pthread error");
        return -1;
    }
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);

    return 0;
}

03.c

#include <myhead.h>
void *task1()
{
    int wfd = open("./2", O_WRONLY);
    if (wfd == -1)
    {
        perror("open error");
        
        pthread_exit(NULL);
    }
    printf("管道已经打开\n");
    char wbuf[128] = "";
    while (1)
    {
        usleep(10);
        printf("写入进程输入>>>");
        fgets(wbuf, sizeof(wbuf), stdin); // 从终端获取字符
        wbuf[strlen(wbuf) - 1] = 0;
        write(wfd, wbuf, strlen(wbuf));
        if (strcmp(wbuf, "quit") == 0)
        {
            break;
        }
    }
}

void *task2()
{
    int rfd = open("./1", O_RDONLY);
    if (rfd == -1)
    {
        perror("open error");
        pthread_exit(NULL);
    }

    printf("管道文件读端打开\n");
    char rbuf[128] = "";
    while (1)
    {
        bzero(rbuf, sizeof(rbuf));
        read(rfd, rbuf, sizeof(rbuf));
        if (strcmp(rbuf, "quit") == 0)
        {
            printf("对方已经关闭输入通道\n");
            break;
        }
        printf("收到消息为:%s\n", rbuf);
    }

}

int main(int argc, char const *argv[])
{
    pthread_t tid1, tid2;
    if (pthread_create(&tid1, NULL, task1, NULL) != 0)
    {
        perror("pthread error");
        return -1;
    }
    if (pthread_create(&tid2, NULL, task2, NULL) != 0)
    {
        perror("pthread error");
        return -1;
    }
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);

    return 0;
}

思维导图

yyzzhd
关注
  • 21
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于eNSP的IPv4加IPv6的企业/校园网络规划设计(综合实验/大作业)
m0_46179473的博客
04-28 7万+
该topo网络中用到的技术有vlan划分、eth-trunk捆绑、MSTP、VRRP、、DHCP中继、OSPF、BFD故障检测、端口安全及隔离、无线WLAN、PPPoE、IS-IS、BGP、MPLS V*N、DHCPsnooping、NQA、NATserver地址映射、NAT(地址池、easyIP两种转换)、telnet、ACL、IPsec V*N、路由引入、默认路由、FW的安全策略规划、ISISv6、OSPFv3、DHCPv6、6to4隧道、BGP4+等。该实验非常具有代表性
Java课程设计/大作业合集
weixin_45344924的博客
06-18 2万+
JavaSE、JavaEE课程设计/大作业/毕业设计，汽车租赁系统、员工管理系统、超市管理系统、网上购物商城
一个简单的网页设计HTML5作业
热门推荐
好好读书
06-26 9万+
简单的html设计作业，初次学习，希望指正！
python有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13...求出这个数列的前20项之和。
当路danglu0010
03-28 1万+
【开发该软件的操作系统】：windows10 【软件开发环境/开发工具】：PyCharm 【编程语言】：Python 【开发目的】：这是老师布置的作业啦~ 供初学者参考学习 【开发者】：江西农业大学2020级大二学生 要求： 有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13...求出这个数列的前20项之和。 分析： 这道题与斐波那契数列有关：斐波那契数列 代码如下： （一）取自：python有一分数序列 # 有一分数序列：2/1，3/2，5/3，8/5，13/8，2
计算数列和2/1，3/2，5/3，8/5......
hqm793899006的博客
11-05 6461
题目描述 有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13，…… 计算这个数列的前n项和。注意：C语言中整数/整数的结果为整数；需要用(float)强制转换为实型或乘以1.0后进行计算。 输入 输入一个正整数n。 输出 输出数列的前n项和(保留两位小数）,输出格式可为：printf(“s=%.2f\n”,…);。 样例输入 10 样例输出 s=16.48 提示 C语言中整数/整数...
ASP.NET大作业/ASP.NET期末项目/大作业
weixin_44971189的博客
05-24 1万+
ASP.NET项目期末大作业 这是一些纯asp.net开发的一些项目(7个)，在我的github账号里面。每个项目还有相对应的开发文档，mdf,ldf文件都在里面，感兴趣的朋友可以通过我的链接跳转到我的github，进不去的朋友可以访问国内的gitee。 github链接跳转 gitee跳转 如果觉得有用的话可以点个星哦，有什么不懂的可以私信我。 截图 ...
python练习题（十九）：有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13...求出这个数列的前n项之和
biubiusion的博客
03-17 2万+
# 题目： # 有一分数序列： # 2/1，3/2，5/3，8/5，13/8，21/13... # 求出这个数列的前n项之和 n = int(input("请输入求和项数：")) n_sum = 0 # 记录前n项和 a = 1 # 分母 b = 2 # 分子 for i in range(n): n_sum += b / a a, b = b, a + b prin...
【python】计算1-1/2+2/3-3/5+5/8-8/13+...的前n项和，n由用户输入（n＞0)，结果用str.format()方法保留小数点后6位数字输出
fuli4869的博客
05-10 3332
【代码】计算1-1/2+2/3-3/5+5/8-8/13+...的前n项和，n由用户输入（n＞0)，结果用str.format()方法保留小数点后6位数字输出。
C语言 ：有一个分数序列 2/1,3/2,5/3,8/5,13/8,21/13,....... 求出这个序列的前20项之和 （有注释）
xiaoxiaoaqian的博客
06-02 1万+
//观察可知： //第二项的分子为：第一项的分子和分母之和 //第二项的分母为：第一项的分子 # include <stdio.h> int main (void) { int k; //k为数列的项数 double i,j,s,t; //i为分母；j为分子；s为数列之和；t用来交换i和j的值 i=1; //第一个分数的分母为1，所以定义i为1 j=2; //第一个分数的分子为2，所以定义j为2 s=0; for(k=1;k<=20;k++
网页编程课程大作业实验报告HTML5 、CSS5 、JavaScript
weixin_47659667的博客
04-12 9578
EditPlus做的简陋网页
Python3+PyQt5的串口工具，具有stm32、stm8的下载功能.zip（皆可应用在毕设/课设/大作业/实训/竞赛/项目
03-29
相关项目设计中，皆可应用在项目开发、毕业设计、课程设计、期末/期中/大作业、工程实训、大创等学科竞赛比赛、初期项目立项、学习/练手等方面中 可借鉴此优质项目实现复刻，也可以基于此项目进行扩展来开发出更多...
Web课设/大作业 （HTML）
01-27
5. **网页交互**：虽然描述中未提及JavaScript，但高级的Web设计可能包含了简单的交互元素，如按钮点击事件、表单验证或者动态效果，这些都是通过JavaScript实现的。 6. **文件组织**：项目包含的“大作业”可能是...
asp.net大作业
09-20
5. **数据访问层**：项目可能包含了与数据库的交互，例如使用ADO.NET、Entity Framework或其他ORM（对象关系映射）工具来连接和操作数据库，如SQL Server。 6. **状态管理**：ASP.NET提供了多种状态管理机制，如...
西工大C/C++大作业
06-08
5. **文件操作**：学会读写文件，包括文件的打开、关闭、读取和写入操作。 6. **内存管理**：理解动态内存分配（malloc/calloc/free）和栈与堆的区别。 7. **面向对象编程**（C++特有）：掌握类的定义，对象的创建...
YOLOV8/V7/V5的PCB缺陷检测:可视化界面+GUI+目标计数+视频目标检测与跟踪
07-20
聚焦计算机相关专业毕设及实战操练，可作课程设计与期末大作业，含全部源码，能直用于毕设，所有源码都经过严格测试，可以直接运行。功能在确认正常工作后才上传。 YOLOV8/V7/V5的PCB缺陷检测:可视化界面+GUI+目标...
【Spring Boot】高效配置管理: 易用性与灵活性并重
weixin_68020300的博客
08-07 1252
本文探讨了Spring Boot中多样化的配置读取方法及其应用场景，强调了配置管理的重要性，并展示了Spring Boot如何通过灵活多变的配置选项简化这一过程。此外，文章还展望了配置管理领域未来的技术趋势和发展方向。对于任何希望深入了解Spring Boot配置管理的开发者来说，这是一篇不容错过的好文。
C++ - 函数重载
jiaowenjie的专栏
08-06 329
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
伐木工 (100%用例)D卷 (Java&&Python&&C++&&Node.js&&C语言)
荆赫同艺的博客
08-07 224
一根 4米长的树木，伐木工不需要切割为 2*2，省去切割成本，直接整根树木交易，为 4*1，收益最大为 4。方式二: 3,2,2,3，但方式二，伐木工多切割一次，增加了切割成本却卖了一样的价格，因此并不是最优收益。一根 2 米长的树木，伐木工不切割，为2*1，收益最大为 2。一根5 米长的树木，伐木工切割为 2*3,收益最大为 6。输出最优收益时的各个树木长度，以空格分隔，按升序排列。一根 10 米长的树木，伐木工可以切割。方式一:3,4,4，也可以切割为。
Spring事务
最新发布
c1tenj2的博客
08-07 436
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
java课程设计/大作业
06-16
Java课程设计或大作业通常是为了让学生将所学的Java知识应用于实际项目中，提升编程能力和解决问题的能力。这类任务通常包含以下几个部分： 1. **选择主题**：你可以选择与日常应用相关的项目，如银行系统、在线商城、学生管理系统、图书管理系统等，或者是游戏开发、数据分析等。 2. **需求分析**：明确项目的目标和功能需求，比如用户登录、数据操作、界面展示等。 3. **设计阶段**：使用UML（统一建模语言）进行系统架构设计，包括类图、接口图、序列图等。 4. **编码实现**：使用Java编写代码，按照面向对象原则（封装、继承、多态）组织代码，可能还会用到设计模式。 5. **数据库管理**：如果涉及数据存储，需要学习如何使用SQL和JDBC进行数据库操作。 6. **异常处理**：考虑边界条件和错误处理，确保程序健壮性。 7. **测试与调试**：编写单元测试和集成测试，通过调试找出并修复问题。 8. **文档撰写**：提供详细的设计文档和用户手册，解释系统的功能和使用方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值