如何选择结构还是类求示例比较。

菜鸟回答：
每一个应用程序必然有一个类，却不一定有一个结构
结构是值类型，类是引用类型
类可以继承，结构不能
类中可以有无参构造函数，结构中的构造函数必须带参
应用上来讲:
结构通常应用于封装一组变量，适用于保存少量将来不会拓展的数据（也就是说不继承）

对于结构，我也很迷，因为使用的实在太少，我想如果将来会用到，可能就会理解加深了吧！

类属于引用类型的数据类型，结构体属于值类型的数据类型，这两种数据类型的本质区别主要是各自指向的内存位置不同。传递类的时候，主要表现为是否同时改变了源对象。类在传递的时候，传递的内容是位于托管内存中的位置，结构体在传递的时候，传递的内容是位于程序堆栈区的内容。当类的传递对象修改时，将同时修改源对象，而结构体的传递对象修改时，不会对源对象产生影响。
在一个类中，可以定义默认的、不带参数的构造函数，而在结构体中不能定义默认的、不带参数的构造函数。两者都可以定义带有参数的构造函数，通过这些参数给各自的字段赋值或初始化

1. using System;
   
2. using System.Collections.Generic;
   
3. using System.Linq;
   
4. using System.Text;
   
5. 
   
6. namespace 类对象
   
7. {
   
8. 
   
9.     //枚举  
   
10.     public enum Gender
    
11.     {
    
12.         男,
    
13.         女
    
14.     }
    
15.     //结构体
    
16.     public struct stuPerson
    
17.     {
    
18.         public string stuName;
    
19.         public int stuAge;
    
20.         public Gender stuSex;
    
21.         public void stuSayHello()
    
22.         {
    
23.             Console.WriteLine("我是{0},年龄{1},性别{2}", stuName, stuAge, stuSex);
    
24.         }
    
25. 
    
26.         //必须定义有参数的构造函数
    
27.         public stuPerson(string name, int age, Gender sex)
    
28.         {
    
29.             this.stuName = name;
    
30.             this.stuAge = age;
    
31.             this.stuSex = sex;
    
32.         }
    
33. 
    
34.     }
    
35.     class Program
    
36.     {
    
37.         static void Main(string[] args)
    
38.         {
    
39.             //实例化类
    
40.             Person Liuxiang = new Person();  //无参数的构造函数实例化的对象
    
41.             Liuxiang.Name = "刘翔";
    
42.             Liuxiang.Age = 30;
    
43.             Liuxiang.Sex = Gender.男;
    
44.             Liuxiang.SayHello();
    
45.             //声明另一个实例
    
46.             Person LXSon = Liuxiang;
    
47.             LXSon.Age = 10;
    
48.             //查看类 LiuXiang 和 LXSon中字段的值
    
49.             Console.WriteLine("LiuXiang 年龄{0}", Liuxiang.Age.ToString());  //10
    
50.             Console.WriteLine("LXSon 年龄{0}", LXSon.Age.ToString());    //10
    
51. 
    
52.             Console.WriteLine();
    
53.             //结构体
    
54.             stuPerson YaoMing = new stuPerson("姚明",33,Gender.男);
    
55.             YaoMing.stuSayHello();
    
56.             stuPerson YMSon = YaoMing;
    
57.             YMSon.stuAge = 13;
    
58.             //查看结构体中 YaoMing 和 YMSon中字段的值
    
59.             Console.WriteLine("YaoMing 年龄{0}", YaoMing.stuAge.ToString());  //10
    
60.             Console.WriteLine("YMSon 年龄{0}", YMSon.stuAge.ToString());    //10
    
61. 
    
62.             Console.ReadLine();
    
63. 
    
64. 
    
65. 
    
66.         }
    
67. 
    
68. 
    
69.     }
    
70. 
    
71.     class Person
    
72.     {
    
73. 
    
74.         //定义字段
    
75.         public string Name;
    
76.         public int Age;
    
77.         public Gender Sex;
    
78. 
    
79.         //定义方法
    
80.         public void SayHello()
    
81.         {
    
82.             Console.WriteLine("我是{0},年龄{1},性别{2}", this.Name, this.Age, this.Sex);
    
83.         }
    
84.         //无参数的构造函数
    
85.         public Person()
    
86.         {
    
87. 
    
88.         }
    
89.         //有参数的构造函数
    
90.         public Person(string name, int age, Gender sex)
    
91.         {
    
92.             this.Name = name;
    
93.             this.Age = age;
    
94.             this.Sex = sex;
    
95.         }
    
96. 
    
97. 
    
98.     }
    
99. 
    
100. }

复制代码

另外类可以实现继承接口，结构只能实现接口

   
   （１）class中默认的成员访问权限是private的，而struct中则是public的。   
   （２）从class继承默认是private继承，而从struct继承默认是public继承。   
一．类与结构的示例比较：   
     
  　　结构示例：        
   
  　　public   struct   Person   
  　　{   
     　　 string   Name;   
     　　 int   height;   
          int   weight   
  　　    public   bool   overWeight()
  　　    {
  　　      //implement   something   
  　　    }   
  　　}   
   
      
  　　类示例：     
     
  　　public   class   TestTime   
  　　{   
  　　   int   hours;  
  　　   int   minutes;
  　　   int   seconds;
  　　   public   void   passtime()   
  　　   {
  　　      //implementation   of   behavior   
  　　   }
  　　}   
  　　调用过程：
  　　public   class   Test   
  　　{
  　　 public   static   ovid   Main   
  　　 {   
  　　    Person   Myperson=new   Person   //声明结构
  　　    TestTime   Mytime=New   TestTime   //声明类
  　　  }  
  　　}