用c++实现一个画图程序，使用EasyX通过菜单选择画线，画圆，区域填充等功能进行展示。菜单包含的功能：中点画线算法，Bresenham画线算法，中点画圆算法，区域填充算法（种子填充算法），二维线段裁剪算法（Cohen-Sutherland裁剪算法），分形算法（函数迭代系统IFS，如蕨叶生成）等。

好的，以下是一个简单的画图程序的实现：

#include <graphics.h>
#include <conio.h>

int main()
{
    // 初始化图形界面
    initgraph(640, 480);

    // 创建菜单
    int menu = 0;
    char* menuItems[] = {"中点画线算法", "Bresenham画线算法", "中点画圆算法", "区域填充算法", "二维线段裁剪算法", "分形算法", "退出"};
    int numMenuItems = sizeof(menuItems) / sizeof(char*);

    while (menu != numMenuItems - 1)
    {
        // 显示菜单
        cleardevice();
        settextstyle(20, 0, "Arial");
        outtextxy(100, 50, "请选择：");
        for (int i = 0; i < numMenuItems; i++)
        {
            if (i == menu)
            {
                settextcolor(YELLOW);
            }
            else
            {
                settextcolor(WHITE);
            }
            outtextxy(100, 100 + i * 30, menuItems[i]);
        }

        // 处理菜单选择
        int key = getch();
        switch (key)
        {
        case 72: // 上箭头
            menu--;
            if (menu < 0)
            {
                menu = numMenuItems - 1;
            }
            break;
        case 80: // 下箭头
            menu++;
            if (menu >= numMenuItems)
            {
                menu = 0;
            }
            break;
        case 13: // 回车键
            switch (menu)
            {
            case 0: // 中点画线算法
                // TODO: 实现中点画线算法
                break;
            case 1: // Bresenham画线算法
                // TODO: 实现Bresenham画线算法
                break;
            case 2: // 中点画圆算法
                // TODO: 实现中点画圆算法
                break;
            case 3: // 区域填充算法
                // TODO: 实现区域填充算法
                break;
            case 4: // 二维线段裁剪算法
                // TODO: 实现二维线段裁剪算法
                break;
            case 5: // 分形算法
                // TODO: 实现分形算法
                break;
            }
            break;
        }
    }

    // 关闭图形界面
    closegraph();
    return 0;
}

在菜单选择对应的功能时，你需要自己实现中点画线算法、Bresenham画线算法、中点画圆算法、区域填充算法、二维线段裁剪算法和分形算法。以下是一些参考实现：

中点画线算法：

void lineMidpoint(int x1, int y1, int x2, int y2, int color)
{
    int dx = x2 - x1;
    int dy = y2 - y1;
    int d = 2 * dy - dx;
    int y = y1;

    for (int x = x1; x <= x2; x++)
    {
        putpixel(x, y, color);
        if (d > 0)
        {
            y++;
            d -= 2 * dx;
        }
        d += 2 * dy;
    }
}

Bresenham画线算法：

void lineBresenham(int x1, int y1, int x2, int y2, int color)
{
    int dx = abs(x2 - x1);
    int dy = abs(y2 - y1);
    int sx = x1 < x2 ? 1 : -1;
    int sy = y1 < y2 ? 1 : -1;
    int err = dx - dy;

    while (true)
    {
        putpixel(x1, y1, color);
        if (x1 == x2 && y1 == y2)
        {
            break;
        }
        int e2 = 2 * err;
        if (e2 > -dy)
        {
            err -= dy;
            x1 += sx;
        }
        if (e2 < dx)
        {
            err += dx;
            y1 += sy;
        }
    }
}

中点画圆算法：

void circleMidpoint(int x0, int y0, int r, int color)
{
    int x = 0;
    int y = r;
    int d = 1 - r;

    while (x <= y)
    {
        putpixel(x0 + x, y0 + y, color);
        putpixel(x0 + y, y0 + x, color);
        putpixel(x0 - x, y0 + y, color);
        putpixel(x0 - y, y0 + x, color);
        putpixel(x0 + x, y0 - y, color);
        putpixel(x0 + y, y0 - x, color);
        putpixel(x0 - x, y0 - y, color);
        putpixel(x0 - y, y0 - x, color);

        if (d < 0)
        {
            d += 2 * x + 3;
        }
        else
        {
            d += 2 * (x - y) + 5;
            y--;
        }
        x++;
    }
}

区域填充算法：

void floodFill(int x, int y, int color)
{
    if (getpixel(x, y) != color)
    {
        putpixel(x, y, color);
        floodFill(x - 1, y, color);
        floodFill(x + 1, y, color);
        floodFill(x, y - 1, color);
        floodFill(x, y + 1, color);
    }
}

二维线段裁剪算法：

const int LEFT = 1 << 0;
const int RIGHT = 1 << 1;
const int BOTTOM = 1 << 2;
const int TOP = 1 << 3;

int computeOutCode(int x, int y, int xmin, int xmax, int ymin, int ymax)
{
    int code = 0;
    if (x < xmin)
    {
        code |= LEFT;
    }
    else if (x > xmax)
    {
        code |= RIGHT;
    }
    if (y < ymin)
    {
        code |= BOTTOM;
    }
    else if (y > ymax)
    {
        code |= TOP;
    }
    return code;
}

bool clipLine(int& x1, int& y1, int& x2, int& y2, int xmin, int xmax, int ymin, int ymax)
{
    int outcode1 = computeOutCode(x1, y1, xmin, xmax, ymin, ymax);
    int outcode2 = computeOutCode(x2, y2, xmin, xmax, ymin, ymax);
    while (true)
    {
        if (outcode1 == 0 && outcode2 == 0) // 全部在视口内
        {
            return true;
        }
        else if (outcode1 & outcode2) // 全部在视口外，不可见
        {
            return false;
        }
        else // 部分在视口内，裁剪
        {
            int x, y;
            int outcode = outcode1 ? outcode1 : outcode2;
            if (outcode & TOP)
            {
                x = x1 + (x2 - x1) * (ymax - y1) / (y2 - y1);
                y = ymax;
            }
            else if (outcode & BOTTOM)
            {
                x = x1 + (x2 - x1) * (ymin - y1) / (y2 - y1);
                y = ymin;
            }
            else if (outcode & RIGHT)
            {
                y = y1 + (y2 - y1) * (xmax - x1) / (x2 - x1);
                x = xmax;
            }
            else if (outcode & LEFT)
            {
                y = y1 + (y2 - y1) * (xmin - x1) / (x2 - x1);
                x = xmin;
            }
            if (outcode == outcode1)
            {
                x1 = x;
                y1 = y;
                outcode1 = computeOutCode(x1, y1, xmin, xmax, ymin, ymax);
            }
            else
            {
                x2 = x;
                y2 = y;
                outcode2 = computeOutCode(x2, y2, xmin, xmax, ymin, ymax);
            }
        }
    }
}

分形算法：

void fern(int x, int y, int n, double len, double alpha)
{
    if (n == 0)
    {
        putpixel(x, y, GREEN);
    }
    else
    {
        double theta = alpha * 3.1415926 / 180.0;
        double x1 = x + len * cos(theta);
        double y1 = y - len * sin(theta);

        fern(x1, y1, n - 1, len / 2, alpha + 15);
        fern(x1, y1, n - 1, len / 2, alpha - 75);

        theta = (alpha + 180) * 3.1415926 / 180.0;
        x1 = x + len * cos(theta);
        y1 = y - len * sin(theta);

        fern(x1, y1, n - 1, len / 2, alpha - 15);
        fern(x1, y1, n - 1, len / 2, alpha + 75);
    }
}

以上是一些参考实现，你可以根据需要自行修改和完善。祝成功！