C# 数据类型与类型转换

原文：https://www.runoob.com/csharp/csharp-data-types.html

在 C# 中，变量分为以下几种类型：

基本数据(值类型)（Value types）
引用类型（Reference types）
指针类型（Pointer types）

一、值类型（Value types）

值类型变量可以直接分配给一个值。它们是从类 System.ValueType 中派生的。

值类型直接包含数据。比如 int、char、float，它们分别存储数字、字符、浮点数。当您声明一个 int 类型时，系统分配内存来存储值。

下表列出了 C# 2010 中可用的值类型：

类型	描述	范围	默认值
byte	8 位无符号整数，1个字节	0 到 255	0
sbyte	8 位有符号整数类型，1个字节	-128 到 127	0
short	16 位有符号整数类型，2个字节	-32,768 到 32,767	0
ushort	16 位无符号整数类型，2个字节	0 到 65,535	0
int	32 位有符号整数类型，4个字节	-2,147,483,648 到 2,147,483,647	0
uint	32 位无符号整数类型，4个字节	0 到 4,294,967,295	0
long	64 位有符号整数类型，8个字节	-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807	0L
ulong	64 位无符号整数类型，8个字节	0 到 18,446,744,073,709,551,615	0
float	32 位单精度浮点型，4个字节	-3.4 x 10³⁸ 到 + 3.4 x 10³⁸	0.0F
double	64 位双精度浮点型，8个字节	(+/-)5.0 x 10^-324 到 (+/-)1.7 x 10³⁰⁸	0.0D
decimal	128 位精确的十进制值，28-29 有效位数,16个字节	(-7.9 x 10²⁸ 到 7.9 x 10²⁸) / 10^{0 到 28}	0.0M
char	16 位 Unicode 字符，2个字节	U +0000 到 U +ffff	'\0'
bool	布尔值	True 或 False	False

如需得到一个类型或一个变量在特定平台上的准确尺寸，可以使用 sizeof 方法。表达式 sizeof(type) 产生以字节为单位存储对象或类型的存储尺寸。下面举例获取任何机器上 int 类型的存储尺寸：

using System;

namespace DataTypeApplication
{
   class Program
   {
      static void Main(string[] args)
      {
         Console.WriteLine("Size of int: {0}", sizeof(int));
         Console.ReadLine();
      }
   }
}

当上面的代码被编译和执行时，它会产生下列结果：Size of int: 4

二、引用类型（Reference types）

引用类型不包含存储在变量中的实际数据，但它们包含对变量的引用。

换句话说，它们指的是一个内存位置。使用多个变量时，引用类型可以指向一个内存位置。如果内存位置的数据是由一个变量改变的，其他变量会自动反映这种值的变化。内置的 引用类型有：object、dynamic 和 string。

1、对象（Object）类型

对象（Object）类型 是 C# 通用类型系统（Common Type System - CTS）中所有数据类型的终极基类。Object 是 System.Object 类的别名。所以对象（Object）类型可以被分配任何其他类型（值类型、引用类型、预定义类型或用户自定义类型）的值。但是，在分配值之前，需要先进行类型转换。

当一个值类型转换为对象类型时，则被称为装箱；另一方面，当一个对象类型转换为值类型时，则被称为拆箱。

装箱：值类型转换为对象类型

int val = 8;
object obj = val;  //整型数据转换为了对象类型（装箱）

拆箱：之前由值类型转换而来的对象类型再转回值类型

/*只有装过箱的数据才能拆箱*/
int val = 8;
object obj = val;  //先装箱
int nval = (int)obj;  //再拆箱

2、动态（Dynamic）类型

您可以存储任何类型的值在动态数据类型变量中。这些变量的类型检查是在运行时发生的。

声明动态类型的语法：

dynamic <variable_name> = value;

例如：

dynamic d = 20;

动态类型与对象类型相似，但是对象类型变量的类型检查是在编译时发生的，而动态类型变量的类型检查是在运行时发生的。

3、字符串（String）类型

字符串（String）类型 允许您给变量分配任何字符串值。字符串（String）类型是 System.String 类的别名。它是从对象（Object）类型派生的。字符串（String）类型的值可以通过两种形式进行分配：引号和 @引号。

例如：

引号 字符串
string str = "zzz.com";

一个 @引号字符串：
string str = @"zzz.com";

C# string 字符串的前面可以加 @（称作"逐字字符串"）将转义字符（\）当作普通字符对待，比如：
string str = @"C:\Windows";

等价于：
string str = "C:\\Windows";

@ 字符串中可以任意换行，换行符及缩进空格都计算在字符串长度之内。
string str = @"<script type=""text/javascript"">
    <!--
    -->
</script>";

注意：
c#中转义双引号"，使用的转义字符仍然是\。
string str = "\"www.zzz.com\"";

但是，在c#的逐字字符中，双引号的转义字符不能用\了，会报错，而是用两个双引号""来表示"。
string str1 = @"""www.zzz.com""";

用户自定义引用类型有：class、interface 或 delegate。我们将在以后的章节中讨论这些类型。

三、指针类型（Pointer types）

指针类型变量存储另一种类型的内存地址。C# 中的指针与 C 或 C++ 中的指针有相同的功能。

声明指针类型的语法：

type* identifier;

例如：

char* cptr;
int* iptr;

我们将在章节"不安全的代码"中讨论指针类型。

四、拓展

1、C# 中char与string 区别

char 属于值类型(Value Type),char 类型的长度是固定的，永远是2个字节，可以使用sizeof获取char的尺寸。
string 属于引用类型(Reference types),string 的长度是无法明确获取的，也就是无法使用sizeof获取，因为它不是一个基础类型，本身并不固定长度，而是取决于内部包含的字符。

简单来说：

char 是字符，string是字符串。
char 一次只能赋值一个字符，用两个字节存储，存储的是该字符的Unicode编码,这里要特别注意的是，char类型的赋值只能用单引号。
string类型用于表示字符串，字符串可以是只包含一个字符，也可以是包含多个字符，它是一串字符,string类型的赋值要用双引号，不能用单引号。

/* char与string之间的转换 */
// string转化成char
string str = "balala";  // 双引号
char chr =  str[1];
Console.WriteLine(str);
Console.WriteLine(chr);

// char转化为string
char chr2 = 'z';  // 单引号
string str2 = chr2.ToString();
Console.WriteLine(chr2);
Console.WriteLine(str2);

2、基元类型(primitive)与FCL(Framework Class Library)

基元类型(primitive)，简单来说就是编译器直接支持的数据类型。基元类型直接映射到Framework类库(FCL)中的类型，例如C#中一个基元类型int直接映射到System.Int32类型。

因此我们在使用c#时候，很多人会有一个小疑问：为啥一个类型会有两种写法，比如string和String, object和Object。

其实他们都是一样的，都是指String类,String是System.String类,string是别名，就像bool/Boolean， int/int32， long/int64 都是一样的，例如：

using System;

namespace FclApplication
{
   class Program
   {
      static void Main(string[] args)
      {
        // 以下两种写法是等价的
        int a = 1;
        Console.WriteLine(a);

        Int32 a1 = 1;
        Console.WriteLine(a1);
      }
   }
}

下表为C#基元类型对应的FCL类型：

C#基元类型	FCL类型	符合CLS
sbyte	System.SByte	否
byte	System.Byte	是
short	System.Int16	是
ushort	System.UInt16	否
int	System.Int32	是
uint	System.UInt32	否
long	System.Int64	是
ulong	System.UInt64	否
float	System.Single	是
double	System.Double	是
decimal	System.Decimal	是
bool	System.Boolean	是
object	System.Object	是
dynamic	System.Object	是
char	System.Char	是
string	System.String	是

建议还是使用string或int这些别名，因为这些别名是根据framework的不同而可能和不同的类相对应的。
假如以后.net framework 运行在16位的操作系统，整型 int 默认变为 System.Int16，如果你使用了int别名，那么你的代码就不需要改了，int自动映射成System.Int16，
如果你使用的是System.Int32，那么你代码都得去修改为System.Int16。

3、关于值类型、引用类型以及“栈”跟“堆”的关系

1.值类型，声明一个值类型的时候，是在“栈”中开辟一个内存空间来存放对应的值，当值类型的值发生改变的时候，则直接修改该内存空间所保存的值。例：

int n1 = 5;
int n2 = n1;
Console.WriteLine(n1 + "  "+ n2);    // 5  5
n2 = 7;
Console.WriteLine(n1 + "  " + n2)    // 5  7

这里首先在“栈”中开辟一个内存空间用来保存 n1 的值 5，接着再在“栈”中开辟一个新的内存空间用来保存 n2 的值 5，所以显示出来的结果是 5 5。然后将 n2 在“栈”中对应的内存空间保存的值修改成 7，故显示出来的结果是 5 7。

2.引用类型，声明一个引用类型的时候，首先是在“堆”中开辟一个内存空间来存放对应的值，然后在“栈”中开辟一个内存空间用于保存在“堆”中开辟的内存空间的地址。当系统调用引用类型的时候，首先去“栈”中获取到地址，然后根据地址在“堆”中找到对应的内存空间来获取到对应值。像数组这样的引用类型

string[] a1 = new string[]{ "a" , "b" , "c" };
string[] a2 = a1;

for(int i = 0; i < a2.Length; i++)
{
    Console.Write(a2[i] + " ");    //a b c
}

a1[2] = "d";
Console.WriteLine();
for(int i = 0; i < a1.Length; i++)
{
    Console.Write(a1[i] + " ");    //a b d
}

Console.WriteLine();
for(int i = 0; i < a2.Length; i++)
{
    Console.Write(a2[i] + " ");    //a b d
}

这里首先是在“堆”中开辟一个内存空间(假设：0X55)用来保存数组a1的值，然后在“栈”中开辟一个内存空间（a1）用于保存地址 0X55。当将 a1 赋给 a2 时，是将地址赋给 a2，即在“栈”中开辟一个内存空间（a2）用于保存地址 0X55，所以输出 a2 的值是 a b c。当将 a1[2]修改成”d”的时候，修改的是“堆”中 0X55 内存空间保存的值，因为 a2 的地址和 a1 的地址一样，所以输出结果是 a b d。

3.而 string 是一个特殊的引用类型，先看下面代码

string a = "123";
string b = a; 
Console.WriteLine(a+" "+b);  //123 123
string b = "456";
Console.WriteLine(a+" "+b);  //123 456

和数组类似的，这里首先在“堆”中开辟一个内存空间(假设：0X88)用来保存 a 的值 123，然后在“栈”中开辟一个内存空间（a）用于保存地址 0X88。

和数组不同的是，当将 a 赋给 b 的时候，首先是在“堆”中开辟一个新的内存空间(假设：0X101)用于保存值 123，然后在“栈”中开辟一个内存空间（b）用于保存地址 0X101，所以输出的结果是 123 123。

当修改 b 值时，并不是修改“堆”中 0X101 内存空间的值，而是在“堆”中重新开辟一个新的内存空间(假设：0X210)用于保存 b 修改后的值，然后将 b 在“栈”中对应的内存空间的所保存的地址修改成 0X210，所以输出的结果是 123 456。而“堆”中的 0X101 内存空间将在下次的垃圾回收中被回收利用。

五、类型转换

https://www.runoob.com/csharp/csharp-type-conversion.html

1、类型转换介绍

类型转换从根本上说是类型铸造，或者说是把数据从一种类型转换为另一种类型。在 C# 中，类型铸造有两种形式：

隐式类型转换 - 这些转换是 C# 默认的以安全方式进行的转换, 不会导致数据丢失。例如，从小的整数类型转换为大的整数类型，从派生类转换为基类。
显式类型转换 - 显式类型转换，即强制类型转换。显式转换需要强制转换运算符，而且强制转换会造成数据丢失。

下面的实例显示了一个显式的类型转换：

namespace TypeConversionApplication
{
    class ExplicitConversion
    {
        static void Main(string[] args)
        {
            double d = 5673.74;
            int i;

            // 强制转换 double 为 int
            i = (int)d;
            Console.WriteLine(i);
            Console.ReadKey();
           
        }
    }
}
// 当上面的代码被编译和执行时，它会产生下列结果：5673

2、C# 类型转换方法

C# 提供了下列内置的类型转换方法：

方法	描述
ToType	把类型转换为指定类型。
ToBoolean	如果可能的话，把类型转换为布尔型。
ToString	把类型转换为字符串类型。
ToChar	如果可能的话，把类型转换为单个 Unicode 字符类型。
ToDateTime	把类型（整数或字符串类型）转换为日期-时间结构。
ToSingle	把类型转换为小浮点数类型。
ToDouble	把类型转换为双精度浮点型。
ToDecimal	把浮点型或整数类型转换为十进制类型。
ToByte	把类型转换为字节类型。
ToSbyte	把类型转换为有符号字节类型。
ToInt16	把类型转换为 16 位整数类型。
ToUInt16	把类型转换为 16 位无符号整数类型。
ToInt32	把类型转换为 32 位整数类型。
ToUInt32	把类型转换为 32 位无符号整数类型。
ToInt64	把类型转换为 64 位整数类型。
ToUInt64	把类型转换为 64 位无符号整数类型。

下面的实例把不同值的类型转换为字符串类型：

using System;

namespace TypeConversionApplication
{
    class StringConversion
    {
        static void Main(string[] args)
        {
            int i = 75;
            float f = 53.005f;
            double d = 2345.7652;
            bool b = true;

            Console.WriteLine(i.ToString());
            Console.WriteLine(f.ToString());
            Console.WriteLine(d.ToString());
            Console.WriteLine(b.ToString());
            Console.ReadKey();
            /* 当上面的代码被编译和执行时，它会产生下列结果：
            75
            53.005
            2345.7652
            True
            */
        }
    }
}

3、隐式转换和显式转换详解

隐式转换：C# 默认的以安全方式进行的转换。本质是从小存储容量数据类型自动转换为大存储容量数据类型，从派生类转换为基类。

namespace TypeConvertion
{   class Class1
    {

    }

    class Class2 : Class1 //类Class2是类Class1的子类
    {

    }
    class Program
    {
        static void Main(string[] args)
        {
            int inum = 100;
            long lnum = inum; // 进行了隐式转换，将 int 型（数据范围小）数据转换为了 long 型（数据范围大）的数据
            Class1 c1 = new Class2(); // 这里也是隐式转换，将一个新建的 Class2 实例转换为了其基类 Class1 类型的实例 C1
        }
    }
}

显式转换：通过用户使用预定义的函数显式完成的，显式转换需要强制转换运算符。

转换类型的范围大小和从属关系和隐式转换相反。显式转换可能会导致数据出错，或者转换失败，甚至无法编译成功。

using System;

namespace TypeConvertion
{   class Class1
    {

    }

    class Class2 : Class1 //类Class2是类Class1的子类
    {

    }
    class Program
    {
        static void Main(string[] args)
        {
            double dnum = 100.1;
            int ifromd = (int)dnum; //double类型显式转换转为int类型

            Class1 c11 = new Class1();
            Class2 c22 = c11 as Class2; //使用as进行显式转换
            Console.WriteLine(c22 is Class1);  // False
            Console.WriteLine(c22 is Class2);  // False
        }
    }
}

4、强制类型转换注意点

1.几种转换的方法：

using System;

namespace TypeConvertion
{
    class Program
    {
        static void Main(string[] args)
        {
            /* int强转 */
            double a = 1.35;
            int a1 = (int)(a);
            Console.WriteLine("使用int强制double转换成int: {0}", a1);
            // string snum = "123";
            // int inum = (int) snum;  // 会报错，int不能强转string
            // Console.WriteLine();

            /* string转int */
            string strNum = "123";
            //方法一: 用 Convert 
            int i1 = Convert.ToInt32(strNum);
            Console.WriteLine("使用Convert转换成int: {0}", i1);

            //方法二: 用 int.Parse(string s)
            int i2 = int.Parse(strNum);
            Console.WriteLine("使用int.Parse转换成int: {0}", i2);

            //方法三: 用 int.TryParse(string s,out int i)
            int i3;
            bool bo = int.TryParse(strNum, out i3);
            Console.WriteLine("使用int.TryParse转换成结果: {0},{1}", bo, i3);
        }
    }
}

2.C# 中对 double 类型的数据取整，可以使用 convert.toint32() 方法，也可使用 int 强制转换为整数，使用 int 时并不存在四舍五入的情况，而是直接将后面的小数位数丢掉。比如:

class Program
{
    static void Main(string[] args)
    {
        double a = 1.35;
        double b = 1.65;
        int a1 = Convert.ToInt32(a);
        int a2 = (int)(a);
        int b1 = Convert.ToInt32(b);
        int b2 = (int)(b);
        Console.WriteLine("{0}使用convert方法转化的结果为：{1}",a,a1);
        Console.WriteLine("{0}使用int强制转换的结果为：{1}",a,a2);
        Console.WriteLine("{0}使用convert方法转化的结果为：{1}", b, b1);
        Console.WriteLine("{0}使用int强制转换的结果为：{1}", b, b2);
        Console.ReadKey();
    }
}

程序运行结果如下：
1.35使用convert方法转化的结果为：1
1.35使用int强制转换的结果为：1
1.65使用convert方法转化的结果为：2
1.65使用int强制转换的结果为：1

3.Convert.ToInt32() 、 int 、 int.Parse() 、int.TryParse 的区别
1.对于转换对象
int：只能是数字类型（float,int,uint等），但不能是字符串。
int.TryParse() 和 int.Parse()：只能是整型字符串（即各种整型 ToString() 之后的形式）不能为浮点型字符串，否则 int.Parse() 就会出现输入的字符串格式不正确的错误，int.TryParse() 也会返回 false，输出参数为 0 。
Convert.ToInt32()：可以为多种类型（例 float，string，bool，DateTime 等）。如果是数字类型，可以是float浮点型等等，如果是字符串，只能是整型字符串。

2.null空值处理：
Convert.ToInt32(null) 会返回 0 而不会产生任何异常。
(int)null 强制转换和 int.Parse(null) 都会抛出异常，一般需要搭配try catch使用。
int.TryParse(null) 其实是对 int.Parse() 做了一个异常处理，如果出现异常则返回 false，并且将输出参数返回 0；

3.对浮点型数据进行四舍五入时候的区别
浮点型只有 Convert.ToInt32() 和 (int) 能进行转换。
   a. Convert.ToInt32(double value) 如果 value 为两个整数中间的数字，则返回二者中的偶数；即 3.5 转换为 4，4.5 转换为 4，而 5.5 转换为 6。不过 4.6 可以转换为 5，4.4 转换为 4 。
   b. int.Parse("4.5") 直接报错:"输入字符串的格式不正确"。
   c. int(4.6) = 4 Int 转化其他数值类型为 Int 时没有四舍五入，直接截取浮点型的整数部分，忽略小数部分。

4.类似的还有Convert.ToDouble 与 Double.Parse 的区别。

实际上 Convert.ToDouble 与 Double.Parse 较为类似，实际上 Convert.ToDouble内部调用了 Double.Parse：

(1)对于参数为null的时候：

Convert.ToDouble参数为 null 时，返回 0.0；
Double.Parse 参数为 null 时，抛出异常。

(2)对于参数为""的时候：

Convert.ToDouble参数为 "" 时，抛出异常；
Double.Parse 参数为 "" 时，抛出异常。

(3)其它区别：

Convert.ToDouble可以转换的类型较多；
Double.Parse 只能转换数字类型的字符串。
Double.TryParse 与 Double.Parse 又较为类似，但它不会产生异常，转换成功返回 true，转换失败返回 false。最后一个参数为输出值，如果转换失败，输出值为 0.0。

附测试代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                //string a = "0.2";
                //string a = null;
                string a = "";
                try
                {
                    double d1 = Double.Parse(a);
                }
                catch (Exception err)
                {
                    Console.WriteLine("d1转换出错:" + err.Message);
                }

                try
                {
                    double d2 = Convert.ToDouble(a);
                }
                catch (Exception err)
                {
                    Console.WriteLine("d2转换出错:" + err.Message);

                }
                try
                {
                    double d3;
                    Double.TryParse(a,out d3);
                }
                catch (Exception err)
                {
                    Console.WriteLine("d3转换出错:" + err.Message);
                }
            }
            finally
            {
                Console.ReadKey();
            }

        }
    }
}

posted @ 2022-08-11 21:27 我用python写Bug 阅读(930) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· Java基本数据类型及溢出、包装类

· C#基本变量与常量

· C#类型转换

· C#学习（二）类型转换

· C#基础1

阅读排行：
· 分享4款.NET开源、免费、实用的商城系统
· 全程不用写代码，我用AI程序员写了一个飞机大战
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· 白话解读 Dapr 1.15：你的「微服务管家」又秀新绝活了
· 上周热点回顾（2.24-3.2）

公告

时钟canvas

昵称：我用python写Bug
园龄： 6年7个月
粉丝： 33
关注： 9

+加关注

2025年3月

日

一

二

三

四

五

六

小小程序员Zzbj

Eating our own dog food