C#重载操作符>> 有什么用？怎么重载？

这个用得不多啊。

在C++里面重载这个操作符做一个流的输入输出。

你也可以尝试用C#来实现以下。根据自己的需要来吧。

谢谢您的回复啊，我是一个学生，有很多东西都还不会，希望在这里学到些什么，我的问题是，怎么对它进行重载？重载后实现对对象的直接输入和输出。

C#虽然可以重载操作符，但和C++比较起来，却有很大的不同。定义的时候重载操作符方法必须是static，而且至少有一个参数（一目和二目分别是一个和两个），C#和C++比起来，最重要的特征是：<、>；==、!=；true、false必须成对出现，即重载了“<”就必须重载“>”，重载了“==”就必须重载“！=”，重载了“true”就必须重载“false”；另外，还必须实现基类object的两个虚方法：GetHashCode()和Equals(object obj)。

using System;
using System.Xml;

namespace ConsoleApplication8
{
    /// <summary>
    /// 姓名类
    /// </summary>
    class Namer
    {
        private string FirstName;
        private string LastName;

        public Namer()
        {
            this.Init(null,null);
        }

        public Namer(string fn,string ln)
        {
            this.Init(fn,ln);
        }

        private void Init(string fn,string ln)
        {
            this.FirstName=fn;
            this.LastName=ln;
        }

        /// <summary>
        /// 重载运算符true
        /// </summary>
        /// <param name="n"></param>
        /// <returns>如果姓名中姓或名有一个为空，就返回假</returns>
        public static bool operator true(Namer n)
        {
            if(n.FirstName==null || n.LastName==null)
                return false;
            else
                return true;
        }

        /// <summary>
        /// 重载运算符false
        /// </summary>
        /// <param name="n"></param>
        /// <returns></returns>
        public static bool operator false(Namer n)
        {
            if(n.FirstName==null || n.LastName==null)
                return false;
            else
                return true;
        }

        /// <summary>
        /// 重载运算符==
        /// </summary>
        /// <param name="n1"></param>
        /// <param name="n2"></param>
        /// <returns></returns>
        public static bool operator ==(Namer n1,Namer n2)
        {
            if(n1.FirstName==n2.FirstName && n1.LastName==n2.LastName)
                return true;
            else
                return false;
        }

        /// <summary>
        /// 重载运算符！=
        /// </summary>
        /// <param name="n1"></param>
        /// <param name="n2"></param>
        /// <returns></returns>
        public static bool operator !=(Namer n1,Namer n2)
        {
            if(n1.FirstName!=n2.FirstName || n1.LastName !=n2.LastName)
                return true;
            else
                return false;
        }


        /// <summary>
        /// 重载运算符>
        /// </summary>
        /// <param name="n1"></param>
        /// <param name="n2"></param>
        /// <returns></returns>
        public static bool operator >(Namer n1,Namer n2)
        {
            return (n1.(n2.FirstName)>0 && n1.(n2.LastName)>0);
        }

        /// <summary>
        /// 重载运算符<
        /// </summary>
        /// <param name="n1"></param>
        /// <param name="n2"></param>
        /// <returns></returns>
        public static bool operator <(Namer n1,Namer n2)
        {
            return (n1.(n2.FirstName)<0 && n1.(n2.LastName)<0);
        }

        /// <summary>
        /// 重写方法，必须有,后面的111是乱加的，你也可以写其它的
        /// </summary>
        /// <returns></returns>
        public override int GetHashCode()
        {
            return base.GetHashCode()*111;
        }

        /// <summary>
        /// 重写方法，必须有
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public override bool Equals(object obj)
        {
            return base.Equals (obj);
        }

        /// <summary>
        /// 重写方法，必须有
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            return "姓:"+this.FirstName+" 名:"+this.LastName;
        }


        public static void Main()
        {
            Namer n1=new Namer("li","zanhong");
            Namer n2=new Namer("ahang","aan");
            //Namer n2=new Namer("li","zanhong");

            if(n1==n2)
                Console.WriteLine("一样的名字");
            else
                Console.WriteLine("不一样的名字");
            /////////////////////////////////////
            if(n1!=n2)
                Console.WriteLine("不一样的名字成立");
            else
                Console.WriteLine("同样的名字成立");
            /////////////////////////////////////
            if(n1>n2)
                Console.WriteLine(n1.ToString()+">"+n2.ToString());
            else if(n1<n2)
                Console.WriteLine(n1.ToString()+"<"+n2.ToString());
            else
                Console.WriteLine("没有正确比较");

            Console.ReadLine();
        }

    }
}

谢谢！我是问的">>" 和"<<"重载,重载后怎么用他来对对象直接输入输出？

右移运算符 (>>) 将第一个操作数向右移动第二个操作数所指定的位数。
备注：
如果第一个操作数为 int 或 uint（32 位数），则移位数由第二个操作数的低五位给出（第二个操作数 & 0x1f）。
如果第一个操作数为 long 或 ulong（64 位数），则移位数由第二个操作数的低六位给出（第二个操作数 & 0x3f）。
如果第一个操作数为 int 或 long，则右移位是算术移位（高序空位设置为符号位）。如果第一个操作数为 uint 或 ulong 类型，则右移位是逻辑移位（高位填充 0）。
用户定义的类型可重载 >> 运算符；第一个操作数的类型必须为用户定义的类型，第二个操作数的类型必须为 int。有关更多信息，请参见 operator。重载二元运算符时，也会隐式重载相应的赋值运算符（如果有）。
示例
using System;
class MainClass
{
    static void Main()
    {
        int i = -1000;
        Console.WriteLine(i >> 3);
    }
}


左移运算符 (<<) 将第一个操作数向左移动第二个操作数指定的位数。第二个操作数的类型必须是 int。
备注：
如果第一个操作数是 int 或 uint（32 位数），则移位数由第二个操作数的低 5 位给出。
如果第一个操作数是 long 或 ulong（64 位数），则移位数由第二个操作数的低 6 位给出。
第一个操作数的高序位被放弃，低序空位用 0 填充。移位操作从不导致溢出。
用户定义的类型可重载 << 运算符（请参见 operator）；第一个操作数的类型必须为用户定义的类型，第二个操作数的类型必须为 int。重载二元运算符时，也会隐式重载相应的赋值运算符（如果有）。
示例
using System;
class MainClass
{
    static void Main()
    {
        int i = 1;
        long lg = 1;
        Console.WriteLine("0x{0:x}", i << 1);
        Console.WriteLine("0x{0:x}", i << 33);
        Console.WriteLine("0x{0:x}", lg << 33);
    }
}

C#限制了以为运算符的使用。
第一个参数必须是和持有该运算符重载的类型相同，第二个参数得是int类型。

简单的试了试。
不如C++用着方便。
你简单参考下～

ICout接口：

using System;
using System.Collections.Generic;
using System.Text;

namespace ObjectShow
{
    /// <summary>
    ///  对象输出接口
    /// </summary>
    public interface ICout
    {
        /// <summary>
        /// 对象ID
        /// </summary>
        int ObjectID
        {
            get;
        }

        /// <summary>
        /// 添加对象到对象字典
        /// </summary>
        void AddObjectToDictionary(string outputString);
    }
}

Cout类

using System;
using System.Collections.Generic;
using System.Text;

namespace ObjectShow
{
    /// <summary>
    /// 输出对象
    /// </summary>
    public class Cout
    {
        /// <summary>
        /// 全局对象：对象字典
        /// </summary>
        private static Dictionary<int, string> Objects = new Dictionary<int, string>();
        /// <summary>
        /// 最近的对象标识
        /// </summary>
        private static int lastObjectID = 0;

        /// <summary>
        /// 添加对象到对象字典
        /// </summary>
        public static int AddObject( string msg)
        {
            int tempObjectID = lastObjectID;

            Objects.Add(lastObjectID++, msg);
          
            return tempObjectID;
        }

        /// <summary>
        /// 重载移位运算符
        /// </summary>
        public static Cout operator >>(Cout cout, int objectID)
        {
            if (cout != null)
            {
                if (Objects.ContainsKey(objectID))
                {
                    cout.Print(Objects[objectID]);
                }
            }

            return cout;
        }

        /// <summary>
        /// 打印字符串
        /// </summary>
        /// <param name="str">字符串</param>
        public void Print(string str)
        {
            Console.Write(str);
        }
    }
}

一个小测试

using System;
using System.Collections.Generic;
using System.Text;

namespace ObjectShow
{
    public class Person : ICout
    {
        private int objectID;                   // 输出对象标识
        private bool hasCreateInstance;         // 是否已经创建实例

        // Person类成员
        private string name;                    

        public string Name
        {
            get
            {
                return name;
            }
        }

        // 构造函数
        public Person()
        {
            hasCreateInstance = false;
            name = string.Empty;
        }
        public Person(string pName)
            : this()
        {
            name = pName;
            this.AddObjectToDictionary( this.name);
        }

        // 重载隐式转换
        public static implicit operator int(Person prsn)
        {
            return prsn.ObjectID;
        }

        #region ICout 成员

        public int ObjectID
        {
            get
            {
                return objectID;
            }
        }

        public void AddObjectToDictionary(string name)
        {
            if (!this.hasCreateInstance)
            {
                this.objectID = Cout.AddObject("Name:" + name);
                this.hasCreateInstance = true;
            }
        }

        #endregion
    }

    public class MainClass
    {
        public static Cout ConsoleOut = new Cout();

        public static void Main()
        {
            Person me = new Person("ZhouFeng");
            ConsoleOut = ConsoleOut >> me;
            Console.ReadKey();
        }
    }
}

解决了，谢谢啊！