题库核心代码：第一部分（顺序结构）

经验分享区
4

有一种A+B的线性高效搞笑抽象简单做法

#include <iostream>
#include <vector>
#include <map>

// Paxos节点角色定义
class Acceptor;
class Proposer;
class Learner;

class Acceptor {
public:
    int highest_proposal_seen = -1;  // 记录见过的最高提案号
    int accepted_value = 0;  // 记录被接受的值

    bool prepare(int proposal_number) {
        // Acceptor接受prepare请求，如果提案号大于当前见过的最大提案号则接受
        if (proposal_number > highest_proposal_seen) {
            highest_proposal_seen = proposal_number;
            return true;
        }
        return false;
    }

    bool accept(int proposal_number, int value) {
        // 如果提案号大于等于最高提案号，Acceptor接受提案并记住值
        if (proposal_number >= highest_proposal_seen) {
            highest_proposal_seen = proposal_number;
            accepted_value = value;
            return true;
        }
        return false;
    }

    int get_accepted_value() {
        return accepted_value;
    }
};

class Proposer {
public:
    int proposal_number = 0;
    int proposed_value = 0;

    void propose(int a, int b, std::vector<Acceptor>& acceptors) {
        proposal_number++;
        proposed_value = a + b;

        // 第一阶段：发送prepare请求
        int prepare_count = 0;
        for (auto& acceptor : acceptors) {
            if (acceptor.prepare(proposal_number)) {
                prepare_count++;
            }
        }

        // 如果大多数Acceptor接受了prepare请求，进入第二阶段
        if (prepare_count > acceptors.size() / 2) {
            int accept_count = 0;

            // 第二阶段：发送accept请求
            for (auto& acceptor : acceptors) {
                if (acceptor.accept(proposal_number, proposed_value)) {
                    accept_count++;
                }
            }
            /*
             如果大多数Acceptor接受了提案，则提案成功
            if (accept_count > acceptors.size() / 2) {
                std::cout << "Proposer: 提案成功，提议值为: " << proposed_value << std::endl;
            } else {
                std::cout << "Proposer: 提案失败，未获得足够接受者的同意。" << std::endl;
            }
        } else {
            std::cout << "Proposer: prepare请求失败，未获得足够接受者的同意。" << std::endl;*/
        }
    }
};

class Learner {
public:
    // 学习者从接受者处学习最终的提案值
    void learn(std::vector<Acceptor>& acceptors) {
        std::map<int, int> value_count;
        for (auto& acceptor : acceptors) {
            value_count[acceptor.get_accepted_value()]++;
        }

        // 找到被大多数接受者接受的值
        for (auto& awa : value_count) {
            int count = awa.second;
            int value = awa.first;
            if (count > acceptors.size() / 2) {
                std::cout /*<< "Learner: 学习到的值为: "*/ << value << std::endl;
                return;
            }
        }

        //std::cout << "Learner: 未能学习到一致的值。" << std::endl;
    }
};

int main() 
{
    int a, b;
    std::cin >> a >> b;  // 输入两个整数

    // 创建5个Acceptor（接受者）
    std::vector<Acceptor> acceptors(5);

    // 创建一个Proposer（提议者）
    Proposer proposer;

    // Proposer提议两个数的和
    proposer.propose(a, b, acceptors);

    // 创建一个Learner（学习者）
    Learner learner;

    // Learner学习最终的和
    learner.learn(acceptors);

    return 0;
//by chatgpt不是我写的不要封我
}

paxos模拟a+b

1 个赞