Printing template types

[ICantC]

My usual overload for operator << doesn't seem to be working with templates, no matter what type I put in, I get some weird hex and have tried several methods and always the same. See below string example:

	friend std::ostream& operator<<(std::ostream& os, T* data)
	{
		return os << *data;
	}

int main()
{
	jlist<std::string>* myList = new jlist<std::string>("test");
	myList->additem("coffee");
	myList->additem("cake");

	jlistIterator<std::string> it(myList);

	it.iterator++;
	it.iterator--;
	std::cout << it.iterator->data; //prints hex

	std::cout << myList->deleteitem("fesfef") << std::endl;
	std::cout << myList->deleteitem("test") << std::endl;
	std::cout << myList->deleteitem("cake") << std::endl;
	std::cout << myList->deleteitem("dsdsd") << std::endl;
	std::cout << myList->length();

	getchar();
	return 0;
}

FULL CODE

#ifndef __GENERICLIST__
#define __GENERICLIST__

#include <ostream>

template <typename T>
class jnode {
public:
	T* data{ nullptr };
	jnode<T>* next{ nullptr };
	jnode<T>* prev{ nullptr };
};

template <typename T>
class jlist {
private:
	int listLength{ 0 };
public:
	jnode<T>* begin{ nullptr };
	jnode<T>* end{ nullptr };
	jlist() {};
	jlist(T item);
	~jlist();
	int length() { return listLength; }
	void additem(T item);
	bool deleteitem(T item);
};

template <typename T>
jlist<T>::jlist(T item)
{
	jnode<T>* newitem = new jnode<T>;
	newitem->data = new T;
	*newitem->data = item;
	begin = newitem;
	end = newitem;
	listLength++;
}

template <typename T>
jlist<T>::~jlist()
{
	if (listLength == 0)
		return;

	if (listLength == 1)
	{
		delete begin->data;
		delete begin;
		return;
	}

	jnode<T>* iterator = begin;
	while (iterator != end && iterator->next != nullptr)
	{
		delete iterator->data;
		iterator = iterator->next;
		delete iterator->prev;
	}
	delete iterator->data;
	delete iterator;
}

template <typename T>
void jlist<T>::additem(T item)
{
	jnode<T>* newitem = new jnode<T>;
	newitem->data = new T;
	*newitem->data = item;

	if (begin != nullptr && end != nullptr)
	{
		end->next = newitem;
		newitem->prev = end;
		end = newitem;
	}
	else
	{
		begin = newitem;
		end = newitem;
	}

	listLength++;
}

template <typename T>
bool jlist<T>::deleteitem(T item)
{
	if (begin == nullptr)
		return false;

	jnode<T>* iterator = begin;
	
	if (begin == end)
	{
		if (*iterator->data == item)
		{
			delete iterator->data;
			delete iterator;
			begin = nullptr;
			end = nullptr;
			listLength--;
			return true;
		}
		return false;
	}

	while (iterator != nullptr)
	{
		if (*iterator->data == item)
		{
			if (iterator == begin)
			{
				begin = iterator->next;
				iterator->next->prev = nullptr;
			}
			else
				iterator->prev->next = iterator->next;

			delete iterator->data;
			delete iterator;
			listLength--;
			return true;
		}
		iterator = iterator->next;
	}
	return false;
}

template <typename T>
class jlistIterator {
private:
	jlist<T>* theList{ nullptr };
public:
	jnode<T>* iterator{ nullptr };
	jlistIterator(jlist<T>* list)
	{
		theList = list;
		iterator = theList->begin;
	}
	jnode<T>* operator++()
	{
		if (iterator->next != nullptr)
			return iterator->next;

		return nullptr;
	}
	jnode<T>* operator--()
	{
		if (iterator->prev != nullptr)
			return iterator->prev;

		return nullptr;
	}
	friend std::ostream& operator<<(std::ostream& os, T* data)
	{
		return os << *data;
	}
};

#endif 

[Ganado]

Try putting a print statement in your operator<<, see if it prints.

Pointers are already overloaded to print using standard library's operator<<:
http://www.cplusplus.com/reference/ostream/ostream/operator-free/

Why not just do:
std::cout << *it.iterator->data << '\n';

Don't pass a pointer to the data, just pass a reference to the data (an std::string). Then, you won't need to define a custom operator<< because one already exists for std::string.

#include <iostream>
#include <string>

class Asdf {
    
  
};

std::ostream& operator<<(std::ostream& os, const Asdf& asdf)
{
    return os << "asdf";
}

template <typename T>
void blah(const T& t)
{
    std::cout << t << '\n';
}

int main()
{
    std::string str = "Hello";
    std::string* p_str = &str;

    Asdf asdf;
    Asdf* p_asdf = &asdf;
    
    blah(str);
    blah(p_str);
    blah(asdf);
    blah(p_asdf);
}