C#基本语法整理-变量&常量&以及相互之间的操作

一.引言

虽然有其他语言的基础，但为了加深印象，这里就从0开始整理C#的一些基本语法，有些地方会有些差异

二.变量类型

为了能够让整体代码更加清晰，我们可以使用#region 和 #endregion 配套使用来折叠功能代码块，本质是编辑器提供给我们的预处理指令，只会在编辑时有用，发布代码后或执行代码时，会被自动删除，所以只是用来预览

#region 折叠代码测试
            Console.WriteLine("代码折叠测试");
            #endregion

1. 有符号的整型变量

变量类型	范围说明	定义示例
sbyte	-127~128	sbyte sb = 1;
int	-21多~21亿多	int i = 2;
short	-32768~32767	short s = 3;
long	-9九百万兆~9百万兆之间的数	long l = 4;

2. 无符号的整型变量

变量类型	范围说明	定义示例
byte	0~255	byte b = 1;
uint	0~42亿多的范围	uint ui = 2;
ushort	0~65535之间的一个数	ushort us = 3;
ulong	0~18百万兆之间的数	ulong ul = 4;

3. 浮点数(小数)

变量类型	范围说明	定义示例
float	存储7/8位有效数字，根据编译器不同，有效数字也可能不同，四舍五入	float f = 0.1234567890f;
double	存储15-17位有效数字，如果不加f，默认是double类型，废弃的数字也会四舍五入	double d = 0.123456789123455;
decimal	存储27~28位的有效数字，不建议使用	decimal de = 0.12464727832778727378283m;

4. 特殊类型

变量类型	范围说明	定义示例
bool	布尔类型，表真假	bool b1 = true; bool b2 = false;
char	字符类型	char c = '陈';
string	字符串类型，用来存储多个字符，没有上限	string name = "faksjdfkalfjsaklfjasklfj";

Tip：

• 不同的变量，存储的范围和类型不一样，本质是占用的内存空间不同,选择不同的数据(变量)类型装载不同的数据,基本来说，数字用int，小数用float，字符串用string，真假用bool
• 多个相同类型变量，同时申明

              int a1 = 1, a2 = 2;
              float f1 = 0.12f, f2 = 0.23f;
              string s1 = "fsafdsa", s2 = "fasdfafa";
  

• 变量申明时可以不赋初值，但在使用前必须得赋值

三.常量的声明

常量的作用是申明一些常用不变的变量，有如下两个特点

1. 必须初始化
2. 不能被修改

// const 变量类型 变量名 = 初始值;
const float PI = 3.1415926f;

四.转义字符

转义字符是字符串的一部分，用来表示一些特殊含义的字符，比如：在字符串中表示 单引号 引号 空格等

1. 常用转义字符

   固定写法 \字符，\和不同的字符组合表示不同的含义

               //单引号 \`
               string str1 = "fafdsa\'";
               // 双引号 \"
               string str2 = "fasdfaf\"";
               // 换行符 \n
               string str3 = "Lfdsafaf\nfdsafa";
               // 斜杠 \\
               string str4 = "fafkadsf\\";
   

2. 不常用转义字符

               // 制表符 \t 等价于一个tab键
               string str5 = "Lfdasfa\tfasfa";
               // 光标退格
               string str6 = "123\b123"; // 输出 12123
               // 空字符
               string str7 = "\0";  // 什么都没有
               // 警报音
               string str8 = "\a"; // 电脑会响一声
   

3. 取消转义字符

               // 字符串前面加上@符
               string str9 = @"fasfda\fasdfa"; 
   

五.类型转换

类型转换也是日常开发中一个比较重要的问题，类型转换就是不同变量类型之间的相互转换,分隐式和显示

1. 隐式转换

   隐式转换的基本规则->不同类型之间自动转换
   大范围装小范围 ``` #region 相同大类型之间的转换 // 有符号 long short int sbyte long l = 1; short s = 1; int i = 1; sbyte sb = 1; l = sb; // sbyte隐式转换成long类型 // sb = s;// 小的装大的报错 // 无符号同理

            // 浮点型 decimal double float
            decimal de = 1.1m;
            double d = 1.1d;
            float f = 1.2f;
            // decimal比较特殊，不能用于隐式转换，存不了double和float
            //de = d;
            //de = f;
            d = f; // float 可以隐式转换成double
   
            // 特殊类型之间不存在隐式转换
            #endregion
   
            #region 无符号和有符号之间的转换
            // 无符号装有符号
            // 无符号 不能装负数
            byte b2 = 1;
            ushort us2 = 1;
            uint ui2 = 1;
            ulong ul2 = 1;
            // 有符号
            sbyte sb2 = 1;
            short s2 = 1;
            int i2 = 1;
            long l2 = 1;
   
            // 无符号装有符号
            // 有符号的变量不能隐式转换成无符号的
            //b2 = sb2;
            //us2 = s2;
   
            // 有符号装无符号
            // 基本原则还是大范围装小范围
            i2 = ui2; // 无符号的可能会超过有符号变量类型所能承载的范围
            i2 = b2; // 这种情况无论怎样，无符号的类型都不可能超过有符号变量的正数范围
            #endregion
   
             #region 浮点数和整数(有、无符号)之间
            // 浮点数装整数
            float f2 = 1.2f;
            double d2 = 1.2d;
            decimal de2 = 1.2m;
   
            // 浮点数是可以装载任何类型的整数
            f2 = l2;
            f2 = ul2;
            // decimal虽然不能隐式存储浮点型，但是可以装整型
            de2 = l2;
            de2 = ul2;
            // 整数装浮点数
            // 整数无法承载浮点数，也就是说浮点型无法隐式转换成整型
            i2 = f2;
            #endregion
    ```
   

   • 关于特殊类型只想说明char类型，char类型本质就是ASCII码，是整数
   • 简单说就是高精度可以承载低精度
     double->float->整数(有无符号)->char
     decimal->整数(有无符号)->char

2. 显示转换

   • 括号强转

     作用:一般情况下，将高精度的类型强制转换为低精度
     语法：变量类型 变量名 = (变量类型)变量;
     注意：精度问题，范围问题

             // 相同大类的整型
             // 有符号整型
             sbyte sb = 1;
             short s = 1;
             int i = 1;
             long l = 1;
     
             //括号强转可能会出现范围问题，造成的异常，高精度或者高范围的向下强转很容易溢出
             s = (short)i;
             Console.WriteLine(s);
             // 无符号同理
             // 浮点数
             float f1 = 1.2f;
             double d1 = 1.2d;
             f1 = (float)d1;
             Console.WriteLine(f1); // 精度会丢失
     
             // 无符号和有符号
             // 相互间可以强转，但是注意范围，超出范围，得到的结果会很奇怪
             uint ui = 1;
             int i2 = 1;
             i2 = (int)ui;
             ui = (uint)i2;
     
             // 浮点和整数
             // 这种强转会丢失精度，并不会四舍五入
             i2 = (int)1.2f;
             Console.WriteLine(i2);
             // char类型和整数也支持强转
             int ascii = (int)'a';
             Console.WriteLine(ascii);
             char a = (char)ascii;
             Console.WriteLine(a);
     
             // bool和string不支持强转
     

   • Parse方法强转

     作用：将字符串类型转换为对应的类型
     语法：变量类型.Parse("字符串");
     注意：字符串必须能够转换成对应类型，否则报错

         // 有符号
         int i4 = int.Parse("123");
         Console.WriteLine(i4);
         //int i5 = int.Parse("123.45"); //报错
         //short s3 = short.Parse("499999"); // 超出范围也会报错
         // 无符号，浮点型类似
         bool b5 = bool.Parse("true");
         Console.WriteLine(b5);
     

   • Convert法

     作用：更准确地将各个类型之间进行相互转换
     语法：Convert.To目标类型(变量或者常量)
     注意：填写的变量或者常量必须正确，否则报错

          // 转字符串
          int a2 = Convert.ToInt32("12");
          Console.WriteLine(a2);
          // 精度更精确
          a2 = Convert.ToInt32(1.667f);
          Console.WriteLine(a2); // 会四舍五入
          // 特殊类型
          a2 = Convert.ToInt32(true);
          Console.WriteLine(a2);
          a2 = Convert.ToInt32(false);
          Console.WriteLine(a2);
          a2 = Convert.ToInt32('a');
          Console.WriteLine(a2);
     
          // 每一个类型都有一个对应的Convert方法
          sbyte sb3 = Convert.ToSByte("1");
          short s3 = Convert.ToInt16("1");
          long l3 = Convert.ToInt64("1");
     
          // 无符号
          byte b3 = Convert.ToByte("1");
          ushort us3 = Convert.ToUInt16("1");
          uint ui3 = Convert.ToUInt32("1");
          ulong ul3 = Convert.ToUInt64("1");
     
          float f3 = Convert.ToSingle("13.2"); // 单精度指的就是float
          double d3 = Convert.ToDouble("13.2");
          decimal de3 = Convert.ToDecimal("13.2");
     
          bool bo3 = Convert.ToBoolean("true");
          char ch3 = Convert.ToChar("a");
          string str3 = Convert.ToString(123);
     

   • 其他类型转string

     作用：拼接打印
     语法：变量.ToString();

       string str4 = 1.ToString();
       string str5 = true.ToString();
       string str6 = 12.3f.ToString();
       // 当我们进行字符串拼接时，就自动会调用 ToString转成字符串
       Console.WriteLine("hello" + 123 + true);
     

六.总结

本文旨在整理变量的一些基本概念，以及基本操作，其实很多时候，程序就等价于 数据结构 + 变量常量 + 程序控制流，所以变量常量这块很基础，也很重要 代码链接