The below code is what I have.. It's a custom type I made called Points that stores co-ordinates on the screen.. The problem is in the PointsArray Struct. When I declare one like so:

PointArray P;
    Point A(10, 5);

    for (int I = 0; I < 5; I++)
    {
        P[I] = A;
        cout<<P[I].X;
    }

It terminates the process with a status of 3.. The Points Array struct is supposed to make a vector/dynamic array of Points. What causes this error 3?

struct Point
{
    int X, Y;
    Point() {X = Y = 0;};                              //Default constructor.
    Point(int X_, int Y_) : X(X_), Y(Y_) {};           //Alternate constructor.
    ~Point(){};                                        //Destructor.

    int operator == (const Point &PT) const            //Are the points Equal?
    {
        return ((X == PT.X) && (Y == PT.Y));
    }

    int operator != (const Point &PT) const            //Are the points Not equal?
    {
        return ((X != PT.X) && (Y != PT.Y));
    }

    Point& operator = (const Point& PT)
    {
        if (this != &PT)
        {
            X = PT.X;
            Y = PT.Y;
        }
        return *this;
    }

    Point operator += (Point PT)
    {
        X += PT.X;
        Y += PT.Y;
        return *this;
    }

    Point operator -= (Point PT)
    {
        X -= PT.X;
        Y -= PT.Y;
        return *this;
    }

    Point MidPointBox (const Box &B);

    friend inline Point operator + (Point P1, Point P2)           //Add two points.
    {
        return Point(P1.X + P2.X, P1.Y + P2.Y);
    }

    friend inline Point operator - (Point P1, Point P2)           //Subtract two points.
    {
        return Point(P1.X - P2.X, P1.Y - P2.Y);                 //No absolute value needed since points can have negative values.
    }

    friend inline int Distance(Point P1, Point P2)              //Friend is for Inheritance and friendship of a Class/Struct.
    {
        return (hypot(P1.X - P2.X, P1.Y - P2.Y));
    }

    friend inline Point Invert(Point PT)                     //Invert a point.
    {
        return Point(-PT.X, -PT.Y);
    }
};
struct PointArray
{
    private:
        Point* P;
        int rows;

    public:
        Point& operator ()(int I)
        {
            return P[I];                            //Return A Point.
        }

        Point& operator[](int I)
        {
            assert(P != 0 && I >= 0 &&  I < rows);  //P <> 0 & I Must be >=0 & I < num of rows. Asserts to terminate the program upon Bad Input.
            return P[I];                            //Return A Point.
        }

        const Point& operator[](int I) const
        {
            assert(P != 0 && I >= 0 && I < rows);   //P <> 0 & I Must be >=0 & I < num of rows.
            return P[I];                            //Return A Point.
        }

        int Rows() const
        {
            return rows;
        }

        operator const Point* () const
        {
            return P;
        }

        operator Point* ()
        {
            return P;
        }

        Point* Resize(int NewSize);
        PointArray& operator = (const PointArray &N);
        PointArray(const PointArray &N);
        PointArray(int I = 2):
            P(I > 0 ? new Point[I] : 0), rows(I) {      //Created a New Point.
        }
        ~PointArray()
        {
            delete[] P;                                 //The new operator was used.. Must delete all instances of P.
            P = 0;
            rows = 0;
        }
};

Edited 4 Years Ago by triumphost: n/a

It should? I want it to be dynamic like a vector so that it pushes the next point into it..

I don't exactly know what you mean by "Expanded". That can be dynamically or allocated previously.

When I step through, it prints:

PointArray P Size = 10    //This is correct because I did PointArray P[10];
P[0] = (1, 2);            //This is correct because I assigned it a point;

So yes it holds the values but I cannot allocate a dynamic array of Points.

If you'd like to run/test/read any of the entire source, see below:

Test Program:

#include "Types.h"
#include <iostream>
#include <vector>

using namespace std;

int main()
{
    Point P(1, 2);
    Point Q(3, 4);

    PointArray Z[10];
    writeln(LEN(Z));

    Z[0] = P;
    Z[1] = Q;

    writeln(*Z[0]);     //NOT sure why I have to use *Z to deference AGAIN?!
    writeln(*Z[1]);

    cin.get();
}

Types.h

#ifndef TYPES_H_INCLUDED
#define TYPES_H_INCLUDED
#include <math.h>
#include <vector>
#include <assert.h>
#include <sstream>

using namespace std;


/** Definitions **/
#define LEN(a) (sizeof(a)/sizeof(*a))
#define HIGH(a) (sizeof(a)/sizeof(*a) - 1)

#define Repeat do{
#define Until(condition) }while(!(condition));

#define writeln(Output) (cout<<Output<<"\n");

/** Types **/

struct Box;
struct Point
{
    int X, Y;
    Point() {X = Y = 0;};                              //Default constructor.
    Point(int X_, int Y_) : X(X_), Y(Y_) {};           //Alternate constructor.
    ~Point(){};                                        //Destructor.

    int operator == (const Point &PT) const            //Are the points Equal?
    {
        return ((X == PT.X) && (Y == PT.Y));
    }

    int operator != (const Point &PT) const            //Are the points Not equal?
    {
        return ((X != PT.X) && (Y != PT.Y));
    }

    Point& operator = (const Point& PT)
    {
        if (this != &PT)
        {
            X = PT.X;
            Y = PT.Y;
        }
        return *this;
    }

    Point operator += (Point PT)
    {
        X += PT.X;
        Y += PT.Y;
        return *this;
    }

    Point operator -= (Point PT)
    {
        X -= PT.X;
        Y -= PT.Y;
        return *this;
    }

    Point MidPointBox (const Box &B);

    friend ostream& operator << (ostream& Str, const Point &PT)      //For use with Writeln & cout.
    {
        Str<<"("<<PT.X<<", "<<PT.Y<<")";
        return Str;
    }

    friend inline Point operator + (Point P1, Point P2)           //Add two points.
    {
        return Point(P1.X + P2.X, P1.Y + P2.Y);
    }

    friend inline Point operator - (Point P1, Point P2)           //Subtract two points.
    {
        return Point(P1.X - P2.X, P1.Y - P2.Y);                 //No absolute value needed since points can have negative values.
    }

    friend inline int Distance(Point P1, Point P2)              //Friend is for Inheritance and friendship of a Class/Struct.
    {
        return (hypot(P1.X - P2.X, P1.Y - P2.Y));
    }

    friend inline Point Invert(Point PT)                     //Invert a point.
    {
        return Point(-PT.X, -PT.Y);
    }
};


struct Box
{
    int X1, Y1, X2, Y2;
    Box(){X1 = Y1 = X2 = Y2 = 0;};                                                      //Default Constructor.
    Box(int X1_, int Y1_, int X2_, int Y2_) : X1(X1_), Y1(Y1_), X2(X2_), Y2(Y2_) {};    //Alternate Constructor.
    ~Box(){};                                                                           //Destructor.

    friend int operator == (const Box &B, const Box &B2)                          //Are the Boxes the same?
    {
        return ((B.X1 == B2.X1) && (B.X2 == B2.X2) && (B.Y1 == B2.Y1) && (B.Y2 == B2.Y2));
    }

    friend inline int operator != (const Box &B, const Box &B2)                                               //Are the Boxes Not the same?
    {
        return !(B == B2);
    }

    Box operator += (Box B)
    {
        X1 += B.X1;
        Y1 += B.Y1;
        X2 += B.X2;
        Y2 += B.Y2;
        return *this;
    }

    Box operator -= (Box B)
    {
        X1 -= B.X1;
        Y1 -= B.Y1;
        X2 -= B.X2;
        Y2 -= B.Y2;
        return *this;
    }

    Box PointToBox(Point UpperLeft, Point LowerRight)
    {
        return Box(UpperLeft.X, UpperLeft.Y, LowerRight.X, LowerRight.Y);
    }

    Box& operator = (const Box& B)
    {
        if (this != &B)
        {
            X1 = B.X1;
            Y1 = B.Y1;
            X2 = B.X2;
            Y2 = B.Y2;
        }
        return *this;
    }

    friend ostream& operator << (ostream& Str, const Box &B)                                  //For use with Writeln & cout.
    {
        Str<<"("<<B.X1<<", "<<B.Y1<<", "<<B.X2<<", "<<B.Y2<<")";
        return Str;
    }

    friend inline Box operator + (Box B1, int S)                                              //Increase Box Size.
    {
        return Box(B1.X1 + S, B1.Y1 + S, B1.X2 + S, B1.Y2 + S);
    }

    friend inline Box operator - (Box B1, int S)                                              //Decrease Box Size.
    {
        if (((B1.X1 - S) < 0) || ((B1.Y1 - S) < 0) || ((B1.X2 - S) < 0) || ((B1.Y2 - S) < 0))
            return Box(-1, -1, -1, -1);                                                     //Return -1's if its not a valid box.
        else if (((B1.X1 - S) == 0) || ((B1.Y1 - S) == 0) || ((B1.X2 - S) == 0) || ((B1.Y2 - S) == 0))
            return Box(0, 0, 0, 0);                                                         //Returns 0's because it becomes a point.
        else
            return Box(B1.X1 + S, B1.Y1 + S, B1.X2 + S, B1.Y2 + S);                         //Return the resized box.
    }
};

struct PointArray
{
    private:
        Point* P;
        int rows;

    public:
        Point& operator ()(int I)
        {
            return P[I];                            //Return A Point.
        }

        Point& operator[](int I)
        {
            assert(P != 0 && I >= 0 &&  I < rows);  //P <> 0 & I Must be >=0 & I < num of rows. Asserts to terminate the program upon Bad Input.
            return P[I];                            //Return A Point.
        }

        const Point& operator[](int I) const
        {
            assert(P != 0 && I >= 0 && I < rows);   //P <> 0 & I Must be >=0 & I < num of rows.
            return P[I];                            //Return A Point.
        }

        int Rows() const
        {
            return rows;
        }

        operator const Point* () const
        {
            return P;
        }

        operator Point* ()
        {
            return P;
        }

        Point* Resize(int NewSize);
        PointArray& operator = (const Point& PT)
        {
            if (this[LEN(this)] != &PT)                    //I think the LEN(this)  is correct?
            {
                P[LEN(this)] = PT;
            }
            return *this;
        }

        PointArray(const PointArray &N);
        PointArray(int I = 2):
            P(I > 0 ? new Point[I] : 0), rows(I) {      //Created a New Point.
        }
        ~PointArray()
        {
            delete[] P;                                 //The new operator was used.. Must delete all instances of P.
            P = 0;
            rows = 0;
        }
};

Point Point::MidPointBox(const Box& B)
{
    return Point(((B.X1 + B.X2)/2), ((B.Y1 + B.Y2)/2));
};


#endif //TYPES_H_INCLUDED

Edited 4 Years Ago by triumphost: n/a

This article has been dead for over six months. Start a new discussion instead.