四川盐亭网站制作公司

C#结构的学习

结构是程序员定义的数据类型，非常的类似于类。有数据成员和函数成员。

成都创新互联公司基于分布式IDC数据中心构建的平台为众多户提供德阳服务器托管 四川大带宽租用 成都机柜租用 成都服务器租用。

但是也有区别：

1）类是引用类型，而结构是值类型；

2）结构是隐式密封的，不能被派生；

语法声明与类相似：

 

  1. //结构的声明 
  2.         struct StructName 
  3.         { 
  4.             //包含的成员变量 
  5.         } 

看下边的示例代码来演示C#结构的使用方法：

 

  1. static void Main(string[] args) 
  2.         { 
  3.             Point first, second, third; 
  4.             first.x = 10; first.y = 10; 
  5.             second.x = 20; second.y = 20; 
  6.             third.x = first.x + second.x; 
  7.             third.y = first.y + second.y; 
  8.  
  9.             Console.WriteLine("first:{0},{1}",first.x,first.y); 
  10.             Console.WriteLine("second:{0},{1}",second.x,second.y); 
  11.             Console.WriteLine("third:{0},{1}",third.x,third.y); 
  12.             Console.ReadKey(); 
  13.         } 
  14.  
  15.         struct Point 
  16.         { 
  17.             public int x; 
  18.             public int y; 
  19.         } 

结构是值类型

 

1）结构类型的变量不能使null；

2）两个结构变量不能引用同一对象

 

  1. static void Main(string[] args) 
  2.         { 
  3.             CSimple cs1 = new CSimple(),cs2=null; 
  4.             Simple ss1 = new Simple(),ss2=new Simple(); 
  5.  
  6.             cs1.x = ss1.x = 5; 
  7.             cs1.y = ss1.y = 10; 
  8.             cs2 = cs1;   //赋值类实例 
  9.             ss2 = ss1;   //赋值结构实例 
  10.  
  11.         } 
  12.  
  13.         class CSimple 
  14.         { 
  15.             public int x; 
  16.             public int y; 
  17.         } 
  18.  
  19.         struct Simple 
  20.         { 
  21.             public int x; 
  22.             public int y; 
  23.         } 

 

先创建一个CSimple类，和一个Simple结构

 

在Main（）分别对它们实例化声明两个个变量后，cs1和cs2分别指向在堆中的引用，而ss1和ss2分别在栈中分配空间并存储。
把一个结构赋值给另外一个结构，就是从一个结构中把值复值给另外一个结构。与类不同的是，复制类变量时只有引用被复制。

如上面的代码，类赋值结束后，cs2和cs1指向堆中的同一个对象。但是在结构赋值结束后，ss2成员的值和ss1成员的值相同。

 

结构中的构造函数和析构函数

语言隐式的为每个结构提供一个无参数的构造函数。这个构造函数把结构的每个成员设置为该类型的默认值，引用成员被设置成null

预定义的无参数构造函数对每个结构都存在，而且不能删除或者重新定义。但是可以创建另外的构造函数，只要他们有参数。这和类不同，对于类，编译器只在没有其它构造函数声明时提供隐式的无参数构造函数。

要调用一个构造函数，包括隐式的无参数构造函数，要使用new运算符。即使不从堆中分配内存也使用new运算符。

如下面的实例：

 

  1. static void Main(string[] args) 
  2.         { 
  3.  
  4.             Simple s1 = new Simple();  //调用隐式的构造函数 
  5.             Simple s2 = new Simple(5, 10);  //调用构造函数 
  6.             Console.WriteLine("{0},{1}",s1.x,s1.y); 
  7.             Console.WriteLine("{0},{1}", s2.x, s2.y); 
  8.              
  9.             Console.ReadKey(); 
  10.         } 
  11.  
  12.         struct Simple 
  13.         { 
  14.             public int x; 
  15.             public int y; 
  16.  
  17.             public Simple(int a, int b) 
  18.             { 
  19.                 x = a; 
  20.                 y = b; 
  21.             } 
  22.         } 

 

也可以不适用new运算符创建结构的实例。但是，有一些限制：

 

1）不能使用数据成员的值，直到显示的设置它

2）不能调用任何函数成员，直到所有数据成员已经被赋值

 

  1. static void Main(string[] args) 
  2.         { 
  3.  
  4.             Simple s1, s2; 
  5.             Console.WriteLine("{0},{1}", s1.x, s1.y);//编译错误,s1.x, s1.y还没有被赋值 
  6.  
  7.             s2.x = 50; 
  8.             s2.y = 10; 
  9.             Console.WriteLine("{0},{1}", s2.x, s2.y); 
  10.  
  11.        
  12.             Console.ReadKey(); 
  13.         } 
  14.  
  15.         struct Simple 
  16.         { 
  17.             public int x; 
  18.             public int y; 
  19.         } 

 

 

 

原创作品，允许转载，转载时请务必以超链接形式标明文章 原始出处 、作者信息和本声明。

C#结构的学习
 

 


网站栏目：C#结构的学习
网页网址：http://scyanting.com/article/gdhjos.html

其他资讯