Unity学前C#：操作符

操作符概览

1.操作符号的本质是函数(即算法)的"简记法"

如果没有"+"，要表示"1+2+3"就要用Add(Add(1,2),3)

比如:

using System;

public class Complex
{
    public int Real { get; set; }
    public int Imaginary { get; set; }

    // 构造函数
    public Complex(int real, int imaginary)
    {
        Real = real;
        Imaginary = imaginary;
    }

    // 加法运算符重载
    public static Complex operator +(Complex c1, Complex c2)
    {
        return new Complex(c1.Real + c2.Real, c1.Imaginary + c2.Imaginary);
    }

    // 显示复数的方法
    public override string ToString()
    {
        return $"{Real} + {Imaginary}i";
    }
}

class Program
{
    static void Main()
    {
        Complex complex1 = new Complex(1, 2);
        Complex complex2 = new Complex(3, 4);

        Complex result = complex1 + complex2;

        Console.WriteLine(result); // 输出：4 + 6i
    }
}

这里的加号其实就是一个函数

2.操作的运算不能脱离与其关联的数据类型

优先级和运算顺序

和c++类似,不多做赘述

操作符详解

new操作符:

1.为创建的实例分配地址

Form form = new From(){Text = "hello world",FormBorderStele =FormBorderStele.SizeableToolWindow}//要注意的是new可以调用构造器并且直接改变内部属性的值

2.为匿名类型创建实例(和var组合使用)

var person = new { name = "czr", age = 10 };
Console.WriteLine(person.GetType());
Console.WriteLine(person.name);
Console.WriteLine(person.age);

3.子类隐藏父类(用new覆盖了父类的函数)

  class Programe
  {
      static void Main(string[] args)//static的作用是不需要创建实体对象效用主函数
      {
          Student student = new Student();
          student.Get_Message();
          Cstudent stu = new Cstudent();
          stu.Get_Message();
      }

  }

  class Student
  {
      public void Get_Message()
      {
          Console.WriteLine("im a stu");
      }
  }

  class Cstudent:Student 
  {
      new public void Get_Message() { Console.WriteLine("im cs a stu"); }
  }

default获得变量的默认值

int a = default(int)

check检查数值溢出

try
{
    uint y = checked(x + 1);
    Console.WriteLine(y);
}
catch(OverflowException ex)
{
    Console.WriteLine("over!");
}

//第二种

check
{
    try
{
    uint y = x + 1;
    Console.WriteLine(y);
}
catch(OverflowException ex)
{
    Console.WriteLine("over!");
}

}

//checck表示检查是否溢出,unchecked表示不检查

 delegate声明委托类型

我现在的理解就是和int这些都是同一类东西,并且有两个用途

第一个就是定义委托类型

using System;

public delegate void MyDelegate(string message);

public class Program
{
    static void Main()
    {
        // 使用匿名方法实例化委托
        MyDelegate myDelegate = delegate (string message)
        {
            Console.WriteLine("Anonymous Method: " + message);
        };

        // 调用委托
        myDelegate("Hello, World!");
    }
}

sizeof得到空间大小

class Stu
{}
Stu stu = new Stu();
sizeof(stu);

is操作符

返回一个bool值,判断x是不是y 

as操作符

在C#中，as 运算符用于尝试将一个对象转换为指定的类型，如果转换成功则返回转换后的对象，否则返回 null，而不会引发异常。这与强制类型转换运算符((type))的区别在于，强制转换如果失败会引发 InvalidCastException 异常，而 as 运算符在失败时返回 null。

//expression as type
object obj = "Hello, World!";

// 使用 as 运算符尝试将 obj 转换为 string 类型
string result = obj as string;

if (result != null)
{
    Console.WriteLine("转换成功：" + result);
}
else
{
    Console.WriteLine("转换失败");
}

？？null值合并操作符

string name = null;
string result = name ?? "DefaultName";

Console.WriteLine(result); // 输出 DefaultName

？：选择操作符

int y=20
int x = (y>60)? 100:20;

类型转化

1.隐式类型转化

只能调用自己以及以上的类的方法

using System;

class Animal
{
    public virtual void MakeSound()
    {
        Console.WriteLine("Animal makes a sound");
    }
}

class Dog : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("Dog barks");
    }
}

class Cat : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("Cat meows");
    }
}

class Program
{
    static void Main()
    {
        Animal myAnimal = new Dog(); // 多态性，将子类的实例赋值给父类的引用
        myAnimal.MakeSound(); // 调用的是 Dog 类的 MakeSound 方法，由于多态性，实际上调用的是运行时类型的方法

        myAnimal = new Cat(); // 多态性，将另一个子类的实例赋值给父类的引用
        myAnimal.MakeSound(); // 调用的是 Cat 类的 MakeSound 方法
    }
}

2.显式类型转化

1. 从 double 到 int：

double doubleValue = 3.14;

int intValue = (int)doubleValue;

Console.WriteLine(intValue); // 输出 3

2. 从 float 到 int：

float floatValue = 2.5f;

int intValue = (int)floatValue;

Console.WriteLine(intValue); // 输出 2

3. 从 string 到 int：

string stringValue = "123";

int intValue = int.Parse(stringValue);

Console.WriteLine(intValue); // 输出 123

或者使用 int.TryParse：

string stringValue = "123";

int intValue;

if (int.TryParse(stringValue, out intValue))

{ Console.WriteLine(intValue);

// 输出 123 } else { Console.WriteLine("无法转换为整数"); }

4. 从枚举到整数：

enum Days { Sun, Mon, Tue, Wed, Thu, Fri, Sat };

Days today = Days.Wed; int dayValue = (int)today;

Console.WriteLine(dayValue);

// 输出 3，因为 Days.Wed 是枚举中的第四个元素，从 0 开始计数

5. 从对象类型到具体类型：

object objValue = 42;

int intValue = (int)objValue;

Console.WriteLine(intValue); // 输出 42

这些都是通过强制类型转换实现的显式类型转换的例子。在进行显式类型转换时，请确保转换是安全的，否则可能会引发异常。例如，如果你试图将包含非数字字符的字符串转换为整数，int.Parse 可能会引发异常。因此，最好使用 int.TryParse 来进行安全的转换。

6.对象到对象之间的类型转换

 class Programe
 {
    public static void Main()
     {
         Stone stone = new Stone();
         Monkey monkey = new Monkey();
         stone.age = 100;
         monkey = (Monkey)stone;
         Console.WriteLine(monkey.age);
     }
    

 }
 class Stone
 {
     public int age;
     public static explicit operator Monkey(Stone stone)
     {
         Monkey monkey = new Monkey();
         monkey.age = stone.age/15;
         return monkey;
     }
 }
 class Monkey
 {
     public int age;
 }