C#学习笔记（六）表达式和运算符、语句、结构以及枚举类型

最新推荐文章于 2025-05-11 22:55:16 发布

原创最新推荐文章于 2025-05-11 22:55:16 发布 · 437 阅读

1 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#C#

C# 专栏收录该内容

15 篇文章

订阅专栏

本文深入探讨C#中的表达式和运算符，包括条件逻辑运算符、位运算符、布尔类型、字面量、用户定义的类型转换、运算符重载、结构、枚举类型及位标志的应用。通过具体示例讲解了这些概念的实际运用。

第八章表达式和运算符

表达式：有返回值，由运算符和操作数构成，运算符则以操作数作为输入，默认的操作数是预定义的类型，如果是用户自定义数据类型，则运算符需要重载在可以进行操作。
条件逻辑运算符：与（&&）,或（||）,非（!）；
逻辑运算符：位与（&）、位或（|）、位异或（^）和非（~）.
布尔类型：C#中的整数不具有布尔含义。
字面量：字符串字面量有两种，一是常规字符串字面量，双引号中可以是字符串、普通转义字符、\x和\u后跟四位十六进制的转义字符；二是逐字字符串字面量，以@开头，双引号中的内容是什么就打印出什么，不具有转义含义，除了将一对双引号变为单个双引号之外。
用户定义的类型转换：两种形式声明，一是隐式转换，格式public static implicit operator TargetType(SourcrType 操作数)；二是显示转换，格式为public static explicit operator TargetType(SourcrType 操作数)；其中，public static implicit/explicit operator 在声明时是必须的。下面示例显示了隐式转换和显示转换在声明和调用时语法的不同。

//用户自定义的类型转换
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace test15
{
    class LimitedInt
    {
        const int Maxvalue = 100;  //定义长整型
        const int Minvalue = 0;
        //public static implicit operator int(LimitedInt Li)   //用户自定义类型隐式转换语法格式
        public static explicit  operator int(LimitedInt Li)   //用户自定义类型显示转换语法格式
        {
            return Li.Intvalue;
        }
       // public static implicit operator LimitedInt(int x)     //用户自定义类型隐式转换语法格式
        public static explicit operator LimitedInt(int x)     //用户自定义类型显示转换语法格式
        {
            LimitedInt Li = new LimitedInt();
            Li.Intvalue = x;
            return Li;
        }
        private int _myint;   //定义私有字段         
        public int Intvalue   //定义公有属性
        {
            get
            {
                if(_myint < Minvalue) return Minvalue;
                else return _myint > Maxvalue ? Maxvalue : _myint;
            }
            set  //隐式值参value
             {
                _myint = value;
             }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            //隐式转换
            //LimitedInt Li = 666;   
            //int vla = Li;

            //显示转换
            LimitedInt LLi = (LimitedInt)66;
            int vall = (int)LLi;
            Console.WriteLine("LLi: {0},vall:{1}",LLi.Intvalue,vall);
        }
    }
}

执行结果：

在这里插入图片描述

typeof运算符：返回作为其参数的任何类型的对象，如果引用类型作为其参数，就返回引用类型的对象，如果枚举类型作为其参数，返回枚举类型成员，通过这个对象，可以了解类型的特征。
运算符的重载：默认运算符的操作数是预定义的类型，如果是用户定义的类型，不可以直接操作，需要进行运算符的重载，重载后的运算符和原来的运算符在功能上一致而并不是创造出新的运算符，就相当于将实际的运算符扩展运用于用户定义类型；格式为public static 用户定义类型 operator 重载运算符(操作数)，下面的示例是将加号和减号运算符进行重载。

//运算符的重载：允许运算符操作用户自定义的类型
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace test16
{
    class LimitedInt
    {
        //格式：public static 类型 operator 运算符(操作数)
        public static LimitedInt operator +(LimitedInt a,LimitedInt b)  //加号运算符的重载
        {
            LimitedInt c = new LimitedInt();
            c.Intvalue = a.Intvalue + b.Intvalue;
            return c;
        }
        public static LimitedInt operator -(LimitedInt a,LimitedInt b)  //减号运算符的重载
        {
            LimitedInt c = new LimitedInt();
            c.Intvalue = a.Intvalue - b.Intvalue;
            return c;
        }
        private int _myint;
        public int Intvalue
        {
            set{_myint = value;}
            get{return _myint;}
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            LimitedInt a1 = new LimitedInt();
            LimitedInt a2 = new LimitedInt();
            LimitedInt a3 = new LimitedInt();

            a1.Intvalue = 15;a2.Intvalue = 16;
            a3.Intvalue = a1.Intvalue - a2.Intvalue;
            Console.WriteLine("a3.Intvalue = {0}",a3.Intvalue);
            a3.Intvalue = a1.Intvalue + a2.Intvalue;
            Console.WriteLine("a3.Intvalue = {0}",a3.Intvalue);
        }
    }
}

执行结果：

在这里插入图片描述

第九章语句

语句：描述程序执行的代码指令。
表达式语句：简单的由表达式和分号构成，复杂的含有块。包括条件执行语句、循环语句、跳转语句。
条件执行语句：if语句;if…else语句;switch语句
循环语句：for循环、foreach循环、while循环、do…while循环（条件后面要加分号）
跳转语句：break、continue、return、goto、throw（抛出异常）。

第十章结构

结构：结构是用户自定义的类型，标志词struct，可以有函数成员和数据成员，但它是值类型，隐式密封的，不可以派生；可以有构造函数，包括实例构造函数或者静态构造函数，但不能有析构函数；结构类型变量不能为null，两个结构变量不能指向相同的对象；
将一个结构赋值给另一个结构，是一种值复制，就是把一个结构的成员的值赋值给另一个结构的成员，数据保存在栈中；把一个类变量赋值给另一个类变量，是一种引用复制，得到的是那个类变量的引用，它们指向了相同的对象，数据存在堆中。
在结构中，字段声明时不能初始化，字段的初始化可以在结构的方法中。
在结构中定义了静态构造函数，当调用显示声明的构造函数或者引用结构的静态成员时会调用静态构造函数。
结构作为返回值时，将创建它的副本并从函数返回；结构作为值参数时，将创建实参结构的副本，该副本用于方法的执行中；结构作为ref参数或者out参数，传入方法的是该结构的一个引用，这样可以修改器=其函数成员。

第十一章枚举类型

枚举：标志词enum，枚举类型也是用户自定义类型，成员之间用逗号隔开，最后一个成员无标点；枚举类型成员都是常量，即便没有枚举变量，也可以通过枚举名和点成员名访问枚举成员；不能对枚举成员使用修饰符，默认与枚举类型有相同的可访问性；枚举类型成员默认是int型，也有默认编号，从0开始，但都可以改变；enum EnumTypename : Typename，如enum Mynum : uint{...}
位标志：标志字的每一个位标志都代表不同的含义，利用枚举可以很好的创建标志字。首先确定需要多少个位标志，并选择合适的无符号整型；然后确定每个位位置代表什么，并为它们赋予名称；用按位或运算符创建标志字，用按位与运算符拆解标志字。
要创建标志字，首先声明一个枚举变量，如果要想知道标志字中是否含有某一个位标志，可以使用HasFlag函数来判断。

//位标志基本用法
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace test17
{
    class Program
    {
        [Flags]
        public enum Hpustudents : uint   //定义成员为无符号整型的枚举类型
        {
            Firstnum = 0x0001,   //定义位标志，成员之间用逗号
            Secondnum = 0x0002,
            Thirdnum = 0x0004,
            Fournum = 0x0008
        }
        List<bool> Showresult = new List<bool>();   //定义bool类型列表,存储判断结果
        //定义数组，存储枚举成员位标志名称
        string[] Receivename ={"Hpustudents.Firstnum","Hpustudents.Secondnum","Hpustudents.Thirdnum","Hpustudents.Fournum","Hpustudents.Thirdnum|Hpustudents.Fournum"};
        public void Setting(Hpustudents hps)    //判断标志字是否含有位标志
        {
            bool HaveFirst = hps.HasFlag(Hpustudents.Firstnum);  //每一个判断结果是bool类型
            Showresult.Add(HaveFirst);
            bool HaveSecond = hps.HasFlag(Hpustudents.Secondnum);
            Showresult.Add(HaveSecond);
            bool HaveThird = hps.HasFlag(Hpustudents.Thirdnum);
            Showresult.Add(HaveThird);
            bool HaveFour = hps.HasFlag(Hpustudents.Fournum);
            Showresult.Add(HaveFour);
            bool HaveTirFou = hps.HasFlag(Hpustudents.Thirdnum|Hpustudents.Fournum);
            Showresult.Add(HaveTirFou);
        }
        public void ShowSetting()
        {
           //第一种显示方式：
           Console.WriteLine("hps.HasFlag(Hpustudents.Firstnum)-->{0}",Showresult[0]);
           Console.WriteLine("hps.HasFlag(Hpustudents.Secondnum)-->{0}",Showresult[1]);
           Console.WriteLine("hps.HasFlag(Hpustudents.Thirdnum)-->{0}",Showresult[2]);
           Console.WriteLine("hps.HasFlag(Hpustudents.Fournum)-->{0}",Showresult[3]);
           Console.WriteLine("hps.HasFlag(Hpustudents.Thirdnum|Hpustudents.Fournum)-->{0}",Showresult[4]);
           Console.WriteLine("............................................................");
           //第二种显示方式：
           for(int i = 0;i < 5;i++)
           {
               Console.WriteLine("hps.HasFlag({0})-->{1}",Receivename[i],Showresult[i]);
           }

        }
        static void Main(string[] args)
        {
            Program prg = new Program();
            Hpustudents hps = new Hpustudents();  //实例化枚举类型
            hps = Hpustudents.Firstnum|Hpustudents.Secondnum|Hpustudents.Thirdnum;  //通过按位或运算符创建一个标志字
            prg.Setting(hps);        //通过类的实例调用方法
            prg.ShowSetting();
        }
    }
}

执行结果：

在这里插入图片描述

GetName方法以枚举类型对象和整数为参数，返回响应的枚举成员的名称；GetNames方法以枚举类型对象为参数，返回所有枚举成员的名称。要获取枚举类型对象，可以使用上面介绍的typeof运算符。
注意在声明枚举类型时，最好开头加上特性修饰 [Flags]，它会告诉编辑器所定义的枚举类型成员，不仅可以作为单独的值，还可以按照位标志进行组合，同时在使用枚举方法ToString时可以更好的返回成员的字符串名称。（ToString以枚举值为参数，将其与枚举常量成员进行比较，如果与某个成员相匹配，则返回该成员的字符串名称）