C#学习（6）操作符

最新推荐文章于 2021-11-21 16:00:45 发布
最新推荐文章于 2021-11-21 16:00:45 发布
阅读量432 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WWWWWangXO/article/details/104237045
版权

操作符概览

操作符概览

操作符的本质

  • 操作符的本质是函数（即算法）的“简记法”
  • 操作符不能脱离与它关联的数据类型
    • 可以说操作符就是与固定数据类型相关联的一套基本算法的简记法
    • 实例：为自定义数据类型创建操作符
namespace Operator
{
    class Program
    {
        static void Main(string[] args)
        {
            Person person1 = new Person();
            Person person2 = new Person();
            person1.Name = "Deer";
            person2.Name = "Deer's wife";
            List<Person> nation = person1 + person2;
            foreach (var p in nation)
            {
                Console.WriteLine(p.Name);
            }
        }
    }

    class Person
    {
        public string Name;

        public static List<Person>operator+(Person p1,Person p2)//operator自定义操作符
        {
            List<Person> people = new List<Person>();
            people.Add(p1);
            people.Add(p2);
            for (int i = 0; i < 11; i++)
            {
                Person child = new Person();
                child.Name = p1.Name + "&" + p2.Name + "'s child";
                people.Add(child);
            }

            return people;
        }
    }
}

优先级与运算顺序

  • 操作符的优先级
    • 可以使用圆括号提高被括起来表达式的优先级
    • 圆括号可以嵌套
    • 不像数学里有圆括号和花括号，在C#语言里“（）”和“{}”有专门的用途
  • 同优先级操作符的运算顺序
    • 除了带有赋值功能的操作符，同优先级操作符都是由左向右进行运算
    • 带有赋值功能的操作符的运算顺序是由右向左
    • 与数学运算不同，计算机语言的同优先级运算没有“结合律”
      • 3+4+5只能理解为Add(Add(3,4),5) 不能理解为Add(3,Add(4,5))
typeof
namespace Operator
{
    class Program
    {
        static void Main(string[] args)
        {
            Type t = typeof(int);//typeof访问类型内部结构 
            Console.WriteLine(t.Namespace);
            Console.WriteLine(t.FullName);
            Console.WriteLine(t.Name);

            int c = t.GetMethods().Length;
            foreach (var m in t.GetMethods())
            {
                Console.WriteLine(m.Name);
            }

            Console.WriteLine(c);
        }
    }
}
default
namespace Operator
{
    class Program
    {
        static void Main(string[] args)
        {
            int x = default(int);//获取结构体类型int的默认值
            Console.WriteLine(x);//“0”

            Form myform = default(Form);//获取引用类型Form的默认值
            Console.WriteLine(myform);//“null”

            Level l = default(Level);//获取枚举类型Level的默认值
            Console.WriteLine(l);//赋值为0的“Low”
        }
    }

    enum Level
    {
        Low = 0,
        Mid = 1,
        High = 2
    }
}
new
namespace Operator
{
    class Program
    {
        static void Main(string[] args)
        {
           Form myform_1 = new Form();//使用new操作符创建一个Form类的实例，并创建实例构造器，还能得到实例的内存地址，
                                    //并且把该地址通过赋值符号交给访问这个实例的变量，平常使用同类型的引用变量来引用这个实例  

            myform_1.Text = "Hello";//这样就可以通过变量来访问实例

            //new操作符附加功能：调用实例的初始化器，直接为属性设置初始值
            Form myform_2 = new Form() { Text="Hello",FormBorderStyle=FormBorderStyle.SizableToolWindow};

            //如果对实例对象的访问是一次性的  则没有必要创建引用变量来引用这个实例。使用new操作符创建一个实例
            //并创建一个初始化器来初始化属性，然后用“.”来访问它的某一个方法，对象过一会就会被垃圾回收器回收
            new Form() { Text = "Hello" }.ShowDialog();

            //使用new操作符为匿名类型创建对象，并且用隐式类型变量来引用这个实例
            var person = new { Name = "Mr.Okay", Age = 1 };
            Console.WriteLine(person.Age);
            Console.WriteLine(person.Name);
            Console.WriteLine(person.GetType().Name);
        }
    }

}
checked&unchecked(检查值是否有溢出)
namespace Operator
{
    class Program
    {
        static void Main(string[] args)
        {
            uint x = uint.MaxValue;//unit最大值
            Console.WriteLine(x);
            String binstr = Convert.ToString(x, 2);//2进制值
            Console.WriteLine(binstr);
            try
            {
                uint y =checked(x + 1);//加1后检测是否溢出
                Console.WriteLine(y);//使用checked检测到则执行catch语句
                                     //若使用unchecked则打印结果为0
            }
            catch (OverflowException oe)
            {

                Console.WriteLine("There's Overflow");//若有溢出抛出提示
            }


            checked//checked作为修饰符的用法，花括号中所有内容会被检测
            {
                try
                {
                    uint y = x + 1;
                    Console.WriteLine(y);
                                         
                }
                catch (OverflowException oe)
                {

                    Console.WriteLine("There's Overflow");//若有溢出抛出提示
                }
            }
        }
    }

}
delegate(现多采用其关键字形式实现委托，操作符形式现用Lambda表达式代替)
sizeof
namespace Operator
{
    class Program
    {
        static void Main(string[] args)
        {
            int x = sizeof(double);//sizeof可查看结构体在内存中所占字节数
            Console.WriteLine(x);//double类型为8
        }
    }

}
->
namespace Operator
{
    class Program
    {
        static void Main(string[] args)
        {
            unsafe
            {
                Student stu;
                stu.ID = 1;
                stu.Score = 99;
                Student* pstu = &stu;//取stu的地址
                pstu->Score = 100;//使用“->”操作符间接访问对象
                Console.WriteLine(stu.Score);//使用“.”操作符可直接访问。打印结果为100
            }
        }
    }

    struct Student
    {
        public int ID;
        public long Score;
    }

}
- & ~
namespace Operator
{
    class Program
    {
        static void Main(string[] args)
        {
            int x = 12345678;
            int y = ~x;//“~”按位取反
            string xstr = Convert.ToString(x, 2).PadLeft(32, '0');//打印二进制数。xstr和ystr按位相反
            string ystr = Convert.ToString(y, 2).PadLeft(32, '0');
            Console.WriteLine(xstr);
            Console.WriteLine(ystr);

            int z = -x;
            Console.WriteLine(z);//相反数原理为按位取反再加1
        }
    }
}
!
namespace Operator
{
    class Program
    {
        static void Main(string[] args)
        {
            Student stu = new Student(null);
            Console.WriteLine(stu.Name);
        }
    }

    class Student
    {
        public string Name;
        public Student(string initName)
        {
            if (!string.IsNullOrEmpty(initName))//"!"操作符常用作非空检测
            {
                this.Name = initName;
            }
            else
            {
                throw new ArgumentException("initName cannot be null or empty");
            }
        }
    }
}
x++ & ++x
namespace Operator
{
    class Program
    {
        static void Main(string[] args)
        {
            int x = 100;
            int y = x++;
            //相当于
            //int y = x;
            //x = y + 1;
            //先赋值，再加
            Console.WriteLine(x);//101
            Console.WriteLine(y);//100

            int a = 100;
            int b = ++a;
            //相当于
            //a = a + 1;
            //int b = a;
            //先加，再赋值
            Console.WriteLine(a);//101
            Console.WriteLine(b);//100
        }
    }  
}
(T)x (类型转换)
namespace Operator
{
    class Program
    {
        static void Main(string[] args)
        {
            string str1 = Console.ReadLine();
            string str2 = Console.ReadLine();
            int x = Convert.ToInt32(str1);//string转int
            int y = Convert.ToInt32(str2);
            Console.WriteLine(x + y);
        }
    }  
}
  • 隐式类型转换
    • 不丢失精度的转换
namespace Operator
{
    class Program
    {
        static void Main(string[] args)
        {
            int x = int.MaxValue;
            long y = x;
        }
    }  
}

隐式数值转换

  • 子类向父类的转换
namespace Operator
{
    class Program
    {
        static void Main(string[] args)
        {
            Teacher t = new Teacher();
            Human h = t;//子类向父类的转换
            Animal a = h;
            //当使用h访问类成员方法时只能访问Eat()和Think()方法

            //因为C#语言规定：当你试图用引用变量访问一个实例从成员的时候，
            //只能访问到该变量的类型所具有的成员。因此a只能访问到Eat()方法
        }
    }  

    class Animal
    {
        public void Eat()
        {
            Console.WriteLine("Eating");
        }
    }

    class Human : Animal
    {
        public void Think()
        {
            Console.WriteLine("Who I am");
        }
    }

    class Teacher : Human
    {
        public void teach()
        {
            Console.WriteLine("I teach Programming");
        }
    }
}
  • 装箱
  • 显式类型转换
    在这里插入图片描述
    • 有可能丢失精度（甚至发生错误）的转换，即cast
namespace Operator
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(ushort.MaxValue);//65535
            uint x = 65536;
            ushort y = (ushort)x;//将大数据存放进小容量的数据类型中会发生精度丢失（强类型转换）
            Console.WriteLine(y);//0
        }
    }     
}
  • 拆箱
  • 使用Convert类
  • ToString方法和各数据类型的Parse/Try Parse方法
namespace Operator
{
    class Program
    {
        static void Main(string[] args)
        {
            double score = 3;
            string str1 = "1";
            string str2 = "2";
            int x = Convert.ToInt32(str1);
            int y = Convert.ToInt32(str2);
            Console.WriteLine(x);//int 1
            Console.WriteLine(y);//int 2
            int result = x + y;
            string str = result.ToString();
            Console.WriteLine(str);//string"3"

            double d = double.Parse(str);//double 3
            Console.WriteLine(d);
            bool b = double.TryParse(str,out score);//bool true
            Console.WriteLine(b);
        }
    }     
}
  • 自定义类型转换操作符
    • 示例
namespace Operator
{
    class Program
    {
        static void Main(string[] args)
        {
            Stone stone = new Stone();
            stone.Age = 5000;
            Monkey wukongsun = (Monkey)stone;
            Console.WriteLine(wukongsun.Age);//10
        }
    }
    
    class Stone
    {
        public int Age;
        public static explicit operator Monkey(Stone stone)//自定义类型转换操作符（显式），
                                                           //隐式选用implicit关键字
        {
            Monkey m = new Monkey();
            m.Age = stone.Age / 500;
            return m;
        }
    }

    class Monkey
    {
        public int Age;
    }
}
>>(左移) & <<（右移）
namespace Operator
{
    class Program
    {
        static void Main(string[] args)
        {
            int x = 7;
            int y = x >> 2;//2进制左移两位
            string str1 = Convert.ToString(x, 2).PadLeft(32, '0');
            string str2 = Convert.ToString(y, 2).PadLeft(32, '0');
            Console.WriteLine(str1);
            Console.WriteLine(str2);
            Console.WriteLine(y);//左移几位相当于乘以2的几次方。打印结果"28"
                                 //右移几位相当于除以2的几次方        
        } 
    }
}

打印结果

is & as
namespace Operator
{
    class Program
    {
        static void Main(string[] args)
        {
            Object o = new Teacher();
            if (o is Teacher) //o是否为Teacher类
            {
                Teacher t = (Teacher)o;
                t.Teach(); 
            }

            Teacher t1 = o as Teacher;//o是否像Teacher  是的话把对象o的地址交给t1  不是的话返回空值null
            if (t1 != null)
            {
                t1.Teach();
            }

        }
    }

    class Animal
    {
        public void Eat()
        {
            Console.WriteLine("Eating");
        }
    }

    class Human : Animal
    {
        public void Think()
        {
            Console.WriteLine("Who I am");
        }
    }

    class Teacher : Human
    {
        public void Teach()
        {
            Console.WriteLine("I teach Programming");
        }
    }
}
&（逻辑与） |（逻辑或） ^（逻辑异或）
namespace Operator
{
    class Program
    {
        static void Main(string[] args)
        {
            int x = 7;
            int y = 28;
            int z = x & y;//按位与
            string strX = Convert.ToString(x, 2).PadLeft(32, '0');
            string strY = Convert.ToString(y, 2).PadLeft(32, '0');
            string strZ = Convert.ToString(z, 2).PadLeft(32, '0');
            Console.WriteLine(strX);
            Console.WriteLine(strY);
            Console.WriteLine(strZ);
        } 
    }
}

与

namespace Operator
{
    class Program
    {
        static void Main(string[] args)
        {
            int x = 7;
            int y = 28;
            int z = x | y;//按位或
            string strX = Convert.ToString(x, 2).PadLeft(32, '0');
            string strY = Convert.ToString(y, 2).PadLeft(32, '0');
            string strZ = Convert.ToString(z, 2).PadLeft(32, '0');
            Console.WriteLine(strX);
            Console.WriteLine(strY);
            Console.WriteLine(strZ);
        } 
    }
}

或

namespace Operator
{
    class Program
    {
        static void Main(string[] args)
        {
            int x = 7;
            int y = 28;
            int z = x ^ y;//按位异或
            string strX = Convert.ToString(x, 2).PadLeft(32, '0');
            string strY = Convert.ToString(y, 2).PadLeft(32, '0');
            string strZ = Convert.ToString(z, 2).PadLeft(32, '0');
            Console.WriteLine(strX);
            Console.WriteLine(strY);
            Console.WriteLine(strZ);
        } 
    }
}

异或

&&（条件与） ||（条件或）
namespace Operator
{
    class Program
    {
        static void Main(string[] args)
        {
            int x = 1;
            int y = 2;
            int a = 3;
            int b = 4;
            if (x < y && a < b)//条件为真
            {
                Console.WriteLine("Hello");//执行
            }

            if (x < y || a > b)//条件为真
            {
                Console.WriteLine("Hello");//执行
            }
        } 
    }
}
？？（null值和并操作符）
namespace Operator
{
    class Program
    {
        static void Main(string[] args)
        {
            int? x = null;//给int类型的x变量赋空值
            int y = x ?? 1;//判断若x为空值。则给y赋值1
            Console.WriteLine(y);    
        } 
    }
}
？：（条件）
namespace Operator
{
    class Program
    {
        static void Main(string[] args)
        {
            int x = 80;
            string str = string.Empty;//str初始化为空字符串
            str = x > 60 ? "Pass" : "Failed";//判断x是否大于60  真则输出Pass，假则输出Failed
            Console.WriteLine(str);
        } 
    }
}
WWWWWangXO
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C# 操作符（1）
weixin_72444803的博客
12-06 293
操作符(Operator) 也叫运算符操作符用来操作数据 被操作符操作的数据叫操作数（Operand）类别|运算符—|—基本|x.y一元乘法加法移位关系和类型检测逻辑”与“逻辑”或“逻辑”非“。。。。图本质 优先级同级运算顺序除了带有赋值功能的操作符，同优先级的操作符都是从左向右进行运算带有赋值功能的操作符运算顺序都是从右向左 与数学运算不同，计算机语言的同优先级运算没有结合律 "[]"示例 访问字典 "[]"放对集合元素的索引 ”++“ ”–“ ”typeof”操作
C#操作符??和?:
飞鹰的专栏
02-21 2354
先看如下代码： string strParam = Request.Params["param"]; if ( strParam== null ) {     strParam= ""; }   string strParam=   Request.Params["param"] == null ? "":
C#中的操作符
lxxlql的专栏
11-07 2077
C#的精彩世界还离不开其提供的丰富的操作符，按照操作数的个数，C#操作符可分为以下几类： 一元操作符 ：++x,x++,--y,z-- 二元操作符：x+y，x-y，x*y 三元操作符：x=(x>a?x:a); 如果从操作符的作用来看，C#操作符可以分为赋值操作符，算术操作符，关系操作符，逻辑操作符，位操作符和其它操作符。 1.赋值操作符 赋值操作符除基本的赋值操
C#的操作符
m0_51743362的博客
11-21 815
操作符概览 操作符也是运算符 操作符是用来操作数据的，被操作符操作的操作的数据叫做操作数 表格中越靠上的优先级越高 同一行的优先级一样 对于赋值操作符是从右边到左边，其他的是从左边到右边 操作符的本质 操作符的本质是函数（即算法） 操作符不能脱离与它关联的数据类型 { int a = 5; int b = 4; int c = a / b; Console.WriteLine(c); //输出为1 double x = 5; do.
C# 操作符
CodeDoraemon的博客
04-15 208
int double 两种类型 简单计算 using System; namespace Class10_操作符详解 { //这是名字空间 internal class Program { //这是类体 public static void Main(string[] args) { int x = 5; int y = 4; int result = x / y
轻松学习C#的读写操作
09-03
在C#编程中，读写操作是至关重要的基础技能，特别是在处理用户输入和文件数据时。本文将深入探讨C#中的几种主要读写方法：`Console.Write()`、`Console.WriteLine()`、`Console.Read()`和`Console.ReadLine()`。通过...
C#编程学习笔记_C#编程学习笔记_
10-02
6. **LINQ（Language Integrated Query）**：C#中的LINQ提供了一种统一的方式来查询各种数据源，如数据库、XML文档或内存中的对象。掌握LINQ的基本查询操作，如Select、Where、Join等，能提高代码的简洁性和效率。 ...
c#学习笔记
09-13
【C#学习笔记】 在C#编程语言中，封装、抽象和访问修饰符是面向对象编程的核心概念。封装是将数据和操作数据的函数绑定在一起，以保护数据免受不必要的外部访问。它通过访问修饰符来实现，这些修饰符定义了类成员的...
C#学习文档
05-11
本“C#学习文档”旨在为初学者和有经验的程序员提供全面的学习资源，帮助大家深入理解和掌握C#编程。 一、C#基础语法 C#的基础语法包括变量声明、数据类型、运算符、控制流程（如if语句、switch语句、for循环、...
c#学习教程pdf
08-20
本教程是为初学者设计的C#学习指南，旨在帮助你快速掌握C#的基础知识和核心概念。 C#的特点包括类型安全、垃圾回收、异常处理以及对组件编程的支持。它的语法简洁明了，深受开发者喜爱。在C#中，类是对象的蓝图，而...
采用按位与（&）按位或（-）算法的简单权限实例
01-30
采用按位与（&）按位或（|）算法的简单权限实例，源代码
C# 操作符
码农
11-01 1061
C# 操作符 　　C# 语言中有大量的操作符，这些操作符是指定在表达式中执行操作的符号，C# 中预定义了算术操作符、逻辑操作符及其它的操作符，有些可以重载，在应用到自定义类型时其意义可以改变。 操作符分类表 操作符类型 　　　　　操作符　　　　　　　　　　　　　　　　　　　　　　 算术 　　　　　　　　+   -   *   /   % 逻辑（布尔型和按位） &   |   ^   !
C#操作符
ZangKangPeng的博客
08-02 231
操作符 （T）x 强制类型转换操作符 例子 string str1 = Console.ReadLine(); string str2 = Console.ReadLine(); Console.WriteLine(str1+str2); 窗口内输入： 12 34 回车后显示： 1234 这里是字符串相加，所以得到的是字符串1234 将字符串类型转换成整数类型 string str1 = Console.ReadLine(); string str2 = Console.ReadLine(); int
C#——操作符
工匠精神
03-23 245
操作符概览 优先级从上到下递减, 同级从左到右，添加“()”改变优先级， 带有赋值功能的运算符从右到左 操作符的本质 操作符的本质时函数（即算法）的“简记法” 简化函数 操作符不能脱离与他相关联的数据类型 操作符可以看作固定数据类型之间的“简记法” 操作符应用实例 Form form = new Form(){} //()中调用构造方法， {}中调用初始化器，可以直接对属性进...
c# 常用操作符
czjnoe的博客
09-24 290
目录 1、nameof 1、nameof 可输出方法、类、属性、变量的名称， class Program { static void Main(string[] args) { WriteLine(nameof(Student)); WriteLine(nameof(Student.Roll)); WriteLine(nameof(Student.Name)); WriteLine(nameof(Student..
C#基础操作符详解（上）
AsunHunt的博客
10-27 257
本节内容： 1.操作符概览； 2.操作符的本质； 3.操作符与运算顺序 4.操作符详解。 1.操作符概览： 操作符（Operator）也译为”运算符” 操作符是用来操作数据的，被操作符操作的数据称为操作数（Operand） 表格从上往下优先级递减，同一行运算符的优先级一样一般按从左到右算， “=”赋值操作符，是先运算右边的值再运算左边的值，所以是最后运算的。 2.操作符的本质 ①操作符的本质是函...
C#编程基础：操作符与表达式详解
C#语言中的操作符按照处理操作数的数量分为单个操作数的一元运算符（如++、--）、两个操作数的二元运算符和三个操作数的三元运算符。例如，`X = Y + Z`就是二元加法运算符`+`的应用。 算术运算符具有优先级，这意味...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值