这个东西,没理解前感觉很难,理解了觉得简单。个人感觉就1点:*内容和&地址。&获取一个十进制的uint地址,而*获得地址的内容。

 


<!--

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

-->    /// 
    
/// 指针,存储的是一个地址的整数。
    
/// 

    class Program
    {
        
delegate void Methods();

        
static void Main(string[] args)
        {
            Demo6();
            Console.ReadKey();
        }

        
static void S(object o)
        {
            Console.WriteLine(o.ToString());
        }

        
static void S(params object[] o)
        {
            
foreach (object obj in o)
                S(obj);
        }

        
#region 指针简单示例
        
unsafe static void Demo1()
        {
            
int x = 10;//整数类型
            int* pX, pY;//指针坐标X、Y
            pX = &x;//取pX地址
            pY = pX;//将pX赋值给pY

            x 
= 15;
            
*pX = 16;
            
*pY = 17;

            S(x);
            S(
*pX);//取得地址的内容
            S(*pY);
        }
        
#endregion

        
#region 指针的类型转换
        
unsafe static void Demo2()
        {
            
//NOTE:类型转换后,uint获得的是地址的十进制格式,并非获取地址的内容。

            
int x = 10;//整数类型
            int* pX, pY;//指针坐标X、Y
            pX = &x;//取pX地址
            pY = pX;//将pX的地址赋值给pY
            uint ux = (uint)pX;//类型转换,获取地址的十进制
            int* pZ = (int*)ux;//类型转换,将地址赋值给pZ

            S(x);
            S(((
uint)pX).ToString("x"));//十六进制内存地址
            S((uint)pY);//十进制内存地址
            S(ux);
            S((
uint)pZ);//十进制内存地址
            S(*pZ);//输出地址的内容
        }
        
#endregion

        
#region DWORD内存块
        
unsafe static void Demo3()
        {
            
decimal m2 = 4.00m;
            
byte b = 100;
            
short s = 200;
            
int i = 300;
            
long l = 400;

            
float f = 1.00f;
            
double d = 2.00;
            
decimal m = 3.00m;

            
            S(
string.Format("byte:{0}"sizeof(byte)));
            S(
string.Format("short:{0}"sizeof(short)));
            S(
string.Format("int:{0}"sizeof(int)));
            S(
string.Format("long:{0}"sizeof(long)));
            S(
string.Format("float:{0}"sizeof(float)));
            S(
string.Format("double:{0}"sizeof(double)));
            S(
string.Format("decimal:{0}"sizeof(decimal)));
            S(
"");
            S(
"从高到矮……");
            S(
string.Format("decimal:{0} +16  ↑", (uint)&m2));
            S(
string.Format("byte:{0} +1  ↑", (uint)&b));
            S(
string.Format("short:{0}  +2  ↑", (uint)&s));
            S(
string.Format("int:{0}  +4  ↑", (uint)&i));
            S(
string.Format("long:{0}  +8  ↑", (uint)&l));
            S(
string.Format("float:{0}  +4  ↑", (uint)&f));
            S(
string.Format("double:{0}  +8  ↑", (uint)&d));
            S(
string.Format("decimal:{0}  +16  ↑", (uint)&m));
            S(
"有没有发现byte和short也是4个字节的内存块?因为.NET约定,最少要占用4个字节。");
        }
        
#endregion

        
#region 指针的运算
        
unsafe static void Demo4()
        {

            
byte b = 8;
            
uint u = 3;
            
double d = 10.0;

            
byte* pByte = &b;
            
uint* pUint = &u;
            
double* pDouble = &d;
            S(
string.Format("byte:{0}", (uint)pByte));
            S(
string.Format("uint:{0}", (uint)pUint));
            S(
string.Format("double:{0}", (uint)pDouble));
            pByte 
-= 3;
            
++pUint;
            S(
"\n");
            
double* pDouble2 = pDouble + 4;
            S(
string.Format("byte:{0}。old - 3 * 1", (uint)pByte));
            S(
string.Format("uint:{0}。old + 4 * 1", (uint)pUint));
            S(
string.Format("double2:{0}。pDouble + 4 * 8", (uint)pDouble2));

        }
        
#endregion

        
#region 结构指针
        
unsafe static void Demo5()
        {
            
            MyStruct ms 
= new MyStruct();
            MyStruct
* pms = &ms;
            (
*pms).X = 5;//传统方式
            pms->= 10;//与C++雷垃圾广告式

            S(ms.X);
            S(ms.Y);

            
int* X = &(pms->X);
            S(
*X);
            
*= 15;
            S(
*X);
            S(ms.X);
        }

        
struct MyStruct
        {
            
public int X;
            
public int Y;
        }
        
#endregion

        
#region 类指针
        
unsafe static void Demo6()
        {
            MyClass mc 
= new MyClass();
            
//MyClass* pmc = &mc;//error,无法获取托管类型,因为它们嵌入一个对象。(结构是值类型)
            fixed (int* X = &(mc.X))
            
fixed (int* Y = &(mc.Y))//*X和*Y固定或者fixed (int* X = &(mc.X), Q = &(mc.Y))。唯一限制,数据类型必须都是int*。
            {
                
*= 5;
                
*= 6;
                S(mc.X 
+ "<-X  Y-> " + mc.Y);
                
fixed (int* Z = &(mc.Z))//*Z固定在X中。生命周期在于X、Y之间。
                {
                    
*= 7;
                    
*= 8;
                    
*= 9;
                    S(mc.X 
+ "<-X  Y-> " + mc.Y + "  Z->" + mc.Z);
                }
                
*= 10;
                
*= 11;
                S(mc.X 
+ "<-X  Y-> " + mc.Y);
            }

        }
        
class MyClass
        {
            
public int X;
            
public int Y;
            
public int Z;
        }
        
#endregion