Need assistance

[LaminarFlow]

So in my last lab i created a number class that derived from string and was used as a base class for both Integer and Double. Right now im javing issues with my number class, so I need to move my isNan functions to my number class and create a virtual function that will work throughout both Integer and Double. Right now I've attempted to create the virtual function but it created alot of issues in both Integer and Double.

[LaminarFlow]

Double.h

#include <cstdlib>
#include <iostream>
#include <sstream>
#include <string>
#include"Integer.h"
#include "Number.h"
#ifndef DOUBLE
#define DOUBLE
using namespace std;

class Double :public Number
{
private:
	double dub;
	bool nan;
	void isNan(string s);
	bool recursiveNaN(std::string strs, int i, int j);

public:
	Double() : Number() {};
	Double(const Double& d) : Number(d.data()) {};
	Double(const Integer& i) : Number(i.data()) {};
	Double();
	Double(const Double& d);
	Double(double d);
	Double(const Integer& i);
	Double(const string str);
	double toDouble() const;
	void equals(string s);
	void equals(double d);
	Double add(const Double& d);
	Double sub(const Double& d);
	Double mul(const Double& d);
	Double div(const Double& d);

	Double add(double& d);
	Double sub(double& d);
	Double mul(double& d);
	Double div(double& d);

	Double operator + (const Double& d);
	Double operator - (const Double& d);
	Double operator * (const Double& d);
	Double operator / (const Double& d);
	Double& operator = (const Double& d);
	Double& operator = (double d);
	Double& operator = (string s);

	bool operator == (const Double& d);
	bool operator == (double d);
	string toString();


};
#endif

Integer.h
#include <cstdlib>
#include <iostream>
#include <sstream>
#include <string>
#include "Number.h"

#ifndef INTEGER
#define INTEGER
using namespace std;

class Integer :public Number
{
private:

	int ints;
	bool nan;
	void isNan(string s);
	bool recursiveNaN(std::string s, int i, int j);
public:
	Integer() :Number() {};
	Integer(const Integer& i) : Number(i.data()) {};
	Integer(const Double& d) : Number(d.data()) {};
	Integer();
	Integer(const Integer& i);
	Integer(int i);
	Integer(const string str);
	int toInt() const;
	void equals(int i);
	void equals(string s);

	Integer add(const Integer& i);
	Integer sub(const Integer& i);
	Integer mul(const Integer& i);
	Integer div(const Integer& i);
	Integer add(int& i);
	Integer sub(int& i);
	Integer mul(int& i);
	Integer div(int& i);

	Integer operator + (const Integer& i);
	Integer operator - (const Integer& i);
	Integer operator * (const Integer& i);
	Integer operator / (const Integer& i);
	Integer& operator = (const Integer& i);
	Integer& operator = (int i);
	Integer& operator = (string s);
	bool operator == (const Integer& i);
	bool operator == (int i);
	string toString();
};
#endif

Number.h
#ifndef NUMBER
#define NUMBER
#include <string>
#include"Double.h"
#include"Number.h"
using std::string;

class Number : public string

{

public:
	Number() { this->assign("0"); }
	Number(string str) { this->assign(str); }
	virtual void recursiveNaN() = 0;

	void isNanVirtual(std::string s)
	{
		recursiveNaN(s, 0, 0);
	}
	
	bool recursiveNaN(std::string s, int i, int j)
	{
		if (s.length() == 0)
			return false;
		if (i == s.length())
			return true;
		if (s[i] > 47 && s[i] < 58)
			return recursiveNaN(s, i + 1, j);
		else if (s[i] == '.')
		{
			if (j == 0)
			{
				j = 1;
				return recursiveNaN(s, i + 1, j);
			}
			else
				return false;
		}
		else
			return false;
	}

};




#endif

double.cpp
#include <iostream>
#include <string>
#include <sstream>
#include"Double.h"
#include"Number.h"
using namespace std;
Double::Double(double d): Number(std::to_string(d)), nan(false)

{

}
Double::Double()
{
	dub = 0.0;
	nan = false;
}

Double::Double(const Double& d)
{
	equals(d.dub);
	nan = false;
}

Double::Double(double d)
{
	dub = d;
	nan = false;
}

Double::Double(const Integer& i)
{
	equals((double)i.toInt());
	nan = false;
}

Double::Double(const string str)
{
	this->equals(str);
}

double Double::toDouble() const
{
	return this->dub;
}

void Double::equals(std::string s)
{
	this->recursiveNaN(s, 0, 0);
	if (this->nan)
	{
		this->assign(s);
	}
	else
		this->assign("0.0");
}

void Double::equals(double d)
{
	dub = d;
}

Double Double::add(const Double& d)

{
	Double results(dub + d.toDouble());
	return results;
}

Double Double::sub(const Double& d)
{
	Double results(dub - d.toDouble());
	return results;
}

Double Double::mul(const Double& d)
{
	Double results(dub * d.toDouble());
	return results;
}

Double Double::div(const Double& d)
{
	Double results(dub / d.toDouble());
	return results;
}

Double Double::add(double& d)
{
	Double results;
	results.equals(this->toDouble() + d);
	return results;

}

Double Double::sub(double& d)
{
	Double results;
	results.equals(this->toDouble() - d);
	return results;
}

Double Double::mul(double& d)
{
	Double results;
	results.equals(this->toDouble() * d);
	return results;
}

Double Double::div(double& d)
{
	Double results;
	results.equals(this->toDouble() / d);
	return results;
}

Double Double::operator + (const Double& d)
{
	return this->add(d);
}

Double Double::operator -(const Double& d)
{
	return this->sub(d);
}

Double Double::operator * (const Double& d)
{
	return this->mul(d);
}

Double Double::operator / (const Double& d)
{
	return this->div(d);
}

Double& Double::operator = (const Double& d)
{
	this->equals(d.toDouble());
	return *this;
}

Double& Double::operator = (double d)
{
	this->equals(d);
	return *this;
}

Double& Double::operator = (std::string s)
{
	this->equals(s);
	return *this;
}

bool Double::operator == (const Double& d)
{
	return this->dub == d.dub;
}
bool Double::operator == (double d)
{
	return this->dub == d;
}
std::string Double::toString()
{
	std::stringstream ss;
	ss << this->dub;
	return ss.str();
}

[code]

[LaminarFlow]

integer.cpp

#include <iostream>
#include <sstream>
#include <string>
#include "Integer.h"

using namespace std;

Integer::Integer()
{
	ints = 0;
	nan = false;
}

Integer::Integer(const Integer& i)
{
	equals(i.ints);
	nan = false;
}

Integer::Integer(int i)
{
	ints = i;
	nan = false;
}

Integer::Integer(const string str)
{
	this->equals(str);
}

int Integer::toInt() const
{

	return this->ints;

}

void Integer::equals(int i)
{

	ints = i;

}

void Integer::equals(string s)
{
	this->recursiveNaN(s, 0, 0);
	if (this->nan)
		this->assign(s);
	else
		this->assign("0");
}

Integer Integer::add(const Integer& i)
{
	Integer results(this->ints + i.toInt());
	return results;
}

Integer Integer::sub(const Integer& i)
{
	Integer results(this->ints - i.toInt());
	return results;
}

Integer Integer::mul(const Integer& i)
{
	Integer results(this->ints - i.toInt());
	return results;
}

Integer Integer::div(const Integer& i)
{
	Integer results(this->ints - i.toInt());
	return results;
}

Integer Integer::add(int& i)
{
	Integer results;
	results.equals(this->toInt() + i);
	return results;
}

Integer Integer::sub(int& i)
{
	Integer results;
	results.equals(this->toInt() - i);
	return results;
}

Integer Integer::mul(int& i)
{
	Integer results;
	results.equals(this->toInt() * i);
	return results;
}

Integer Integer::div(int& i)
{
	Integer results;
	results.equals(this->toInt() / i);
	return results;
}

Integer Integer::operator + (const Integer& i)
{
	return this->add(i);
}
Integer Integer::operator - (const Integer& i)
{
	return this->sub(i);
}
Integer Integer::operator * (const Integer& i)
{
	return this->mul(i);
}
Integer Integer::operator / (const Integer& i)
{
	return this->div(i);
}

Integer& Integer::operator=(const Integer& i)
{
	this->equals(i.toInt());
	return *this;
}

Integer& Integer::operator = (int i)
{
	this->equals(i);
	return *this;
}

Integer& Integer::operator = (string s)
{
	this->equals(s);
	return *this;
}

bool Integer::operator==(const Integer& i)
{
	return this->ints == i.ints;
}

bool Integer::operator == (int i)
{
	return this->ints = i;
}

std::string Integer::toString()
{
	std::stringstream ss;
	ss << this->ints;
	return ss.str();
}
main.cpp
#include <fstream>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>

#include "Double.h"
#include "Integer.h"
using namespace std;
string toString(int num);
string toString(float num);

int writeToFile(vector <float*> dNumbers);
int writeToFile(vector <int*> iNumbers);
int main()
{
	vector <int*> iNumbers;
	vector <float*> dNumbers;
	char data[100];
	fstream ifile;

	ifile.open("num.txt");
	if (!ifile)
	{
		cout << "ERROR WITH FILE";
		return 1;
	}

	while (!ifile.eof())
	{
		ifile.getline(data, 100);
		// checking if its either a dub or an int with an if else
		if (strstr(data, "."))
		{
			dNumbers.push_back(new float(atof(data)));
		}
		else
		{
			iNumbers.push_back(new int(atoi(data)));
		}
	}
	writeToFile(iNumbers);
	writeToFile(dNumbers);
	ifile.close();
	cout << "Files have been made";
};
string toString(int num)
{
	stringstream ss;
	ss << num;
	return ss.str();
}

string toString(float num)
{
	stringstream ss;
	ss << num;
	return ss.str();
}

int writeToFile(vector <float*> dNumbers)
{
	ofstream outFileDub;
	outFileDub.open("double.txt");
	if (!outFileDub)
	{
		cout << "ERROR WITH FILE" << endl;
		return 1;
	}

	for (vector <float*> ::const_iterator iter = dNumbers.begin(); iter != dNumbers.end(); iter++)
	{
		outFileDub << toString(**iter) << endl;
	}

	outFileDub.close();

	return 0;
}
int writeToFile(vector <int*> iNumbers)
{
	ofstream outFileInt;
	outFileInt.open("integer.txt");
	if (!outFileInt)
	{
		cout << "ERROR WITH FILE" << endl;
		return 1;
	}

	for (vector <int*> ::const_iterator iter = iNumbers.begin(); iter != iNumbers.end(); iter++)
	{
		outFileInt << toString(**iter) << endl;
	}

	outFileInt.close();

	return 0;

}

[jlb]

I need help with fixing my code so i can do the next assignment...

So what exactly seems to be wrong with your code?

[salem c]

It desperately needs code tags!
@LaminarFlow
Read and act -> https://www.cplusplus.com/articles/jEywvCM9/

[LaminarFlow]

I need help with the polymorphism part just with me adding the numbers class with the virtual function since when i tried to put it in now my code doesnt work. How do i use the Nan function that i have in number.h to work with double and integer. Cuz the next part is just adding an exceptions class but i already made my class and i just cant get my virtual function to work. It gives me alot of errors also im using visual studios 2019... I just want to know what im doing wrong so i can correct it and an example how to fix it @jlb