请问这个出错提示是什么意思？？

vanxining 2013-03-12 04:55:44



1>TestString.cpp

1>TestString.cpp(22) : error C2784: “Ning::String<CharT> Ning::operator +(const Ning::String<CharT> &,const Ning::String<CharT> &)”: 无法从“重载函数类型”为“const Ning::String<CharT> &”推导 <未知> 参数

1>        String.hpp(9) : 参见“Ning::operator +”的声明

1>TestString.cpp(22) : error C2676: 二进制“+”: “string”不定义该运算符或到预定义运算符可接收的类型的转换

以下是String.hpp的内容：



#include <cstring>



namespace Ning

{

	template< typename CharT >

	class String;



	template< typename CharT >

	String<CharT> operator+(const String<CharT>& s1, const String<CharT>& s2);



	/// 字符串类

	template< typename CharT >

	class String

	{

	public:

		

		typedef unsigned size_type;



		/// \brief 构造函数

		String(const CharT* s = 0, size_type len = 0);



		/// \brief 复制构造函数

		String(const String& other);



		/// \brief 重载赋值操作符

		String& operator=(const String& other);



		/// \brief 设定字符串内容

		void assign(const CharT* s);

		void assign(const CharT* s, size_type len);

		void assign(const String& other);



		/// \brief 清空字符串

		void clear();



		/// \brief 析构函数

		~String();



		//============================================================



		/// \brief 获取字符串长度

		size_type size() const { return m_len; }



		/// \brief 返回内部 C 字符串指针

		const CharT* c_str() const;



		/// \brief 字符串是否为空

		bool empty() const { return m_len == 0; }



		//============================================================



		/// \brief 字符串连接操作符

		friend String operator+ <CharT>(const String& s1, const String& s2);



	private:



		CharT* m_str;

		size_type m_len;

	};



	//////////////////////////////////////////////////////////////////////////



	template< typename CharT >

	struct StrTypeTrait

	{

		static typename String< CharT >::size_type len(const CharT* s);

		static int cmp(const CharT* s1, const CharT* s2);

	};



	template<>

	struct StrTypeTrait< char >

	{

		static String< char >::size_type len(const char* s) {

			return strlen( s );

		}



		static int cmp(const char* s1, const char* s2) {

			return strcmp( s1, s2 );

		}

	};



	template< typename CharT >

	Ning::String<CharT>::~String()

	{

		clear();

	}



	//////////////////////////////////////////////////////////////////////////



	template< typename CharT >

	Ning::String<CharT>::String(const CharT* s, size_type len)

		: m_str( 0 ), m_len( len )

	{

		assign( s, len );

	}



	template< typename CharT >

	Ning::String<CharT>::String(const String& other)

		: m_str( 0 ), m_len( 0 )

	{

		assign( other );

	}



	template< typename CharT >

	String<CharT>& Ning::String<CharT>::operator=(const String<CharT>& other)

	{

		assign( other );

		return *this;

	}



	template< typename CharT >

	void Ning::String<CharT>::assign(const CharT* s)

	{

		assign( s, 0 );

	}



	template< typename CharT >

	void Ning::String<CharT>::assign(const CharT* s, size_type len)

	{

		if( s )

		{

			if( len == 0 )

				len = StrTypeTrait< CharT >::len( s );



			if( len > 0 )

			{

				m_str = new CharT[len + 1];

				memcpy( m_str, s, len );

			}



			m_str[len] = 0;



			//============================================================



			m_len = len;

		}

	}



	template< typename CharT >

	void Ning::String<CharT>::assign(const String& other)

	{

		if( &other != this )

		{

			clear();

			assign( other.m_str, other.m_len );

		}

	}



	template< typename CharT >

	void Ning::String<CharT>::clear()

	{

		if( m_str )

		{

			delete [] m_str;

			m_str = 0;

		}

	}



	template< typename CharT >

	const CharT* Ning::String<CharT>::c_str() const

	{

		const static CharT ch = 0;

		return m_str ? m_str : &ch;

	}



	//////////////////////////////////////////////////////////////////////////



	template< typename CharT >

	String<CharT> operator+(const String<CharT>& s1, const String<CharT>& s2)

	{

		String<CharT> ret;



		if( !s1.empty() || !s2.empty() )

		{

			ret.m_len = s1.size() + s2.size();

			ret.m_str = new CharT[ret.m_len + 1];



			if( !s1.empty() )

				memcpy( ret.m_str, s1.m_str, s1.size() );



			if( !s2.empty() )

				memcpy( ret.m_str + s1.size(), s2.m_str, s2.size() );



			ret.m_str[ret.m_len] = 0;

		}



		return ret;

	}



}

TestString.cpp的内容：





#include "String.hpp"

#include <cstdio>



typedef Ning::String< char > string;



void Print(const string& s)

{

	printf( "%s[Length: %d]\n", s.c_str(), s.size() );

}



int main()

{

	string s1( "Hello" );

	string s2 = s1;

	Print( s2 );



	string s3;

	Print( s3 );



	s3.assign( "World!" );

	string s4 = s1 + " " + s3; // 这里不能连加！！

	Print( s4 );



	return 0;

}

...全文

127 2 打赏收藏转发到动态举报

写回复

用AI写文章

2 条回复

切换为时间正序

请发表友善的回复…

发表回复

mujiok2003 2013-03-12

打赏
举报

重载一下咯


#include <cstring>
#include <cstdio>

namespace Ning
{


  /// 字符串类
  template< typename CharT >
  class String
  {
  public:
    
    typedef unsigned size_type;

    /// \brief 构造函数
    String(const CharT* s = 0, size_type len = 0);

    /// \brief 复制构造函数
    String(const String& other);

    /// \brief 重载赋值操作符
    String& operator=(const String& other);

    /// \brief 设定字符串内容
    void assign(const CharT* s);
    void assign(const CharT* s, size_type len);
    void assign(const String& other);

    /// \brief 清空字符串
    void clear();

    /// \brief 析构函数
    ~String();

    //============================================================

    /// \brief 获取字符串长度
    size_type size() const { return m_len; }

    /// \brief 返回内部 C 字符串指针
    const CharT* c_str() const;

    /// \brief 字符串是否为空
    bool empty() const { return m_len == 0; }

    //============================================================

    /// \brief 字符串连接操作符
    template<typename ChT>
    friend String<ChT> operator+ (const String<ChT>& s1, const String<ChT>& s2);

  private:

    CharT* m_str;
    size_type m_len;
  };

  //////////////////////////////////////////////////////////////////////////

  template< typename CharT >
  struct StrTypeTrait
  {
    static typename String< CharT >::size_type len(const CharT* s);
    static int cmp(const CharT* s1, const CharT* s2);
  };

  template<>
  struct StrTypeTrait< char >
  {
    static String< char >::size_type len(const char* s) {
      return strlen( s );
    }

    static int cmp(const char* s1, const char* s2) {
      return strcmp( s1, s2 );
    }
  };

  template< typename CharT >
  Ning::String<CharT>::~String()
  {
    clear();
  }

  //////////////////////////////////////////////////////////////////////////

  template< typename CharT >
  Ning::String<CharT>::String(const CharT* s, size_type len)
  : m_str( 0 ), m_len( len )
  {
    assign( s, len );
  }

  template< typename CharT >
  Ning::String<CharT>::String(const String& other)
  : m_str( 0 ), m_len( 0 )
  {
    assign( other );
  }

  template< typename CharT >
  String<CharT>& Ning::String<CharT>::operator=(const String<CharT>& other)
  {
    assign( other );
    return *this;
  }

  template< typename CharT >
  void Ning::String<CharT>::assign(const CharT* s)
  {
    assign( s, 0 );
  }

  template< typename CharT >
  void Ning::String<CharT>::assign(const CharT* s, size_type len)
  {
    if( s )
    {
      if( len == 0 )
      len = StrTypeTrait< CharT >::len( s );

      if( len > 0 )
      {
        m_str = new CharT[len + 1];
        memcpy( m_str, s, len );
      }

      m_str[len] = 0;

      //============================================================

      m_len = len;
    }
  }

  template< typename CharT >
  void Ning::String<CharT>::assign(const String& other)
  {
    if( &other != this )
    {
      clear();
      assign( other.m_str, other.m_len );
    }
  }

  template< typename CharT >
  void Ning::String<CharT>::clear()
  {
    if( m_str )
    {
      delete [] m_str;
      m_str = 0;
    }
  }

  template< typename CharT >
  const CharT* Ning::String<CharT>::c_str() const
  {
    const static CharT ch = 0;
    return m_str ? m_str : &ch;
  }

  //////////////////////////////////////////////////////////////////////////

  template< typename CharT >
  String<CharT> operator+(const String<CharT>& s1, const String<CharT>& s2)
  {
    String<CharT> ret;

    if( !s1.empty() || !s2.empty() )
    {
      ret.m_len = s1.size() + s2.size();
      ret.m_str = new CharT[ret.m_len + 1];

      if( !s1.empty() )
      memcpy( ret.m_str, s1.m_str, s1.size() );

      if( !s2.empty() )
      memcpy( ret.m_str + s1.size(), s2.m_str, s2.size() );

      ret.m_str[ret.m_len] = 0;
    }

    return ret;
  }

  // overloaded
  template<typename CharT>
  String<CharT> operator+(const String<CharT>& s1, CharT const* s2)
  {
    return s1 + (String<CharT>)(s2);
  }

  template<typename CharT>
  String<CharT> operator+ (CharT const* s1, const String<CharT>& s2)
  {
    return (String<CharT>)(s1) + s2;
  }

}


typedef Ning::String<char> NString;

void Print(const NString& s)
{
  printf( "%s[Length: %d]\n", s.c_str(), s.size() );
}

int main()
{
  NString s1( "Hello" );
  NString s2 = s1;
  Print( s2 );

  NString s3;
  Print( s3 );

  s3.assign( "World!" );
  NString s4 = s1 + " " + s3; // 这里不能连加！！
  Print( s4 );

  return 0;
}

vanxining 2013-03-12