实用主义编程¶

std::vector<int> foo(int i){
    std::vector<int> v{};
    // some code
    return v;
}

inline ::std::vector<int> foo(const int& i){
    ::std::vector<int> v{};
    // some code
    return std::move(v);
}

std::vector<int> foo(int i){
    std::vector<int> v{};
    // some code
    return v;
}

def calculate_total_price(items):
    total_price = 0
    for item in items:
        total_price += item.price
    return total_price

    for(int i = 0; i<s.length(); i++){
        if(s[i] == 'a'){
            s[i] = 'b';
        }
    }

    i += 1  # 增加 i 的值

    i += 1 # 跳过表头行，数据从下一行开始

    try{
        // 可能有毛病的代码
        // 我们甚至可以人造异常
        // 例如throw new Exception("这是一个人造异常");
    }
    catch(Exception e){
        // 出了毛病就执行的代码，例如打印错误信息
    }
    finally{
        // 无论如何都会执行的代码
    }

try:
    user = User.get_by_id(user_id)
except UserNotFoundError:
    logger.error(f"用户{user_id}不存在")
    return {"error": "用户不存在"}

def divide(a, b):
    return a / b

def divide(a, b):
    assert b != 0, "除数不能为零！"
    return a / b

def divide(a, b):
    if b == 0:
        raise ValueError("除数不能为零！")
    return a / b

#include <assert.h>
void divide(int a, int b) {
    assert(b != 0 && "除数不能为零！");
    printf("%d\n", a / b);
}

    2025-07-16 14:30:00 [user.py:45] ERROR 用户123登录失败：密码错误

请帮我写一个Python函数，计算两个数的和。

请帮我写一个使用MVC架构的Flask Web应用程序，包含以下功能：
1. 用户注册和登录
2. 用户可以发布文章
3. 用户可以查看文章列表
4. 用户可以查看文章详情
请帮我写出代码文件结构和框架即可，不必写出具体的业务逻辑。
# ----- 分割线 -----
请帮我写出XXX文件的代码，实现XXX业务逻辑。

    pip freeze > requirements.txt

    pip install -r requirements.txt

    npm install

    yarn install

def add(a: int, b: int) -> int:
    """
    计算两个整数的和。
    参数：
        a (int): 第一个整数。
        b (int): 第二个整数。
    返回值：
        int: 两个整数的和。
    """
    return a + b

#include <iostream>
#include <utility>
#include <math.h>

class Map
{
private:
    static constexpr int WIDTH = 8;
    static constexpr int HEIGHT = 8;
    int map[WIDTH][HEIGHT];

public:
    void init()
    {
        for (auto i = 0; i < WIDTH; i++)
        {
            for (auto j = 0; j < HEIGHT; j++)
            {
                Map::map[i][j] = 0;
            }
        }
        // 初始化棋盘
        // 这里用1代表白方棋子，2代表黑方棋子
        // 使用-1代表障碍物
        // map[i][j]代表第i行第j列，注意此处下标从0开始
        map[0][2] = 2;
        map[0][5] = 2;
        map[2][0] = 2;
        map[2][7] = 2;
        map[5][0] = 1;
        map[5][7] = 1;
        map[7][2] = 1;
        map[7][5] = 1;
        // 上文进行了黑白方棋子的初始化。
    }
    void move_chess(std::pair<int, int> start_pos, std::pair<int, int> end_pos)
    {
        auto temp = Map::map[start_pos.first][start_pos.second];
        Map::map[start_pos.first][start_pos.second] = 0;
        Map::map[end_pos.first][end_pos.second] = temp;
    }
    void place_obstacle(std::pair<int, int> obstacle_pos)
    {
        Map::map[obstacle_pos.first][obstacle_pos.second] = -1;
    }
    // 这里我们引用了一个参数player，来表示当前是哪个玩家在操作
    // true代表白方，false代表黑方
    // 这里黑方先行，在初始参数应为false
    void move(std::pair<int, int> start_pos, std::pair<int, int> end_pos, std::pair<int, int> obstacle_pos, bool &player)
    {
        if (player == false && Map::map[start_pos.first][start_pos.second] != 2)
        {
            std::cout << "now is black's turn , please move black" << std::endl;
            return;
        }
        else if (player == true && Map::map[start_pos.first][start_pos.second] != 1)
        {
            std::cout << "now is white's turn , please move white" << std::endl;
            return;
        }
        // 首先判断是否合法移动
        if (start_pos.first == end_pos.first) // 横向移动
        {
            for (auto i = std::min(start_pos.second, end_pos.second); i <= std::max(start_pos.second, end_pos.second); i++)
            {
                if (Map::map[start_pos.first][i] != 0 && i != start_pos.second)
                {
                    std::cout << "there is a obstacle in your move way" << std::endl;
                    return;
                }
            }
        }
        else if (start_pos.second == end_pos.second) // 纵向移动
        {
            for (auto i = std::min(start_pos.first, end_pos.first); i <= std::max(start_pos.first, end_pos.first); i++)
            {
                if (Map::map[i][start_pos.second] != 0 && i != start_pos.first)
                {
                    std::cout << "there is a obstacle in your move way" << std::endl;
                    return;
                }
            }
        }
        else if (std::abs(start_pos.first - end_pos.first) == std::abs(start_pos.second - end_pos.second)) // 斜向移动
        {
            for (auto i = 1; i <= std::abs(start_pos.first - end_pos.first); i++)
            {
                int check_x = start_pos.first < end_pos.first ? start_pos.first + i : start_pos.first - i;
                int check_y = start_pos.second < end_pos.second ? start_pos.second + i : start_pos.second - i;
                if (Map::map[check_x][check_y] != 0)
                {
                    std::cout << "there is a obstacle in your move way" << std::endl;
                    return;
                }
            }
        }
        else
        {
            std::cout << "unavailable move" << std::endl;
            return;
        }
        move_chess(start_pos, end_pos);
        // 其次检查是否有障碍物
        if (end_pos.first == obstacle_pos.first) // 横向移动
        {
            for (auto i = std::min(end_pos.second, obstacle_pos.second); i <= std::max(end_pos.second, obstacle_pos.second); i++)
            {
                if (Map::map[end_pos.first][i] != 0 && i != end_pos.second)
                {
                    std::cout << "there is a obstacle in your obstacle way" << std::endl;
                    move_chess(end_pos, start_pos);
                    return;
                }
            }
        }
        else if (end_pos.second == obstacle_pos.second) // 纵向移动
        {
            for (auto i = std::min(end_pos.first, obstacle_pos.first); i <= std::max(end_pos.first, obstacle_pos.first); i++)
            {
                if (Map::map[i][end_pos.second] != 0 && i != end_pos.first)
                {
                    std::cout << "there is a obstacle in your obstacle way" << std::endl;
                    move_chess(end_pos, start_pos);
                    return;
                }
            }
        }
        else if (std::abs(end_pos.first - obstacle_pos.first) == std::abs(end_pos.second - obstacle_pos.second)) // 斜向移动
        {
            for (auto i = 1; i <= std::abs(end_pos.first - obstacle_pos.first); i++)
            {
                int check_x = end_pos.first < obstacle_pos.first ? end_pos.first + i : end_pos.first - i;
                int check_y = end_pos.second < obstacle_pos.second ? obstacle_pos.second + i : obstacle_pos.second - i;
                if (Map::map[check_x][check_y] != 0)
                {
                    std::cout << "there is a obstacle in your obstacle way" << std::endl;
                    move_chess(end_pos, start_pos);
                    return;
                }
            }
        }
        else
        {
            std::cout << "unavailable move" << std::endl;
            move_chess(end_pos, start_pos);
            return;
        }

        // 最后进行移动
        player = player ? false : true;
        place_obstacle(obstacle_pos); // 先放置障碍物
    }
    void print()
    {
        for (auto i = 0; i < WIDTH; i++)
        {
            for (auto j = 0; j < HEIGHT; j++)
            {
                std::cout << Map::map[i][j] << " ";
            }
            std::cout << std::endl;
        }
    }
};
int main()
{
    Map gamemap;
    gamemap.init();
    bool player = false; // 黑方先行
    int x, y, end_x, end_y, obstacle_x, obstacle_y;
    while (true)
    {
        gamemap.print();
        std::cin >> x >> y >> end_x >> end_y >> obstacle_x >> obstacle_y;
        gamemap.move(std::make_pair(x, y), std::make_pair(end_x, end_y), std::make_pair(obstacle_x, obstacle_y), player);
    }
    return 0;
}

    int map[WIDTH][HEIGHT];

    std::array<std::array<int, HEIGHT>, WIDTH> map;

enum class CellType{ EMPTY, WHITE, BLACK, OBSTACLE };

// 辅助的Pattern结构体
struct Pattern{ int row; int col; CellType type; };
// class Map 改名为 Board 更合适，防止和 std::map 冲突
static constexpr int INIT_NUM = 8;
static constexpr std::array<Pattern, INIT_NUM> initial_patterns{
        Pattern{0, 2, CellType::BLACK},
        Pattern{0, 5, CellType::BLACK},
        Pattern{2, 0, CellType::BLACK},
        Pattern{2, 7, CellType::BLACK},
        Pattern{5, 0, CellType::WHITE},
        Pattern{5, 7, CellType::WHITE},
        Pattern{7, 2, CellType::WHITE},
        Pattern{7, 5, CellType::WHITE}};
Board()
{
    for (auto &row : board)
        row.fill(CellType::EMPTY);
    for (const auto &pattern : initial_patterns)
        board.at(pattern.row).at(pattern.col) = pattern.type;
}

std::ostream &operator<<(std::ostream &os, const CellType &cell)
{
    switch (cell)
    {
    case CellType::EMPTY:
        os << ".";
        break;
    case CellType::WHITE:
        os << "W";
        break;
    case CellType::BLACK:
        os << "B";
        break;
    case CellType::OBSTACLE:
        os << "X";
        break;
    default:
        break;
    }
    return os;
}

enum class PlayerType{ WHITE, BLACK };
struct Pos // 这个结构体用来表示位置，替代先前所说的 using Pos = std::pair<int, int>;
{
    int x;
    int y;
    constexpr bool operator==(const Pos &other) const
    {
        return x == other.x && y == other.y;
    }
};

class Board // This class represents the game board with necessary methods like moving pieces, placing obstacles and getting cell states
{
private:
    static constexpr int SIZE = 8;
    std::array<std::array<CellType, SIZE>, SIZE> board;
    static constexpr std::array<Pattern, 8> initial_patterns{
        Pattern{0, 2, CellType::BLACK},
        Pattern{0, 5, CellType::BLACK},
        Pattern{2, 0, CellType::BLACK},
        Pattern{2, 7, CellType::BLACK},
        Pattern{5, 0, CellType::WHITE},
        Pattern{5, 7, CellType::WHITE},
        Pattern{7, 2, CellType::WHITE},
        Pattern{7, 5, CellType::WHITE}};

public:
    Board()
    {
        for (auto &row : board)
            row.fill(CellType::EMPTY);
        for (const auto &pattern : initial_patterns)
            board.at(pattern.row).at(pattern.col) = pattern.type;
    }
    // getter and setter for cell
    const CellType at(const Pos &pos) const { return board.at(pos.x).at(pos.y); }
    void set_cell(const Pos &pos, CellType type) { board.at(pos.x).at(pos.y) = type; }

    // getter for the whole board, no setter to avoid external modification
    const auto &get_board() const { return board; }

    // getter for board size, static method, no need to instantiate Board
    static const int get_size() { return SIZE; }

    // method to move a piece
    void move_piece(const Pos &start, const Pos &end, CellType type)
    {
        board.at(start.x).at(start.y) = CellType::EMPTY;
        board.at(end.x).at(end.y) = type;
    }

    // method to place an obstacle
    void place_obstacle(const Pos &pos) { board.at(pos.x).at(pos.y) = CellType::OBSTACLE; }
};

namespace Rules
{
    template <typename T>
    int sgn(T val){ return (T(0) < val) - (val < T(0));}
    // 这是一个工具函数，非常有用，可以用来判断一个数的正负，且不必担心类型问题

    inline CellType side_to_cell(PlayerType player) { return player == PlayerType::WHITE ? CellType::WHITE : CellType::BLACK; }
    void flip_player(PlayerType &player) { player = (player == PlayerType::WHITE) ? PlayerType::BLACK : PlayerType::WHITE; }

    bool path_clean(const Board &board, const Pos &a, const Pos &b)
    {
        int dx = sgn(b.first - a.first);
        int dy = sgn(b.second - a.second);
        // These are the increments for each step along the path
        int steps = std::max(std::abs(b.first - a.first), std::abs(b.second - a.second));
        for (int step = 1; step < steps; ++step)
        {
            int x = a.first + step * dx;
            int y = a.second + step * dy;
            if (auto cell = board.get_cell({x, y}); cell != CellType::EMPTY)
            {
                return false; // Obstacle found
            }
        }
        return true; // Path is clear
    }
    bool try_move(Board &board, const Pos &start, const Pos &end, PlayerType player)
    {
        CellType self = side_to_cell(player);
        if (board.get_cell(start) != self)
        {
            std::cout << (player == PlayerType::WHITE
                              ? "now is white's turn, please move white\n"
                              : "now is black's turn, please move black\n");
            return false;
        }
        if (!(path_clean(board, start, end)))
        {
            std::cout << "there is a obstacle in your move way\n";
            return false;
        }

        /* 真正执行 */
        board.move_piece(start, end, self);
        return true;
    }
    bool try_shoot(Board& board, const Pos &piece, const Pos& obstacle)
    {
        if (!(path_clean(board, piece, obstacle)))
        {
            std::cout << "there is a obstacle in your shooting way\n";
            return false;
        }
        board.place_obstacle(obstacle);
        return true;
    }
};

namespace IO{
    std::ostream std::ostream &operator<<(std::ostream &os, const CellType &cell) { ... } // 前面已经写过了

    void print_board(const Board &board)
    {
        for (const auto &row : board.get_board())
        {
            for (const auto &cell : row)
            {
                std::cout << cell << " ";
            }
            std::cout << "\n";
        }
    }

    void read_move(Pos &start, Pos &end)
    {
        std::cout << "Enter your move (start_x start_y end_x end_y): ";
        int sx, sy, ex, ey;
        std::cin >> sx >> sy >> ex >> ey;
        start = {sx, sy};
        end = {ex, ey};
    }

    void read_obstacle(Pos &obstacle)
    {
        std::cout << "Enter your obstacle position (obstacle_x obstacle_y): ";
        int ox, oy;
        std::cin >> ox >> oy;
        obstacle = {ox, oy};
    }
};

int main()
{
    Board game_map;
    PlayerType current_player = PlayerType::BLACK; // Black starts first
    Pos start, end, obstacle;
    while (1)
    {
        IO::print_board(game_map);

        do{
            IO::read_move(start, end);
        }while(!Rules::try_move(game_map, start, end, current_player));

        do{
            IO::read_obstacle(obstacle);
        }while(!Rules::try_shoot(game_map, end, obstacle));
        Rules::flip_player(current_player);
    }
}

void try_move(Board &board, const Pos &start, const Pos &end, PlayerType player)
{
    CellType self = side_to_cell(player);
    if (board.at(start) != self)
        throw std::invalid_argument("You are trying to move a piece that is not yours or that does not exist.");
    if (!(path_clean(board, start, end)))
        throw std::invalid_argument("There is an obstacle in your moving way.");

    /* 真正执行 */
    board.move_piece(start, end, self);
    return;
}

// IO中增加一个print_error函数
void print_error(const std::exception &e)
{
    std::cerr << "Error: " << e.what() << std::endl;
    std::cerr << "Please try again." << std::endl;
}

// C++中没有try-until-success的语法糖，我们可以自己写一个模板函数来实现这个功能
// 最好不要在主函数中直接while(true){try{}catch{}}，这会使得主要函数变得臃肿不堪
// 因此我们写一个模板函数 retry 来封装这个逻辑
template <class F>
auto retry(F&& f) -> decltype(f()) // 根据调用自动推导返回值类型
{
    while (true) {
        try { return f(); } // 尝试调用 f，如果成功则返回结果
        catch (const std::exception& e) { IO::print_error(e); } // 如果抛出异常，则捕获并打印错误信息
    }
} // 这里没有std::forward，因为我们不需要转交f，而是直接调用它，因此不必搞完美转发

// 主函数中改为这样
while(game){
    IO::print_board(game_map);
    retry([&]{
        IO::read_move(start, end);
        Rules::try_move(game_map, start, end, current_player);
    }); // 用Lambda表达式把多个待调用对象包成一个，实际上这一行是retry(lambda)。
    retry([&]{
        IO::read_obstacle(obstacle);
        Rules::try_shoot(game_map, end, obstacle);
    });
    Rules::flip_player(current_player);
}

class MoveError : public std::runtime_error
{
    using std::runtime_error::runtime_error; // 继承构造函数
    std::string_view type() const noexcept { return "MoveError"; } // 定义自己的异常类型
};

void read_move(Pos &start, Pos &end)
{
    std::cout << "Enter your move (start_x start_y end_x end_y): ";
    int sx, sy, ex, ey;
    std::cin >> sx >> sy >> ex >> ey;
    auto lambda = [](int val)
    { return val >= 0 && val < Board::get_size(); };
    if (std::cin.fail())
    {
        std::cin.clear();                                                   // clear the fail state
        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // discard invalid input
        throw std::invalid_argument("Invalid input format. Please enter integers only.");
    }
    else if (!(lambda(sx) && lambda(sy) && lambda(ex) && lambda(ey)))
    {
        std::cin.clear();
        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
        throw std::out_of_range("Input positions are out of board range.");
    }
    start = {sx, sy};
    end = {ex, ey};
}

template <typename T>
[[nodiscard]] constexpr int sgn(T val) noexcept
{
    static_assert(std::is_arithmetic_v<T>, "sgn requires an arithmetic type");
    return (T(0) < val) - (val < T(0));
}

#ifndef BOARD_HPP
#define BOARD_HPP // 经典编译守卫
#include <array>
#include "cell_type.hpp" // 假设我们把 CellType 枚举类型放在了一个单独的头文件中
#include "pattern.hpp"   // 假设我们把 Pattern 结构体放在了一个单独的头文件中
struct Pos; // 前向声明 Pos 结构体
class Board
{
private:
    static constexpr int SIZE = 8;
    std::array<std::array<CellType, SIZE>, SIZE> board;
    static constexpr std::array<Pattern, 8> initial_patterns;
public:
    Board();
    const CellType at(const Pos &pos) const;
    void set_cell(const Pos &pos, CellType type);
    const auto &get_board() const;
    static const int get_size();
    void move_piece(const Pos &start, const Pos &end, CellType type);
    void place_obstacle(const Pos &pos);
};
#endif // BOARD_HPP

#include "board.hpp"
// 初始化 initial_patterns 静态成员
constexpr std::array<Pattern, 8> Board::initial_patterns{
    Pattern{0, 2, CellType::BLACK}, ... // 这里直接照着上文抄下来就可以了，后同
};
Board::Board()
{
    for (auto &row : board)
        row.fill(CellType::EMPTY);
    for (const auto &pattern : initial_patterns)
        board.at(pattern.row).at(pattern.col) = pattern.type;
}
const CellType Board::at(const Pos &pos) const { return board.at(pos.x).at(pos.y); }
void Board::set_cell(const Pos &pos, CellType type) { board.at(pos.x).at(pos.y) = type; }
const auto &Board::get_board() const { return board; }
const int Board::get_size() { return SIZE; }
void Board::move_piece(const Pos &start, const Pos &end, CellType type)
{
    board.at(start.x).at(start.y) = CellType::EMPTY;
    board.at(end.x).at(end.y) = type;
}
void Board::place_obstacle(const Pos &pos) { board.at(pos.x).at(pos.y) = CellType::OBSTACLE; }

cmake_minimum_required(VERSION 3.10)
project(AmazonsGame)
set(CMAKE_CXX_STANDARD 17)
add_executable(AmazonsGame main.cpp board.cpp rules.cpp io.cpp) # 把所有源文件都加进去
# 这里因为没有用到第三方库，所以不需要find_package和target_link_libraries等命令
# 如果用到了第三方库，例如Google Test等，就需要加上这些命令

mkdir my_project
cd my_project # 这里是你的项目文件夹
pixi init  # 初始化pixi项目
# 编辑pixi.toml，添加你需要的依赖
# 或者也可以命令式
pixi add numpy pandas matplotlib
pixi install  # 安装依赖