How to avoid a common bug in a large codebase?

int age = 27;

std::wstring str = std::wstring(L"User's age is: ");
str += age;

std::string str2 = std::string("User's age is: ");
str2 += age;

namespace myapp
{
    typedef std::string String;
    typedef std::wstring UTFString;
}

namespace myapp
{
/** std::basic_string with limited and controlled interface.
    */
    template< class _Elem, class _Traits, class _Ax >
    class limited_string
    {
    public:
    	typedef std::basic_string< _Elem , _Traits, _Ax > _String; // this is for easier writing
    	typedef limited_string< _Elem, _Traits, _Ax > _MyType; // this is for easier writing

    private:
    	_String m_string; // here the real std::basic_string object that will do all the real work!

    public:

    	// constructor proxies... (note that those ones are not complete, it should be exactly the same as the original std::basic_string
    	// see some STL docs to get the real interface to rewrite)
    	limited_string() : m_string {}
    	limited_string( const _MyType& l_string ) : m_string( l_string.m_string ) {}
    	limited_string( const _Elem* raw_string ) : m_string( raw_string ) {}
    	//... etc...

    	// operator proxies...
    	_MyType& operator= ( const _MyType& l_string )
    	{
    		m_string = l_string.m_string;
    	}
    	// etc...
    	// but we don't want the operator += with int values so we DON'T WRITE IT!

    	// other function proxies...
    	size_t size() const { return m_string.size(); } // simply forward the call to the real string!
    	// etc...you know what i mean...

    	// to work automatically with other STL algorithm and functions we add automatic conversion functions:
    	operator const _Elem*() const { return m_string.c_str(); }

    	// etc..


    };
}

// instead of those lines...
    //typedef std::string String;
    //typedef std::wstring UTFString;

    // use those ones
    typedef limited_string< char, std::char_traits<char>, std::allocator<char> >				String; // like std::string typedef
    typedef limited_string< wchar_t, std::char_traits<wchar_t>,	std::allocator<wchar_t> >		UTFString; // like std::wstring typedef

error C2676: binary '+=' : 'myapp::UTFString' does not define this operator or a conversion to a type acceptable to the predefined operator
error C2676: binary '+=' : 'myapp::String' does not define this operator or a conversion to a type acceptable to the predefined operator

#include <string>
#include <iostream>

namespace myapp
{

    /** std::basic_string with limited and controlled interface.
    */
    template< class _Elem, class _Traits, class _Ax >
    class limited_string
    {
    public:
    	typedef std::basic_string< _Elem , _Traits, _Ax > _String; // this is for easier writing
    	typedef limited_string< _Elem, _Traits, _Ax > _MyType; // this is for easier writing

    private:
    	_String m_string; // here the real std::basic_string object that will do all the real work!

    public:

    	// constructor proxies... (note that those ones are not complete, it should be exactly the same as the original std::basic_string
    	// see some STL docs to get the real interface to rewrite)
    	limited_string() : m_string {}
    	limited_string( const _MyType& l_string ) : m_string( l_string.m_string ) {}
    	limited_string( const _Elem* raw_string ) : m_string( raw_string ) {}
    	//... etc...

    	// operator proxies...
    	_MyType& operator= ( const _MyType& l_string )
    	{
    		m_string = l_string.m_string;
    	}
    	// etc...
    	// but we don't want the operator += with int values so we DON'T WRITE IT!

    	// other function proxies...
    	size_t size() const { return m_string.size(); } // simply forward the call to the real string!
    	// etc...you know what i mean...

    	// to work automatically with other STL algorithm and functions we add automatic conversion functions:
    	operator const _Elem*() const { return m_string.c_str(); }

    	// etc..


    };

    // instead of those lines...
    //typedef std::string String;
    //typedef std::wstring UTFString;

    // use those ones
    typedef limited_string< char, std::char_traits<char>, std::allocator<char> >				String; // like std::string typedef
    typedef limited_string< wchar_t, std::char_traits<wchar_t>,	std::allocator<wchar_t> >		UTFString; // like std::wstring typedef
}

int main()
{
    using namespace myapp;

    int age = 27;

    UTFString str = UTFString(L"User's age is: ");
    str += age; // compilation error!
    std::wcout << str << std::endl;

    String str2 = String("User's age is: ");
    str2 += age; // compilation error!
    std::cout << str2 << std::endl;

    std::cin.ignore();

    return 0;
}

#!/bin/tcsh
# Pass the file to test as the first argument.

echo "#include <string>
void operator+=(std::string const& , int const&);
void operator+=(std::string const& , int);"
| cat - $1
| g++ -c -x c++ -  >& /dev/null


echo $status

MyString str;
str += 27;