C#类与结构体究竟谁快——各种函数调用模式速度评测

最新推荐文章于 2023-02-02 12:07:43 发布
最新推荐文章于 2023-02-02 12:07:43 发布
阅读量7.3k 收藏 19
点赞数 5
分类专栏： 数学&优化技巧 #All - 所有 文章标签： c# byte 测试 2010 assembly 优化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zyl910/article/details/6788417
版权

以前我一直有个疑惑——在C#中，究竟是类（class）比较快，还是结构体（struct）比较快？
当时没有深究。

最近我遇到一个难题，需要将一些运算大的指针操作代码给封装一下。原先为了性能，这些代码是以硬编码的形式混杂在算法逻辑之中，不但影响了算法逻辑的可读性，其本身的指针操作代码枯燥、难懂、易写错，不易维护。所以我希望将其封装一下，简化代码编写、提高可维护性，但同时要尽可能地保证性能。
由于那些指针操作代码很灵活，简单的封装不能解决问题，还需要用到接口（interface）以实现一些动态调用功能。
为了简化代码，还打算实现一些泛型方法。
本来还想因32位指针、64位指针的不同而构造泛型类，可惜发现C#不支持将int/long作为泛型类型约束，只好作罢。将设计改为——分别为32位指针、64位指针编写不同的类，它们实现同一个接口。

在C#中，有两类封装技术——
1.基于类（class）的封装。在基类中定义好操作方法，然后在派生类中实现操作方法。
2.基于结构体（struct）的封装。在接口中定义好操作方法，然后在结构体中实现该接口的操作方法。
我分别使用这两类封装技术编写测试代码，然后做性能测试。

经过反复思索，考虑 类、结构体、接口、泛型 的组合，我找出了15种函数调用模式——
硬编码
静态调用
调用派生类
调用结构体
调用基类
调用派生类的接口
调用结构体的接口
基类泛型调用派生类
基类泛型调用基类
接口泛型调用派生类
接口泛型调用结构体
接口泛型调用结构体引用
接口泛型调用基类
接口泛型调用派生类的接口
接口泛型调用结构体的接口


测试代码为—— 

using System;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;

namespace TryPointerCall
{
	/// <summary>
	/// 指针操作接口
	/// </summary>
	public interface IPointerCall
	{
		/// <summary>
		/// 指针操作
		/// </summary>
		/// <param name="p">源指针</param>
		/// <returns>修改后指针</returns>
		unsafe byte* Ptr(byte* p);
	}

#region 非泛型
	/// <summary>
	/// [非泛型] 指针操作基类
	/// </summary>
	public abstract class PointerCall : IPointerCall
	{
		public abstract unsafe byte* Ptr(byte* p);
	}

	/// <summary>
	/// [非泛型] 指针操作派生类: 指针+偏移
	/// </summary>
	public class PointerCallAdd : PointerCall
	{
		/// <summary>
		/// 偏移值
		/// </summary>
		public int Offset = 0;

		public override unsafe byte* Ptr(byte* p)
		{
			return unchecked(p + Offset);
		}
	}

	/// <summary>
	/// [非泛型] 指针操作结构体: 指针+偏移
	/// </summary>
	public struct SPointerCallAdd : IPointerCall
	{
		/// <summary>
		/// 偏移值
		/// </summary>
		public int Offset;

		public unsafe byte* Ptr(byte* p)
		{
			return unchecked(p + Offset);
		}
	}

#endregion

#region 泛型
	// !!! C#不支持将整数类型作为泛型约束 !!!
	//public abstract class GenPointerCall<T> : IPointerCall where T: int, long
	//{
	//    public abstract unsafe byte* Ptr(byte* p);

	//    void d()
	//    {
	//    }
	//}

#endregion

#region 全部测试
	/// <summary>
	/// 指针操作的一些常用函数
	/// </summary>
	public static class PointerCallTool
	{
		private const int CountLoop = 200000000;	// 循环次数

		/// <summary>
		/// 调用指针操作
		/// </summary>
		/// <typeparam name="T">具有IPointerCall接口的类型。</typeparam>
		/// <param name="ptrcall">调用者</param>
		/// <param name="p">源指针</param>
		/// <returns>修改后指针</returns>
		public static unsafe byte* CallPtr<T>(T ptrcall, byte* p) where T : IPointerCall
		{
			return ptrcall.Ptr(p);
		}
		public static unsafe byte* CallClassPtr<T>(T ptrcall, byte* p) where T : PointerCall
		{
			return ptrcall.Ptr(p);
		}
		public static unsafe byte* CallRefPtr<T>(ref T ptrcall, byte* p) where T : IPointerCall
		{
			return ptrcall.Ptr(p);
		}

		// C#不允许将特定的结构体作为泛型约束。所以对于结构体只能采用上面那个方法，通过IPointerCall接口进行约束，可能会造成性能下降。
		//public static unsafe byte* SCallPtr<T>(T ptrcall, byte* p) where T : SPointerCallAdd
		//{
		//    return ptrcall.Ptr(p);
		//}

		private static int TryIt_Static_Offset;
		private static unsafe byte* TryIt_Static_Ptr(byte* p)
		{
			return unchecked(p + TryIt_Static_Offset);
		}
		/// <summary>
		/// 执行测试 - 静态调用
		/// </summary>
		/// <param name="sOut">文本输出</param>
		private static unsafe void TryIt_Static(StringBuilder sOut)
		{
			TryIt_Static_Offset = 1;

			// == 性能测试 ==
			byte* p = null;
			Stopwatch sw = new Stopwatch();
			int i;
			unchecked
			{
				#region 测试
				// 硬编码
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = p + TryIt_Static_Offset;
				}
				sw.Stop();
				sOut.AppendLine(string.Format("硬编码:\t{0}", sw.ElapsedMilliseconds));

				// 静态调用
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = TryIt_Static_Ptr(p);
				}
				sw.Stop();
				sOut.AppendLine(string.Format("静态调用:\t{0}", sw.ElapsedMilliseconds));

				#endregion // 测试
			}
		}

		/// <summary>
		/// 执行测试 - 非泛型
		/// </summary>
		/// <param name="sOut">文本输出</param>
		private static unsafe void TryIt_NoGen(StringBuilder sOut)
		{
			// 创建
			PointerCallAdd pca = new PointerCallAdd();
			SPointerCallAdd spca;
			pca.Offset = 1;
			spca.Offset = 1;

			// 转型
			PointerCall pca_base = pca;
			IPointerCall pca_itf = pca;
			IPointerCall spca_itf = spca;

			// == 性能测试 ==
			byte* p = null;
			Stopwatch sw = new Stopwatch();
			int i;
			unchecked
			{
				#region 调用
				#region 直接调用
				// 调用派生类
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = pca.Ptr(p);
				}
				sw.Stop();
				sOut.AppendLine(string.Format("调用派生类:\t{0}", sw.ElapsedMilliseconds));

				// 调用结构体
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = spca.Ptr(p);
				}
				sw.Stop();
				sOut.AppendLine(string.Format("调用结构体:\t{0}", sw.ElapsedMilliseconds));

				#endregion	// 直接调用

				#region 间接调用
				// 调用基类
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = pca_base.Ptr(p);
				}
				sw.Stop();
				sOut.AppendLine(string.Format("调用基类:\t{0}", sw.ElapsedMilliseconds));

				// 调用派生类的接口
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = pca_itf.Ptr(p);
				}
				sw.Stop();
				sOut.AppendLine(string.Format("调用派生类的接口:\t{0}", sw.ElapsedMilliseconds));

				// 调用结构体的接口
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = spca_itf.Ptr(p);
				}
				sw.Stop();
				sOut.AppendLine(string.Format("调用结构体的接口:\t{0}", sw.ElapsedMilliseconds));

				#endregion	// 间接调用

				#endregion	// 调用

				#region 泛型调用

				#region 泛型基类约束
				// 基类泛型调用派生类
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = CallClassPtr(pca, p);
				}
				sw.Stop();
				sOut.AppendLine(string.Format("基类泛型调用派生类:\t{0}", sw.ElapsedMilliseconds));

				// 基类泛型调用基类
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = CallClassPtr(pca_base, p);
				}
				sw.Stop();
				sOut.AppendLine(string.Format("基类泛型调用基类:\t{0}", sw.ElapsedMilliseconds));

				#endregion // 泛型基类约束

				#region 泛型接口约束 - 直接调用
				// 接口泛型调用派生类
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = CallPtr(pca, p);
				}
				sw.Stop();
				sOut.AppendLine(string.Format("接口泛型调用派生类:\t{0}", sw.ElapsedMilliseconds));

				// 接口泛型调用结构体
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = CallPtr(spca, p);
				}
				sw.Stop();
				sOut.AppendLine(string.Format("接口泛型调用结构体:\t{0}", sw.ElapsedMilliseconds));

				// 接口泛型调用结构体引用
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = CallRefPtr(ref spca, p);
				}
				sw.Stop();
				sOut.AppendLine(string.Format("接口泛型调用结构体引用:\t{0}", sw.ElapsedMilliseconds));

				#endregion	// 直接调用

				#region 间接调用
				// 接口泛型调用基类
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = CallPtr(pca_base, p);
				}
				sw.Stop();
				sOut.AppendLine(string.Format("接口泛型调用基类:\t{0}", sw.ElapsedMilliseconds));

				// 接口泛型调用派生类的接口
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = CallPtr(pca_itf, p);
				}
				sw.Stop();
				sOut.AppendLine(string.Format("接口泛型调用派生类的接口:\t{0}", sw.ElapsedMilliseconds));

				// 接口泛型调用结构体的接口
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = CallPtr(spca_itf, p);
				}
				sw.Stop();
				sOut.AppendLine(string.Format("接口泛型调用结构体的接口:\t{0}", sw.ElapsedMilliseconds));

				#endregion	// 间接调用

				#endregion	// 泛型调用

			}
		}

		/// <summary>
		/// 执行测试 - 泛型
		/// </summary>
		/// <param name="sOut">文本输出</param>
		private static unsafe void TryIt_Gen(StringBuilder sOut)
		{
			// !!! C#不支持将整数类型作为泛型约束 !!!
		}

		/// <summary>
		/// 执行测试
		/// </summary>
		public static string TryIt()
		{
			StringBuilder sOut = new StringBuilder();
			sOut.AppendLine("== PointerCallTool.TryIt() ==");
			TryIt_Static(sOut);
			TryIt_NoGen(sOut);
			TryIt_Gen(sOut);
			sOut.AppendLine();
			return sOut.ToString();
		}
	}
#endregion

}



编译器——
VS2005：Visual Studio 2005 SP1。
VS2010：Visual Studio 2010 SP1。
采用上述编译器编译为Release版程序，最大速度优化。


机器A——
HP CQ42-153TX
处理器：Intel Core i5-430M(2.26GHz, Turbo 2.53GHz, 3MB L3)
内存容量：2GB (DDR3-1066)

机器B——
DELL Latitude E6320
处理器：Intel i3-2310M(2.1GHz, 3MB L3)
内存容量：4GB (DDR3-1333，双通道)

测试环境——
A_2005：机器A，VS2005，Window 7 32位。
A_2010：机器A，VS2010，Window 7 32位。
B_2005：机器B，VS2005，Window 7 64位（x64）。
B_2010：机器B，VS2010，Window 7 64位（x64）。
B_2010xp：机器B，VS2010，Window XP SP3 32位。

测试结果（单位：毫秒）——

模式A_2005A_2010B_2005B_2010B_2010xp
硬编码163162232495
静态调用162161232395
调用派生类570487456487606
调用结构体16216095620100
调用基类565571453513874
调用派生类的接口810728779708929
调用结构体的接口10521055117511751267
基类泛型调用派生类97556810551148671
基类泛型调用基类98456910551152671
接口泛型调用派生类1383729134615311062
接口泛型调用结构体5661627671149107
接口泛型调用结构体引用487164752816100
接口泛型调用基类1378812133715351072
接口泛型调用派生类的接口1376810133815331102
接口泛型调用结构体的接口15421133248620131365


结果分析——
先看第1列数据（A_2005），发现“静态调用”、“调用结构体”与“硬编码”的时间几乎一致，很可能做了函数展开优化。其次最快的是“接口泛型调用结构体引用”，比“接口泛型调用结构体”快了16%。但是“接口泛型调用结构体的接口”最慢，“调用结构体的接口”也比较慢。其他的基于类的调用模式的速度排在中间。而且发现泛型方法速度较慢。
然后看第2列数据（A_2010），发现“接口泛型调用结构体”、“接口泛型调用结构体引用”也与“硬编码”的时间几乎一致，表示它们也是做了函数展开优化的，看来在VS2010中不需要使用ref优化结构体参数。“调用结构体的接口”、“接口泛型调用结构体的接口”两个都成了垫底。泛型方法的速度有了很大的提高，几乎与非泛型调用速度相当。
再看第3列数据（B_2005），并与第1列（A_2005）进行比较，发现“静态调用”与“硬编码”的时间几乎一致，而“调用结构体”要慢一些。“接口泛型调用结构体”、“接口泛型调用结构体引用”比较慢，排在了“调用基类”、“调用派生类”的后面。可能是64位环境（x64）的特点吧。
再看第4列数据（B_2010），并与第3列（B_2005）进行比较，发现大部分变慢了，尤其是结构体相关的，难道VS2010的x64性能还不如VS2005？我将平台改为“x64”又编译了一次，结果依旧。
再看第5列数据（B_2010xp），发现32位WinXP下的大部分项目比64位Win7下要快，真诡异。而且发现“静态调用”、“调用结构体”与“硬编码”的时间几乎一致，看来“调用结构体”一直是被函数展开优化的，而64位下的静态调用有着更深层次的优化，所以比不过。


我觉得在要求性能的情况下，使用结构体封装指针操作比较好，因为直接调用时会做函数展开优化，大多数情况下与硬编码的性能一致。在遇到需要一些灵活功能时，可考虑采用“接口泛型调用结构体引用”的方式，速度有所下降。接口方式最慢，尽可能不用。一定要用接口的话，应优先选择非泛型版。

（完）

测试程序exe——
http://115.com/file/dn6hvcm3

http://download.csdn.net/detail/zyl910/3614511

 

源代码下载——
http://115.com/file/aqz70zy3

http://download.csdn.net/detail/zyl910/3614514


目录——
C#类与结构体究竟谁快——各种函数调用模式速度评测：http://blog.csdn.net/zyl910/article/details/6788417
再探C#类与结构体究竟谁快——考虑栈变量、栈分配、64位整数、密封类：http://blog.csdn.net/zyl910/article/details/6793908
三探C#类与结构体究竟谁快——MSIL（微软中间语言）解读：http://blog.csdn.net/zyl910/article/details/6817158
四探C#类与结构体究竟谁快——跨程序集（assembly）调用：http://blog.csdn.net/zyl910/article/details/6839868
目录——
C#类与结构体究竟谁快——各种函数调用模式速度评测：http://blog.csdn.net/zyl910/article/details/6788417
再探C#类与结构体究竟谁快——考虑栈变量、栈分配、64位整数、密封类：http://blog.csdn.net/zyl910/article/details/6793908
三探C#类与结构体究竟谁快——MSIL（微软中间语言）解读：http://blog.csdn.net/zyl910/article/details/6817158
四探C#类与结构体究竟谁快——跨程序集（assembly）调用：http://blog.csdn.net/zyl910/article/details/6839868

zyl910
关注
  • 5
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 14
    评论
专栏目录
[源代码]C#类与结构体究竟谁快
09-19
[源代码]C#类与结构体究竟谁快——各种函数调用模式速度评测 详见—— http://blog.csdn.net/zyl910/article/details/6788417 C#类与结构体究竟谁快——各种函数调用模式速度评测
结构体在函数中的调用，传值调用和传址调用的区别。
dyeecho的博客
11-27 1082
结构体在函数中的调用，传值调用和传址调用的区别。
【C#】结构体struct和类class的比较
u014437141的博客
04-15 119
代码出自 https://blog.csdn.net/qq_42672770/article/details/112761229 文章目录background1、Code2、Results3、Conclusion background 都知道sturct使用栈内存访问更快,class使用堆内存访问相对慢,为什么还会有class内使用struct的写法呢? 1、Code using System.Diagnostics; namespace BlogProject { struct MyS.
C#运算和函数调用性能测试
游戏猫的博客
07-21 683
CPU I7-6700K 4.0GHZ 10万次函数调用耗时2ms，每秒可调用5000万次（0.05G次） 100万次加或乘运算在2ms左右，每秒可调用5亿次(0.5G次） 100万次开根号6ms左右，每秒可调用1.7亿次（0.17G次） 加法和乘法混合运算跟简单加法或乘法性能基本一样。 mono和.net性能差别不大。...
三探C#类与结构体究竟谁快——MSIL（微软中间语言）解读
zyl910的专栏
09-24 1553
上次我分别测试了类与结构体（http://blog.csdn.net/zyl910/article/details/6788417）、密封类（http://blog.csdn.net/zyl910/article/details/6793908）的函数调用速度评测。现在进行进一步
使用struct来存储10w数据比class来存储10w数据能够节约三分之一的内存？
JuCheap
05-07 551
使用struct来存储10w数据比class来存储10w数据能够节约三分之一的内存
class类类型和struct结构体类型异同点?_在C#中使用Struct代替Class
weixin_35767180的博客
01-12 382
最近在尝试优化Spine的渲染器，中途发现自己手上的Unity版本其实已经支持ref return了，故有此文。一般优化性能都会想到Native化，但这种想法其实是不对的。Cpp效率高，其实并不是因为它本身语言效率高，而是它提供的一些独有的语言特性可以获得更高的效率。也就是说，如果你直接把一个C#的代码翻译成Cpp编译，获得的效率提升其实并不显著。而Unity本来也是在用il2cpp，本体本来也就...
C# 类（Class）和结构（struct)的比较
i78i845的博客
02-02 353
结构构造函数并不动态分配对象并返回对它的引用，而是直接返回结构值本身(通常是堆栈上的一个临时位置)，然后根据需要复制该结构值。对于作为类实现的 Point，，实例化了 101个单独对象，其中，数组需要一个，其100 个元素每个都需要一个。对干结构，每个变量都有自己的数据副本，对一个变量的操作不会影响另一个变量。例如，下面的代码段产生的输出取决于 Point 是类还是结构。对于类，两个变量可能引用同一对象，因此对一个变量进行的操作可能影响另一个变量所引用的对象。a对b的赋值创建了该值的一个副本。
[测试程序exe]C#类与结构体究竟谁快
09-19
[测试程序exe]C#类与结构体究竟谁快——各种函数调用模式速度评测 详见—— http://blog.csdn.net/zyl910/article/details/6788417 C#类与结构体究竟谁快——各种函数调用模式速度评测
调用示例.rar_C#调用c++ dll_C#调用函数指针_C#调用结构体_结构体_调用C dll
07-15
C#调用C++ dll, 包括结构体, 数组, 函数指针, 字符串等等
基于C#调用c++Dll结构体数组指针的问题详解
08-28
下面小编就为大家分享一篇基于C#调用c++Dll结构体数组指针的问题详解，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
C#调用C++动态库，执行回调函数并传递结构体参数
12-25
c#调用C++动态库、执行回调函数，并回传结构体参数数据。vs2017环境编写C#和C++动态库，这个为完整工程例子，可供相关人员学习参考。
如何在DOS中枚举PCI设备
热门推荐
zyl910的专栏
07-01 2万+
File:      zEnumPCIName:      如何在DOS中枚举PCI设备Author:    zyl910Blog:      http://blog.csdn.net/zyl910/Version:   V1.0Updata:    2006-6-30下载（注意修改下载后的扩展名）前言~~~~　　学计算机这么多年了，PCI这个名词不知道叫了几百遍了。可是，我一直不知道
用VB写高效的图像处理程序 V2.0（2006-5-24）
zyl910的专栏
05-24 1万+
用VB写高效的图像处理程序 V2.0（2006-5-24）作者：zyl910 一、为什么这么慢？ 二、DIB的结构 三、DIB访问函数
用VB6写的一个简单俄罗斯方块代码
zyl910的专栏
05-30 1万+
网络上有很多俄罗斯方块代码。它们大都为了视觉效果，程序比较复杂，不利于学习游戏编程。所以我写了个简单俄罗斯方块代码，尽量用VB本身的功能，没有复杂的DirectX。下载（注意修改下载后的扩展名） mBlock.bas Attribute VB_Name = "mBlock"Option
终于真正明白了超光速旅行中的时间倒流现象
zyl910的专栏
12-15 1万+
我最开始看见相对论中的一些概念时，总觉得违背直观、难以理解。可是过了一段时间，会突然发现，一切原来是这样一回事。因为光速是300000km/s，所以距地球为d光年的恒星，它的发出来的光要过d年才能到达地球。换句话说，我们现在看见的是该恒星d年前的景象。假设在今年一月份的时候，有一艘飞船位于离地球一光年的位置，它以两倍光速匀速直线地飞回地球。所以该飞船花半年时间就能到达地球，即今年七月份时我
[C] 跨平台使用TCHAR——让Linux等平台也支持tchar.h，解决跨平台时的格式控制字符问题，多国语言的同时显示（兼容vc/gcc/bcb，支持Windows/Linux/Mac）
zyl910的专栏
01-17 1万+
作者：zyl910 　　将Windows程序移植到Linux等平台时，经常会遇到tchar.h问题与字符串的格式控制字符问题（char串、wchar_t串、TCHAR串混合输出）。本文探讨如何解决这些问题。 一、背景 1.1 历史 　　传统的C程序使用char字符串，采用ANSI+DBCS方案来支持当地语言，不能实现多国语言同时显示。 　　当年微软在设计Windows NT时考虑到国
c# 调用 c 回调函数 结构体
最新发布
07-25
C是一种编程语言，由美国计算机科学家德尼斯·里奇在20世纪70年代初开发。它是一种通用的、结构化的高级编程语言。 C的设计目标是提供高效的编译器，并能与底层的操作系统进行良好的交互。因此，C语言广泛应用于系统编程、嵌入式系统、操作系统和编译器的开发以及其他对性能要求较高的领域。 C语言的语法简洁且灵活，支持面向过程的编程范式。C的核心功能包括变量、数据类型、运算符、流程控制语句和函数。它也提供了许多标准库函数，使得开发者能够更方便地进行各种操作。 C语言具有良好的可移植性，且易于学习和使用。许多编程语言都受到C的影响，例如C++、C#、Java等。这些语言都从C中借鉴了语法和特性，因此学习C语言可以为后续学习其他编程语言打下坚实的基础。 尽管C语言在一些方面有限制和不足，但它仍然是许多开发人员和计算机科学家的首选语言之一。通过使用C语言，开发者可以更好地控制程序的细节，从而提高程序的性能和效率。此外，C语言的广泛应用也使得很多开源库和工具都以C语言编写，进一步扩展了C语言的应用领域。 总结来说，C语言是一种高效、灵活且通用的编程语言。它的设计目标是与操作系统良好交互，适用于系统编程和对性能有要求的领域。学习C语言可以为后续学习其他编程语言打下基础，并有助于开发者掌握底层细节和提高程序性能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值