1.C#数据类型 ................................................................ 2

2.C#转义符 .................................................................... 2

3.ASCII码 ..................................................................... 3

4.标识符 ......................................................................... 3

5.数据类型 ..................................................................... 4

6.顺序结构 ..................................................................... 4

7.选择结构 ..................................................................... 4

8.循环结构 ..................................................................... 4

9.构造函数 ..................................................................... 5

10.析构函数 ................................................................... 5

11.属性 ........................................................................... 5

12.静态成员 ................................................................... 6

13.实例成员 ................................................................... 6

14.重载 ........................................................................... 6

15.覆盖 ........................................................................... 6

16.继承 ........................................................................... 7

17.抽象成员 ................................................................... 7

18.虚函数 ....................................................................... 8

19.接口 ........................................................................... 8

20.代理 ........................................................................... 8

1. C#数据类型

表1 C#数据类型

2.C#转义符

表2 C#转义符

3.ASCII码

表3 ASCII码

4.标识符

组成：52个字母（大小写字母），10个数字（0~9），1个下划线（ _ ），1个原义说明符“@”。

开头：字母、下划线或原义说明符“@”。

说明：一般情况下标识符不能是关键字，若使用关键字，须在关键字前面加上“@”符号；

“@”只能用于开头，不能位于其他位置，也不能单独使用。在C和C++中是不能使用关键字的，C#中可以在关键字前面加上@使之成为标识符。

5.数据类型

图1 C#数据类型之间的结构关系

6.顺序结构：程序的执行都是一行接一行、自上而下地进行，不遗漏任何代码。

7.选择结构：有条件的执行代码，条件取决于计算的结果。不是所用的代码都能被执行。

说明：实现选择的方法如下：

1. If?else?

2. switch?case?

8.循环结构：重复执行相同的语句（重复执行一定的次数，或者在满足测试条件后停止执行）。

说明：实现循环的方法有如下四种：

1. do?while?

2. while?

3. for

4. foreach

循环的中断：在循环块中采用某种方式退出循环的操作。

说明：使循环中断的方法有以下几种：

1. break

2. continue

3. goto?labeled?

4. return

9.构造函数：创建对象是被调用于初始化对象的函数。

10.析构函数：删除对象时被调用于执行一些清理工作（释放内存等）。 说明：

1. 构造器与析构器都属于类的成员。

2. 构造函数、析构函数的名称均与类名相同

3. 构造器和析构器都没有返回值，不能在构造器和析构器前面使用使用数据类型关键字。

4. 使用new操作符定义类的实例对象时，会自动调用构造器，当删除该对象时，系统自动调用析构器。

5．析构器中不能出现任何参数（括号内不允许有参数列表）。

6. 构造器和析构器都不能被继承，但可以被其派生类所调用。

11.属性：属性可以用来封装数据，可以限制外部对类中成员变量的存取权限，实现

良好的数据封装和数据隐藏。

说明：

1. 属性不能使用括号（），没有参数列表。

2. 属性不能使用void类型，返回值的类型一定要和属性成员的类型相同。

3. 属性不为数据存储分配空间。

4. 属性有静态属性与实例属性之分。

5. 在C#中，静态属性成员不能通过对象实例化进行引用，也就是不能通过this关键字来

引用静态属性成员，this关键字只能引用实例属性成员。

6. 静态属性成员前面不能使用virtual、abstract、override 修饰符。

7. 不能把get部分与set部分分成两个属性来分别定义，即不能使用相同名字的两个属性成

员来分别包含get部分和set部分以组成一个属性成员访问。

8. 派生类中可以对基类属性成员重载。

12.静态成员：静态成员是指类成员只有一个副本且被属于该类的所有实例对象共享。

13.实例成员：实例成员是指该成员的副本出现在所有属于该类的实例对象中，

每个实例成员副本之间不能共享。

说明：

1. 如果类成员的前面有static 修饰符，那么它就被称为静态成员，否则该成员就被称为实例成员。

2. 对静态成员的定义的解释：对于类A 的静态成员a ，实例对象a1 和a2 同时占有a ，如果a1 改变了a 的数据，那么a2 得到的就是改变数据后的a 。

3. 对实例成员的定义的解释：对于类C 的实例成员c ,实例对象c1 和c2 分别有自己的c ,而且c1 对c 的数值的改变并不影响c2 中c 的数值，c2 得到的c 的数值还是原来自己的数据。

4. 通过实例对象来引用静态成员是非法的，应通过直接的类成员来引用静态成员。

5. 实例成员必须通过实例化对象来引用，不能通过类成员直接引用。

14.重载：方法名称相同，方法功能不同，实现方法重用。

说明：

1. 方法重载的条件：参数数目不同或参数类型不同。

2. 重载发生在同一个类中。

15.覆盖：

说明：

1. 覆盖是指函数名称、函数类型、访问级别、参数类型、参数个数、参数排列顺序都相同的情况下发生的。

2. 覆盖发生在派生类与基类中。

3. 基类中该成员必须有virtual关键字标识。

4. 派生类中该成员有override关键字标识。

5. 覆盖与被覆盖的方法必须有相同的可访问性。

6. 不能覆写static方法和非虚方法，即只能覆写基类中的虚函数、抽象函数、重载函数。

7. 覆盖函数中的override修饰符不能和new、static、virtual、abstract修饰符同时出现。

16.继承：子类继承父类的所有特性和操作。

说明：

1. 继承的作用主要是实现软件的代码重用和软件功能的扩充。

2. C#中的继承都是单继承，即类A 只能继承类B ，而不能再有第二个类作为类A 的基

类。只有通过使用接口才可能出现多继承的情况，即类A 可以同时继承两个以上的接口。

3. 派生类包含了基类中除了构造器、析构器、私有成员以外的所有可继承成员。

4. 继承具有传递性，即类A派生类B ，类B派生类C，那么类C除了继承类B的可继承

成员外，同时还继承了类C的所有可继承成员。

5. 派生类可以扩展基类的操作和特性，但是不能删除继承下来的基类成员。

6. 派生类中可以使用new关键字重载基类中的成员，达到成员隐藏的目的。它和成员重载

是相辅相成的。

7. 基类与派生类不能出现循环依赖关系。

8. 以sealed 关键字声明的类不能作为基类。

9. 派生类的访问范围不能大于基类的访问范围。比如派生类B的访问级别为public ，那

么当基类A的访问级别为private或者internal时，就会发生编译错误。

10. 派生类成员初始化时，先调用基类的构造器，然后再调用派生类的构造器。

11. 基类和派生类是一个相对的概念。

17.抽象成员：成员前面有abstract修饰符标识。

说明：

1. 抽象方法只是从逻辑上对操作进行了描述，并不对操作进行具体的实现。它和虚函数不

同，虚函数中可以包含具体的运算来实现指定的操作。

2. abstract修饰符能够应用在类、方法前面，使用abstract修饰符声明的类只能作为基类来

派生出其他的类，即抽象类不能创建具体的对象类、不能产生实例。

3. 抽象方法必须在抽象类中声明。

4. 抽象成员没有代码实现块，即抽象成员后面没有｛｝。

5. 抽象成员的访问权限不能是private。

6. 抽象方法前面不能使用static、virtual、override修饰符。

7. 抽象类可以派生出另一个抽象类。

8. 任何派生自抽象类的类必须使用override关键字来实现抽象类中所有的抽象成员，除非

派生类本身也是抽象类。

18.虚函数：函数使用virtual修饰符标识。

说明：

1. 虚函数不能同时为静态函数。

2. 虚函数可以在派生类中通过使用override关键字来实现重载，即虚函数被重新定义（覆盖）。

3. 虚函数修饰符vritual不能和static、abstract、override修饰符同时出现。

19.接口：通过接口可以实现子类的多重继承。

说明：

1. 接口是一个引用类型，通过接口可以实现多重继承。

2. C#中接口可有new、public、protected、internal、private等修饰符。

3. 接口中只能声明抽象成员（所以不能直接对接口进行实例化（即不能使用new操作符声明一个接口的实例对象）），而不能声明共有的域或者私有的成员变量。

4. 接口声明不包括数据成员，只能包含方法、属性、事件、索引等成员。

5. 接口名称一般都以“I”作为首字母（当然不这样声明也可以），这也是接口和类的一个区别之一。

6. 接口成员的访问级别是默认的（默认为public），所以在声明时不能再为接口成员指定任何访问修饰符，否则编译器会报错。

7. 接口成员不能有static、abstract、override、vritual修饰符，使用new修饰符不会报错，但会给出警告说不需要关键字new。

8. 在声明接口成员的时候，不准为接口成员编写具体的可执行代码，也就是说，只要在对接口进行声明时指明接口的成员名称和参数就可以了。

9. 接口一旦被继承，子类需要把接口中所有成员实例化（通过具体的可执行代码实现接口抽象成员的操作）。

20. 代理：代理是引用类型，它主要用来引用静态方法或者对象实例。 说明：

1. C#中没有C++中功能强大但是最容易出现问题的指针（Pointer），而是使用了近似于C++中的指针功能的代理。不过代理的安全性提高了，它具有功能更强大的类型保护和安全机制。

2. 使用代理前需要先进行声明，代理的文法结构为：

delegate-declaration:

attributes (opt) delegate-modifiers(opt) delegate result-type identifier (formal-parameter-list(opt));

3. 在对代理进行了声明之后，就可以使用代理了。在C#中使用代理同使用一个普通的引用数据类型一样，首先需要使用new运算符创建一个代理实例对象，然后把代理指向

要引用的方法，最后就可以在程序中像调用方法一样引用代理的实例对象调用它指向的方法。

4. 多重代理就是把代理同时指向多个方法，即通过一条语句来执行多个方法。但是，这

些方法必须具有相同的参数，而且这些方法的返回类型必须是void。

5. 多重代理中的Combine（）方法可以将不同的代理组合在一起，在实际编程中，不需

要显式调用该方法，可以直接使用加号运算符（“+”）来调用Combine()。

6. 多重代理中的Remove()方法可以从一个多重代理中除去一个代理，可以使用减号运算

符（“—”）来调用Remove()。

（完）

第二篇：C笔试自已总结

1 堆和栈那个是对程序员透明的？

答案：栈。

对程序员透明是指程序员不需要关心 举例来说 有些api函数对程序员透明 那么程序员只关心这个函数的功能 而不需要了解函数内部是如何实现的

堆和栈的区别可以用如下的比喻来看出：

使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。

使用堆就象是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。

2 请结合具体实例阐述一下面向对象中"多态"的概念。

答案：同一操作用于不同的类的实例,不同的类将进行不同的解释,最后产生不同的结果,它有两种: →编译时多态---- 通过overload来实现,系统在编译时,根据传递的参数和返回的类型等信息决定实现何种操作

→运行时多态---- 通过override来实现，根据运行时具体对象的类型决定调用哪个方法。

1． 问题：完全二叉树的结构

答案：深度为k，有n个节点的二叉树，当且仅当其每一个节点

都与深度 为k的满二叉树中编号从1至n的结点一一对应时，称之为完全

二叉树。

当初面试人员画了几个树让我辨认谁是完全二叉树。

3． 问题：什么是索引

答案：索引依附于基表，建立索引是加快查询的有效手段。

4． 问题：什么是视图 答案：视图是关系数据库系统提供给用户以多角度观察数据库中数据的重要机制。是从一个或多个基表（或视图）导出的表，它

与基本表不同，是虚表。

5． 问题：什么是游标

答案：游标是系统为用户开设的一个数据缓冲区，存放SQL语句的执行结果，每个游标区都有一个名字。用户可以通过游标逐一

获取记录，并赋给主变量，交由主语言进一步处理。

6． 问题：对数据库操作的语句

答案：select，insert，update，delete

7． 问题：数据库的操作过程

答案：（1）加载驱动程序；（2）建立数据库连接；（3）向数据库

发送SQL 语句；（4）事务处理；（5）管理连接。

8． 问题：所知道的排序方法的种类

答案：插入，快速，选择，交换，归并，基数，希尔等。

9． 问题：什么是MVC

答案：这个大家都清楚，可查询有关资料。 MVC本来是存在于Desktop程序中的，M是指数据模型，V是指用户界面，C则是控制器。使用MVC的目的是将M和V的实现代码分离，从而使同一个程序可以使用不同的表现形式。比如一批统计数据你可以分别用柱状图、饼图来表示。C存在的目的则是确保M和V的同步，一旦M改变，V应该同步更新。

模型－视图－控制器（MVC）

char *p；int i；p++与i++的区别？这个大家都知道就是p++是指向下一个元素，p的移动位置与p指针指向的类型有关，i++是自身增加一。差不多就是这样说的。

p保存占多少位？ 我开始说与它指向的类型有关，然后她提示我说她不是那个意思，然后我说我感觉是在内存中占16位吧?我是这样说的，其实我也不清楚，c都忘了。

char *p=malloc（100），给p分配了多少个字节的空间？是堆内存还是栈内存？

我回答100个，（但是我忘了是堆还是栈）我认为是堆内存。

4。一个程序编译完成后在内存中是如何存储的？？

我说这个没有学过，我把我认为的说了一下，她说她就是随便问问。

编译完，存储在硬盘上，obj文件。运行的时候才加载到内存中

5。java有多态性，继承，什么意思？是如何实现的？

（这个我虽然也知道大概 但是好像理解的也不是太深刻，说不太清晰）

答：我就说了前几天老师利用接口与DAOFactory实现的那个例子，她说那抽象类呢，我说不太上来但是也就我理解的说了点。我又扯上了重载，她就问重载是多态吗？我说不是（因为我记得不是），但是可以实现多态。说得很乱

class A{}

class B extends A{}

class C extends A{}

class D extends B{}

class E extends B{}

多态就是一个类型多个形态，它一般体现在类继承中；

上面的多态势这样体现的，A是所有类的父类，B、C继承了A，他们是A的多态，D、E同样，是B的多态，同时，因为D、E继承了B，B继承了A，所以D、E又是A的多态

数据抽象、继承和多态是面向对象程序设计语言的三大特性。多态，我觉得它的作用就是用来将接口和实现分离开，改善代码的组织结构，增强代码的可读性。在某些很简单的情况下，或许我们不使用多态也能开发出满足我们需要的程序，但大多数情况，如果没有多态，

就会觉得代码极其难以维护。

三层架构:是什么 ?

正确答案：（web服务器，数据库服务器，应

用程序服务器）

表现层：就是你提交到最终交互的产品，能够实物看到的。

逻辑层：说简单点就是你怎样把不同的数据层串联起来的代码存放的地方。

数据访问层：所有涉及到数据处理或访问的代码全部写在这一层

1、让我谈谈面向对象是怎样理解的？ 对象就是一个名词，例如：猫

方法就是一个动作，例如：吃

属性就是属性，例如：颜色,名字

实例就是具体化，例如：

新建一个实例 我的猫=new 猫

定义 我的猫.颜色=黑色

定义 我的猫.名字=宝宝

调用 我的猫.吃(老鼠)

程序运行了 黑色宝宝吃老鼠

3、谈谈继承、多态、封装、抽象、重载、虚函数、抽象类。

重载verload;指使用同一个方法名,在调用时,编译器会根据方法参数列表的不同或是返回值类型的不同决定调用的方法。也就是说，同上个名称的方法能具备不同的功能。

比如:

functionGetSum(a:integer;b:integer):integer;overload; //求两个整数的和,返回值为整型;

functionGetSum(a:double;b:integer):double;overload; //求整数与实数的和,返回值为实数型;

functionGetSum(a:double;b:double):double;overload; //求实数的和,返回值为实数型;

虚函数是在基类中定义的，目的是不确定它的派生类的具体行为。例： 定义一个基类：class Animal//动物。它的函数为breathe()//呼吸。 再定义一个类class Fish//鱼 。它的函数也为breathe() 再定义一个类class Sheep //羊。它的函数也为breathe() 为了简化代码，将Fish,Sheep定义成基类Animal的派生类。

然而Fish与Sheep的breathe不一样，一个是在水中通过水来呼吸，一个是直接呼吸空气。所以基类不能确定该如何定义breathe，所以在基类中只定义了一个virtual breathe,它是一个空的虚函数。具本的函数在子类中分别定义。程序一般运行时，找到类，如果它有基

类，再找它的基类，最后运行的是基类中的函数，这时，它在基类中找到的是virtual标识的函数，它就会再回到子类中找同名函数。派生类也叫子类。基类也叫父类。这就是虚函数的产生，和类的多态性（breathe）的体现.

用一个简单的例子，比如说一个教师，我们把它作为一个抽象类，有自己的属性，比如说年龄，教育程度，教师编号等等，而教师也是分很多种类的，我们就可以继承教师类而扩展特有的种类属性，而普遍属性已经直接继承了下来。

而接口呢~还是拿教师做例子，教师的行为很多，除了和普通人相同的以外，还有职业相关的行为，比如改考卷，讲课等等，我们把这些行为定义成无body的方法，作为一个集合，它是一个interface。而教师张三李四的各自行为特点又有不同，那么他们就可以扩展自己的行为body。从这点意义上来说，interface偏重于行为。

总之，在许多情况下，接口确实可以代替抽象类，如果你不需要刻意表达属性上的继承的话。

1.final 怎么用？

答：final可以用在定义变量、方法以及类。

final的变量必须要初始化，也可以将初始化的操作推到类的静态块中进行，而且这样的变量不能再被重新赋值，可以将其看成这个类的“常量”了。

final的方法不能被所在的类的子类重写。

final的类不能再被继承了。

2.那么，finally怎么用？

答：finally适合try、catch块配合使用的。finally一般放一些收尾的代码，也就是说，不管try块中的代码是否正常执行，也不管catch块中的代码是否工作了，finally中的代码都要执行。比如，JDBC或是Hibernate中的关闭连接操作，就是放在finally中执行的。

final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。

finally是异常处理语句结构的一部分，表示总是执行

finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。

3.wait方法和sleep方法的区别？

答：他们都是用来堵塞、挂起当前线程的方法，大体上应该是wait方法可以释放原先占有的资源，而 sleep方法好像不能... 在以前的编写的代码中，我几乎没有用过控制线程的操作，这部分知识我确实不敢随便说。

两个人(A,B)都在(等待)看电影

A(sleep) 等待的时候不会把座位让给别人

B(wait) 也在等待但是它可以把座位让给别人自己站着

也就是说A等待的时候不给把资源交给别人..

而B等待的时候可以把资源交给别人...

1、在C＃中，string str = null 与 string str = “” 请尽量使用文字或图象说明其中的区别。 回答要点：说明详细的空间分配。(10分) 答：string str = null 是不给他分配内存空间,而string str = "" 给它分配长度为空字符串的内存空间.

２、请详述在dotnet中类(class)与结构(struct)的异同：(10分) 答：Class可以被实例化,属于引用类型,是分配在内存的堆上的,Struct属于值类型,是分配在内存的栈上的.

4、分析以下代码，完成填空(10分)

string strTmp = "abcdefg某某某";

int i= System.Text.Encoding.Default.GetBytes(strTmp).Length; int j= strTmp.Length;

以上代码执行完后，i= j=

答：i=13,j=10

1.new有几种用法

第一种:new Class();

第二种:覆盖方法

public new XXXX(){}

第三种:new 约束指定泛型类声明中的任何类型参数都必须有公共的无参数构造函数。

值类型和引用类型的区别？写出C#的样例代码。

答:结构是值类型,类是引用类型,所以传结构就是值类型的应用啦,传对象或类就是引用类型的,这个不用多写了吧.

进程和线程分别怎么理解？

答:进程是老子,线程是儿子,没有老子就没有儿子,一个老子可以有多个儿子.一个儿子可以成为别人的儿子,一个老子也可以为别的老子生儿子.

如何在一个c++文件中包含一个c文件

extern "C"

在c++中，内联函数是怎么用的

内联函数就是在你写完程序后，在编译的时候，引用了内联函数的地方，编译器会将内联函数名换成内联函数体，以减少函数调用的时间消耗。一般情况下，用在函数体比较小，而调用特别频繁的情况下。就好比有一堆西瓜放在那里，普通的函数调用是谁要吃谁就去拿，而内联函数就是提前把西瓜分到了每个要的人的手里，这样就节约了去拿西瓜的时间了。 内联函数跟宏的意思差不多，就是在函数调用的地方，把函数调用语句改成函数体，比如： inline int fun(int a,int b)

{

return a+b;

}

main()

{

int a=1,b=2,c;

c=fun(a,b);

}

相当于

main()

{

int a=1,b=2,c;

c=a+b;

}

因为函数调用时，CPU要保存现场，要把参数入栈，要把返回值弹出，这是一个很复杂很消耗时间的过程，而内联函数相当于宏，不必处理保存现场，参数入栈等操作，所以速度比一般函数调用要快。

不过一般来说，内联函数要求不能带循环等复杂的结构，否则会被编译器做普通函数处理。 通常内联函数是为了提高函数调用的速度

Final和finally有什么区别

final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。 finally是异常处理语句结构的一部分，表示总是执行。

finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。 那final变量在哪儿初始化呢？

final变量初始化: 很多文章都这么说:其初始化可以在两个地方,一是其定义处,二是在构造函数中,两者只能选其一。胡说八道!final变量可以在任何可以被始化的地方被始化,但只能且必须被初始化一次.1)一旦被初始化后就不能再次赋值(重新指向其它对象),2)在任何引用之前或退出作用域时必须被初始化.

数据库中 视图的概念？是不是真实存在的？在物理空间上

视图：在SQL中，视图是外模式一级数据结构的基本单位。它是从一个或几个基本表中导出的 表，是从现有基本表中抽取若干子集组成用户的“专用表”。

基本表：基本表的定义指建立基本关系模式,而变更则是指对数据库中已存在的基本表进行删除与修改。

区别：1、视图是已经编译好的sql语句。而表不是

2、视图没有实际的物理记录。而表有。

3、表是内容，视图是窗口

4、表只用物理空间而视图不占用物理空间，视图只是逻辑概念的存在，表可以及时四对它进行修改，但视图只能有创建的语句来修改

5、表是内模式，试图是外模式

6、视图是查看数据表的一种方法，可以查询数据表中某些字段构成的数据，只是一些SQL语句的集合。从安全的角度说，视图可以不给用户接触数据表，从而不知道表结构。

7、表属于全局模式中的表，是实表；视图属于局部模式的表，是虚表。

8、视图的建立和删除只影响视图本身，不影响对应的基本表。

联系：视图（view）是在基本表之上建立的表，它的结构（即所定义的列）和内容（即所有数据行）都来自基本表，它依据基本表存在而存在。一个视图可以对应一个基本表，也可以对应多个基本表。视图是基本表的抽象和在逻辑意义上建立的新关系

游标是什么

游标字面理解就是游动的光标。

用数据库语言来描述：游标是映射在结果集中一行数据上的位置实体，有了游标，用户就可以访问结果集中的任意一行数据了，将游标放置到某行后，即可对该行数据进行操作，例如提取当前行的数据等。

DBMS的概念

数据库自带的的管理自身数据处理事务的工具