用c++实现stop and wait协议

以下是使用C语言实现stop-and-wait协议的示例代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <stdbool.h>

#define MAX_PKT_SIZE 1024   // 数据包最大大小
#define TIMEOUT 5           // 超时时间（秒）
#define MAX_SEQ 1           // 最大序号

typedef enum {
    frame_arrival,  // 数据帧到达事件
    timeout,        // 超时事件
    network_layer_ready,    // 网络层准备好事件
} event_type;

typedef struct {
    char data[MAX_PKT_SIZE];    // 数据
} packet;

typedef struct {
    int seq;        // 序列号
    int ack;        // 确认号
    packet info;    // 数据帧
} frame;

frame *sender_frame = NULL; // 发送方数据帧
frame *receiver_frame = NULL;   // 接收方数据帧

bool network_layer_ready = false;   // 网络层是否准备好
bool ack_received = false;  // 是否收到确认帧
bool timeout_occurred = false;  // 是否发生超时

int seq_num = 0;    // 序列号

// 发送数据帧
void send_data(frame *f) {
    printf("Sending data: %s\n", f->info.data);
}

// 发送确认帧
void send_ack(int ack) {
    printf("Sending ACK: %d\n", ack);
}

// 模拟网络层发送数据
void from_network_layer(packet *p) {
    printf("Enter data to send: ");
    fgets(p->data, MAX_PKT_SIZE, stdin);
    network_layer_ready = true;
}

// 模拟网络层接收数据
void to_network_layer(packet *p) {
    printf("Received data: %s", p->data);
}

// 模拟物理层发送数据帧
void to_physical_layer(frame *f) {
    send_data(f);
}

// 模拟物理层接收数据帧
void from_physical_layer(frame *f) {
    if (ack_received) {
        // 收到确认帧，清除ack_received
        ack_received = false;
        return;
    }
    printf("Enter ACK to send: ");
    scanf("%d", &f->ack);
    getchar();  // 读取换行符
    send_ack(f->ack);
}

// 发送方事件处理
void sender(event_type event) {
    switch (event) {
        case network_layer_ready:
            // 网络层准备好，发送数据帧
            from_network_layer(&sender_frame->info);
            sender_frame->seq = seq_num;
            to_physical_layer(sender_frame);
            printf("Sent frame with seq#%d\n", seq_num);
            seq_num = (seq_num + 1) % (MAX_SEQ + 1);
            break;
        case timeout:
            // 超时事件，重新发送数据帧
            printf("Timeout occurred, resending frame with seq#%d\n", sender_frame->seq);
            to_physical_layer(sender_frame);
            break;
        case frame_arrival:
            // 收到确认帧，清除ack_received
            from_physical_layer(receiver_frame);
            ack_received = true;
            break;
    }
}

// 接收方事件处理
void receiver(event_type event) {
    switch (event) {
        case frame_arrival:
            // 数据帧到达，发送确认帧并交付数据
            from_physical_layer(sender_frame);
            if (sender_frame->seq == receiver_frame->ack) {
                to_network_layer(&sender_frame->info);
                receiver_frame->ack = (receiver_frame->ack + 1) % (MAX_SEQ + 1);
            }
            printf("Received frame with seq#%d, sending ACK#%d\n", sender_frame->seq, receiver_frame->ack);
            to_physical_layer(receiver_frame);
            break;
    }
}

int main() {
    // 初始化数据帧
    sender_frame = (frame *) malloc(sizeof(frame));
    receiver_frame = (frame *) malloc(sizeof(frame));

    // 初始化随机数种子
    srand(time(NULL));

    while (true) {
        if (rand() % 2 == 0) {
            // 发送方事件
            if (network_layer_ready) {
                sender(network_layer_ready);
                network_layer_ready = false;
            } else if (timeout_occurred) {
                sender(timeout);
                timeout_occurred = false;
            }
        } else {
            // 接收方事件
            receiver(frame_arrival);
        }

        // 模拟延迟和丢失
        if (rand() % 10 == 0) {
            printf("Frame lost\n");
        } else {
            // 模拟延迟
            sleep(1);

            // 模拟超时
            if (rand() % 2 == 0) {
                printf("Frame timed out\n");
                timeout_occurred = true;
            }
        }
    }

    return 0;
}

这段代码模拟了stop-and-wait协议的发送方和接收方行为，包括发送数据帧、发送确认帧、模拟网络层的数据收发、模拟物理层的数据收发、处理超时和丢失等事件。在运行代码时，可以通过控制台输入数据来模拟网络层的数据输入。代码中使用了随机数模拟了网络延迟和丢失的情况，以及超时事件的发生。