Implementation of DDA Line Algorithm I have tested all the cases of how a line could be


vertically
horizontally 
has a slope that's positive or less than 1


The function works, but I would like it reviewed, such as if there are overflows, etc.

// Draw line using DDA Algorithm
void Graphics::DrawLine( int x1, int y1, int x2, int y2, Color&amp;color )
{

    float xdiff = x1-x2; 
    float ydiff = y1-y2; 
    int slope  = 1; 
    if ( y1  == y2  )
    {
        slope = 0;
    }
    else if (  x1 == x2 )
    {
        slope = 2; // vertical lines have no slopes...
    }
    else
    {
        slope = (int)xdiff/ydiff; 
    }

    if ( slope &lt;= 1 )
    {    
        int startx = 0;
        int endx   = 0;
        if ( x1 &gt; x2 )
        {
            startx = x2;
            endx   = x1;
        }
        else 
        {
            startx = x1;
            endx   = x2;
        }

        float y = y1; // initial value
        for(int x = startx; x &lt;= endx; x++)
        {
            y += slope;
            DrawPixel(x, (int)abs(y), color);
        }
    }

    else if ( slope &gt; 1 )
    {
        float x = x1; // initial value
        for(int y = y1;y &lt;= y2; y++)
        {
            x += 1/slope;
            DrawPixel((int)x, y, color);
        }

    }

}
Here are some flaws in the current algorithm.


xdiff will have a roundoff error if x1-x2 is large in magnitude, likewise for the y variables.
slope is set to 1 for no reason, and then immediately reinitialized to something else.
slope is restricted to an integer, when most slopes will not be integral.
It's impossible to justify setting the slope of a vertical line to 2. There are slopes greater than 2 that are not vertical lines.
In the line slope = (int)xdiff/ydiff;, casting is higher precedence than division, so this will first cast xdiff to an int, overflowing if xdiff &gt; MAXINT, throwing away the fractional part if there is one, then dividing this int by ydiff. The odds of this being the actual slope are very small.
startx and endx are initialized to 0 for no reason, then immediately reinitialized to somethiing else.
Roundoff errors will accumulate as you repeatedly add slope to y (or 1/slope to x).
What's the justification for the abs(y)? If y changes sign in the range, this will cause a kink in the line. Similarly for x.