Static member object

[zanklob]

Hello,
I am new in c++ and I am curious as how should I declare an object of a class as a member of another class. When I declared it outside of my class and main as global it worked fine but when I try to declare it as member of a class I get errors. This is my code:

#include <iostream>
#include <cstring>
#include <string>
#include <map>

//A class that keeps count of how many pointers point to each string and handles them.
class StringManager
{
public:

	StringManager() {}

	~StringManager()
	{
		pointer_count.clear();
	}

    //Adds or increments a certain element in the map.
	std::string* AddString(std::string* a_Data)
	{

		if (pointer_count.empty())
		{
			pointer_count.insert(std::pair<std::string*, int>(a_Data, 1));
			return a_Data;
		}
		else
		{
			std::string* p_str;
			std::string str;
			std::string data;
			data = *a_Data;

			for (Map_Type::iterator iter = pointer_count.begin(); iter != pointer_count.end(); ++iter)
			{
				p_str = iter->first;
				str = *p_str;
				if (data.compare(str) == 0)
				{
					a_Data = iter->first;
					++iter->second;
				}
				else
				{
					pointer_count.insert(std::pair<std::string*, int>(a_Data, 1));
				}
			}
			return a_Data;
		}
	}

    //Deletes or decrements a certain map element.
	void DeleteString(std::string* a_Data)
	{
		for (Map_Type::iterator iter = pointer_count.begin(); iter != pointer_count.end(); ++iter)
		{
			if (iter->first == a_Data)
			{
				if (iter->second == 1)
				{
					pointer_count.erase(iter);

				}
				else
				{
					--iter->second;
				}
			}
		}
	}

	void PrintString(std::string* a_Data)
	{
		for (Map_Type::iterator iter = pointer_count.begin(); iter != pointer_count.end(); ++iter)
		{
			std::cout << "String " << *iter->first << " has : " << iter->second << " pointer(s), the address is: " << iter->first << std::endl;
		}
	}

private:
	friend class StringHolder;
	typedef std::map<std::string*, int> Map_Type;
	Map_Type pointer_count; //A map that keeps track of the pointers.

};//class StringManager

//static StringManager g_StrMgr;

//A class that keeps a pointer to a string object
class StringHolder
{
public:

	StringHolder(std::string a_Data)
	{
		m_Data = &a_Data;
		m_Data = g_StrMgr.AddString(m_Data);
	}

	void operator+=(std::string rhs)
	{
	    std::string* newStr = new std::string (*m_Data);
	    (*newStr).append(rhs);
	    g_StrMgr.AddString(newStr);
	    g_StrMgr.DeleteString(m_Data);
		m_Data = newStr;
	}

	~StringHolder()
	{
		g_StrMgr.DeleteString(m_Data);
	}

	void Print()
	{
		g_StrMgr.PrintString(m_Data);
		std::cout << "\n" << std::endl;
	}

private:
	std::string* m_Data;
	static StringManager g_StrMgr;

};//class StringHolder


int main()
{
	std::string test_a = "toli";
	std::string test_b = "vago";
	std::string test_c = "toli";
	StringHolder a(test_a);
	a.Print();
	StringHolder b(test_a);
	b.Print();
	StringHolder c(test_b);
	c.Print();
	b += "vago";
	b.Print();
	StringHolder d(test_c);
	d.Print();
	StringHolder e(test_c);
	e.Print();
	return 0;
}

Plus do I have a memory leak? Wherever I try to delete my new string I get errors.