Question

我最近开始重构一些遗留代码并遇到两个用于绘制坐标网格的函数，问题是这些函数只在它们处理的正交变量上有所不同，就像那样

void DrawScaleX(HDC dc, int step, int x0, int x1, int y0, int y1)
{
    for(int x = x0; x < x1; x += step)
    {
         MoveToEx(dc, x, y0, NULL);
         LineTo(dc, x, y1);
    }
}
void DrawScaleY(HDC dc, int step, int x0, int x1, int y0, int y1)
{
    for(int y = y0; y < y1; y += step)
    {
         MoveToEx(dc, x0, y, NULL);
         LineTo(dc, x1, y);
    }
}

所以，如果我决定添加一些奇特的东西，比如抗锯齿，或者只是改变绘图铅笔，或者我必须在两者中加入相同的代码，而且它的代码重复，这很糟糕，我们都知道为什么。

我的问题是你如何将这两个函数重写为一个函数以避免这个问题？

Answer 1

为什么你不将for循环的主体提取到一个单独的函数中？然后你可以在提取的函数中做有趣的事情。

void DrawScaleX(HDC dc, int step, int x0, int x1, int y0, int y1)
{
    for(int x = x0; x < x1; x += step)
    {
        DrawScale(dc, x, y0, x, y1);
    }
}

void DrawScaleY(HDC dc, int step, int x0, int x1, int y0, int y1)
{
    for(int y = y0; y < y1; y += step)
    {
        DrawScale(dc, x0, y, x1, y);
    }
}

private void DrawScale(HDC dc, int x0, int y0, int x1, int y1)
{
    //Add funny stuff here

    MoveToEx(dc, x0, y0, NULL);
    LineTo(dc, x1, y1);

    //Add funny stuff here
}

Answer 2

绘制直线只是简单地连接两个点，并在特定方向，X和/或Y上绘制渐变增量（x0，y0）和（x1，y1）。在规模的情况下，这可以归结为踩踏方向（也许两个方向都很有趣）。

template< int XIncrement, YIncrement >
struct DrawScale
{
  void operator()(HDC dc, int step, int x0, int x1, int y0, int y1)
  {
    const int deltaX = XIncrement*step;
    const int deltaY = YIncrement*step;
    const int ymax = y1;
    const int xmax = x1;
    while( x0 < xmax && y0 < ymax )
    {
        MoveToEx(dc, x0, y0, NULL);
        LineTo(dc, x1, y1);
        x0 += deltaX;
        x1 += deltaX;
        y0 += deltaY;
        y1 += deltaY;
    }
  }
};
typedef DrawScale< 1, 0 > DrawScaleX;
typedef DrawScale< 0, 1 > DrawScaleY;

模板将完成它的工作：在编译时，编译器将删除所有空语句，即deltaX或deltaY为0，关于调用哪个函数，一半代码在每个函数中消失。

你可以在这个uniq函数中添加反别名，铅笔的东西，并获得由编译器生成的正确生成的代码。

这是对类固醇的剪切和粘贴; - ）

- ppi

Answer 3

这是我自己的解决方案


class CoordGenerator
{
public:
    CoordGenerator(int _from, int _to, int _step)
        :from(_from), to(_to), step(_step), pos(_from){}
    virtual POINT GetPoint00() const = 0;
    virtual POINT GetPoint01() const = 0;
    bool Next()
        {
            if(pos > step) return false;
            pos += step;
        }
protected:
    int from;
    int to;
    int step;
    int pos;
};

class GenX: public CoordGenerator
{
public:
    GenX(int x0, int x1, int step, int _y0, int _y1)
        :CoordGenerator(x0, x1, step),y0(_y0), y1(_y1){}
    virtual POINT GetPoint00() const
        {
            const POINT p = {pos, y0};
            return p;
        }
    virtual POINT GetPoint01() const
        {
            const POINT p = {pos, y1};
            return p;
        }
private:
    int y0;
    int y1;
};

class GenY: public CoordGenerator
{
public:
    GenY(int y0, int y1, int step, int _x0, int _x1)
        :CoordGenerator(y0, y1, step),x0(_x0), x1(_x1){}
    virtual POINT GetPoint00() const
        {
            const POINT p = {x0, pos};
            return p;
        }
    virtual POINT GetPoint01() const
        {
            const POINT p = {x1, pos};
            return p;
        }
private:
    int x1;
    int x0;
};

void DrawScale(HDC dc, CoordGenerator* g)
{
    do
    {
        POINT p = g->GetPoint00();
        MoveToEx(dc, p.x, p.y, 0);
        p = g->GetPoint01();
        LineTo(dc, p.x, p.y);
    }while(g->Next());
}

但我觉得这个问题太复杂了，所以我很期待看到你的解决方案。

Answer 4

嗯，一个明显的“解决方案”是创建一个函数并添加一个额外的参数（类似枚举类型）。然后在里面执行if（）或switch（），并执行适当的操作。因为嘿，函数的功能是不同的，所以你必须在某处执行那些不同的操作。

但是，这会增加运行时的复杂性（在运行时检查），这样可以在编译时更好地检查。

我不明白将来在两个（或更多功能）中添加额外参数会出现什么问题。它是这样的：

为所有功能添加更多参数
编译你的代码，它不会在很多地方编译，因为它没有传递新的参数。
通过传递新参数来修复所有调用这些函数的地方。
的利润！：）

如果它是C ++，当然你可以将函数作为模板，而是添加一个额外的参数，你添加一个模板参数，然后专门化模板实现来做不同的事情。但在我看来，这只是模糊了这一点。代码变得难以理解，并且使用更多参数扩展代码的过程仍然完全相同：

添加额外参数
编译代码，它不会在一堆地方编译
修复所有调用该功能的地方

所以你什么都没赢，但让代码更难理解。不是一个有价值的目标，IMO。

Answer 5

我想我会搬家：

     MoveToEx(dc, x0, y, NULL);
     LineTo(dc, x1, y);

进入自己的函数DrawLine（x0，y0，x0，y0），您可以从每个现有函数调用它们。

然后有一个地方可以添加额外的绘画效果吗？

Answer 6

一些模板......：）

void DrawLine(HDC dc, int x0, int y0, int x0, int x1)
{
    // anti-aliasing stuff
    MoveToEx(dc, x0, y0, NULL);
    LineTo(dc, x1, y1);
}

struct DrawBinderX
{
    DrawBinderX(int y0, int y1) : y0_(y0), y1_(y1) {}

    void operator()(HDC dc, int i)
    {
        DrawLine(dc, i, y0_, i, y1_);
    }

private:
    int y0_;
    int y1_;

};

struct DrawBinderY
{
    DrawBinderX(int x0, int x1) : x0_(x0), x1_(x1) {}

    void operator()(HDC dc, int i)
    {
        DrawLine(dc, x0_, i, x1_, i);
    }

private:
    int x0_;
    int x1_;

};

template< class Drawer >
void DrawScale(Drawer drawer, HDC dc, int from, int to, int step)
{
    for (int i = from; i < to; i += step)
    {
         drawer(dc, i);
    }
}

void DrawScaleX(HDC dc, int step, int x0, int x1, int y0, int y1)
{
    DrawBindexX drawer(y0, y1);
    DrawScale(drawer, dc, x0, x1, step);
}

void DrawScaleY(HDC dc, int step, int x0, int x1, int y0, int y1)
{
    DrawBindexY drawer( x0, x1 );
    DrawScale(drawer, dc, y0, y1, step);
}

正交变量代码重复问题

6 个答案: