雅虎公司C#笔试题  (转自:http://www.chinacs.net/)

雅虎公司C#笔试题，包括问答题和选择题两部分。试试看，你能回答出多少题，可以通过雅虎的考试吗？

Question 1. (单选)

在计算机网络中,表征数据传输可靠性的指标是

1. 传输率

2. 误码率

3. 信息容量

4. 频带利用率

Question 2. (单选)

以下关于链式存储结构的叙述中哪一条是不正确的?

1. 结点除自身信息外还包括指针域,因此存储密度小于顺序存储结构

2. 逻辑上相邻的结点物理上不必邻接

3. 可以通过计算直接确定第i个结点的存储地址

4. 插入、删除运算操作方便,不必移动结点

Question 3. (单选)

以下哪一个不是栈的基本运算

1. 删除栈顶元素

2. 删除栈底元素

3. 判断栈是否为空

4. 将栈置为空栈

Question 4. (单选)

以下关于广义表的叙述中,正确的是

1. 广义表是0个或多个单元素或子表组成的有限序列

2. 广义表至少有一个元素是子表

3. 广义表不可以是自身的子表

4. 广义表不能为空表

Question 5. (单选)

如果一棵二叉树结点的前序序列是A、B、C,后序序列是C、B、A,则该二叉树结点的对称序序列

1. 必为A、B、C

2. 必为A、C、B

3. 必为B、C、A

4. 不能确定

Question 6. (单选)

在虚拟页式存储管理方案中,下面哪一部分完成将页面调入内存的工作?

1. 缺页中断处理

2. 页面淘汰过程

3. 工作集模型应用

4. 紧缩技术利用

Question 7. (单选)

在DOS系统中,用于记录和管理磁盘数据区使用情况的数据结构

1. 位图表

2. 空闲块表

3. 文件分配表

4. 文件控制块

Question 8. (单选)

设有关系R(S,D,M),其函数依赖集F={S→D,D→M}。则关系R至多满足

1. 1NF

2. 2NF

3. 3NF

4. BCNF

Question 9. (单选)

在数据库逻辑设计中,当将E-R图转换为关系模式时,下面的做法哪一个是不正确的?

1. 一个实体类型转换为一个关系模式

2. 一个联系类型转换为一个关系模式

3. 由实体类型转换成的关系模式的主键是该实体类型的主键

4. 由联系类型转换成的关系模式的属性是与该联系类型相关的诸实体类型的属性的全体

Question 10. (单选)

计算机网络按照所覆盖的地理范围分类,可以分广域网、局域网与

1. TCP/IP网

2. ATM网

3. ISDN

4. 城域网

Question 11. (单选)

计算机网络拓扑结构主要取决于它的

1. 资源子网

2. FDDI网

3. 通信子网

4. 路由器

Question 12. (单选)

网络协议的三个要素是语法、语义与

1. 工作原理

2. 时序

3. 进程

4. 服务原语

Question 13. (单选)

TCP/IP参考模型中,电子邮件协议SMTP依赖于传输层的

1. UDP协议

2. IP协议

3. TCP协议

4. 802.2协议

Question 14. (单选)

IEEE802.2协议中10BASE-T标准规定在使用5类双绞线时,从网卡到集线器的最大距离为

1. 100m

2. 185m

3. 300m

4. 500m

Question 15. (单选)

100Mbps Fast Ethernet与10Mbps Ethernet 工作原理的相同之处主要在

1. 介质访问控制方法

2. 物理层协议

3. 网络层

4. 发送时钟周期

Question 16. (单选)

在Client/Server计算模式中,中间件middleware的作用是隔离应用与

1. 结构化查询语言SQL

2. 应用进程

3. 网络

4. IP地址

Question 17. (单选)

当用户向ISP申请Internet帐户时,用户的E-mail帐户应包括

1. IP地址

2. WWW地址

3. 用户密码(Password)

4. 用户名(User Name)与用户密码(Password)

Question 18. (单选)

WWW的超链接中定位信息所在的位置使用的是

1. 超文本(hypertext)技术

2. 统一资源定位器(URL, Uniform Resource Locators)

3. 超媒体(hypermedia技术)

4. 超文本标注语言HTML

Question 19. (单选)

计算机网络系统与分布式系统之间的区别主要是

1. 系统物理结构

2. 系统高层软件

3. 传输介质类型

4. 服务器类型

Question 20. (单选)

帧中继系统设计的主要目标是用于互连多个

1. 广域网

2. 电话网

3. 局域网

4. 0)ATIM网

Question 21. (单选)

ATM网络采用固定长厦的信元传送数据，信元长度为

1. 1024B

2. 53B

3. 128B

4. 64B

Question 22. (单选)

TCP/IP参考模型中的主机-网络层对应于OSI RM中的

1. 网络层

2. 物理层

3. 数据链路层

4. 物理层与数据链路层

Question 23. (单选)

计算机网络最突出的优点是：

1. 计算精度高

2. 内存容量大

3. 运算速度快

4. 连网的计算机能够相互共享资源

Question 24. (单选)

计算机网络分为局域网、城域网与广域网，其划分的依据是：

1. 数据传输所使用的介质

2. 网络的作用范围

3. 网络的控制方式

4. 网络的拓扑结构

Question 25. (单选)

用二分法查找一个长度为10的、排好序的线性表，查找不成功时，最多需要比较多少次？

1. 5

2. 2

3. 4

4. 1

Question 26. (单选)

模块内聚度越高，说明模块内各成分彼此结合的程度越

1. 松散

2. 紧密

3. 无法判断

4. 相同

Question 27. (单选)

软件需求分析阶段的输出主要是

1. 需求说明书

2. 开发计划

3. 可行性报告

4. 设计说明书

Question 28. (单选)

以下选项中不是项目经理的职责的是？

1. 需求分析

2. 计划

3. 计划跟踪

4. 质量管理

Question 29. (单选)

单元测试一般在什么时候进行？

1. 编码完成后

2. 系统测试前

3. 测试用例编写完成后

4. 集成测试后

Question 30. (多选)

配置管理能起到以下哪些作用？

1. 版本管理

2. 变更管理

3. 需求管理

4. 测试管理

Question 31. (单选)

根据线程安全的相关知识，分析以下代码，当调用test方法时i>10时是否会引起死锁?

public void test(int i)

{

lock(this)

{

if (i>10)

{

i--;

test(i);

}

}

}

1. 会锁死

2. 不会锁死

Question 32. (单选)

以下描述错误的是（）

1. 在C++中支持抽象类而在C#中不支持抽象类。

2. C++中可在头文件中声明类的成员而在CPP文件中定义类的成员，在C#中没有头文件并且在同一处声明和定义类的成员。

3. 在C#中可使用 new 修饰符显式隐藏从基类继承的成员。

4. 在C#中要在派生类中重新定义基类的虚函数必须在前面加Override。

Question 33. (单选)

int[][] myArray3=new int[3][]{new int[3]{5,6,2},new int[5]{6,9,7,8,3},new int[2]{3,2}}; myArray3[2][2]的值是（）。

1. 9

2. 2

3. 6

4. 越界

Question 34. (单选)

在C#中利用Socket进行网络通信编程的一般步骤是：建立Socket侦听、（ ）、利用Socket接收和发送数据。

1. 建立Socket连接

2. 获得端口号；

3. 获得IP地址；

4. 获得主机名；

Question 35. (单选)

如果设treeView1=new TreeView(),TreeNode node=new TreeNode("根结点" )，则treeView1.Nodes.Add(node)返回的是一个 ()类型的值。

1. TreeNode；

2. int；

3. string；

4. TreeView；

Question 36. (单选)

声明一个委托public delegate int myCallBack(int x); 则用该委托产生的回调方法的原型应该是

1. void myCallBack(int x)

2. int receive(int num)

3. string receive(int x)

4. 不确定的

Question 37. (单选)

关于ASP.NET中的代码隐藏文件的描述正确的是

1. Web窗体页的程序的逻辑由代码组成，这些代码的创建用于与窗体交互。编程逻辑唯一与用户界面不同的文件中。该文件称作为“代码隐藏”文件，如果用C＃创建，该文件

2. 项目中所有Web窗体页的代码隐藏文件都被编译成.EXE文件

3. 项目中所有的Web窗体页的代码隐藏文件都被编译成项目动态链接库（.dll）文件

4. 以上都不正确

Question 38. (单选)

What compiler switch creates an xml file from the xml comments in the files in an assembly?

1. /text

2. /doc

3. /xml

4. /help

Question 39. (单选)

下面的代码实现了设计模式中的什么模式

public class A {

private A instance;

private A() {

}

public static A Instance {

get

{

if ( A == null )

A = new A();

return instance;

}

}

}

1. Factory

2. Abstract Factory

3. Singleton

4. Builder

Question 40. (单选)

class Class1

{

public static int Count = 0;

static Class1()

{

Count++;

}

public Class1()

{

Count++;

}

}

Class1 o1 = new Class1();

Class1 o2 = new Class1();

请问，Class1.Count的值是多少？( )

1. 1

2. 2

3. 3

4. 4

Question 41. (单选)

abstract class BaseClass

{

public virtual void MethodA()

{

Console.WriteLine("BaseClass");

}

public virtual void MethodB()

{

}

}

class Class1: BaseClass

{

public void MethodA()

{

Console.WriteLine("Class1");

}

public override void MethodB()

{

}

}

class Class2: Class1

{

new public void MethodB()

{

}

}

class MainClass

{

public static void Main(string[] args)

{

Class2 o = new Class2();

o.MethodA();

}

}

请问，此程序输出结果是:

1. BaseClass

2. BassClass Class1

3. Class1

4. Class1 BassClass

Question 42. (单选)

public static void Main(string[] args)

{

int i = 2000;

object o = i;

i = 2001;

int j =(int) o;

Console.WriteLine("i={0},o={1}, j={2}",i,o,j);

}

1. i=2001,o=2000,j=2000

2. i=2001,o=2001,,j=2001

3. i=2000,o=2001,,j=2000

4. i=2001,o=2000,j=2001

Question 43. (多选)

您要创建ASP.NET应用程序用于运行AllWin公司内部的Web站点，这个应用程序包含了50个页面。您想要配置这个应用程序以便当发生一个HTTP代码错误时它可以显示一个自定义的错误页面给用户。您想要花最小的代价完成这些目标，您应该怎么做？(多选)

1. 在这个应用程序的Global.asax文件中创建一个Application_Error过程去处理ASP.NET代码错误。

2. 在这个应用程序的Web.config文件中创建一个applicationError节去处理ASP.NET代码错误。

3. 在这个应用程序的Global.asax文件中创建一个CustomErrors事件去处理HTTP错误。

4. 在这个应用程序的Web.config文件中创建一个CustomErrors节去处理HTTP错误。

Question 44. (单选)

如下程序的运行结果是：

public abstract class A

{

public A()

{

Console.WriteLine(''A'');

}

public virtual void Fun()

{

Console.WriteLine("A.Fun()");

}

}

public class B: A

{

public B()

{

Console.WriteLine(''B'');

}

public new void Fun()

{

Console.WriteLine("B.Fun()");

}

public static void Main()

{

A a = new B();

a.Fun();

}

}

1. A B A.Fun()

2. A B B.Fun()

3. B A A.Fun()

4. B A B.Fun()

Question 45. (单选)

Which of these string definitions will prevent escaping on backslashes in C#?*

1. string s = #”n Test string”;

2. string s = “’n Test string”;

3. string s = @”n Test string”;

4. string s = “n Test string”;

Question 46. (单选)

Which of the following operations can you NOT perform on an ADO.NET DataSet?

1. A DataSet can be synchronised with a RecordSet.

2. A DataSet can be synchronised with the database.

3. A DataSet can be converted to XML.

4. You can infer the schema from a DataSet

Question 47. (单选)

In Object Oriented Programming, how would you describe encapsulation?

1. The conversion of one type of object to another.

2. The runtime resolution of method calls.

3. The exposition of data.

4. The separation of interface and implementation.

Question 48. (单选)

How does assembly versioning in .NET prevent DLL Hell?

1. The runtime checks to see that only one version of an assembly is on the machine at any one time.

2. .NET allows assemblies to specify the name AND the version of any assemblies they need to run.

3. The compiler offers compile time checking for backward compatibility.

4. It doesn’t.

Question 49. (单选)

三种常用的字符串判空串方法：

1: bool isEmpty = (str.Length == 0);

2: bool isEmpty = (str == String.Empty);

3: bool isEmpty = (str == "");

哪种方法最快？

1. 1

2. 2

3. 3

Question 50. (单选)

public sealed class SampleSingleton1

{

private int m_Counter = 0;

private SampleSingleton1()

{

Console.WriteLine(""初始化SampleSingleton1。"");

}

public static readonly SampleSingleton1 Singleton = new SampleSingleton1();

public void Counter()

{

m_Counter ++;

}

}

以上代码实现了设计模式中的哪种模式？

1. 原型

2. 抽象工厂

3. 单键

4. 生成器


刚看完了这份试题,有些题是送分的,有些又觉得偏书面知识了,最重要的还是要看几轮面试啊!

第二种推论：

1.如果为1条病狗，第一天那条狗必死，因为狗主人没看到病狗，但病狗存在。

2.若为2条病狗，狗主人为a、b。 a看到一条病狗，b也看到一条病狗，但a看到b的病狗没死故知狗数不为1，而其他人没病狗，所以自己的狗必为病狗，故开枪；而b的想法与a一样，故也开枪。由此，为2时，第一天后2条狗必死。

3.若为3条病狗，狗主人为a、b、c。 a第一天看到2条病狗，若a设自己的不是病狗，由推理2，第二天看时，那2条狗没死，故狗数肯定不是2，而其他人没病狗，所以自己的狗必为病狗，故开枪；而b和c的想法与a一样，故也开枪。由此，为3时，第二天后3条狗必死。

4.余下即为递推了，由n-1推出n。答案：n为4。第四天看时，狗已死了，但是在第三天死的，故答案是3条。

企业回复：这样的问题考察人的思维严密性和思维活跃性。小朱同学的回答当时很让我们感到吃惊，他能在这样的环境下保持冷静的头脑，确实很难得。

世界通用的中国人

在全球化时代，要更好的生存与发展，必须具备适应国际大舞台、融入国际大舞台的素质。因此，非国际化不可，国际化的内涵很多，要具有国际化的语言、国际化的知识、国际化的思想、国际化的观念、国际化的意识、国际化的精神。

要做国际化的人，首先要有极强的国际语言沟通能力。

再有一种能力，就是合作能力，特别是多文化的团队合作能力。

国际化的方式很多，不仅可以出国，而且在国内也可进行国际化 ―― 学好英语，学好国外的先进科学技术和先进思想文化。通过译著，通过互联网，通过国内的外企、合资企业等等，都可以培养国际化的素质。

时代既给我们提供了前所未有的机遇，又给我们前所未有的挑战。

日本的教育目标是培养 “ 世界通用的日本人 ” ，同样，我们每一个人都应当成为 “ 世界通用的中国人 ” 。
总之，我们既应当真正成为一个合格的中国人，即民族化的中国人；又应当是国际化的中国人。既掌握了我们本民族的一切优秀思想文化，又掌握了全世界的整个先进思想文化。这是我们迎接时代的挑战，成为新世纪所需要的高能人才的必由之路。


通专和合

掌握 “ 狡兔三窟 ” 的应变本领

随着时代的发展，科学越来越呈高度综合化的趋势，再加上知识陈旧的加速，只专已经行不通了。今天的各个行业职业变换异常频繁，每个行业都有它的成长期、成熟期、衰退期。一到衰退期，行业内大批人员都面临被淘汰的命运。据统计，美国人以前一生平均得变 2.5 个职业。每个人更不可能 “ 从一而终 ” ，新时代需要有 “ 狡兔三窟 ” 的应变本领。

通才的综合素质高，能够轻松地通达各个领域，转换领域非常容易，能够很快适应新的行业、新的职务。

通才，不是精通一切，通晓一切，而是要具有通达一切的才能。换句话说，就是在一切本领。才能中，要特别重视那些能够 “ 一通百通 ” 的本领和才能。哪些是一通百通的本领呢？主要是学习能力、思维能力、创造能力。无论谁，无论你专攻何种领域，都必须善于学习、善于思维、善于创造。


“T” 字型结构

胡适有一段精辟的分析：理想中的学者，既能博大，又能精深。精深的方面，是他的专门学问，博大的方面则是他的旁搜博览。做 “ 金字塔型结构 ” 的人，做 “T 字型结构 ” 的人，博大与精深和合，通才与专才和合。

鲁迅先生有句名言：博识家的话多浅，专门家的话多悖。

光是通，容易浅薄，不能精深 ; 光是专，容易变得陕隘、局限，甚至发出令人可笑的悖论。

2.解决模式匹配问题的方案:

A:  朴素的模式匹配算法(思路简单,但不够简便时间长 有回溯) : 最简单和最直接的做法.用P中的字符依次与T中的字符进行比较 遇到不相等的字符,则可将P右移一个字符,从新进行比较,直到某次匹配成功或者到达P的最右字符移出T为止.

如: 若P="aaaba", T="aaabbaaaba", 则匹配过程如下图

 T:     a   a   a   b   b   a   a   a   b  a
 P:     a   a   a   b   a                                                                 
            a   a   a   b   a                 
                                .....
                            a   a   a   b  a            

从上不难分析,最坏的情况是"每次比较都在最后一个字符出现不等,每趟最多比较M次,最多比较N-M+1趟,总的比较次数最多为M*(N-M+1)" ,时间复杂性为0(M*N). 在P右移一位时,不管上一趟比较的中间结果是什么,因此回溯是不可避免的(如: 前3个aaa 不需要一位一位的移 ) .下面我来介绍无回溯的KMP算法.


3.KMP算法解决匹配中哪些主要问题: 
A.当字符串比较出现不等时,确定下一趟比较前 应该将P右移多少个字符; 
B. P右移后,应该从哪个字符开始和T中刚才比较时不等的那个字符继续开始比较.

    我们通过朴素模式匹配的例子来引出问题. 在第一次比较过程中失败的是P的第4个字符b,这表明P的前4个字符是成功的.模式P的第3个字符b在它的前3个字符(aaa)中并未出现.因此,在下一次比较时候,至少要将P向后移4个字符; 再看P的第一个字符与最后一个字符是相同的因此将P右移4个字符后 再从第一个字符比较 可定也是不等的.  综上所诉:应该将P右移5个字符 再从P的第0个字符和T的第5个字符开始比较!

KMP算法核心: KMP算法借助于一个辅助数组next来确定当匹配过程中出现不等时,模式P右移的位置和开始比较的位置.next[i]的取值只与模式P本身的前i+1项有关,而与目标T无关.     匹配过程中遇到Pi不等于Tj时,若next[i]>=0,则应将P右移i-next[i]位个字符,用P中的第next[i]个字符与Tj 进行比较;若:next[i]= -1,P中的任何字符都不必再与Tj比较,而应将P右移i+1个字符,从P0和Tj+1从新开始下一轮比较(可能不太好理解,自己找个例子,对着话一句一句试试看)
 
  因此只要计算出与模式P相关的next数组,按上面的含义,就可以很容易地给出串的匹配算法.(问题就这样转化了)

 C.next的计算:  以P = " 01001010100001"为例.

  i   :            0   1   2   3   4   5   6    .....  
  P   :            0   1   0   0   1   0   1    .....

 j(next[i]) :     -1   0   0   1   1   2   3    .....
修正(next[i])  :  -1   0  -1   1   0  -1   3    .....
例子中的j(next[i])为未修正前的next数组(关于修正我会在下次提到).
如1:我们要算next[2]的值,有关的为P本身的前2个字符0,1.   在字符串01中,寻找出   "左右相同的最大字符串,此字符串所含字符的个数就为next[i]的值"而0不等于1,相同字符串不存在,所以next[i] = 0;

如2:我们要算next[6]的值,有关的为P本身前6个字符010010  此字符串中010 = 010
左右相同的最大字符串为010,个数为3.所以next[i]=3;

如3:我们要算next[5]的值,有关的为P本身前5个字符01001 此字符串中 01=01 左右相同的最大字符串为01,个数为2.所以next[i]=2;


通过上面的例子大家应该有所了解了,有什么问题可以留言给我.

                       

             
             KMP的算法     VC++6.0

 

Cmystring::GenKMPNext(int *next, CMyString *s)

{ int i=0; j=-1;

   next[0]=-1;

 while(i<s->length)

  {

  while(j>=0&&s->str[i]!=s->str[j])

     j=next[j];

   i++;j++;

   if(s->str[i]==s->str[j])

      next[i]=next[j];
  else  next[i]=j;}

}


/////////////////// 串类的find()方法 KMP匹配算法////////////////////////
int CMyString::find(const CMyString *S)
{
    int i , j , *next = new int[s->length];
    GenKMPNext(next, s);
    for(i= 0,j=0;i< s->length&&j<length;)
    {
        if( s->str[i] = =str[j] ) { i++ , j++;}
        else
            if(next[i] >=0)
                 i = next[i];
            else
            { i = 0; j++}
     }
     if(i>= s->length)
       return  j - s->length;
     else
          return -1;
}


                

#define CMyString

#define max_string_size 1024                                 //第一串的最大长度为1024

class CMyString
{
private:
 int length;                                               //字符串的实际长度
 
 char str[max_string_size+1];                              //包括最后的结束符 字符串的存处空间；
public:
 
 CMyString();
 
    CMyString(const char * s);                                //构造一个字符指针所指的对象
 
 ~CMyString();
 
 concatenate(const concatenate *s);                                //将字符串S插入到本字符串之后
 
 insert(const int pos, const CMyString *s);                 //将字符串插入到本字符串POS所指的位置
 
 delete(const int pos, const int len);                      //删除从POS位置起的连续len个字符
   
 CMyString substring(const int pos, cont int len);          //从pos位置起 提取一个长度为len的子串

 char *getstring();                                                  //获取本字符串

 int getstring();                                                         / /获取字符串长度

 int find(const CMyString *s);                               //在字符串中查找S首次出现的位置，如不包含S 则返回0；
   
};
#endif



//////////////////////////////串类的实现/////////////////////////////////////////


#include<iostream.h>

#include"CMyString.h"

#include"memory.h"

#include"stdafx.h"                    //不懂 stdafx.h 是什么意思

CMyString::CMyString()
{
 length=0;
 str[0]=0;
}

//////////////////构造2//////////
CMyString::CMyString(const char *s)                     
{
 char *p1,*p2;
 for(length=0,p1=str,p2=(char *)s;  *p2;  length++)
  *p1++ = *p2++;
 *p1=0;
}

/////////////////////析够//////////
CMyString::~CMyString()
{}

//////////////将字符串S插入到本字符串之后//////////////
CMyString::concatenate(const concatenate *s)
{
 if(length+s ->length <= max_string_size+1)
 {
  mencpy(str+length, s->str .s->length+1);
  length += s->length;
 }
 else
 {
  cout<<"error"<<endl;
 }
}

////////////删除从POS位置起的连续len个字符///////
CMyString::delete(const int pos, const int len)
{
 int rlen = len;
 if(pos +rlen > length)]
  rlen = length - pos;
 length -= rlen;
 memcpy( str +pos,str+pos+rlen, length - pos+1);
}

/////////////////在字符串中查找S首次出现的位置，如不包含S 则返回0///////////////
int CMyString::find(const CMyString *s)
{
 ..
}

////////////////获取字符串长度/////////
int CMyString::getlegth()
{
 return length;
}

char *CMyString::getstring()

{
 char *tmpstr = new char[length+1];
 memcpy(tmpstr , str ,length +1);
 return tmpstr;
}

////////////////将字符串插入到本字符串POS所指的位置/////////
CMyString::insert(const int pos, const CMyString *s)
{
 if(length + s -> length <= max_string_size)
 {
  memcpy(str + pos + s -> length, str+pos,length-pos+1);
  memcpy(str+pos,s->str,s->length);
  length +=s ->length;
 }
 else
 {
  cout<<"error"<<endl;
 }
}

/////////////////从pos位置起 提取一个长度为len的子串//////////
CMyString CMyString::substring(const int pos,const int len)
{
 int rlen = len;
 CMyString tmpstr("");
 if(pos +len >length)
  rlen = length - pos;
 memcpy(tmpstr.str,str+pos,len);
 tmpstr.length = rlen;
 tmpstr.str[tmpstr.length] = 0;
 return tmpstr;
}

template <class t>
node<t> *linkedlist<t>::getnode(const t&item ,node<t> *ptr);
{
 node<t> *newnode = new node<t>(item ptr);
 if(!newnode)
 {
  cerr<<"faied"<<e<endl;
  return null'
 }
 return newnode;                                   // 返回指向新生成接点的指针
}

template <class t>
void *linkedlist<t>::freenode(node<t> *ptr)
{
 if(!ptr)
 {
  cerr<<"invalid node pointer!"<<endl;
  return 0;
 }
 delete ptr;
}

template <class t>                                    //构造函数 建立一个空链表。
linkedlist<t>::linkedlist<void>:front(null),rear(null),prevter(null),currptr(null),size(0),position(-1)
{}

template <class t>
linkedlist::~linkedlist()
{
 clear();
}

template <class t>                                   //重载赋值运算符的函数.
linkedlist<t> &linkedlist<t>::operator = (const linkedlist<t> *orglist)
{
 node<t> *p = orglist.front;
 clear();                                         //这里清空链表是为了给复制做好准备么？
 while(p)  //                                    这里想不明白，大家帮我详细解释下？ 
 {
  insertafter(p->data);
  p=p->nextnode();
 }        //                                     ENDL；
setposition(orglist.position);                       //这又是什么意思？要去复习重载了。
return *this;                                       

template <class t>
int linkedlist<t>::size(void) const
{
 return size;
}

template <class t>
boolean linkedlist<t>::isempty(void) const
{
 return size?false:ture;
}

template <class t>
int linkedlist<t>::nextnode(void)
{
 if(position>=0 && position<size)
 {
  position++;                                   //将当前结点往后移了一位。
        prevptr = currptr;
  currptr = currptr->nextnode();
 }
 else
 {
  position = size;                                //否则将此结点设置为最后结点。
        return position;
 }
}

template <class t>                                   //链表中重置当前结点位置的函数。
int linkedlist<t>::setpostion(int pos)
{
 if(!size)
  return -1;
 if(pos<0||pos>size-1)
 {
  cerr<<"error position"<<endl;
  return -1;
 }
 prevptr = null;
 currptr = front;
 position = 0;
 for(int k=0;k<pos;k++)
 {
  position++;
  prevptr = currptr;
  currptr = currptr->nextnode();
 }
 return position;
}

template <class t>
int linkedlist::getposition(void)const
{
 return position;
}

template <class t>                       //重要：链表中在当前结点处插入新结点的函数；
void linkedlist<t>::insertat(const t& item)
{
 node<t> *newnode;
 if(!size)                            //空表中插入。
 {
  newnode = getnode(item, front);
  front = rear = newnode;
  position = 0;
 }
 else if(!prevptr)                   //在表头插入                 
 {
  newnode = getnode(item , front);
        front = newnode;
 }
 else                                //在链表中间插入插入
 { 
  newnode = getnode(item , front);
  prevptr = insertafter(newnode);
 }
 size++;
 currptr = newnode;                  //新插入的结点为当前结点
}

template <class t>                       //重要：链表中在当前结点后插入新结点的函数；
void linkedlist<t>::insertafter(const t& item)
{
 node<t> *newnode;
 if(!size)                            //空表中插入。
 {
  newnode = getnode(item);
  front = rear = newnode;
  position = 0;
 }
 else if(currptr == rear||!currptr)   //在链表尾插入
 {
  newnode = getnode(item);
  rear->insertafter(newnode);
  prevptr=newnode;
  rear = newnode;
  position = size;
 }
 else
 {
  newnode = getnode(item ,currptr->nextnode());    //  在表的中间插入
  currptr->insertafter(newnode);
  prevptr = currptr;
  position++
 }
  size++;
  currptr = newnode;
}

template <class t>
void linkedlist<t>::deleteat(void)                  //重要：删除当前结点的函数
{
 node<t> *oldnode;
 if(!currptr)                                     //若表为空或者已到表尾，则给出错误提示并返回
 {
  cerr<<"currptr position is invalid!"<<endl;
  return;
 }
 if(!prevtr)                                       //删除表头结点。
 {
  oldnode = front;
  front = currptr->nextnode();
 }
 else
 {
  oldnode = prevptr->deleteafter();            //删除的是表中结点；
 }
 if(oldnode == rear)
 {
  rear = prevptr;                              //删除的是表尾结点，则修改表尾指针和当前位置结点值
  position--;
 }
 currptr = oldnode->nextnode();                  //后续结点作为新的当前结点
 freenode(oldnode);                              //释放原当前结点
 size--;                                         //链表大小减1；
}

template <class t>
void linkedlist<t>::deleteafter(void)
{
 node<t> *oldnode;
 if(!currptr||currptr==rear)
 {
  cerr<<"current position is invalid!"<<endl;
  return;
 }
 oldnode = currptr->deleteafter();                //保存被删除结点的指针并从链表中删除该结点。
 if(oldnode == rear)
 {
  rear == currptr;                              //删除的是表尾结点。
 }
 freenode(oldnode);
 size--;
}

template <class t>                                  //获取当前结点的函数
T linkedlist<t>::getdata(void) const
{
 if(!size || !currptr)                              //若表为空或已经到达表尾之后，则出错。
 {
  cerr<<"currptr node not exit!"<<endl;           //给出错误信息并退出。
  exit(1);
 }
 return currptr->data;
}

 
template <class t>                                //链表中修改当前结点数据的函数
void linkedlist<t>::setdata(const T& item)
{
 if(!size||!currptr)
 {
  cerr<<"data:current node not exit!"<<endl;
  exit(1);
 }
 currptr->data = item;
}

template <class t>
void linkedlist<t>::clear(void)
{
 node<t> *currptr=front,*nextnode;
 while(currnode)
 {
  nextnode = currnode->nextnode();
  freenode(currnode);
  currnode = nextnode;
 }
 front = rear = prevptr = currptr = null;                //修改空链表数据
    size = 0;
 position = -1;
}