Getting my code to print out the sequential section

[jollyholly11]

I am trying to print out the sequential part of my code. It is not working. Nothing is printing.

my.class.h
#ifndef MYCLASS_H
#define MYCLASS_H

#include <iostream>
#include <string>
#include <sstream>
#include <fstream>
#include <vector>
#include <ostream>
enum myMode { SEQUENTIAL, PRIME, COMPOSITE, FIB};

using namespace std;

template<typename T>
class MyArray
{
private:
	int maxSize = 0; 
	T* myArray;
	int currentSize = 0;
	int size = 0;
	//int index;

public:
	MyArray(const int ARRAY_SIZE) {
		myArray = (T*)malloc(sizeof(T)*ARRAY_SIZE);
		maxSize = ARRAY_SIZE;
		currentSize = 0;
	};

	void push_back(T item) {
		myArray[currentSize] = item;
		currentSize++;
		/*for (int i = 0; i < currentSize.size(); i++) {
			currentSize;
		}*/
	};
	~MyArray() {}

	class Iterator
	{
	private:
		// Iterator data and functions
		int numbers = 0;
		int myMode = 0;
		int sizeTwo = 0;
		int pointerTwo = 0;
		T* vecWin;
		
	public:
		Iterator(T* vec) {
			vecWin = vec;
		};
		Iterator(T* vec, int size) {
			vecWin = vec;
			sizeTwo = size;
		};
		Iterator(T* vec, int size, int pointer) {
			vecWin = vec;
			pointerTwo = pointer;
			sizeTwo = size;
		};
		Iterator(T* vec, int size, int pointer, int mode) {
			vecWin = vec;
			pointerTwo = pointer;
			sizeTwo = size;
			myMode = mode;
		};
		bool operator!=(const Iterator& other) const {
			//need to be able to compare the iterator to other and have it do stuff
			/*if (other == mode) {

			}*/
			return false;
		};
	
		void operator++() {
			if (myMode == SEQUENTIAL) {
				//sizeTwo++;//this is the only if else statement that should theoritically do what it is suppose to. I really wonder if I am ever going to figure this out.
				//vecWin++;
				pointerTwo++;
			}
			else if (myMode == PRIME) {
				//need to be able to go through the prime numbers
				vecWin++;//temp 
			}
			else if (myMode == COMPOSITE) {
				//need to go through and 1 2 4 8 
				vecWin++;//temp
			}
			else if (myMode == FIB) {
				vecWin++;//temp
			}
		
		};
		//cout << i << endl interger
		//cout << *i << endl pointer
		//cout << &i << endl reference to the pointer -pointer pointer or the address of the address 
		T& operator*() const {
			return *vecWin;
		};
		T& operator[](int i) const {
			//return MyArray[i];//temp
			return vecWin[i];
		};
		string toString() const {
			stringstream ss;
			ss << "size=" << sizeTwo << " index=" << vecWin << " mode=" << myMode << endl;
			return ss.str(); 
		};
		friend ostream& operator<< (ostream& os, Iterator& iter) {
			os << iter.toString();// mode is working however size and index aren't
			return os;
		};
	};
	Iterator begin() {
		return Iterator(myArray, currentSize, 0);
	};
	Iterator begin(int mode) {
		return Iterator(myArray, currentSize, 0, mode);
	};
	Iterator end() {
		return Iterator(myArray, currentSize, 0);
	};
	
	string toString() const {
		ostringstream out;
		for (int i = 0; i < currentSize; i++) {
			out << myArray[i] << " ";
		}
		return out.str();
	};
	friend ostream& operator<< (ostream& os, const MyArray<T>& myArray) {
		os << myArray.toString();
		return os;
	};
};
#endif // MYCLASS_H
main.cpp
#include <iostream>
#include <string>
#include <sstream>
#include <fstream>
#include <vector>
#include "myClass.h"
#define MAX_ARRAY_SIZE	1000
//enum myMode { SEQUENTIAL, PRIME, COMPOSITE, FIB };

using namespace std;

#ifdef _MSC_VER
#define _CRTDBG_MAP_ALLOC  
#include <crtdbg.h>
#define VS_MEM_CHECK _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
#else
#define VS_MEM_CHECK;
#endif

/*********************************************************************
*********************************************************************/
int main(int argc, char * argv[]) {
	VS_MEM_CHECK;// checking for leaks
	//ifstream in(argv[1]);
	//ostream& out = (argc < 3);
	string inputFile = argv[1];
	string outputFile = argv[2];
	int data = 0;
	
	ifstream in(inputFile);//Opening the file

	if (!in.is_open()) return -1;
	ofstream out(outputFile);

	MyArray<int> numbers(MAX_ARRAY_SIZE);// doing the my array and printing out the array
	while (!in.eof()) {
		in >> data;
		numbers.push_back(data);
	}
	out << "myARRAY" << endl;
	out << numbers << endl << endl;

	out << "SEQUENTIAL" << endl;//Going through the array sequentially
	MyArray<int>::Iterator iter1 = numbers.begin();
	out << "iter1: " << iter1 << endl;
	for (MyArray<int>::Iterator iter1 = numbers.begin(); iter1 != numbers.end(); ++iter1) {
		out << *iter1 << ' ';
	}
	out << endl << endl;

	out << "PRIME" << endl;//Going through the prime numbers
	MyArray<int>::Iterator iter2 = numbers.begin(PRIME);
	out << "iter2: " << iter2 << endl;
	for (MyArray<int>::Iterator iter2 = numbers.begin(PRIME); iter2 != numbers.end(); ++iter2) {
		out << *iter2 << ' ';
	}
		out << endl << endl;

	out << "COMPOSITE" << endl;//Going through the composite
	MyArray<int>::Iterator iter3 = numbers.begin(COMPOSITE);
	out << "iter3: " << iter3 << endl;
	for (MyArray<int>::Iterator iter3 = numbers.begin(COMPOSITE); iter3 != numbers.end(); ++iter3) {
		out << *iter3 << ' ';
	}
	out << endl << endl;

	out << "FIBINOCCI" << endl;// Going through the finbinocci sequence
	MyArray<int>::Iterator iter4 = numbers.begin(FIB);
	out << "iter4: " << iter4 << endl;
	for (MyArray<int>::Iterator iter4 = numbers.begin(FIB); iter4 != numbers.end(); ++iter4) {
		out << *iter4 << "=" << iter4[-2] << "+" << iter4[-1] << ' ';
	}
		out << endl << endl;

	in.close();//Closing the files
	out.close();

	return 0;
};

[ne555]

bool operator!=(const Iterator& other) const {
   return false;
}

for (
   MyArray<int>::Iterator iter1 = numbers.begin();
   iter1 != numbers.end(); //alway false, so never enter the loop
   ++iter1
) {