Checking if a function failed to convert a variable of a given type to std::string

[DragonOsman]

On LearnCPP, I came across code that converts a variable of any given type to an std::string. There's also this warning there: "Note that this solution omits any error checking. It is possible that inserting tX into oStream could fail. An appropriate response would be to throw an exception if the conversion fails.". So I was wondering how to check for that case. Any suggestions, guys?

This is the code shown on the site:

#include <iostream>
#include <sstream>
#include <string>
 
template <typename T>
inline std::string ToString(T tX)
{
    std::ostringstream oStream;
    oStream << tX;
    return oStream.str();
}

int main()
{
    using namespace std;
    string sFour(ToString(4));
    string sSixPointSeven(ToString(6.7));
    string sA(ToString('A'));
    cout << sFour << endl;
    cout << sSixPointSeven << endl;
    cout << sA << endl;
}

Note: I haven't tried running this code yet.

Edit: I just tried doing a check, but I don't know how to make it throw the exception to see if it works, so I'd like some help:

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

template <typename T>
inline std::string ToString(T tX);

int main()
{
	using namespace std;
	try
	{
		string sFour{ ToString(4) };
		string sSixPointSeven{ ToString(6.7) };
		string sA{ ToString('A') };
		cout << sFour << "\n" << sSixPointSeven << "\n" << sA << "\n";
	}
	catch (exception& e)
	{
		cerr << e.what() << "\n";
		keep_window_open();
	}
	keep_window_open();
	return 0;
}

template <typename T>
inline std::string ToString(T tX)
{
	using namespace std;
	ostringstream oStream;
	if (!((oStream << tX) ? true : false))
	{
		throw exception::exception();
	}
	return oStream.str();
}

Thanks in advance.

[JLBorges]

// note: compile-time error if T is not an output-streamable type.
template < typename T > inline std::string ToString( const T& tX )
{
	std::ostringstream stm ;

	if( stm << tX ) return stm.str() ;
        else throw std::runtime_error( "conversion failed" ) ;
}

[DragonOsman]

Thanks. I'll try that.

Edit:
I can't catch the exception correctly for some reason. Please tell me what I'm doing wrong here:

template <typename T>
inline std::string ToString(T tX);

class IntArray
{
private:
	int *m_pnData;
	int m_nLength;
public:
	IntArray()
	{
		m_nLength = 0;
		m_pnData = 0;
	}

	IntArray(const int nLength, const int *pnData)
		:m_nLength{ nLength }, m_pnData{ new int[m_nLength] }
	{
	}

        ~IntArray()
	{
		delete[] m_pnData;
		m_nLength = 0;
		m_pnData = 0;
	}

	int getLength() const { return m_nLength; }

	int& operator[](const int nIndex)
	{
		return m_pnData[nIndex];
	}

	friend std::ostream& operator<< (std::ostream &out, const IntArray& anArray)
	{
		out << anArray.m_pnData;
		return out;
	}
};

int main()
{
	using namespace std;
	IntArray anArray;
	for (int nCount = 0; nCount < 10; nCount++)
	{
		anArray[nCount] = nCount;
	}
	try
	{
		string sFour{ ToString(anArray) };
		string sSixPointSeven{ ToString(6.7) };
		string sA{ ToString('A') };
		cout << sFour << "\n" << sSixPointSeven << "\n" << sA << "\n";
	}
	catch (runtime_error &runError(string))
	{
		cerr << runError("conversion failed").what() << "\n";
	}
	catch (...)
	{
		cerr << "Unknown exception caught\n";
	}
	keep_window_open();
	return 0;
}

template <typename T>
inline std::string ToString(T tX)
{
	using namespace std;
	ostringstream oStream;
	if (oStream << tX)
	{
		return oStream.str();
	}
	else
	{
		throw runtime_error("conversion failed");
	}
}

[Moschops]

I expect because that exception isn't thrown, because this code segFaults before it gets there when you do this
anArray[nCount] = nCount;
because m_pnData is a null pointer, having been set to the value 0 and never changed.

If I was reviewing this code, I would say that IntArray is what I technically call a "badly designed" class, because it's possible to create it in a state such that when someone tries to use it, it segFaults.

[DragonOsman]

So I need to make sure it's not a null pointer? How do I assign it to a non-Null value, though?

[Moschops]

Like this:
m_pnData = new int[m_nLength]
which is being done in the other constructor. Did you write this code? It seems odd that you know how to allocate some memory in a constructor, and at the same time not know how to do it.

[DragonOsman]

I was having trouble actually correctly calling that constructor, I guess.

Anyway, since the IntArray class a vector-like class (sans template, though - template version was shown in another lesson) that I got from LearnCPP itself in an earlier lesson, using the same code from the original class works. But now it's working a bit too well and I don't know what type or variable to use to test the exception.

Here's the code:

#include <iostream>
#include <string>
#include <sstream>
#include <stdexcept>
#include "IntArray.h"
#include "ArrayException.h"
#include "keep_window_open.h"

template <typename T>
inline std::string ToString(T tX);

int main()
{
	using namespace std;
	IntArray anArray{ 10 };
	for (int nCount = 0; nCount < anArray.GetLength(); nCount++)
	{
		anArray[nCount] = nCount;
	}
	try
	{
		string sFour{ ToString(anArray[4]) };
		cout << sFour << "\n";
	}
	catch (runtime_error &r)
	{
		cerr << r.what() << "\n";
		keep_window_open();
		return 0;
	}
	catch (exception &e)
	{
		cerr << e.what() << "\n";
		keep_window_open();
		return 1;
	}
	catch (...)
	{
		cerr << "Unknown exception caught\n";
		keep_window_open();
		return 2;
	}
	string sSixPointSeven{ ToString(6.7) };
	string sA{ ToString('A') };
	cout << sSixPointSeven << "\n" << sA << "\n";
	keep_window_open();
	return 0;
}

template <typename T>
inline std::string ToString(T tX)
{
	using namespace std;
	ostringstream oStream;
	if (oStream << tX)
	{
		return oStream.str();
	}
	else
	{
		throw runtime_error("conversion failed");
	}
}

For the class code:
IntArray.h:

#ifndef INTARRAY_H
#define INTARRAY_H

class IntArray
{
private:
	int m_nLength;
	int *m_pnData;
public:
	IntArray();
	IntArray(const int nLength);
	~IntArray();
	void Erase();
	int& operator[](const int nIndex);
	int GetLength() const;
	void Reallocate(const int nNewLength);
	void Resize(const int nNewLength);
	void InsertBefore(const int nValue, const int nIndex);
	void Remove(const int nIndex);
	void InsertAtBeginning(const int nValue);
	void InsertAtEnd(const int nValue);
	int GetElement(const int nIndex) const;
	friend std::ostream& operator<< (std::ostream &out, const IntArray &anArray);
};

#endif 

IntArray.cpp:

#include <iostream>
#include "IntArray.h"
#include "ArrayException.h"

IntArray::IntArray()
{
	m_nLength = 0;
	m_pnData = 0;
}

IntArray::IntArray(const int nLength)
	:m_pnData{ new int[nLength] }, m_nLength{ nLength }
{
}

IntArray::~IntArray()
{
	delete[] m_pnData;
}

void IntArray::Erase()
{
	delete[] m_pnData;
	m_pnData = 0;
	m_nLength = 0;
}

int& IntArray::operator[](const int nIndex)
{
	if (nIndex < 0 || nIndex >= m_nLength)
	{
		throw ArrayException{ "Invalid index" };
	}
	return m_pnData[nIndex];
}

int IntArray::GetLength() const
{
	return m_nLength;
}

// Reallocate resizes the array.  Any existing elements will be destroyed.
// This function operates quickly.

void IntArray::Reallocate(const int nNewLength)
{
	// First we delete any existing elements
	Erase();

	// If our array is going to be empty now, return here
	if (nNewLength <= 0)
	{
		return;
	}

	// Then we have to allocate new elements
	m_pnData = new int[nNewLength];
	m_nLength = nNewLength;
}

// Resize resizes the array.  Any existing elements will be kept.
// This function operates slowly.
void IntArray::Resize(const int nNewLength)
{
	// If we are resizing to an empty array, do that and return
	if (nNewLength <= 0)
	{
		Erase();
		return;
	}

	// Now we can assume nNewLength is at least 1 element.  This algorithm
	// works as follows: First we are going to allocate a new array.  Then we
	// are going to copy elements from the existing array to the new array.
	// Once that is done, we can destroy the old array, and make m_pnData
	// point to the new array.

	// First we have to allocate a new array
	int *pnData = new int[nNewLength];

	// Then we have to figure out how many elements to copy from the existing
	// array to the new array.  We want to copy as many elements as there are
	// in the smaller of the two arrays.
	if (m_nLength > 0)
	{
		int nElementsToCopy = (nNewLength > m_nLength) ? m_nLength : nNewLength;

		// Now copy the elements one by one
		for (int nIndex = 0; nIndex < nElementsToCopy; nIndex++)
		{
			pnData[nIndex] = m_pnData[nIndex];
		}
	}

	// Now we can delete the old array because we don't need it any more
	delete[] m_pnData;

	// And use the new array instead!  Note that this simply makes m_pnData point
	// to the same address as the new array we dynamically allocated.  Because
	// pnData was dynamically allocated, it won't be destroyed when it goes out of scope.
	m_pnData = pnData;
	m_nLength = nNewLength;
}

void IntArray::InsertBefore(const int nValue, const int nIndex)
{
	// Sanity check our nIndex value
	if (nIndex < 0 || nIndex >= m_nLength)
	{
		throw ArrayException{ "Invalid index" };
	}

	// First create a new array one element larger than the old array
	int *pnData = new int[m_nLength + 1];

	// Copy all of the elements up to the index
	for (int nBefore = 0; nBefore < nIndex; nBefore++)
	{
		pnData[nBefore] = m_pnData[nBefore];
	}

	// Insert our new element into the new array
	pnData[nIndex] = nValue;

	// Copy all of the values after the inserted element
	for (int nAfter = nIndex; nAfter < m_nLength; nAfter++)
	{
		pnData[nAfter + 1] = m_pnData[nAfter];
	}

	// Finally, delete the old array, and use the new array instead
	delete[] m_pnData;
	m_pnData = pnData;
	m_nLength += 1;
}

void IntArray::Remove(const int nIndex)
{
	// Sanity check our nIndex value
	if (nIndex < 0 || nIndex >= m_nLength)
	{
		throw ArrayException{ "Invalid index" };
	}

	// First create a new array one element smaller than the old array
	int *pnData = new int[m_nLength - 1];

	// Copy all of the elements up to the index
	for (int nBefore = 0; nBefore < nIndex; nBefore++)
	{
		pnData[nBefore] = m_pnData[nBefore];
	}

	// Copy all of the values after the removed element
	for (int nAfter = nIndex + 1; nAfter < m_nLength; nAfter++)
	{
		pnData[nAfter - 1] = m_pnData[nAfter];
	}

	// Finally, delete the old array, and use the new array instead
	delete[] m_pnData;
	m_pnData = pnData;
	m_nLength -= 1;
}

void IntArray::InsertAtBeginning(const int nValue)
{
	InsertBefore(nValue, 0);
}

void IntArray::InsertAtEnd(const int nValue)
{
	InsertBefore(nValue, m_nLength);
}

int IntArray::GetElement(const int nIndex) const
{
	return m_pnData[nIndex];
}

std::ostream& operator<< (std::ostream &out, const IntArray &anArray)
{
	out << anArray.m_pnData;
	return out;
}

ArrayException.h:

#ifndef ARRAYEXCEPTION_H
#define ARRAYEXCEPTION_H

#include <iostream>

class ArrayException
{
private:
	std::string m_strError;
public:
	ArrayException();
	ArrayException(const std::string &strError);
	const std::string& GetError() const;
};

#endif 

ArrayException.cpp:

#include <iostream>
#include "ArrayException.h"

// not meant to be called
ArrayException::ArrayException()
{

}

ArrayException::ArrayException(const std::string &strError)
	:m_strError{ strError }
{
}

const std::string& ArrayException::GetError() const
{
	return m_strError;
}