zoukankan      html  css  js  c++  java
  • C#运算符大全_各种运算符号的概述及作用

    以下是对C#中各种运算符号的说明及作用进行了详细的总结介绍
    一、[]

    方括号 ([]) 用于数组、索引器和属性,也可用于指针。

    1、数组类型是一种后跟 [] 的类型:
    int[] fib = new int[100]; //创建一个有100元素的数组
    若要访问数组的一个元素,则用方括号括起所需元素的索引:
    fib[0] = fib[1] = 1;
    for( int i=2; i<100; ++i ) fib[i] = fib[i-1] + fib[i-2];// 如果数组索引超出范围,则会引发异常。

    2、不能重载数组索引运算符;但类型可以定义采用一个或多个参数的索引器和属性。索引器参数括在方括号中(就像数组索引一样),但索引器参数可声明为任何类型(这与数组索引不同,数组索引必须为整数)。
    例如,.NET Framework 定义 Hashtable 类型,该类型将键和任意类型的值关联在一起。
    Collections.Hashtable h = new Collections.Hashtable();
    h["a"] = 123; // note: using a string as the index

    3、方括号还用于指定属性(C# 编程指南):
    [attribute(AllowMultiple=true)]
    public class Attr
    {
    }
    4、可以使用方括号来指定指针索引:
    unsafe fixed ( int* p = fib )   // p points to fib from earlier example
    {
        p[0] = p[1] = 1;
        for( int i=2; i<100; ++i ) p[i] = p[i-1] + p[i-2];
    }

    二、()
    除了用于指定表达式中的运算顺序外,圆括号还用于指定强制转换或类型转换:
    double x = 1234.7;
    int a;
    a = (int)x; // cast double to int

    三、.
    点运算符 (.) 用于成员访问。点运算符指定类型或命名空间的成员。例如,点运算符用于访问.NET Framework 类库中的特定方法:
    System.Console.WriteLine("hello");

    四、::
    命名空间别名限定符运算符 (::),用于查找标识符。它通常放置在两个标识符之间,例如:
    global::System.Console.WriteLine("Hello World");
    备注:
    命名空间别名限定符可以是 global。这将调用全局命名空间中的查找,而不是在别名命名空间中。

    五、+
    + 运算符既可作为一元运算符也可作为二元运算符。
    备注:
    一元 + 运算符是为所有数值类型预定义的。对数值类型进行一元 + 运算的结果就是操作数的值。
    为数值类型和字符串类型预定义了二元 + 运算符。对于数值类型,+ 计算两个操作数之和。当其中的一个操作数是字符串类型或两个操作数都是字符串类型时,+ 将操作数的字符串表示形式串联在一起。
    委托类型也提供二元 + 运算符,该运算符执行委托串联。

    实例:
    using System;
    class MainClass
    {
        static void Main()
        {
            Console.WriteLine(+5);        // unary plus
            Console.WriteLine(5 + 5);     // addition
            Console.WriteLine(5 + .5);    // addition
            Console.WriteLine("5" + "5"); // string concatenation
            Console.WriteLine(5.0 + "5"); // string concatenation
            // note automatic conversion from double to string
        }
    }

    六、-
    - 运算符既可作为一元运算符也可作为二元运算符。
    一元 - 运算符是为所有数值类型预定义的。数值类型的一元 - 运算的结果是操作数的反数。
    二元 - 运算符是为所有数值类型和枚举类型预定义的,其功能是从第一个操作数中减去第二个操作数。
    委托类型也提供二元 - 运算符,该运算符执行委托移除。

    示例:
    using System;
    class MainClass
    {
        static void Main()
        {
            int a = 5;
            Console.WriteLine(-a);
            Console.WriteLine(a - 1);
            Console.WriteLine(a - .5);
        }
    }

    七、*
    乘法运算符 (*),用于计算操作数的积。另外还用作取消引用运算符,允许读取和写入指针。
    备注:
    所有数值类型都具有预定义的乘法运算符。
    * 运算符还用来声明指针类型和取消引用指针。该运算符只能在不安全的上下文中使用,通过unsafe 关键字的使用来表示,并且需要 /unsafe 编译器选项。取消引用运算符也称为间接寻址运算符。

    示例:
    using System;
    class MainClass
    {
        static void Main()
        {
            Console.WriteLine(5 * 2);
            Console.WriteLine(-.5 * .2);
            Console.WriteLine(-.5m * .2m); // decimal type
        }
    }

    八、/
    除法运算符 (/) 用第二个操作数除第一个操作数。所有数值类型都具有预定义的除法运算符。
    using System;
    class MainClass
    {
        static void Main()
        {
            Console.WriteLine(-5/2);
            Console.WriteLine(-5.0/2);
        }
    }

    九、%
    模数运算符 (%) 计算第二个操作数除第一个操作数后的余数。所有数值类型都具有预定义的模数运算符。
    using System;
    class MainClass
    {
        static void Main()
        {
            Console.WriteLine(5 % 2);       // int
            Console.WriteLine(-5 % 2);      // int
            Console.WriteLine(5.0 % 2.2);   // double
            Console.WriteLine(5.0m % 2.2m); // decimal
            Console.WriteLine(-5.2 % 2.0); // double
        }
    }

    十、&
    & 运算符既可作为一元运算符也可作为二元运算符。
    备注:
    一元 & 运算符返回操作数的地址(要求 unsafe 上下文)。
    为整型和 bool 类型预定义了二进制 & 运算符。对于整型,& 计算操作数的逻辑按位“与”。对于 bool 操作数,& 计算操作数的逻辑“与”;也就是说,当且仅当两个操作数均为 true 时,结果才为 true。
    & 运算符计算两个运算符,与第一个操作数的值无关。例如:
    int i = 0;
    if (false & ++i == 1)
    {
    }

    十一、|
    二元 | 运算符是为整型和 bool 类型预定义的。对于整型,| 计算操作数的按位“或”结果。对于 bool 操作数,| 计算操作数的逻辑“或”结果;也就是说,当且仅当两个操作数均为 false时,结果才为 false。
    using System;
    class MainClass
    {
        static void Main()
        {
            Console.WriteLine(true | false); // logical or
            Console.WriteLine(false | false); // logical or
            Console.WriteLine("0x{0:x}", 0xf8 | 0x3f);   // bitwise or
        }
    }

    十二、^
    二元 ^ 运算符是为整型和 bool 类型预定义的。对于整型,^ 将计算操作数的按位“异或”。对于 bool 操作数,^ 将计算操作数的逻辑“异或”;也就是说,当且仅当只有一个操作数为 true时,结果才为 true。
    using System;
    class MainClass
    {
        static void Main()
        {
            Console.WriteLine(true ^ false); // logical exclusive-or
            Console.WriteLine(false ^ false); // logical exclusive-or
            // Bitwise exclusive-or:
            Console.WriteLine("0x{0:x}", 0xf8 ^ 0x3f);
        }
    }

    十三、!
    逻辑非运算符 (!) 是对操作数求反的一元运算符。为 bool 定义了该运算符,当且仅当操作数为false 时才返回 true。
    using System;
    class MainClass
    {
        static void Main()
    {
            Console.WriteLine(!true);
            Console.WriteLine(!false);
        }
    }

    十四、~
    ~ 运算符对操作数执行按位求补运算,其效果相当于反转每一位。按位求补运算符是为int、uint、long 和 ulong 类型预定义的。
    using System;
    class MainClass
    {
        static void Main()
        {
            int[] values = { 0, 0x111, 0xfffff, 0x8888, 0x22000022};
            foreach (int v in values)
            {
                Console.WriteLine("~0x{0:x8} = 0x{1:x8}", v, ~v);
            }
        }
    }

    十五、=
    赋值运算符 (=) 将右操作数的值存储在左操作数表示的存储位置、属性或索引器中,并将值作为结果返回。操作数的类型必须相同(或右边的操作数必须可以隐式转换为左边操作数的类型)。
    using System;
    class MainClass
    {
        static void Main()
        {
            double x;
            int i;
            i = 5; // int to int assignment
            x = i; // implicit conversion from int to double
            i = (int)x; // needs cast
            Console.WriteLine("i is {0}, x is {1}", i, x);
            object obj = i;
            Console.WriteLine("boxed value = {0}, type is {1}",
                      obj, obj.GetType());
            i = (int)obj;
            Console.WriteLine("unboxed: {0}", i);
        }
    }

    十六、<
    所有数值和枚举类型都定义“小于”关系运算符 (<),如果第一个操作数小于第二个操作数,该运算符返回 true,否则返回 false。
    using System;
    class MainClass
    {
        static void Main()
        {
            Console.WriteLine(1 < 1.1);
            Console.WriteLine(1.1 < 1.1);
        }
    }

    十七、>
    所有数值类型和枚举类型都定义“大于”关系运算符 >,如果第一个操作数大于第二个操作数,它将返回 true,否则返回 false。
    using System;
    class MainClass
    {
        static void Main()
        {
            Console.WriteLine(1.1 > 1);
            Console.WriteLine(1.1 > 1.1);
        }
    }

    十八、?:
    条件运算符 (?:) 根据布尔型表达式的值返回两个值中的一个。条件运算符的格式如下
    condition ? first_expression : second_expression;

    备注:
    如果条件为 true,则计算第一表达式并以它的计算结果为准;如果为 false,则计算第二表达式并以它的计算结果为准。只计算两个表达式中的一个。

    使用条件运算符,可以更简洁、雅观地表达那些否则可能要求 if-else 结构的计算。例如,为在sin 函数的计算中避免被零除,可编写为
    if(x != 0.0) s = Math.Sin(x)/x; else s = 1.0;
    或使用条件运算符,
    s = x != 0.0 ? Math.Sin(x)/x : 1.0;

    十九、++
    增量运算符 (++) 将操作数加 1。增量运算符可以出现在操作数之前或之后:

    备注:
    第一种形式是前缀增量操作。该操作的结果是操作数加 1 之后的值。
    第二种形式是后缀增量操作。该运算的结果是操作数增加之前的值。
    数值类型和枚举类型具有预定义的增量运算符。用户定义的类型可重载 ++ 运算符。在枚举时通常允许整型运算。

    二十、--
    减量运算符 (--) 将操作数减 1。减量运算符可以出现在操作数之前或之后:--variable 和variable--。第一种形式是前缀减量操作。该运算的结果是操作数减小“之后”的值。第二种形式是后缀减量操作。该运算的结果是操作数减小“之前”的值。

    备注:
    数值类型和枚举类型具有预定义的增量运算符。
    用户定义的类型可重载 -- 运算符(请参见运算符)。在枚举时通常允许整型运算。

    二十一、&&
    条件“与”运算符 (&&) 执行其 bool 操作数的逻辑“与”运算,但仅在必要时才计算第二个操作数。
    备注:
    操作
    x && y
    对应于操作
    x & y
    不同的是,如果 x 为 false,则不计算 y(因为不论 y 为何值,“与”操作的结果都为false)。这被称作为“短路”计算。

    不能重载条件“与”运算符,但常规逻辑运算符和运算符 true 与 false 的重载,在某些限制条件下也被视为条件逻辑运算符的重载。

    二十二、||
    条件“或”运算符 (||) 执行 bool 操作数的逻辑“或”运算,但仅在必要时才计算第二个操作数。
    备注:
    操作
    x || y
    对应于操作
    x | y
    不同的是,如果 x 为 true,则不计算 y(因为不论 y 为何值,“或”操作的结果都为true)。这被称作为“短路”计算。

    不能重载条件“或”运算符,但规则逻辑运算符和运算符 true 与 false 的重载,在某些限制条件下也被视为条件逻辑运算符的重载。

    二十三、<<
    左移运算符 (<<) 将第一个操作数向左移动第二个操作数指定的位数。第二个操作数的类型必须是 int。

    备注:
    如果第一个操作数是 int 或 uint(32 位数),则移位数由第二个操作数的低 5 位给出。
    如果第一个操作数是 long 或 ulong(64 位数),则移位数由第二个操作数的低 6 位给出。
    第一个操作数的高序位被放弃,低序空位用 0 填充。移位操作从不导致溢出。
    用户定义的类型可重载 << 运算符(请参见 operator);第一个操作数的类型必须为用户定义的类型,第二个操作数的类型必须为 int。重载二元运算符时,也会隐式重载相应的赋值运算符(如果有)。

    二十四、>>
    右移运算符 (>>) 将第一个操作数向右移动第二个操作数所指定的位数。

    备注:
    如果第一个操作数为 int 或 uint(32 位数),则移位数由第二个操作数的低五位给出(第二个操作数 & 0x1f)。

    如果第一个操作数为 long 或 ulong(64 位数),则移位数由第二个操作数的低六位给出(第二个操作数 & 0x3f)。

    如果第一个操作数为 int 或 long,则右移位是算术移位(高序空位设置为符号位)。如果第一个操作数为 uint 或 ulong 类型,则右移位是逻辑移位(高位填充 0)。

    用户定义的类型可重载 >> 运算符;第一个操作数的类型必须为用户定义的类型,第二个操作数的类型必须为 int。有关更多信息,请参见 operator。重载二元运算符时,也会隐式重载相应的赋值运算符(如果有)。

    二十五、==
    对于预定义的值类型,如果操作数的值相等,则相等运算符 (==) 返回 true,否则返回 false。对于 string 以外的引用类型,如果两个操作数引用同一个对象,则 == 返回 true。对于string 类型,== 比较字符串的值。

    备注:
    用户定义的值类型可重载 == 运算符(请参见 operator)。用户定义的引用类型也可重载 == 运算符,尽管在默认情况下,无论对于预定义的引用类型还是用户定义的引用类型,== 的行为都与上面描述的相同。如果重载 ==,则还必须重载 !=。在枚举时通常允许整型运算。

    二十六、!=
    如果操作数相等,则不等运算符 (!=) 返回 false,否则,返回 true。为所有类型(包括字符串和对象)预定义了不等运算符。用户定义的类型可重载 != 运算符。

    备注:
    对于预定义的值类型,如果操作数的值不同,则不等运算符 (!=) 返回 true,否则,返回false。对于 string 以外的引用类型,如果两个操作数引用不同的对象,则 != 返回 true。对于 string 类型,!= 比较字符串的值。

    用户定义的值类型可重载 != 运算符(请参见 operator)。用户定义的引用类型也可重载 != 运算符,尽管在默认情况下,无论对于预定义的引用类型还是用户定义的引用类型,!= 的行为都与上面描述的相同。如果重载 !=,则还必须重载 ==。在枚举时通常允许整型运算。

    二十七、<=
    所有数值和枚举类型都定义了“小于等于”关系运算符 (<=),如果第一个操作数小于或等于第二个操作数,则该运算符将返回 true,否则返回 false。

    二十八、>=
    所有数值类型和枚举类型都定义“大于等于”关系运算符 >=,如果第一个操作数大于或等于第二个操作数,该运算符将返回 true,否则返回 false。

    二十九、+=
    加法赋值运算符。
    备注:
    使用 += 赋值运算符的表达式,例如
    x += y
    等效于
    x = x + y
    不同的是 x 只计算一次。+ 运算符的含义取决于 x 和 y 的类型(例如,对于数值操作数,其含义为相加;对于字符串操作数,其含义为串联)。

    不能直接重载 += 运算符,但用户定义的类型可以重载 + 运算符(请参见 operator)。

    三十、-=
    减法赋值运算符。
    备注:
    使用 -= 赋值运算符的表达式,如
    x -= y
    等效于
    x = x - y
    不同的是 x 只计算一次。- 运算符的含义取决于 x 和 y 的类型(例如,对于数值操作数,其含义为相减;对于委托操作数,其含义为移除)。

    不能直接重载 -= 运算符,但用户定义的类型可重载 - 运算符(请参见 operator)。

    三十一、*=
    二元乘法赋值运算符。
    备注:
    使用 *= 赋值运算符的表达式,如
    x *= y
    等效于
    x = x * y
    不同的是 x 只计算一次。为数值类型预定义了 * 运算符以执行乘法操作。
    不能直接重载 *= 运算符,但用户定义的类型可重载 * 运算符(请参见 operator)。

    三十二、/=
    除法赋值运算符。
    备注:
    使用 /= 赋值运算符的表达式,如
    x /= y
    等效于
    x = x / y
    不同的是 x 只计算一次。为数值类型预定义了 / 运算符以执行除法操作。
    不能直接重载 /= 运算符,但用户定义的类型可重载 / 运算符(请参见 operator)。对于所有复合赋值运算符,隐式重载二元运算符会重载等效的复合赋值。

    三十三、%=
    模块赋值运算符。
    备注:
    使用 %= 赋值运算符的表达式,如
    x %= y
    等效于
    x = x % y
    不同的是 x 只计算一次。为数值类型预定义了 % 运算符,以计算相除后的余数。
    不能直接重载 %= 运算符,但用户定义的类型可重载 % 运算符(请参见运算符(C# 参考))。

    三十四、&=
    “与”赋值运算符。
    备注:
    使用 &= 赋值运算符的表达式,如
    x &= y
    等效于
    x = x & y
    不同的是 x 只计算一次。& 运算符对整数操作数执行按位逻辑“与”运算,对 bool 操作数执行逻辑“与”运算。
    不能直接重载 &= 运算符,但用户定义的类型可重载二元 & 运算符(请参见 operator)。

    三十五、|=
    “或”赋值运算符。
    备注:
    使用 |= 赋值运算符的表达式,例如
    x |= y
    等效于
    x = x | y
    不同的是 x 只计算一次。| 运算符对整型操作数执行按位逻辑“或”运算,对布尔操作数执行逻辑“或”运算。
    不能直接重载 |= 运算符,但用户定义的类型可以重载 | 运算符(请参见 operator)。

    三十六、^=
    “异或”赋值运算符。
    备注:
    下列形式的表达式
    x ^= y
    按如下规则计算:
    x = x ^ y
    不同的是 x 只计算一次。^ 运算符对整数操作数执行按位“异或”运算,对 bool 操作数执行逻辑“异或”运算。
    不能直接重载 ^= 运算符,但用户定义的类型可重载 ! 运算符(请参见 operator)。

    三十七、<<=
    左移赋值运算符。
    备注:
    下列形式的表达式
    x <<= y
    按如下规则计算:
    x = x << y
    不同的是 x 只计算一次。<< 运算符将 x 向左移动 y 指定的位数。
    不能直接重载 <<= 运算符,但用户定义的类型可重载 << 运算符(请参见 operator)。

    三十八、>>=
    右移赋值运算符。
    备注:
    下列形式的表达式
    x >>= y
    按如下规则计算:
    x = x >> y
    不同的是 x 只计算一次。>> 运算符根据 y 指定的量对 x 进行右移位。
    不能直接重载 >>= 运算符,但用户定义的类型可重载 >> 运算符(请参见 operator)。

    三十九、->
    -> 运算符将指针取消引用与成员访问组合在一起。
    备注:
    以下形式的表达式
    x->y
    (其中 x 为 T* 类型的指针,y 为 T 的成员)等效于
    (*x).y
    -> 运算符只能在非托管代码中使用。
    不能重载 -> 运算符。

    四十、??
    如果 ?? 运算符的左操作数非空,该运算符将返回左操作数,否则返回右操作数。

    备注:
    可空类型可以包含值,或者可以是未定义的。?? 运算符定义当可空类型分配给非可空类型时返回的默认值。如果在将可空类型分配给非可空类型时不使用 ?? 运算符,将生成编译时错误。如果使用强制转换,并且当前未定义可空类型,将发生 InvalidOperationException 异常。

  • 相关阅读:
    Qt Qaction和触发函数建立连接的方法
    Qt QChart缩放后坐标轴间隔取整
    Qt 编译时报错“退出,退出代码2”的原因
    Qt Qchart 中清空绘图
    Qt QChartView 如何放入widget
    Qt QChart之曲线图,饼状图,条形图使用
    Qt 实现控件不响应鼠标点击事件
    Qt css样式大全(整理版)
    Qt 加载qss文件
    Qt 如何处理密集型耗时的事情(频繁调用QApplication::processEvents)
  • 原文地址:https://www.cnblogs.com/1175429393wljblog/p/5461235.html
Copyright © 2011-2022 走看看