ich stoße auf ein etwas seltsames Verhalten.
Und zwar scheint die Zuweisung über den "="-Operator nur teilweise zu funktionieren.

Was ich habe:

struct vec2
{
	float x;
	float y;
	inline vec2( ) : x(0.0f), y(0.0f) { };
	inline vec2(float px, float py) : x(px), y(py) { };
}

class BendedLine
{
public:
    BendedLine()
    {
        m_numPoints = 0;
        m_pPoints = 0;
    }

    BendedLine(int numPoints, vec2* pPoints)
    {
        m_numPoints = numPoints;
        m_pPoints = pPoints;
    }

    ~BendedLine()
    {
        delete[] m_pPoints;
    }

    inline BendedLine operator=(BendedLine& rhs)
    {
        std::cout<<"=Operator: ";
        m_numPoints = rhs.m_numPoints;
        delete m_pPoints;
        m_pPoints = new vec2[m_numPoints];
        for(int i = 0; i < m_numPoints; i++)
        {
            m_pPoints[i] = vec2(rhs.m_pPoints[i].x, rhs.m_pPoints[i].y);
            std::cout<<m_pPoints[i].x << " / " <<m_pPoints[i].y << ", ";
        }
        std::cout<<"\n";
        return *this;
    }

    inline const int numPoints() const
    {
        return m_numPoints;
    }

    inline const vec2 get(int i) const
    {
        return m_pPoints[i];
    }

private:
    int m_numPoints;
    vec2* m_pPoints;
};

Soo, das ganze benutze ich nun:

vec2* point = new vec2[3];
point[0] = vec2(1,1);
point[1] = vec2 (2,2);
point[2] = vec2(3,3);
BendedLine l1(3, point);
BendedLine l2;
l2 = l1;
printLine(l1);
printLine(l2);

Als Ausgabe erhalte ich:
=Operator: 1,1 / 2,2 / 3,3
l1: 1,1 / 2,2 / 3,3
l2: x,y / 2,2 / 3,3

Wobei x,y hier scheinbar zufällige, jedoch immer sehr kleine Zahlen sind.
(Z.B. 1.8013e-38)

Wieso verhaut es mir die? Und wieso immer nur den ersten Vector?

zeig mal printLine...

du kannst in zeile 29 genauso gut schreiben:
m_pPoints[i] = rhs.m_pPoints[i];

da du ja den vector kopierst

und übergib deine rhs als const&

@on topic:
Der Zuweisungsoperator sieht erstmal gut aus, aber der Kopierkonstruktor fehlt. Nicht, dass du print per-value aufrufst und ein temporäres Objekt dir deinen Speicher wieder freigibt, ohne dass du es merkst.

PS:
Gebogen heißt bent, nicht bended

Der Zuweisungsoperator sieht erstmal gut aus,

Er verkraftet keine Selbstzuweisung.

Und sonst kann ich sagen: Verletzung der 3er-Regel (wurde aber schon genannt).

Und noch ein +1 für std::vector.