一个程序员的奋斗历程(续)
前段时间处理了很多事情，一直没有写下去，花光了所有的积蓄买了一套房子，同时把户口的事情也基本办完了，这几天稍微缓口气。昨天跟我的一个老上司见面聊了半天，心里感慨万千。他从外在条件看让不少外人羡慕，二十多岁做过到了863项目的负责人，博士毕业的爱人单位也非常好。现在三十出头的他在一个通信公司做产品经理，工资虽然不算高但也有一两万，而且还持有股份。但是我们了解的人才理解他的艰辛。“白领”这个词在一些人看来是仿佛是一个动人的光环，但是在我看来是一个无奈的名字，每天行走在大街上，来来往往的车流中有多少是“白领”的？又有几个“白领”住的起高档的住宅？在上海一套别墅300万不足为奇，按揭贷款下来总额接近600万，年薪二十万在上海算是一个中高级“白领”，高额的税金去掉了你百分之几十的收入后，这样算下来不吃不喝也要四十多年，加上生活的其他开支，注定了你与这样的住宅无缘。看着外面一套套别墅，一辆辆好车，我不知道它们是谁的，但我知道其中没有什么白领。我觉得自己很渺小，在这个喧闹的都市中我如同一只蚂蚁，但我有不甘于平凡，我不愿做一个单纯的“白领”。

　　其实很多朋友并不了解我，我不是一个追逐时尚技术的人，我只是不愿意做一个所谓的“白领”，更加不愿意做一个单纯的“程序员”。我不甘愿平凡的生活一辈子。我在不断的努力，我的方向非常明确，我要做多数人不做和做不到的事情，很多朋友对我这样频繁的换方向不理解，觉得一个人只要熟悉一种技术就可以了，对于这样的看法我只能说你浅薄，现在的大的系统和产品往往都是软件、硬件和应用相结合的，我要做的不是哪个方面的专家，而是希望能够成为系统设计师。我不相信一个只精通发动机的专家能够设计一辆好车，同样我也不相信对硬件一窍不通的人能做出一个操作系统，或者一个对财会没有一点概念的人能设计出一个优秀的财务软件。在工作中我发现社会上非常缺乏边缘人才，尤其是在国内。在国外一个人软硬件兼修非常普遍。如果设计产品的人只了解他的专业那么是很难有出色的设计。所以我必须趁着自己年轻学的更加广泛一些，这样才能提高自己的综合素质，这也是为什么高校那么多非专业课程。学习工作了这些年，实际上都没有脱离IT这个行业，我现在的公司开发一个系统时，先是将最终功能列举清楚并分析可行性，然后划分哪些是用芯片实现，哪些是用硬件电路实现，哪些是用软件实现，这样的设计才能做出最好的系统。如果一个设计者单纯只懂一个方面是不可能做到这一点的。

　　自负常常伴随着无知，记得我大学毕业时，论文答辩会上我和专家组组长争起来了，因为我对自己的设计非常得意，而他虽然是鸡蛋里挑骨头，但是由于知识非常有限，我无法回答他的问题，所以有些“恼羞成怒”。我原来一直喜欢用“所谓”最好的开发工具，记得做过一个愚蠢的设计，一个排课表的软件我用VC+Oracle开发。这些经历我牢记在心，时刻提醒自己学会谦虚。我的亲身经历加上我对一些身边朋友的观察发现这样一个现象。当一个人只会他认为最好的技术，而对其他的一无所知，这样的人经常是目空一切。
从第一个“Hello World”到今天的操作系统，前前后后写了很多代码，从这中间我也积累了很多心得。由于我是在没有人指导的情况下自学编码的，所以走了很多弯路，也犯了不少错误。最初我写程序全凭自己的感觉，写一个新程序对结构设计不很重视，以为学好语言，数据结构就可以写出好的程序，其实远不是这样的。没有设计的情况下，也可以写，但是程序无法写的很大、很复杂。我个人的经验是这样的系统超过8000行我就无法控制了，以前我用VC写过一个Windows下的应用程序，大概8000行左右我对它失去了控制，整个代码一团糟，这8000行倒是可以相对稳定的运行，但是我没有能力再增加什么新的代码，动辄前后冲突，要么就是新代码与旧设计格格不入，需要调整旧的程序。最开始我写程序喜欢追求代码的精巧，别人很多行写出来的代码自己只写很少就可以实现，感觉那样比较酷。其实这样也是非常错误的，我现在写程序非常注重结构设计，为了结构清晰我愿意牺牲一点效率。

　　下面一段话是我写程序的座右铭，希望与大家共勉：

　　Make it right before you make it faster.
　　Keep it right when you make it faster.
　　Make it clear before you make it faster.
　　Do not sacrifice clarity for small gains in efficiency.
　　Brian Kernighan

　　另外补充一点：我和我的女朋友现在非常好，双方的家人都认可了，我们决定在近期结婚。

第十四章 堆栈

一般来说堆栈指的是，临时寄存货物的地方，比如你正在读书，同房间的人请求你马上将垃圾袋拿出去，你放下手中的书并小心的做好标记，当你手提垃圾袋走到门边时，突然电话铃声响了，你放下垃圾袋，并留意一下垃圾袋的位置就去接电话，接完电话，回到放垃圾袋的地方然后把它拿出去，当你返回并从新坐下后，将书翻到原先读到的地方，又继续读起来。

计算机程序有时也需要停止当前所做的事情去处理其他任务，事实上函数调用就是告诉程序停止当前执行的函数，转向一个新的函数，正像你被打断前需要记住正在做的事情一样，程序在转向下一个函数之前，也需记录当前函数停在了什么地方以及其中各个变量的值，用来保存这些临时信息的数据结构在编程语言中叫堆栈。

堆栈是一个按后进先出(LIFO)方式工作的数据列表，当中断任务完成后，最后放进堆栈的数据一定是最先被弹出，就像盘中的一堆菜，最后放在上面的菜是最先要吃到的菜。堆栈通常是使用数组或链接表来建立的。

在命名空间System.Collections中，有专门用于堆栈的非泛型类Stack，另外在System.Collections.Generic命名空间中还有泛型类Stack。下面我们学习非泛型类Stack。

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
一 Stack 构造函数
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

语法1：
public Stack ()
 
说明：初始化 Stack 类的新实例，该实例为空并且具有默认初始容量。

语法2：

public Stack (int capacity)

参数
capacity：Stack 可包含的初始元素数。

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
二 常用方法
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

★  Stack.Push  

语法

public virtual void Push (Object obj)
 
参数
obj：要推入到 Stack 中的 Object。该值可以为空引用。

说明：将对象插入 Stack 的顶部。

示例1

using System;
using System.Collections;
public class SamplesStack
{
    public static void Main()
    {
        Stack myStack = new Stack();
        myStack.Push("1");
        myStack.Push("2");
        myStack.Push("3");
        foreach (Object i in myStack)
        {
            Console.WriteLine(" {0}", i);
        }
    }  
}

★ Stack.Pop

语法

public virtual Object Pop ()
 
返回值：返回从 Stack 的顶部移除的 Object。

示例2

using System;
using System.Collections;
public class SamplesStack
{
    public static void Main()
    {
        Stack myStack = new Stack();
        myStack.Push("1");
        myStack.Push("2");
        myStack.Push("3");
        foreach (Object i in myStack)
        {
            Console.WriteLine(" {0}", i);
        }
        //移除顶部的一个元素并返回它
        Console.WriteLine("(Pop)\t\t{0}", myStack.Pop());
        //验证移除
        foreach (Object i in myStack)
        {
            Console.WriteLine(" {0}", i);
        }
    }  

}

★ Stack.Peek

语法

public virtual Object Peek ()

返回值：位于 Stack 顶部的 Object但不将其移除。

示例3

using System;
using System.Collections;
public class SamplesStack
{
    public static void Main()
    {
        Stack myStack = new Stack();
        myStack.Push("1");
        myStack.Push("2");
        myStack.Push("3");
        foreach (Object i in myStack)
        {
            Console.WriteLine(" {0}", i);
        }
        //返回顶部的一个元素但不将其移除
        Console.WriteLine("(Peek)\t\t{0}", myStack.Peek());
        //验证
        foreach (Object i in myStack)
        {
            Console.WriteLine(" {0}", i);
        }
    }  

}

★ Stack.Contains

语法

public virtual bool Contains (Object obj)

参数
obj
要在 Stack 中查找的 Object。该值可以为空引用。

返回值
如果在 Stack 中找到 obj，则为 true；否则为 false。
 
说明

此方法确定某元素是否在 Stack 中。

示例4

using System;
using System.Collections;
public class SamplesStack
{
    public static void Main()
    {
        Stack myStack = new Stack();
        myStack.Push("a");
        myStack.Push("b");
        myStack.Push("c");
        foreach (Object i in myStack)
        {
            Console.WriteLine(" {0}", i);
        }
        Console.WriteLine("Contains返回值：{0}", myStack.Contains("a"));
    }

}

★ Object.Equals

语法1
 
public virtual bool Equals (Object obj)

语法2

public static bool Equals (Object objA,Object objB)

说明：确定两个 Object 实例是否相等。

示例5

using System;
public class Sample
{
    void Method()
    {
        Object Obj1 = new Object();
        Object Obj2 = new Object();
        Console.WriteLine(Obj1.Equals(Obj2));
        Console.WriteLine(Equals(Obj1,Obj2));
        Obj2 = Obj1;
        Console.WriteLine(Obj1.Equals(Obj2));
        Console.WriteLine(Equals(Obj1, Obj2));
    }
    static void Main()
    {
        Sample mySample = new Sample();
        mySample.Method();
    }
}

★ Stack.CopyTo

语法

public virtual void CopyTo (Array array,int index)

说明：
从指定数组索引开始将 Stack 复制到现有一维 Array 中，复制过程按后进先出的顺序进行，类似于连续调用 Pop 所返回的元素的顺序。

示例6

using System;
using System.Collections;
public class SamplesStack
{

    public static void Main()
    {
        Stack myStack = new Stack();
        myStack.Push("a");
        myStack.Push("b");
        myStack.Push("c");
        myStack.Push("d");
        myStack.Push("e");
        myStack.Push("f");

        //-------------------------------
        Object[] myarray = new Object[10];
        myarray[0] = "1";
        myarray[1] = "2";
        myarray[2] = "3";
        myarray[3] = "4";
        myarray[4] = "5";
      
       //-------------------------------
        myStack.CopyTo(myarray,4);
        foreach (Object obj in myarray)
        {
            System.Console.WriteLine(obj);
        }
    }
}

★ Stack.ToArray

语法
public virtual Object[] ToArray ()

返回值：返回新数组，包含 Stack 的元素的副本。

说明：将 Stack 复制到新数组中，复制过程按后进先出的顺序进行。

示例7

using System;
using System.Collections;
public class SamplesStack
{

    public static void Main()
    {
        Stack myStack = new Stack();
        myStack.Push("a");
        myStack.Push("b");
        myStack.Push("c");
        myStack.Push("d");
        myStack.Push("e");
        myStack.Push("f");
       //-------------------------------
        Object[] Myarray = myStack.ToArray();
        foreach (Object obj in Myarray)
        {
            System.Console.WriteLine(obj);
        }
    }
}

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
三 常用属性
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

★ Stack.Count 属性

语法：public virtual int Count { get; }

属性值：Stack 中包含的元素数。

说明：获取 Stack 中包含的元素数，Count 是 Stack 中实际存储的元素数，通常容量始终大于或等于 Count。

示例8

using System;
using System.Collections;
public class SamplesStack
{

    public static void Main()
    {
        Stack myStack = new Stack();
        myStack.Push("a");
        myStack.Push("b");
        myStack.Push("c");
        myStack.Push("d");
        myStack.Push("e");
        myStack.Push("f");
       //-------------------------------
        System.Console.WriteLine(myStack.Count);
       
    }
}

★ Stack.SyncRoot 属性

语法：public virtual Object SyncRoot { get; }

属性值：可用于同步对 Stack 的访问的 Object。

说明：

若要创建 Stack 的同步版本，请使用 Synchronized 方法。但是，派生类可以使用 SyncRoot 属性来提供它们自己的 Stack 同步版本。同步代码必须在 Stack 的 SyncRoot 上执行操作，而不是直接在 Stack 上执行操作。这确保了从其他对象派生的集合的正确操作。特别是，它维护了与其他线程的正确同步，这些线程可能同时正在修改 Stack 对象。

从头到尾对一个集合进行枚举本质上并不是一个线程安全的过程。即使一个集合已进行同步，其他线程仍可以修改该集合，这将导致枚举数引发异常。若要在枚举过程中保证线程安全，可以在整个枚举过程中锁定集合，或者捕捉由于其他线程进行的更改而引发的异常。

示例9

示例显示如何在整个枚举过程中使用 SyncRoot 锁定集合：

using System;
using System.Collections;
public class SamplesStack
{
    public static void Main()
    {
        Stack myStack = new Stack();
        myStack.Push("a");
        myStack.Push("b");
        myStack.Push("c");
        myStack.Push("d");
        myStack.Push("e");
        myStack.Push("f");
       //-------------------------------   
        lock (myStack.SyncRoot)
        {
            foreach (Object item in myStack)
            {
                System.Console.WriteLine(item);
            }
        }
    }
}

★ Stack.IsSynchronized 属性

语法：
public virtual bool IsSynchronized { get; }

属性值：
如果对 Stack 的访问是同步的（线程安全），则为 true；否则为 false。默认为 false。

说明：

若要保证 Stack 的线程安全，则必须通过由 Synchronized 方法返回的包装来执行所有操作。

示例10

using System;
using System.Collections;
public class SamplesStack
{

    public static void Main()
    {
        Stack myStack = new Stack();
        myStack.Push("The");
        myStack.Push("quick");
        myStack.Push("brown");
        myStack.Push("fox");
       //--------------------------------
        Stack mySyncdStack = Stack.Synchronized(myStack);
        Console.WriteLine("{0}",myStack.IsSynchronized);
        Console.WriteLine("{0}", mySyncdStack.IsSynchronized);
    }
}

补充：

数据在计算机内的存贮形式和数据的表示方法

一、内存的组织形式

⑴ 位  二进制数所表示的数据的最小单位，就是二进制的1位数，简称位（bit）。
计算机中的存贮器是由千千万万个小的电子线路单元组成的，每个单元称为一个“位”，它有两个稳定的工作状态（例如二极管或三极管的截止和导通，磁性元件的消磁与充磁等），分别以0和1表示，因此计算机存贮的信息是以二进制形式存贮的。内存贮器通常是由集成电路组成的，它包括几万、几十万、几百万甚至上亿个“位”。

⑵ 字节  为了便于管理，通常将8个“位”组成一个“字节”（byte）。也就是说一个字节可以放8个二进制数，如01100111，内存中存储数据时是以字节为单位的，字节是计算机中的最小存储单元。例如：一个字符占一个字节，一个整数占2个字节，一个实数占4个字节等。

⑶ 字长   若干个字节组成一个字（Word），其位数称为字长。一个“字”中可以存放一条计算机指令或一个数据，如果一个计算机系统以32个二进制的信息表示一条指令，就称这台计算机的“字长”为32位。通常所说的“32位机”就是以32位作为一个“字”的，一次传输的信息为32个位。

字长是计算机能直接处理的二进制数的数据位数，直接影响到计算机的功能、用途及应用领域。常见的字长有8位、16位、32位、64位等。

⑷ 字节、字的位编号

1个字节的位编号如下：               
B7  B6  B5  B4 B3  B2  B1  B0
高位字节               低位字节

2个字节（16位）组成的字的编号如下：
B15 B14 B13 B12 B11 B10 B9 B8 B7 B6 B5 B4 B3 B2 B1 B0
  高    位    字   节          低    位     字    节

我们把字最左边的一位称为最高有效位，最右边的一位称为最低有效位。在16位字中，我们称左边８位为高位字节，右边８位为低位字节。
 
⑸ 地址   每个字节有一个“地址”，只有通过地址才能找到某个存贮单元，并从中取数或向其存贮数据。计算机的整个内存被划分成若干个存储单元，每个存储单元可存放8位二进制数。每个存储单元可以存放数据或程序代码。为了能有效地存取该单元内存储的内容，每个单元必须有唯一的编号来标识，这个编号称为地址。

二、计算机中数据的表示

计算机最主要的功能是信息处理，要使计算机能处理信息，首先必须将各类信息转换成由二进制数0和1表示的代码，这一过程称为编码。计算机能处理的数据除了数值数据之外，更多的是字符、图像、图形、声音等非数值信息所对应的非数值数据。在计算机内部，各种信息都必须经过数字化编码后才能被传送、存储和处理。因此要了解计算机的工作原理，就必须了解编码知识，掌握信息编码的概念与处理技术是很重要的。

1、数字化编码的概念
所谓编码，就是采用少量的基本符号，按照一定的组合原则，表示大量复杂多样的信息。基本符号的种类和这些符号的组合规则是一切信息编码的两大要素。例如用26个英文字母表示英文词汇，用10个阿拉伯数码表示数字等，就是典型的编码例子。
在计算机中，广泛采用的是只用“0”和“1”两个基本符号组成的二进制码。
2、二进制数
(1) 二进制数的表示方法
数制，即进位计数制，是指用统一的符号规则来表示数值的方法。数制有多种形式。我们最熟悉的是十进制数，除习惯上使用的十进制数制外，计算机领域中更多是使用二进制、八进制和十六进制等数制。
数制中的三个术语：

⑴ 数位。数位是指数码在一个数中所处的位置，例如
数字 1235.67

处在0位上的数字是 5
处在1位上的数字是 3
....

处在-1位上的数字是 6
处在-2位上的数字是 7

通常小数点左侧的位数用n表示，右侧的位数用m表示。

⑵ 基数。基数是指在数位上所能使用的数码的个数，例如十进位计数制中，每个数位上可以使用的数码为0，1，2…9十个数码，即其基数为10。

⑶ 权位。一个数字放在不同的数位上，表示的大小是不一样的，例如数字6放在0位（个位）上，其大小为6，即6*10^0，放在1位（十位）上，表示60，即6*10^1;也就是说一个数字放在不同的数位上，其大小是该数字乘一个固定的数值，这个固定的数值叫位权；

位权 = 基数^n|m

十进制数有十个基本数码0、1、2、3、4、5、6、7、8、9，进位原则是逢10进1，基数为10，依照这个规律，二进制数的数码为0和1，进位原则是逢2进1，基数为2。十进制与二进制的表示方法如下。

十进制与二进制的对应关系表

十进制数  0  1   2   3   4   5   6   7    8    9
二进制数  0  1 10  11 100 101 110 111 1000  1001

(2) 计算机中为什么要使用二进制数

⑴ 实现容易。二进制数只有两个数码：0和1，而电子器件的物理状态有两种稳定状态的很多，从而实现容易。例如，晶体管的导通和截止、脉冲的有和无等等，都可以有来表示二进制的1和0。

⑵ 运算规则简单。例如，一位二进制数的加法运算和一位二进制数的乘法运算规则为：
        0+0=0                            0×0=0
        0+1=1+0=1                        0×1=1×0=0
        1+1=10（逢二向高位进一）         1×1=1
而减法和除法是加法和乘法的逆运算，根据上述规则，很容易实现二进制的四则运算。

⑶ 能方便使用逻辑代数。二进制数的0和1与逻辑代数“假”和“真”相对应，可使算术运算和逻辑运算共用一个运算器，易于进行逻辑运算。逻辑运算与算术运算的主要区别是：逻辑运算是按位进行的，没有进位和借位。

⑷ 记忆和传输可靠。电子元件对应的两种状态是一种质的区别，而不是量的区别，识别起来较容易。用来表示0和1的两种稳定状态的电子元件工作可靠、抗干扰强、存储和可靠性好，不易出错。

3、数制之间的转换

(1)十进制和二进制之间的转换

由于人们习惯于十进制，因此常常要进行十进制和二进制数的转换工作。只要记住二进制的最基本的规定是逢二进一。一个十进制整数化为二进制数只需将它一次又一次的被2除，得到的余数（从最后一次的余数读起）就是用二进制表示的数。例如：

得到 (11)10 =(1011)2
在上面的式子中，括号的注脚10或2分别表示括号中的数是十进制数或二进制数。

如果一个二进制整数要化为十进制数，课外要将它的最后一位乘以2^0,最后第二位乘以2^1，…依此类推，将各项相加就得到用十进制数表示的数。如：
(1011)2 = 1*2^3+0*2^2+1*2^1+1*2^0
        = 2^3+2^1+2^0
        = (11)10

(2)八进制

⑴ 八进制与二进制之间的转换

由于二进制写起来很长，很难记，为方便起见，二进制数由低向高每三位组成一组，如：10110101111可分为10，110，101，111四组，每一组代表一个0到7之间的数，因为3位的二进制数是不会等于或大于8的，(111)2=(7)10,也就是说，以三位二进制作为一组（位）的数是适八进一的。(8)10 = 2^3=(1000)2就需要4位二进制数表示，即要向前一组数进一位。这种逢八进一的数称为八进制数。现分别把上面的数据每3位一组用八进制表示：

二进制        10  110  101  111
八进制         2   6    5    7

八进制数和二进制数很容易互相转换，一个二进制数要转换为八进制数，只需将每3位二进制的数用一个八进制数表示即可。反之，如果知道一个八进制数，要转换为二进制数，只需将每位八进制数分别用3位二进制数表示即可。如八进制数10500用二制数表示：

八进制     1     0    5    0    0
二进制    001   000  101  000  000

即得：(001000101000000)2

⑵ 八进制与十进制数间的转换

八进制数转换为十进制数，它的基数为8，位权为8^n|m

(163. 24)8 = 1×8^2+6×8^1+3×8^0+2×8^-1+4×8^-2
             =(115.3125)10

反之，一个十进制数要转换为八进制数，只需将它不断除以8，其余数的排列（由最手一个余数开始）就是以八进制表示的数。如下所示：

(3)十六进制

⑴ 十六进制与二进制之间的转换

由于一个字节包含8个二进位，因此常把一个字节中的8位分成二组，每组4个位，如10110101可以分为1011和0101，两组之间用逗号分割，即 1011，0101 。第一组用一个数来代表，一个4位的二进制数不会超过十进制数15，因为(1111)2是十进制15，(16)10是(10000)2，超过4位了。为便于表示，规定0到15之间每一个数都用一个符号来表示，在16进制中以A，B，C，D，E，F 分别代表十进制数10，11，12，13，14，15.见下表：

二进制数      八进制数     十六进制数     十进制数

0000           00            0             0
0001           01            1             1
0010           02            2             2
0011           03            3             3
0100           04            4             4
0101           05            5             5
0110           06            6             6
0111           07            7             7
1000           10            8             8
1001           11            9             9
1010           12            A             10
1011           13            B             11
1100           14            C             12
1101           15            D             13
1110           16            E             14
1111           17            F             15
10000          20           10             16

如果有一个二进制数1010110000110111，可表示为：

二进制     1010   1100   0011  0111
十六进制     A      C      3     7

即得(1010110000110111)2 = (AC37)16

将一个十六进制数转换为二进制数，只需将其每一位分别转换为二进制数即可。例如：

十六进制     7      2      C      F
二进制     0111   0010   1100   1111

即得 (72CF)16 = (0111001011001111)2

每个十六进制数都就表示为4位二进制数，如2应表示为0010，而不应只写成10，否则就会丢失某些位。很容易看出：72CF点两个字节，即每两位十六进制数在内存中占一个字节。

⑵ 十六进制与十进制数间的转换

十六进制数的基数为16，权位为16^n|m

例如：(2BC.48)16 = 2*16^2+B*16^1+C*16^0+4*16^-1+8*16^-2
                 = (700.28125)10

反之，一个十进制数要转换成十六进制数，课外需将它不断除以16，取其余数由下到上顺序排列即可。如下所示：

即得(41700)10 = (A2E4)16

一个数或一个代码究竟以十进制形式表示或以八进制形式表示，或以十六进制形式表示，全视使用或阅读方便。

一般说，在计算机外部（例如在程序中的常量）用十进制数表示。表示内存中存贮情况用二进制、八进制或十六进制比较直观。其实，八进制和十六进制是二进制派生出来的，用八进制或十六进制的好处在于数的位数少，便于记忆和书写。例如十进制数245用二进制表示为八位（11111110），用八进制表示为3位（376），用十六进制表示只需2位（FE）。

在应用时，应弄清楚所用的数是以什么进制表示的（二进制？八进制？十六进制？或十进制？）对非十进制中的10和100应分别读作“壹零”和“壹零零”，而不要误读作“拾”和“壹佰”。

C# 也允许您重载运算符，以供您自己的类使用。这样做，可以使使用用户定义的数据类型就像使用基本数据类型一样自然、合理。例如，您可以创建一个名为 ComplexNumber 的新数据类型来表示一个复杂的数字，并提供使用标准算术运算符对此类数字执行数学运算的方法，如使用 + 运算符将两个复杂数字相加。

若要重载某个运算符，可以编写一个函数，在其命名运算符之后加上要重载的运算符的符号。例如，可按以下方法重载 + 运算符：

public static ComplexNumber operator+(ComplexNumber a, ComplexNumber b)

所有运算符重载均为类的静态方法。此外还应注意，重载相等运算符 (==) 时，还必须重载不相等运算符 (!=)。< 和 > 运算符以及 <= 和 >= 运算符也必须成对重载。

以下是可重载的运算符的完整列表：

•   一元运算符：+、-、!、~、++、--、true、false
•   二元运算符：+, -, *, /, %, &, |, ^, <<, >>, ==, !=, >, <, >=, <=

下面的代码示例创建一个重载 + 和 - 运算符的 ComplexNumber 类：

代码

public class ComplexNumber
{
    private int real;
    private int imaginary;

    public ComplexNumber() : this(0, 0)  // constructor
    {
    }

    public ComplexNumber(int r, int i)  // constructor
    {
        real = r;
        imaginary = i;
    }

    // Override ToString() to display a complex number in the traditional format:
    public override string ToString()
    {
        return(System.String.Format("{0} + {1}i", real, imaginary));
    }

    // Overloading '+' operator:
    public static ComplexNumber operator+(ComplexNumber a, ComplexNumber b)
    {
        return new ComplexNumber(a.real + b.real, a.imaginary + b.imaginary);
    }

    // Overloading '-' operator:
    public static ComplexNumber operator-(ComplexNumber a, ComplexNumber b)
    {
        return new ComplexNumber(a.real - b.real, a.imaginary - b.imaginary);
    }
}

使用这个类，您就可以用以下代码创建和操作两个复杂的数字：

代码

class TestComplexNumber
{
    static void Main()
    {
        ComplexNumber a = new ComplexNumber(10, 12);
        ComplexNumber b = new ComplexNumber(8, 9);

        System.Console.WriteLine("Complex Number a = {0}", a.ToString());
        System.Console.WriteLine("Complex Number b = {0}", b.ToString());

        ComplexNumber sum = a + b;
        System.Console.WriteLine("Complex Number sum = {0}", sum.ToString());

        ComplexNumber difference = a - b;
        System.Console.WriteLine("Complex Number difference = {0}", difference.ToString());
    }
}

如程序所示，您现在可以用非常直观的方式对属于 ComplexNumber 类的对象使用加减运算符。结果如下：

Complex Number a = 10 + 12i

Complex Number b = 8 + 9i

Complex Number sum = 18 + 21i

Complex Number difference = 2 + 3i

第十章 命名空间

★ Windows平台

我们经常使用的操作系统Windows是一个平台，它为Windows应用程序提供运行环境，在这个平台上包含了很多具有各种功能的代码块(类，函数等)，这些代码块组成了一个很大的库，叫 Windows API，我们经常使用的对话框窗口，文档接口窗口，组件服务等等都是Windows API的一部分。

★ .NET Framwork平台

.NET Framwork也是一个平台，它建立在Windows平台基础之上，在这个平台上除了可以应用Windows平台上的部分功能接口外，还提供了大量具有自己特色的功能块，这些功能块主要有类，接口等组成，为了更好的组织这些代码块，.NET Framwork对他们进行了分组管理，按照不同的需求把它们放到不同的容器中，这种包含特定代码块的容器叫做命名空间。

使用 C# 编程时，通过两种方式来大量使用命名空间。其一是使用命名空间来组织它的众多类，也就是在C#中预定义了许多命名空间，其二是在较大的编程项目中，声明自己的命名空间，用于帮助控制类名称和方法名称的范围，也就是可以自定义命名空间。

★ 访问命名空间

大多数 C# 应用程序从一个 using 指令节开始。该节列出应用程序将会频繁使用的命名空间，避免程序员在每次使用其中包含的方法时都要指定完全限定的名称。

示例

using System;
class Hello
{
    static void Main()
    {
        Console.WriteLine("Hello World!");
    }
}

说明：

在访问命名空间时，要使用using指令进行指定并且放在程序的开头，如果不在第一行指定命名空间，在输出语句中就必须书写命名空间的名称。

例如：

class Hello
{
    static void Main()
    {
        System.Console.WriteLine("Hello World!");
    }
}

★ 命名空间别名

从上面的示例中我们学会了使用using指令为程序指定要使用的命名空间，除此以外using指令还有一个功能，就是建立命名空间别名而引用命名空间，其格式如下：

using 别名 = 命名空间
using 别名 = 命名空间.类名

示例

现在我们为System.Console起一个别名，假如叫做Alias，则程序可以写为如下形式：

using Alias = System.Console;
class Hello
{  
    static void Main()
    {    
       Alias.WriteLine("Hello World!");
    }
}

★ 自定义命名空间

除了上面使用 using 指定使用内置命名空间外，在较大的编程项目中，声明自己的命名空间可以帮助控制类名称和方法名称的范围。命名空间声明使用namespace关键字，格式如下所示：

namespace 名称
{
   类型声明
}

示例

namespace SampleNamespace
{
    class SampleClass
    {
        public void SampleMethod()
        {
            System.Console.WriteLine("SampleNamespace");
        }
    }
}

★ 命名空间嵌套

实际上命名空间是用来表示一个范围的。在项目中创建范围的能力有助于组织代码，并提供创建全局唯一的类型的途径。

示例

示例中名为 myClass 的类在两个命名空间中定义，其中一个命名空间嵌套在另一个之内。. 运算符用于区分所调用的方法。

namespace N1
{
    class myClass
    {
        public void SampleMethod()
        {
            System.Console.WriteLine("SampleMethod1");
        }
    }

    namespace N2
    {
        class myClass
        {
            public void SampleMethod()
            {
                System.Console.WriteLine("SampleMethod2");
            }
        }
    }

    class Mainclass
    {
        static void Main(string[] args)
        {
            myClass uter = new myClass();
            outer.SampleMethod();
            N1.myClass outer2 =new myClass();
            outer2.SampleMethod();
            N2.myClass inner = new N2.myClass();
            inner.SampleMethod();

        }
    }
}

输出
SampleMethod1
SampleMethod1
SampleMethod2

★ 完全限定名

命名空间和类型的名称必须唯一，由指示逻辑层次结构的完全限定名描述。例如，语句 A.B 表示 A 是命名空间或类型的名称，而 B 则嵌套在其中。

下面的示例中有嵌套的类和命名空间。在每个实体的后面，需要完全限定名作为注释。

namespace N1     // N1
{
    class C1      // N1.C1
    {
        class C2   // N1.C1.C2
        {
        }
    }
    namespace N2  // N1.N2
    {
        class C2   // N1.N2.C2
        {
        }
    }
}

在以上代码段中要注意：

1 命名空间 N1 是全局命名空间的成员。它的完全限定名是 N1。

2 命名空间 N2 是命名空间 N1 的成员。它的完全限定名是 N1.N2。

3 类 C1 是 N1 的成员。它的完全限定名是 N1.C1。

在此代码中使用了两次 C2 类名。但是，完全限定名是唯一的。第一个类名在 C1 内声明；因此其完全限定名是：N1.C1.C2。第二个类名在命名空间 N2 内声明；因此其完全限定名是：N1.N2.C2。

使用以上代码段，可以用以下方法将新的类成员 C3, 添加到命名空间 N1.N2 内：

namespace N1.N2
{
    class C3   // N1.N2.C3
    {
    }
}

★ 隐藏全局命名空间

位于.NET Framwork根部的命名空间都是全局命名空间，当命名空间中的成员与全局命名空间同名时，就会隐藏全局命名空间的成员。

示例

在下面的代码中，Console 在 System 命名空间中解析为 TestApp.Console 而不是 Console 类型。

using System;
class TestApp
{
    public class System { }
    const int Console = 7;
    const int number = 66;
    static void Main()
    {
      
        //System.Console.WriteLine(number);
    }
}

由于类 TestApp.System 隐藏了 System 命名空间，因此使用 System.Console 会导致错误。

★ 引用全局命名空间

要将隐藏的全局命名空间显现出来，可以使用global:: 来引用全局命名空间。

示例

using System;
class TestApp
{
    public class System { }
    const int Console = 7;
    const int number = 66;
    static void Main()
    {
        global::System.Console.WriteLine(number);
    }
}

示例

使用::也可以引用命名空间别名

using Alias = System;
class TestApp
{
    public class System { }
    const int Console = 7;
    const int number = 66;
    static void Main()
    {
        Alias.Console.WriteLine(number);
        Alias::Console.WriteLine(number);
    }
}

★ 命名空间具有以下属性：

1 组织大型代码项目。

2 以 . 运算符分隔。

3 using directive 意味着不需要为每个类指定命名空间的名称。

4 global 命名空间是“根”命名空间：global::system 始终引用 .NET Framework 命名空间 System。

静态类与非静态类基本相同，但存在一个区别：静态类不能实例化。也就是说，不能使用 new 关键字创建静态类类型的变量。

因为没有实例变量，所以要使用类名本身访问静态类的成员。

例：

static class CompanyInfo

{

   public static string GetCompanyName() { return "CompanyName"; }

    public static string GetCompanyAddress() { return "CompanyAddress"; }

    //...

}

和所有类类型一样，当加载引用静态类的程序时，.NET Framework 公共语言运行时 (CLR) 将加载该静态类的类型信息。程序不能指定加载静态类的确切时间。但是，可以保证在程序中首次引用该类前加载该类，并初始化该类的字段并调用其静态构造函数。静态构造函数仅调用一次，在程序驻留的应用程序域的生存期内，静态类一直保留在内存中。

对于只对输入参数进行运算而不获取或设置任何内部实例字段的方法集，静态类可以方便地用作这些方法集的容器。例如，在 .NET Framework 类库中，静态类 System.Math 包含的一些方法只执行数学运算，而无需存储或检索特定 Math 类实例特有的数据。

静态类的主要特性：

仅包含静态成员。

无法实例化。

是密封的。

不能包含实例构造函数。

创建静态类（A）与创建仅包含静态成员和私有构造函数的类（B）基本相同，私有构造函数阻止类被实例化。出现B这种情况易选用A。

使用静态类的优点在于，编译器能够执行检查以确保不致偶然地添加实例成员。编译器将保证不会创建此类的实利。

静态类是密封的，因此不可被继承。它们不能从除 Object 外的任何类中继承。静态类不能包含实例构造函数，但可以包含静态构造函数。如果非静态类包含需要进行重要的初始化的静态成员，也应定义静态构造函数。

    下面是一个静态类的示例，它包含两个在摄氏温度和华氏温度之间执行来回转换的方法：

public static class TemperatureConverter

{

    public static double CelsiusToFahrenheit(string temperatureCelsius)

    {

        // Convert argument to double for calculations.

        double celsius = Double.Parse(temperatureCelsius);

        // Convert Celsius to Fahrenheit.

        double fahrenheit = (celsius * 9 / 5) + 32;

        return fahrenheit;

    }

    public static double FahrenheitToCelsius(string temperatureFahrenheit)

    {

        // Convert argument to double for calculations.

        double fahrenheit = Double.Parse(temperatureFahrenheit);

        // Convert Fahrenheit to Celsius.

        double celsius = (fahrenheit - 32) * 5 / 9;

        return celsius;

    }

}

class TestTemperatureConverter

{

    static void Main()

    {

        Console.WriteLine("Please select the convertor direction");

        Console.WriteLine("1. From Celsius to Fahrenheit.");

        Console.WriteLine("2. From Fahrenheit to Celsius.");

        Console.Write(":");

        string selection = Console.ReadLine();

        double F, C = 0;

        switch (selection)

        {

            case "1":

                Console.Write("Please enter the Celsius temperature: ");

                F = TemperatureConverter.CelsiusToFahrenheit(Console.ReadLine());

                Console.WriteLine("Temperature in Fahrenheit: {0:F2}", F);

                break;

            case "2":

                Console.Write("Please enter the Fahrenheit temperature: ");

                C = TemperatureConverter.FahrenheitToCelsius(Console.ReadLine());

                Console.WriteLine("Temperature in Celsius: {0:F2}", C);

                break;

            default:

                Console.WriteLine("Please select a convertor.");

                break;

        }

        // Keep the console window open in debug mode.

        Console.WriteLine("Press any key to exit.");

        Console.ReadKey();

    }

}

/* Example Output:

    Please select the convertor direction

    1. From Celsius to Fahrenheit.

    2. From Fahrenheit to Celsius.

    :2

    Please enter the Fahrenheit temperature: 20

    Temperature in Celsius: -6.67

    Press any key to exit.

 */

静态成员

非静态类可以包含静态的方法、字段、属性或事件。即使没有创建类的实例，也可以调用该类中的静态成员。始终通过类名而不是实例名称访问静态成员。

无论对一个类创建多少个实例，它的静态成员都只有一个副本。

静态方法和属性不能访问其包含类型中的非静态字段和事件，并且不能访问任何对象的实例变量（除非在方法参数中显式传递）。

更常见的做法是声明具有一些静态成员的非静态类，而不是将整个类声明为静态类。静态字段有两个常见的用法：一是记录已实例化对象的个数，二是存储必须在所有实例之间共享的值。

静态方法可以被重载但不能被重写，因为它们属于类，不属于类的任何实例。

虽然字段不能声明为 static const，但 const 字段的行为在本质上是静态的。这样的字段属于类型，不属于类型的实例。因此，可以同对待静态字段一样使用 ClassName.MemberName 表示法来访问 const 字段。不需要对象实例。

C# 不支持静态局部变量（在方法范围内声明的变量）。

通过在成员的返回类型之前使用 static 关键字可以声明静态类成员，如下面的示例所示：

public class Automobile

{

    public static int NumberOfWheels = 4;

    public static int SizeOfGasTank

    {

        get

        {

            return 15;

        }

    }

    public static void Drive() { }

    public static event EventType RunOutOfGas;

    // Other non-static fields and properties...

}

静态成员在第一次被访问之前并且在调用静态构造函数（如有存在）之前进行初始化。若要访问静态类成员，应使用类名而不是变量名来指定该成员的位置，如下面的示例所示：

Automobile.Drive();

int i = Automobile.NumberOfWheels;

如果类包含静态字段，请提供在加载类时初始化这些字段的静态构造函数。

对静态方法的调用以 Microsoft 中间语言 (MSIL) 生成调用指令，而对实例方法的调用生成 callvirt 指令，该指令还检查 null 对象引用。但是，两者之间的性能差异在大多数时候并不明显。

int i;
for (i = 0; i < 10; i++)
{
   string text = "Line " + Convert.ToString(i);
   Console.WriteLine("{0}", text);
}
Console.WriteLine("Last text output in loop: {0}", text);

字符串变量text是for循环的局部变量，这段代码不能编译，因为在该循环外部调用的Console.WriteLine()试图使用该变量text，这超出了循环的作用域。修改代码，如下所示：

int i;
string text;
for (i = 0; i < 10; i++)
{
   text = "Line " + Convert.ToString(i);
   Console.WriteLine("{0}", text);
}
Console.WriteLine("Last text output in loop: {0}", text);

这段代码也会失败，原因是变量必须在使用前声明和初始化，而text是在for循环中初始化的。赋给text的值在循环块退出时就丢失了。但是还可以进行如下修改：

int i;
string text = "";
for (i = 0; i < 10; i++)
{
   text = "Line " + Convert.ToString(i);
   Console.WriteLine("{0}", text);
}
Console.WriteLine("Last text output in loop: {0}", text);

这次text是在循环外部初始化的，可以访问它的值。这段简单代码的结果如图6-6所示。

图 6-6

在循环中最后赋给text的值可以在循环外部访问。

可以看出，这个主题的内容需要花一点时间来掌握。在前面的示例中，循环之前赋给text空字符串，而在循环之后的代码中，该text就不会是空字符串了，其原因不能立即看出。

这种情况的解释涉及到分配给text变量的内存空间，实际上任何变量都是这样。只声明一个简单的变量类型，并不会引起其他的变化。只有在给变量赋值后，这个值才占用一块内存空间。如果这种占据内存空间的行为在循环中发生，该值实际上定义为一个局部值，在循环的外部会超出了其作用域。

即使变量本身没有局部化到循环上，循环所包含的值也局部化到该循环上。但是，在循环外部赋值可以确保该值是主体代码的局部值，在循环内部它仍处于其作用域中。这意味着变量在退出主体代码块之前是没有超出作用域的，所以可以在循环外部访问它的值。

幸而，C#编译器可检测变量作用域的问题，它生成的响应错误信息可以帮助我们理解变量作用域的问题。

最后一个要注意的问题是，应采用“最佳实践”。一般情况下，最好在声明和初始化所有的变量后，再在代码块中使用它们。一个例外是把循环变量声明为循环块的一部分，例如：

for (int i = 0; i < 10; i++)
{
   ...
}

其中i局部化于循环代码块中，但这是可以的，因为我们很少需要在外部代码中访问这个计数器。

－域表示与对象或类相关联的变量。

－域的声明中如果加上了readonly修饰符，表明该域为只读域。对于只读域我们只能在域的定义中和它所属类的构造函数中进行修改。在其他情况下，域是“只读”的。

－static readonly的作用和#define、const的作用类似。区别是：const型表达式的值是在编译时形成的，而static readonly表达式的值直到程序运行时才形成。如：

public class A

{

public static readonly int X = 1;

}

－C/C＋＋中未经初始化的变量是不能使用的。在C＃中，系统将为每个未经初始化的变量提供一个默认值。对于所有引用类型的变量，默认值是null。所有值类型的变量的默认值是固定的。对于静态域，类在装载时对其进行初始化；对于非静态域，在类的实例创建时进行初始化。在默认的初始化之前，域的值是不可预测的。

例如下面的代码是合法的：

class Test

{

       static int a = b+ 1;

       static int b = a+ 1;

}

实际上等价于：a = 1; b = 2;

而下面的代码则是非法的：

class A