Operator overloading problem

[sooli]

I need to create an overloaded cout that will print the contents of an array.

so I can say output << a << endl;

and it will print the contents of the object a... which happens to be an array.

class info:

class List 
{
	public:

		List();

		bool empty(); //returns true of false if empty

		void front(); //makes current position at beginning of list

		void end(); //makes current position at the end of list

		void prev(); //places current position at the previous element in the list

		void next(); //places current position at the next element in the list

		int getPos(); //returns current position or where you are in the list

		int SetPos(int); //places current position in a certain position in the list

		void insertBefore(int); //inserts a new element before the current position

		void insertAfter(int); //inserts a new element after the current position

		int getElement(); //returns the one element that current position is pointing to

		int size(); //returns the size of the list(number of elements in the list)

		void replace(int); //replace the current element with a new one

		void erase(); //deletes the current element

		void clear(); //makes the list an empty list
		
		void reverse(); //reverse elements in a list

		void swap(List);  //swaps all the elements of one list with another list
		
		int getMax(); //return Max Size based on const CAPACITY

		void display(); //displays contents of list

        private:

	int current;
	int length;
	static const int CAPACITY = 20;
	int arrayList[CAPACITY];
	int arrayCopy[CAPACITY];

};

constructor:

List::List()
		{
			//constructor - initialize array's at position 1
			int maxLen=CAPACITY;
			
			length=0;
			current=0;
			arrayList[length];
			arrayCopy[length];
			//clean up garbage...
			for(int i=0;i<CAPACITY;i++)
				{
					arrayList[i]=0;
					arrayCopy[i]=0;
				}
		}

I have one overloaded method... which returns the size of the array

ostream& operator <<(ostream& output,  List& out)
	{
		 
		output << out.size()<< endl;
		
		return output;
	}

I understand this code, I am simply calling the size method from the program, but i don't know how to pass in the array so that i can print it line by line... simple syntax i am sure... but the whole thing is baffling me... I need to be able to call this on any variation of the class, so it cannot be specific to any one array.

[weaknessforcats]

Isn't the array:

int arrayList[CAPACITY];

?

That is, the array member of your List class?

So the overload you have:

ostream& operator <<(ostream& output,  List& out)
     {
        output << out.size()<< endl;
 
         return output;
     }

already has the array because it's inside the List object named out. However, this function is not a member function of List so you have no access to the array. What you want to so is:

ostream& operator <<(ostream& output,  List& out)
     {
       for (int x =0; x< out.size(); ++x)
       {
        output << out[x];
       }       
 
         return output;
     }

Unfortunately, out[x] won't compile until you overload the index operator in List:

int List::operator[](int a)
{
    return arrayList[a];
}

Keep me posted on how you are coming along.

[sooli]

well, you gave me an idea... and it seems to be working - instead of overloading the list operator, I used my existing methods to produce the data I wanted by creating a loop:

[code]

ostream& operator <<(ostream& output, List& out)
{

output << out.size()<< endl;
out.front(); //sets position to the front of array
for (int i=0; i<out.size(); i++) //increment index i thereby stepping thru array
{
output << out.getElement( ) << " " ; //print out value of position i
out.next(); //advances current position by one in array

}
return output;
}

Thanks for jogging the brain!

[weaknessforcats]

Yep. Looks like a solution.

In fact, by not modifying the List class you have increased encapsulation since there is now less code dependent upon the list class implementation. On a real job, this will get you noticed.

[sooli]

@ Weaknessforcats : Thanks for the encouragement!