.net中对象序列化技术浅谈 (转）

原文：http://blog.csdn.net/zhoufoxcn/archive/2009/03/11/3978874.aspx 

.net中对象序列化技术浅谈 (转）
序列化是将对象状态转换为可保持或传输的格式的过程。与序列化相对的是反序列化，它将流转换为对象。这两个过程结合起来，可以轻松地存储和传输数据。例如，可以序列化一个对象，然后使用 HTTP 通过 Internet 在客户端和服务器之间传输该对象。反之，反序列化根据流重新构造对象。此外还可以将对象序列化后保存到本地，再次运行的时候可以从本地文件中“恢复”对象到序列化之前的状态。
在.net中有提供了几种序列化的方式：
二进制序列化
XML序列化
SOAP序列化

二进制序列化
所谓二进制序列化，指的是对象序列化之后是二进制形式的。二进制序列化是通过BinaryFormatter类来实现的，这个类位于System.Runtime.Serialization.Formatters.Binary命名空间下。

XML序列化
所谓XML序列化，是指对象序列化之后的结果是XML形式的。保存XML序列化是通过XmlSerializer 类来实现的， 这个类位于System.Xml.Serialization命名空间下。

SOAP序列化
所谓SOAP序列化是指对象序列化之后的结果符合SOAP协议，也就是可以通过SOAP协议传输（不知道SOAP协议？百度一下吧）。SOAP序列化是通过SoapFormatter类来实现的，这个类位于System.Runtime.Serialization.Formatters.Soap命名空间下，并且需要注意需要手动添加对这个命名空间的引用，如下图所示：
 

下面编写一个类用于序列化和反序列化，这个类的代码如下：

using System;  
using System.Collections.Generic;  
using System.Text;  
 
namespace MySerializeDemo  
{  
    [Serializable]  
    /// <summary>  
    /// 要序列化的对象  
    /// 作者：周公  
    /// 编写时间：2009-03-10  
    /// </summary>  
    public class MyObject  
    {  
        //[NonSerialized]  
        private string name;  
        private DateTime birthday;  
        private string homePlace;  
        /// <summary>  
        /// 出生地  
        /// </summary>  
        public string HomePlace  
        {  
            get { return homePlace; }  
            set { homePlace = value; }  
        }  
   
        /// <summary>  
        /// 生日  
        /// </summary>  
        public DateTime Birthday  
        {  
            get { return birthday; }  
            set { birthday = value; }  
        }  
   
        /// <summary>  
        /// 姓名  
        /// </summary>  
        public string Name  
        {  
            get { return name; }  
            set { name = value; }  
        }  
   
        /// <summary>  
        /// 年龄  
        /// </summary>  
        public int Age  
        {  
            get { return DateTime.Now.Year - birthday.Year; }  
        }  
        /// <summary>  
        /// override了ToString()方法  
        /// </summary>  
        /// <returns></returns>  
        public override string ToString()  
        {  
            return string.Format("姓名：{0},生日：{1},出生地：{2},年龄：{3}",name,birthday,homePlace,Age);  
        }  
   
    }  
} 
using System;
using System.Collections.Generic;
using System.Text;

namespace MySerializeDemo
{
    [Serializable]
    /// <summary>
    /// 要序列化的对象
    /// 作者：周公
    /// 编写时间：2009-03-10
    /// </summary>
    public class MyObject
    {
        //[NonSerialized]
        private string name;
        private DateTime birthday;
        private string homePlace;
        /// <summary>
        /// 出生地
        /// </summary>
        public string HomePlace
        {
            get { return homePlace; }
            set { homePlace = value; }
        }
 
        /// <summary>
        /// 生日
        /// </summary>
        public DateTime Birthday
        {
            get { return birthday; }
            set { birthday = value; }
        }
 
        /// <summary>
        /// 姓名
        /// </summary>
        public string Name
        {
            get { return name; }
            set { name = value; }
        }
 
        /// <summary>
        /// 年龄
        /// </summary>
        public int Age
        {
            get { return DateTime.Now.Year - birthday.Year; }
        }
        /// <summary>
        /// override了ToString()方法
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            return string.Format("姓名：{0},生日：{1},出生地：{2},年龄：{3}",name,birthday,homePlace,Age);
        }
 
    }
}
下面是分别用上面的三个类进行序列化和反序列化的代码：

view plaincopy to clipboardprint?
using System;  
using System.Collections.Generic;  
using System.Text;  
using System.IO;  
using System.Runtime.Serialization.Formatters;  
using System.Runtime.Serialization.Formatters.Binary;  
using System.Runtime.Serialization.Formatters.Soap;  
using System.Xml.Serialization;  
 
namespace MySerializeDemo  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            MyObject obj = new MyObject();  
            obj.Birthday = new DateTime(1979, 11, 7);  
            obj.HomePlace = "湖北";  
            obj.Name = "周公";  
            Console.WriteLine("========使用BinaryFormatter类进行序列化和反序列化。====");  
            BinarySerialize(obj);  
            BinaryDeserialize("C:\\MyObject.dat");  
            Console.WriteLine("========使用SoapFormatter类进行序列化和反序列化。====");  
            SOAPSerialize(obj);  
            SOAPDeserialize("C:\\MyObject.soap");  
            Console.WriteLine("========使用XmlSerializer类进行序列化和反序列化。====");  
            XMLSerialize(obj);  
            XMLDeserialize("C:\\MyObject.xml");  
        }  
        /// <summary>  
        /// 二进制序列化对象  
        /// </summary>  
        /// <param name="obj"></param>  
        public static void BinarySerialize(MyObject obj)  
        {  
            using (FileStream stream = new FileStream("C:\\MyObject.dat", FileMode.Create, FileAccess.Write))  
            {  
                BinaryFormatter formater = new BinaryFormatter();  
                formater.Serialize(stream, obj);  
                Console.WriteLine("对象已经被序列化。" + obj.ToString());  
            }  
        }  
        /// <summary>  
        /// 二进制反序列化  
        /// </summary>  
        /// <param name="fileName"></param>  
        public static void BinaryDeserialize(string fileName)  
        {  
            using (FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read))  
            {  
                BinaryFormatter formater = new BinaryFormatter();  
                MyObject obj=(MyObject)formater.Deserialize(stream);  
                Console.WriteLine("对象已经被反序列化。" + obj.ToString());  
            }  
        }  
 
        /// <summary>  
        /// 二进制序列化对象  
        /// </summary>  
        /// <param name="obj"></param>  
        public static void SOAPSerialize(MyObject obj)  
        {  
            using (FileStream stream = new FileStream("C:\\MyObject.soap", FileMode.Create, FileAccess.Write))  
            {  
                SoapFormatter formater = new SoapFormatter();  
                formater.Serialize(stream, obj);  
                Console.WriteLine("对象已经被序列化。" + obj.ToString());  
            }  
        }  
        /// <summary>  
        /// 二进制反序列化  
        /// </summary>  
        /// <param name="fileName"></param>  
        public static void SOAPDeserialize(string fileName)  
        {  
            using (FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read))  
            {  
                SoapFormatter formater = new SoapFormatter();  
                MyObject obj = (MyObject)formater.Deserialize(stream);  
                Console.WriteLine("对象已经被反序列化。" + obj.ToString());  
            }  
        }  
        /// <summary>  
        /// XML序列化  
        /// </summary>  
        /// <param name="obj"></param>  
        public static void XMLSerialize(MyObject obj)  
        {  
            using (FileStream stream = new FileStream("C:\\MyObject.xml", FileMode.Create, FileAccess.Write))  
            {  
                XmlSerializer serializer = new XmlSerializer(typeof(MyObject));  
                serializer.Serialize(stream, obj);  
                Console.WriteLine("对象已经被序列化。" + obj.ToString());  
            }  
        }  
        /// <summary>  
        /// XML反序列化  
        /// </summary>  
        /// <param name="fileName"></param>  
        public static void XMLDeserialize(string fileName)  
        {  
            using (FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read))  
            {  
                XmlSerializer serializer = new XmlSerializer(typeof(MyObject));  
                MyObject obj = (MyObject)serializer.Deserialize(stream);  
                Console.WriteLine("对象已经被反序列化。" + obj.ToString());  
            }  
        }  
    }  
} 
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Runtime.Serialization.Formatters;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization.Formatters.Soap;
using System.Xml.Serialization;

namespace MySerializeDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            MyObject obj = new MyObject();
            obj.Birthday = new DateTime(1979, 11, 7);
            obj.HomePlace = "湖北";
            obj.Name = "周公";
            Console.WriteLine("========使用BinaryFormatter类进行序列化和反序列化。====");
            BinarySerialize(obj);
            BinaryDeserialize("C:\\MyObject.dat");
            Console.WriteLine("========使用SoapFormatter类进行序列化和反序列化。====");
            SOAPSerialize(obj);
            SOAPDeserialize("C:\\MyObject.soap");
            Console.WriteLine("========使用XmlSerializer类进行序列化和反序列化。====");
            XMLSerialize(obj);
            XMLDeserialize("C:\\MyObject.xml");
        }
        /// <summary>
        /// 二进制序列化对象
        /// </summary>
        /// <param name="obj"></param>
        public static void BinarySerialize(MyObject obj)
        {
            using (FileStream stream = new FileStream("C:\\MyObject.dat", FileMode.Create, FileAccess.Write))
            {
                BinaryFormatter formater = new BinaryFormatter();
                formater.Serialize(stream, obj);
                Console.WriteLine("对象已经被序列化。" + obj.ToString());
            }
        }
        /// <summary>
        /// 二进制反序列化
        /// </summary>
        /// <param name="fileName"></param>
        public static void BinaryDeserialize(string fileName)
        {
            using (FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read))
            {
                BinaryFormatter formater = new BinaryFormatter();
                MyObject obj=(MyObject)formater.Deserialize(stream);
                Console.WriteLine("对象已经被反序列化。" + obj.ToString());
            }
        }

        /// <summary>
        /// 二进制序列化对象
        /// </summary>
        /// <param name="obj"></param>
        public static void SOAPSerialize(MyObject obj)
        {
            using (FileStream stream = new FileStream("C:\\MyObject.soap", FileMode.Create, FileAccess.Write))
            {
                SoapFormatter formater = new SoapFormatter();
                formater.Serialize(stream, obj);
                Console.WriteLine("对象已经被序列化。" + obj.ToString());
            }
        }
        /// <summary>
        /// 二进制反序列化
        /// </summary>
        /// <param name="fileName"></param>
        public static void SOAPDeserialize(string fileName)
        {
            using (FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read))
            {
                SoapFormatter formater = new SoapFormatter();
                MyObject obj = (MyObject)formater.Deserialize(stream);
                Console.WriteLine("对象已经被反序列化。" + obj.ToString());
            }
        }
        /// <summary>
        /// XML序列化
        /// </summary>
        /// <param name="obj"></param>
        public static void XMLSerialize(MyObject obj)
        {
            using (FileStream stream = new FileStream("C:\\MyObject.xml", FileMode.Create, FileAccess.Write))
            {
                XmlSerializer serializer = new XmlSerializer(typeof(MyObject));
                serializer.Serialize(stream, obj);
                Console.WriteLine("对象已经被序列化。" + obj.ToString());
            }
        }
        /// <summary>
        /// XML反序列化
        /// </summary>
        /// <param name="fileName"></param>
        public static void XMLDeserialize(string fileName)
        {
            using (FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read))
            {
                XmlSerializer serializer = new XmlSerializer(typeof(MyObject));
                MyObject obj = (MyObject)serializer.Deserialize(stream);
                Console.WriteLine("对象已经被反序列化。" + obj.ToString());
            }
        }
    }
}
这个程序的运行效果如下：
 
可见通过上面三个类都能实现将对象序列化保存，并且都能反序列化还原到对象被序列化之前的状态（这正是序列化意义所在，能保存对象运行时的状态并且还能还原）。如果运行上面的代码会在C盘根目录下创建三个文件，分别是MyObject.dat、MyObject.soap和MyObject.xml文件，因为MyObject.dat是二进制文件，所以无法查看文件的内容，但是我们可以打开MyObject.soap和MyObject.xml这两个文件来比较一下有什么区别。
MyObject.soap文件的后缀虽然是.soap，但是还是可以用记事本打开的，下面是MyObject.soap文件的内容：
view plaincopy to clipboardprint?
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:clr="http://schemas.microsoft.com/soap/encoding/clr/1.0" SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"> 
<SOAP-ENV:Body> 
<a1:MyObject id="ref-1" xmlns:a1="http://schemas.microsoft.com/clr/nsassem/MySerializeDemo/MySerializeDemo%2C%20Version%3D1.0.0.0%2C%20Culture%3Dneutral%2C%20PublicKeyToken%3Dnull"> 
<name id="ref-3">周公</name> 
<birthday>1979-11-07T00:00:00.0000000+08:00</birthday> 
<homePlace id="ref-4">湖北</homePlace> 
</a1:MyObject> 
</SOAP-ENV:Body> 
</SOAP-ENV:Envelope> 
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:clr="http://schemas.microsoft.com/soap/encoding/clr/1.0" SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
<SOAP-ENV:Body>
<a1:MyObject id="ref-1" xmlns:a1="http://schemas.microsoft.com/clr/nsassem/MySerializeDemo/MySerializeDemo%2C%20Version%3D1.0.0.0%2C%20Culture%3Dneutral%2C%20PublicKeyToken%3Dnull">
<name id="ref-3">周公</name>
<birthday>1979-11-07T00:00:00.0000000+08:00</birthday>
<homePlace id="ref-4">湖北</homePlace>
</a1:MyObject>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>
MyObject.xml文件也可以用记事本打开，它的内容如下：

view plaincopy to clipboardprint?
<?xml version="1.0"?> 
<MyObject xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
  <HomePlace>湖北</HomePlace> 
  <Birthday>1979-11-07T00:00:00</Birthday> 
  <Name>周公</Name> 
</MyObject> 
<?xml version="1.0"?>
<MyObject xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <HomePlace>湖北</HomePlace>
  <Birthday>1979-11-07T00:00:00</Birthday>
  <Name>周公</Name>
</MyObject>
熟悉SOAP协议的朋友一看MyObject.soap文件的内容就知道它符合SOAP协议，MyObject.xml文件毫无疑问是一个符合XML规范的文件。

对代码作几点说明：
1、如果采用BinaryFormatter类或者SoapFormatter类来实现序列化，则一定要给类加上Serializable属性，如代码中所示：
view plaincopy to clipboardprint?
[Serializable]  
    /// <summary>  
    /// 要序列化的对象  
    /// 作者：周公  
    /// 编写时间：2009-03-10  
    /// </summary>  
    public class MyObject 
[Serializable]
    /// <summary>
    /// 要序列化的对象
    /// 作者：周公
    /// 编写时间：2009-03-10
    /// </summary>
    public class MyObject
如果不给要序列化的对象加上这个属性，那么采用采用BinaryFormatter类或者SoapFormatter类来实现序列化时会报异常，但使用XmlSerializer 类序列化对象时可以不用这个属性。
2、另外，如果不想序列化某个字段，可以给其加上NonSerialized属性，这样在序列化时就不会保存这个这个字段的值了，比如不想序列化name这个字段，可以如下写代码：

view plaincopy to clipboardprint?
…//其它代码  
//[NonSerialized]  
private string name;  
…//其它代码 
…//其它代码
//[NonSerialized]
private string name;
…//其它代码
再次运行刚才的程序会得到如下效果：
 
看有黄色底线部分，因为name字段不被序列化，所以通过二进制序列化和SOAP序列化之后再反序化就得不到原来的值了。
3、最后还需要说明一点的是，SoapFormatter类在.net3.5开始已经过时了，微软建议使用BinaryFormatter类来序列化和反序列化了。

周公
2009-03-11 0:17


本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/zhoufoxcn/archive/2009/03/11/3978874.aspx

转载于:https://www.cnblogs.com/fightLonely/archive/2010/05/26/1744209.html

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/379206.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

递归-输出字符串所有的组合情况（代码、分析、汇编）

递归-输出字符串所有的组合情况（代码、分析、汇编）

目录&#xff1a;代码&#xff1a;分析&#xff1a;汇编&#xff1a;代码&#xff1a; #include <stdio.h>/*程序描述&#xff1a;输出字符串所有的组合情况使用permutation函数进行将指定的下标值&#xff0c;与最大下标值这个范围的每个下标值进行交换每调用一次permu…
阅读更多...
课本例子代码第四章

课本例子代码第四章

【例4.1】设计一个控制台应用程序&#xff0c;采用二分查找方法在给定的有序数组a中查找用户输入的值&#xff0c;并提示相应的查找结果。 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks;namespace C…
阅读更多...
一个简单的python日志服务器

一个简单的python日志服务器

一个简单的python日志服务器&#xff0c;主要目的是搜集各python logging记录的日志&#xff0c;将其简单汇总。源码如下&#xff1a; # -*- coding: utf-8 -*-Created on 2012-06-14 19:50 summary: a simple logging server. use gevent and logging modules author: JerryK…
阅读更多...
c#中queue_C＃中的Queue.Enqueue（）方法示例

c#中queue_C＃中的Queue.Enqueue（）方法示例

c#中queueC&#xff03;Queue.Enqueue()方法 (C# Queue.Enqueue() method) Queue.Enqueue() method is used to add an object/element at the end of the Queue. Queue.Enqueue()方法用于在Queue的末尾添加一个对象/元素。 Syntax: 句法&#xff1a; void Queue.Enqueue(Obj…
阅读更多...
C#调用Web Service时的身份验证

C#调用Web Service时的身份验证

转自&#xff1a;http://www.anqn.com/dev/vc/2010-01-23/a09122769.shtml 在项目开发&#xff0c;我们经常会使用WebService&#xff0c;但在使用WebService时我们经常会考虑以下问题&#xff1a;怎么防止别人访问我的WebService?从哪里引用我的WebService?对于第一个问题&a…
阅读更多...
递归-计算字符串长度（代码、分析、汇编）

递归-计算字符串长度（代码、分析、汇编）

目录&#xff1a;代码&#xff1a;分析&#xff1a;汇编&#xff1a;代码&#xff1a; main.c #include <stdio.h>//该程序用递归计算字符串长度int strlen(const char* s) {if( s NULL ){return -1;}else if( *s \0 ){return 0;}else{return strlen(s1) 1;} }int m…
阅读更多...
Java LinkedList void clear（）方法与示例

Java LinkedList void clear（）方法与示例

LinkedList void clear()方法 (LinkedList void clear() method) This method is available in package java.util.Collection and here, Collection is an interface. 该方法在java.util.Collection包中可用&#xff0c;在这里&#xff0c; Collection是一个接口。 This metho…
阅读更多...
Python-杨辉三角

Python-杨辉三角

在控制台输出如图所示一个8层的杨辉三角。 杨辉三角介绍&#xff1a; 每个数等于它上方两数之和 每行数字左右对称&#xff0c;由1开始逐渐变大 第n行的数字有n项&#xff0c;将n取8 def yanghui(n):l[1,1]for x in range(1,n):for a in range(x):l[a]l[a]l[a1]l.insert(0,1)…
阅读更多...
如何向妻子解释OOD（转）

如何向妻子解释OOD（转）

前言 此文译自CodeProject上<How I explained OOD to my wife>一文&#xff0c;该文章在Top Articles上排名第3&#xff0c;读了之后觉得非常好&#xff0c;就翻译出来&#xff0c;供不想读英文的同学参考学习。 作者(Shubho)的妻子(Farhana)打算重新做一名软件工程师(她…
阅读更多...
不安全代码和指针资料汇编

不安全代码和指针资料汇编

不安全代码和指针&#xff08;C# 编程指南&#xff09;为了保持类型安全&#xff0c;默认情况下&#xff0c;C# 不支持指针运算。不过&#xff0c;通过使用 unsafe 关键字&#xff0c;可以定义可使用指针的不安全上下文。有关指针的更多信息&#xff0c;请参见主题指针类型。 注…
阅读更多...
ffmpeg-从flv文件中提取AAC音频数据保存为文件

ffmpeg-从flv文件中提取AAC音频数据保存为文件

AAC ADTS格式协议&#xff1a; 从flv文件中提取AAC音频数据保存为文件。 如果需要详细了解AAC ADTS格式&#xff0c;可以查询文档。 原文件&#xff1a; 提取aac文件&#xff1a; main.c #include <stdio.h> #include <libavutil/log.h>> #include <lib…
阅读更多...
Python-统计《水调歌头·明月几时有》字符出现次数。

Python-统计《水调歌头·明月几时有》字符出现次数。

统计《水调歌头明月几时有》字符出现次数。 明月几时有&#xff0c;把酒问青天。 不知天上宫阙&#xff0c;今夕是何年&#xff1f; 我欲乘风归去&#xff0c;又恐琼楼玉宇&#xff0c;高处不胜寒。 起舞弄清影&#xff0c;何似在人间&#xff01; 转朱阁&#xff0c;低绮户&am…
阅读更多...
Linux网络编程入门 (转载)

Linux网络编程入门 (转载)

(一)Linux网络编程--网络知识介绍 Linux网络编程--网络知识介绍客户端和服务端 网络程序和普通的程序有一个最大的区别是网络程序是由两个部分组成的--客户端和服务器端. 客户端 在网络程序中&#xff0c;如果一个程序主动和外面的程序通信&#xff0c;那么我们…
阅读更多...
在Python中将字符串拆分为字符数组

在Python中将字符串拆分为字符数组

Given a string and we have to split into array of characters in Python. 给定一个字符串&#xff0c;我们必须在Python中拆分为字符数组。 将字符串拆分为字符 (Splitting string to characters) 1) Split string using for loop 1)使用for循环分割字符串 Use for loop t…
阅读更多...
SQL表值函数和标量值函数的区别 [转]

SQL表值函数和标量值函数的区别 [转]

SQL表值函数和标量值函数的区别 写sql存储过程经常需要调用一些函数来使处理过程更加合理&#xff0c;也可以使函数复用性更强&#xff0c;不过在写sql函数的时候可能会发现&#xff0c;有些函数是在表值函数下写的有些是在标量值下写的&#xff0c;区别是表值函数只能返回一个…
阅读更多...
N Queen（代码、分析、汇编）

N Queen（代码、分析、汇编）

目录&#xff1a;代码&#xff1a;分析&#xff1a;汇编&#xff1a;代码&#xff1a; main.c #include <stdio.h>/* 程序描述&#xff1a;输出N*N中符合左右对角线与上下左右方向都没被使用的位置在每一行的所有情况使用检测左上角&#xff0c;正上角&#xff0c;右上…
阅读更多...
kotlin 计算平方_Kotlin程序计算自然数之和

kotlin 计算平方_Kotlin程序计算自然数之和

kotlin 计算平方Given a number number, and we have to calculate the sum of all natural numbers from 1 to number. 鉴于一些数字 &#xff0c;我们必须从1计算所有自然数的总和数量 。 Example: 例&#xff1a; Input:number 15Output:120用于计算Kotlin中自然数之和的…
阅读更多...
Python-身份证核对

Python-身份证核对

中华人民共和国居民身份证号码由17 位数字和1位校验码组成。其中&#xff0c;前6位为所在地编号&#xff0c;第7~14 位为出生年月日&#xff0c;第15~17位为登记流水号&#xff0c;其中第17位偶数为女性&#xff0c;奇数为男性。校验码的生成规则如下: 将前面的身份证号码17位数…
阅读更多...
VC 加载套接字库

VC 加载套接字库

//加载套接字库 WORD wVersionRequested;//套接字库版本信息 WSADATA wsaData; int err; wVersionRequested MAKEWORD(1,1); err WSAStartup(wVersionRequested,&wsaData); if(err ! 0){ //加载失败 return; } if(LOBYTE(wsaData.wVersion) ! 1 || //判断是不是所请求的…
阅读更多...
统计各种字符个数

统计各种字符个数

#include <stdio.h> #include <conio.h>int main(int argc, char * argv[]) {char ch;int letters 0, space 0, digit 0, others 0;printf("请输入一组字符串:\n");while((chgetchar())!\n){if(ch>a && ch < z || ch >A &&…
阅读更多...
最新文章

Copyright @ 2022~2023