关于流操作符重载！！

[wvins]

流操作符重载有什么要求吗？
为什么我得重载操作符总提示无法访问类的私有成员呢？

具体代码身边没有，下次再贴了。

[llf_hust]

把
#include<iostream>
using namespace std;
改为
#include<iostream.h>

[Jagen在路上]

没什么特殊要求，下面是我曾经实现过的代码，你看看。

compack.h

/*!
* 通用输入包处理类，这给类表现了数据包处理的一种思路。
*
* @author 赵鑫磊
* @short 通用输入包处理类
*/
class __EXPORT_NET kx_ComInPacket : public kx_InPacket
{
protected: // 保护数据
const uint8* m_pbData; // 数据
uint32 m_nDataLen; // 数据长度
const uint8* m_pbCursor; // 数据指针

public: // 构造

/*!
* 输入信令包类构造函数, 根据输入缓冲区数据构造输入信令处理类,
* 初始化保护成员m_szData,m_nDataLen,m_pCurssor。
*
* @param data 输入数据缓冲区地址
* @param len 输入数据缓冲区长度
*/
kx_ComInPacket( const uint8* data, uint32 len )
{
m_pbData = m_pbCursor = data;
m_nDataLen = len;
}
public: // 属性

/*! 获得缓冲区数据,不能对缓冲区数据进行修改，一般用于数据的传送。*/
virtual const uint8* getData( void ) const{ return m_pbData; }

/*! 获得缓冲区的大小,用于需获得当前缓冲区的长度的计算。*/
virtual int32 getSize( void ){ return m_nDataLen; }

public: //方法

/*!
* 从缓冲区中输入一个字节,缓冲区数据指针向后移动一个字节。
*
* @param b 用于接收字节数据
* @return 输入包实例
*/
virtual kx_InPacket& operator>>( uint8& b );

/*!
* 从缓冲区中输入一个字,缓冲区数据指针向后移动一个字。
*
* @param w 用于接收字数据
* @return 输入包实例引用
*/
virtual kx_InPacket& operator>>( uint16& w );

/*!
* 从缓冲区中输入一个双字,缓冲区数据指针向后移动一个双字。
*
* @param dw 用于接收双字数据
* @retrun 输入包实例引用
*/
virtual kx_InPacket& operator>>( uint32& dw );

/*!
* 从缓冲区中输入一个ASCII字符串,根据缓冲区中当前指针的位
* 置指向的一个字的内容确定字符串的长度，并根据这个长度读
* 取随后的数据到str缓冲区中。
*
* @param str 用于接收ASCII字符串
* @return 输入包实例引用
*/
virtual kx_InPacket& operator>>( const char*& str );

/*!
* 从缓冲区中输入一个ASCII字符串。调用
* kx_InPacket& operator>>( const LPCHAR& str )获得字符
* 串数据，之后传递给string。
*
* @param str 用于接收ASCII字符串
* @return 输入包实例引用
*/
kx_InPacket& operator>>( string& str );

/*!
* 读取缓冲区中的数据，但不能对数据进行修改.一般先调用一次，用
* 于获得缓冲区的数据长度，之后再调用，将缓冲区数据复制到新的
* 缓冲区。
*
* @param size 用于返回缓冲区中数据的长度
* @return 缓冲区中数据的指针
*/
const uint8* readData( int32& size ) const;
};
//---------------------------------------------------------------------------

#ifndef MAX_PACKET_SIZE
#define MAX_PACKET_SIZE 8192
#endif

/*!
* 通用输出包处理类，这给类表现了数据包处理的一种思路。
*
* @author 赵鑫磊
* @short 通用输出包处理类
*/
class __EXPORT_NET kx_ComOutPacket : public kx_OutPacket
{
protected: // 保护成员
uint8 m_arrbData[MAX_PACKET_SIZE]; // 数据缓冲区
uint8* m_pbCursor; // 数据指针

public: // 构造

/*!
* 输出信令包类构造函数,将数据指针指向缓冲区起始地址
*/
kx_ComOutPacket( void ) { m_pbCursor = m_arrbData; }

public: // 属性

/*!
* 获得缓冲区数据,获得缓冲区地址。不能对缓冲区数据进
* 行修改，一般用于数据的传送。
*
* @retrun 缓冲区地址
*/
const uint8* getData( void ) const{ return m_arrbData; }

/*!
* 获得缓冲区的大小,用于需获得当前缓冲区的长度的计算。
*
* @return 缓冲区的大小
*/
int32 getSize( void ) { return static_cast<int32>( m_pbCursor - m_arrbData ); }

public: // 方法

/*!
* 设置当前数据指针,调整当前的数据指针，便于数据的反复检索。
*
* @param off 相对于数据缓冲区起始位置的偏移量
* @return 原数据指针位置
*/
uint32 setCursor( uint32 off );

/*!
* 向数据缓冲区输出一个字节的数据。同时数据指针后移
* 一个字节。
*
* @param b 要输出的数据
* @return 输出包实例引用
*/
virtual kx_OutPacket& operator<<( uint8 b );

/*!
* 向数据缓冲区输出一个字的数据。同时数据指针后移一
* 个字。
*
* @param w 要输出的数据
* @return 输出包实例引用
*/
virtual kx_OutPacket& operator<<( uint16 w );

/*!
* 向数据缓冲区输出一个双字数据。同时数据指针后移
* 一个双字。
*
* @param dw 要输出的双字数据
* @return 输出包实例引用
*/
virtual kx_OutPacket& operator<<( uint32 dw );

/*!
* 向数据缓冲区输出一个字符串数据。首先在当前数据指
* 针位置插入一个字的字符串长度数据接下来存放字符串
* 数据，数据指针后移到字符串末尾。
*
* @param str 要输出的字符串
* @return 输出包实例引用
*/
virtual kx_OutPacket& operator<<( const char* str );

/*!
* 向数据缓冲区输出一个字符串数据。首先将string类型转换成
* char*类型，调用成员函数kx_OutPacket& operator<<( const char* str )
* 参数: const string& str 要输出的字符串
* 返回值： kx_OutPacket& 输出包实例引用
*/
kx_OutPacket& operator<<( const string& str )
{
return operator<<( str.c_str() );
}

/*!
* 向输出缓冲区写入数据,数据指针后移。
*
* @param Buf 要写入数据的缓冲区地址
* @param size 要写入数据的字节数
*/
virtual void writeData( const uint8* Buf, int32 size );

};

};

[Jagen在路上]

compack.cpp

#include "kx_compacket.h"

#ifndef WIN32
# include <netinet/in.h>
#else
# include <winsock2.h>
#endif

//---------------------------------------------------------------------------
namespace kxlib {

// kx_ComInPacket
//---------------------------------------------------------------------------
// 从缓冲区中输入一个字节
kx_InPacket& kx_ComInPacket::operator>>( uint8& b )
{
if ( m_pbCursor <= m_pbData + m_nDataLen - sizeof(b) )
{
b = *( reinterpret_cast< const BYTE* >( m_pbCursor ) );
m_pbCursor += sizeof(b);
}
else
{
b = 0;
}
return (*this);
}

//---------------------------------------------------------------------------
// 从缓冲区中输入一个字
kx_InPacket& kx_ComInPacket::operator>>( uint16& w )
{
if ( m_pbCursor <= m_pbData + m_nDataLen - sizeof(w) )
{
w = ntohs( *( reinterpret_cast< const WORD* >( m_pbCursor ) ) );
m_pbCursor += sizeof(w);
}
else
{
w = 0;
}
return (*this);
}

//---------------------------------------------------------------------------
// 从缓冲区中输入一个双字
kx_InPacket& kx_ComInPacket::operator>>( uint32& dw )
{
if ( m_pbCursor <= m_pbData + m_nDataLen - sizeof(dw) )
{
dw = ntohl( *( reinterpret_cast< const DWORD* >( m_pbCursor ) ) );
m_pbCursor += sizeof(dw);
}
else
{
dw = 0;
}
return (*this);
}

//---------------------------------------------------------------------------
// 从缓冲区中输入一个ASCII字符串
kx_InPacket& kx_ComInPacket::operator>>( const char*& str )
{
uint16 len;
operator>>( len );

if ( m_pbCursor <= m_pbData + m_nDataLen - len && ! m_pbCursor[ len - 1 ] )
{
str = reinterpret_cast< const char* >( m_pbCursor );
m_pbCursor += len;
}
else
{
str = "";
}
return (*this);
}

//---------------------------------------------------------------------------
// 从缓冲区中输入一个ASCII字符串
kx_InPacket& kx_ComInPacket::operator>>( string& str )
{
const char* p;
operator >>( p );
str = p;
return (*this);
}

//---------------------------------------------------------------------------
// 读取缓冲区中的数据，但不能对数据进行修改
const uint8* kx_ComInPacket::readData( int32& size ) const
{
size = static_cast<int32>( m_nDataLen - ( m_pbCursor - m_pbData ) );
return m_pbCursor;
}

//kx_ComOutPacket
//---------------------------------------------------------------------------
// 设置当前数据指针
uint32 kx_ComOutPacket::setCursor( uint32 off )
{
uint32 old = static_cast< uint32 >( m_pbCursor - m_arrbData );
m_pbCursor = m_arrbData + off;
return old;
}

//---------------------------------------------------------------------------
// 向数据缓冲区输出一个字节的数据。
kx_OutPacket& kx_ComOutPacket::operator<<( uint8 b )
{
if ( m_pbCursor <= m_arrbData + MAX_PACKET_SIZE - sizeof( b ) )
{
*( reinterpret_cast< uint8* >( m_pbCursor ) ) = b;
m_pbCursor += sizeof( b );
}
return (*this);
}

//---------------------------------------------------------------------------
// 向数据缓冲区输出一个字的数据
kx_OutPacket& kx_ComOutPacket::operator<<( uint16 w )
{
if ( m_pbCursor <= m_arrbData + MAX_PACKET_SIZE - sizeof( w ) )
{
*( reinterpret_cast< uint16* >( m_pbCursor ) )= htons(w);
m_pbCursor += sizeof( w );
}
return (*this);
}

//---------------------------------------------------------------------------
// 向数据缓冲区输出一个双字数据
kx_OutPacket& kx_ComOutPacket::operator<<( uint32 dw )
{
if ( m_pbCursor <= m_arrbData + MAX_PACKET_SIZE - sizeof( dw ) )
{
*( reinterpret_cast< uint32 *>( m_pbCursor ) ) = htonl(dw);
m_pbCursor += sizeof( dw );
}
return (*this);
}

//---------------------------------------------------------------------------
// 向数据缓冲区输出一个ASCII字符串
kx_OutPacket& kx_ComOutPacket::operator<<( const char* str )
{
uint16 len = static_cast< uint16 >( strlen( str ) + 1 );
if ( m_pbCursor <= m_arrbData + MAX_PACKET_SIZE - sizeof( len ) - len )
{
operator<<( len );
strcpy( reinterpret_cast< char* >( m_pbCursor ), str );
m_pbCursor += len;
}
return (*this);
}

//---------------------------------------------------------------------------
// 向输出缓冲区写入数据
void kx_ComOutPacket::writeData( const uint8* buf, int32 size )
{
if ( m_pbCursor <= m_arrbData + MAX_PACKET_SIZE - size )
{
memcpy( m_pbCursor, buf, size );
m_pbCursor += size;
}
}

};

[killer1984]

要访问私有成员就把重载的操作符声明为友元。

[wvins]

把
#include<iostream>
using namespace std;
改为
#include<iostream.h>

可以解释一下为什么吗？
也许会使这个问题！
友元啊什么的应该没问题！