Is it possible to convert a program written in C++ to Java

[Martin Ndhlovu]

I have the program below written in C++ andI want to have it in Java so that I can use it in any operating system

#include <iostream>
#include <cassert>

using namespace std;

template <class elemType>
class arrayListType
{
public:
    const arrayListType<elemType>& operator=(const arrayListType<elemType>&);
		//Overload the assignment operator

    bool isEmpty();
		//Function to determine whether the list is empty
		//Postcondition: Returns true if the list is empty; 
 		//        	    otherwise, returns false.
    bool isFull();
		//Function to determine whether the list is full
		//Postcondition: Returns true if the list is full; 
 		//               otherwise, returns false.
    int listSize();
		//Function to determine the number of elements in the list
		//Postcondition: Returns the value of length.
    int maxListSize();
		//Function to determine the size of the list
 		//Postcondition: Returns the value of maxSize.
    void print() const;
		//Function to output the elements of the list
		//Postcondition: Elements of the list are output on the 
 		//               standard output device.
    bool isItemAtEqual(int location, const elemType& item);
		//Function to determine whether the item is the same 
 		//as the item in the list at the position specified by
		//Postcondition: Returns true if the list[location] 
		//               is the same as the item; otherwise, 
		//		     returns false.
   void insertAt(int location, const elemType& insertItem);
		//Function to insert an item in the list at the 
		//position specified by location. The item to be inserted 
		//is passed as a parameter to the function.
		//Postcondition: Starting at location, the elements 
 		//               of the list are shifted down, 
 		//               list[location] = insertItem;, and
 		//               length++;    
 		//       If the list is full or location is out of
		//	   range, an appropriate message is displayed.    
   void insertEnd(const elemType& insertItem);
		//Function to insert an item at the end of the list 
		//The parameter insertItem specifies the item to be 
		//inserted.
		//Postcondition: list[length] = insertItem; and length++;
 		//               If the list is full, an appropriate 
		//               message is displayed.
    void removeAt(int location);
		//Function to remove the item from the list at the 
		//position specified by location 
		//Postcondition: The list element at list[location] is 
		//               removed and length is decremented by 1.
		//       If location is out of range, an appropriate message
		//       is displayed.
    void retrieveAt(int location, elemType& retItem);
		//Function to retrieve the element from the list at the  
		//position specified by location 
		//Postcondition: retItem = list[location] 
		//      If location is out of range, an appropriate 
		//      message is displayed.
    void replaceAt(int location, const elemType& repItem);
		//Function to replace the elements in the list at the 
		//position specified by location. The item to be replaced 
		//is specified by the parameter repItem.
		//Postcondition: list[location] = repItem 
		//      If location is out of range, an appropriate 
		//      message is displayed.
    void clearList();
		//Function to remove all the elements from the list 
		//After this operation, the size of the list is zero.
 		//Postcondition: length = 0;
    int seqSearch(const elemType& item);
  		//Function to search the list for a given item. 
		//Postcondition: If the item is found, returns the location 
		//               in the array where the item is found; 
   		//               otherwise, returns -1.
    void insert(const elemType& insertItem);
		//Function to insert the item specified by the parameter 
		//insertItem at the end of the list. However, first the
		//list is searched to see whether the item to be inserted 
		//is already in the list. 
		//Postcondition: list[length] = insertItem and length++
		//     If the item is already in the list or the list
		//     is full, an appropriate message is displayed.
    void remove(const elemType& removeItem);
		//Function to remove an item from the list. The parameter 
		//removeItem specifies the item to be removed.
		//Postcondition: If removeItem is found in the list,
		//      it is removed from the list and length is 
		//      decremented by one.

    arrayListType(int size = 100);
		//constructor
		//Creates an array of the size specified by the 
		//parameter size. The default array size is 100.
		//Postcondition: The list points to the array, length = 0, 
		//               and maxSize = size

    arrayListType(const arrayListType<elemType>& otherList); 
		//copy constructor

    ~arrayListType();
		//destructor
		//Deallocates the memory occupied by the array.

protected:
    elemType *list; 	//array to hold the list elements
    int length;		//to store the length of the list
    int maxSize;		//to store the maximum size of the list
};



template <class elemType>
bool arrayListType<elemType>::isEmpty()
{
	return (length == 0);
}

template <class elemType>
bool arrayListType<elemType>::isFull()
{
	return (length == maxSize);
}

template <class elemType>
int arrayListType<elemType>::listSize()
{
	return length;
}

template <class elemType>
int arrayListType<elemType>::maxListSize()
{
	return maxSize;
}

template <class elemType>
void arrayListType<elemType>::print() const
{
	for(int i = 0; i < length; i++)
		cout<<list[i]<<" ";
	cout<<endl;
}

template <class elemType>
bool arrayListType<elemType>::isItemAtEqual
                   (int location, const elemType& item)
{
	return(list[location] == item);
}

template <class elemType>
void arrayListType<elemType>::insertAt
                   (int location, const elemType& insertItem)
{
	if(location < 0 || location >= maxSize)
		cerr<<"The position of the item to be inserted "
			<<"is out of range."<<endl;
	else
		if(length >= maxSize)  //list is full
			cerr<<"Cannot insert in a full list"<<endl;
		else
		{
			for(int i = length; i > location; i--)
				list[i] = list[i - 1];	//move the elements down

			list[location] = insertItem;	//insert the item at the 
 										//specified position

			length++;	//increment the length
		}
} //end insertAt

template <class elemType>
void arrayListType<elemType>::insertEnd(const elemType& insertItem)
{
	if(length >= maxSize)  //the list is full
		cerr<<"Cannot insert in a full list."<<endl;
	else
	{
		list[length] = insertItem;	//insert the item at the end
		length++;	//increment length
	}
} //end insertEnd

template <class elemType>
void arrayListType<elemType>::removeAt(int location)
{
	if(location < 0 || location >= length)
    	cerr<<"The location of the item to be removed "
			<<"is out of range."<<endl;
	else
	{
   		for(int i = location; i < length - 1; i++)
	 		list[i] = list[i+1];

		length--;
	}
} //end removeAt

template <class elemType>
void arrayListType<elemType>::retrieveAt
                     (int location, elemType& retItem)
{
	if(location < 0 || location >= length)
    	cerr<<"The location of the item to be retrieved is "
			<<"out of range."<<endl;
	else
		retItem = list[location];
} // retrieveAt

template <class elemType>
void arrayListType<elemType>::replaceAt
                    (int location, const elemType& repItem)
{
	if(location < 0 || location >= length)
    	cerr<<"The location of the item to be replaced is "
			<<"out of range."<<endl;
	else
		list[location] = repItem;

} //end replaceAt

template <class elemType>
void arrayListType<elemType>::clearList()
{
	length = 0;
} // end clearList

template <class elemType>
int arrayListType<elemType>::seqSearch(const elemType& item)
{
	int loc;
	bool found = false;

	for(loc = 0; loc < length; loc++)
	   if(list[loc] == item)
	   {
		found = true;
		break;
	   }

	if(found)
		return loc;
	else
		return -1;
} //end seqSearch

template <class elemType>
void arrayListType<elemType>::insert(const elemType& insertItem)
{
	int loc;

	if(length == 0)					 //list is empty
		list[length++] = insertItem; //insert the item and 
 									 //increment the length
	else
		if(length == maxSize)
			cout<<"Cannot insert in a full list."<<endl;
		else
		{
			loc = seqSearch(insertItem);

			if(loc == -1)   //the item to be inserted 
							//does not exist in the list
				list[length++] = insertItem;
			else
				cerr<<"the item to be inserted is already in "
 					<<"the list. No duplicates are allowed."<<endl;
	}
} //end insert

template <class elemType>
void arrayListType<elemType>::remove(const elemType& removeItem)
{
	int loc;

	if(length == 0)
		cerr<<"Cannot delete from an empty list."<<endl;
	else
	{
		loc = seqSearch(removeItem);

		if(loc != -1)
			removeAt(loc);
		else
			cout<<"The tem to be deleted is not in the list."
				<<endl;
	}

} //end remove


template <class elemType>
arrayListType<elemType>::arrayListType(int size)
{
	if(size < 0)
	{
		cerr<<"The array size must be positive. Creating "
 			<<"an array of size 100. "<<endl;

 	   maxSize = 100;
 	}
 	else
 	   maxSize = size;

	length = 0;

	list = new elemType[maxSize];
	assert(list != NULL);
}

template <class elemType>
arrayListType<elemType>::~arrayListType()
{
	delete [] list;
}

	//copy constructor
template <class elemType>
arrayListType<elemType>::arrayListType
                   (const arrayListType<elemType>& otherList)
{
   maxSize = otherList.maxSize;
   length = otherList.length;
   list = new elemType[maxSize]; 	//create the array
   assert(list != NULL);	//terminate if unable to allocate
 							//memory space

   for(int j = 0; j < length; j++)  //copy otherList
 	   list [j] = otherList.list[j];
}//end copy constructor


template <class elemType>
const arrayListType<elemType>& arrayListType<elemType>::operator=
			(const arrayListType<elemType>& otherList)
{
	if(this != &otherList)	//avoid self-assignment
	{				   
	   delete [] list;				   
	   maxSize = otherList.maxSize;		   
       length = otherList.length;			   
	  
       list = new elemType[maxSize];		   
	   assert(list != NULL);			   

       for(int i = 0; i < length; i++)	   
	   	    list[i] = otherList.list[i];	   
	}

    return *this;					   	   
}

using namespace std;

class newString
{
		//Overloads the stream insertion and extraction operators
    friend ostream& operator<<(ostream&, const newString&);
    friend istream& operator>>(istream&, newString&);

public:
    const newString& operator=(const newString&); 
		//Overloads the assignment operator
    newString(const char *); 
		//constructor; conversion from the char string
    newString();  
		//default constructor to initialize the string to null
    newString(const newString&); 
		//copy constructor
    ~newString(); 
		//destructor

    char& operator[] (int);  
    const char& operator[](int) const;

		//Overloads the relational operators
    bool operator==(const newString&) const;
    bool operator!=(const newString&) const;
    bool operator<=(const newString&) const;
    bool operator<(const newString&)  const;
    bool operator>=(const newString&) const;
    bool operator>(const newString&)  const;

private:
    char *strPtr;   //pointer to the char array 
                    //that holds the string
    int strLength;  //data member to store the length 
					//of the string
};

//Implementation file newString.cpp

#include <iomanip>
#include <cstring>
#include <cassert>
//#include "newString.h"

using namespace std;

      //constructor: conversion from the char string to newString
newString::newString(const char *str) 
{
   strLength = strlen(str);
   strPtr = new char[strLength+1]; 	//allocates memory to store 
  									//the char string
   assert(strPtr != NULL);
   strcpy(strPtr,str);				//copies the string into strPtr
}

	//default constructor to store the null string
newString::newString() 
{
		strLength = 0;
		strPtr = new char[1];
		assert(strPtr != NULL);
		strcpy(strPtr,"");
}

newString::newString(const newString& rightStr)  //copy constructor
{
	strLength = rightStr.strLength;
	strPtr = new char[strLength + 1];
	assert(strPtr != NULL);
	strcpy(strPtr, rightStr.strPtr);
}

newString::~newString()  //destructor
{
	delete [] strPtr;
}

//Overloads the assignment operator
const newString& newString::operator=(const newString& rightStr)
{
	if(this != &rightStr) //avoids self-copy
	{
		delete [] strPtr;
		strLength = rightStr.strLength;
		strPtr = new char[strLength + 1];
		assert(strPtr != NULL);
		strcpy(strPtr, rightStr.strPtr);
	}
	return *this; 
}

char& newString::operator[] (int index)
{
	assert(0 <= index && index < strLength);
	return strPtr[index];
}

const char& newString::operator[](int index) const
{
	assert(0 <= index && index < strLength);
	return strPtr[index];
}

		//Overloads the relational operators
bool newString::operator==(const newString& rightStr) const
{
	return(strcmp(strPtr, rightStr.strPtr) == 0);
}

bool newString::operator<(const newString& rightStr) const
{
	return(strcmp(strPtr, rightStr.strPtr) < 0);
}

bool newString::operator<=(const newString& rightStr) const
{
	return(strcmp(strPtr, rightStr.strPtr) <= 0);
}

bool newString::operator>(const newString& rightStr) const
{
	return(strcmp(strPtr, rightStr.strPtr) > 0);
}

bool newString::operator>=(const newString& rightStr) const
{
	return(strcmp(strPtr, rightStr.strPtr) >= 0);
}

bool newString::operator!=(const newString& rightStr) const
{
	return(strcmp(strPtr, rightStr.strPtr) != 0);
}

//Overloads the stream insertion operator << 
ostream& operator<<(ostream& osObject, const newString& str)
{
	osObject<<str.strPtr;
	return osObject;
}

//Overload the stream extraction operator >> 
istream& operator>>(istream& isObject, newString& str)
{
	char temp[81];

	isObject>>setw(81)>>temp;
	str = temp;
	return isObject;
}

#include <iostream>

//#include "newString.h"
//#include "arrayListType.h"

using namespace std;

int main()
{
    arrayListType<int> intList(100);			 			//Line 1
    arrayListType<newString> stringList;					//Line 2

    int counter;											//Line 3
    int number;												//Line 4

    cout<<"Line 5: Processing the integer list"
		<<endl;												//Line 5
    cout<<"Line 6: Enter 5 integers: ";						//Line 6
										
    for(counter = 0; counter < 5; counter++)				//Line 7
    {	
		cin>>number;						 				//Line 8
		intList.insertAt(counter, number);		 			//Line 9
    }

    cout<<endl;												//Line 10
    cout<<"Line 11: The list you entered is: ";				//Line 11
    intList.print();										//Line 12
    cout<<endl;												//Line 13

    cout<<"Line 14: Enter the item to be deleted: ";		//Line 14
    cin>>number;											//Line 15
    intList.remove(number);									//Line 16
    cout<<"Line 17: After removing "<<number
		<<", the list is:"<<endl;							//Line 17
    intList.print();										//Line 18
    cout<<endl;												//Line 19

    newString str;						 					//Line 20

    cout<<"Line 21: Processing the string list"
		<<endl;												//Line 21
	
    cout<<"Line 22: Enter 5 strings: ";						//Line 22

    for(counter = 0; counter < 5; counter++)				//Line 23
    {
		cin>>str;											//Line 24
		stringList.insertAt(counter, str);		 			//Line 25
    }

    cout<<endl;												//Line 26
    cout<<"Line 27: The list you entered is: "
	  	  <<endl;											//Line 27
    stringList.print();										//Line 28
    cout<<endl;												//Line 29

    cout<<"Line 30: Enter the string to be deleted: ";		//Line 30
    cin>>str;												//Line 31
    stringList.remove(str);									//Line 32
    cout<<"Line 33: After removing "<<str
	  	 <<", the list is:"<<endl;				 			//Line 33
    stringList.print();										//Line 34
    cout<<endl;												//Line 35	

    int intListSize;										//Line 36

    cout<<"Line 37: Enter the size of the integer "
	  	 <<"list: ";						 				//Line 37
    cin>>intListSize;										//Line 38

    arrayListType<int> intList2(intListSize);		 		//Line 39

    cout<<"Line 40: Processing the integer list"
	 	 <<endl;											//Line 40
    cout<<"Line 41: Enter "<<intListSize
	 	 <<" integers: ";									//Line 41

    for(counter = 0; counter < intListSize; counter++) 		//Line 42
    {
	 	 cin>>number;										//Line 43
	  	 intList2.insertAt(counter, number);		 		//Line 44
    }

    cout<<endl;												//Line 45
    cout<<"Line 46: The list you entered is: "<<endl;		//Line 46
    intList2.print();										//Line 47
    cout<<endl;												//Line 48

    return 0;
}

[Tim Moores]

Algorithms and data types can certainly be ported (or reimplemented) in other programming languages. This looks like an array/list kind of class; does it do anything Java's built-in ArrayList class doesn't? Using that would make it interoperable with the rest of the Collections framework.

[Randall Twede]

c++ to java is probably the easiest port IMO.

[Campbell Ritchie]

I would have thought C# is easier to port to Java®.

[Carey Brown]

A tricky part of this conversion would be the handling of overloaded operators. You'll end up creating some methods to emulate the overloaded operators. The difficult part will be the combing of the C++ code, trying to determine if an operator is overloaded or not.

[Randall Twede]

I stand corrected Campbell. Of course c# would be easier. But c++ is a lot like Java was my point.

[Dave Tolls]

Randall Twede wrote:I stand corrected Campbell. Of course c# would be easier. But c++ is a lot like Java was my point.

Some syntax, maybe, but I think the similarity is mostly illusion.

It's been a while since I had to rework C++ into Java, but it always involved understanding the problem rather than simply attempting a translation, which is how any other conversion works, whether 'similar' or not.  The only thing that converts are fairly basic algorithms, and even then there are plenty of pitfalls.

[Campbell Ritchie]

Dave Tolls wrote:

Randall Twede wrote:. . . But c++ is a lot like Java was my point.

Some syntax, maybe, but I think the similarity is mostly illusion. . . .

Agree. But we do see people here who think the similar syntax means the same thing in both languages, and they end up with dangerous confusion.

[Randall Twede]

Well, I just remember that learning c++ was a breeze since I knew java. I've never ported a program before. It sounds a little daunting. I would probably draw a class diagram, and then just write it again in the new language.