作者leo770319 (水水水水水水妖)
看板NTU-Exam
标题[试题] 97下 庄庭瑞 程式语言 期末考
时间Thu Jun 25 17:19:20 2009
课程名称︰程式语言
课程性质︰资管系选修
课程教师︰庄庭瑞
开课学院:管理学院
开课系所︰资管系
考试日期(年月日)︰2009.6.17
考试时限(分钟):120分钟
是否需发放奖励金:是
(如未明确表示,则不予发放)
试题 :
Part 1. Answer ○ if the statement is true; answer ╳ if the statement is
false. 4 points for each question.
1 In Smalltalk, one can tell which object is bound to self by looking at the
program text alone.
2 Both C++ and Smalltalk use garbage collection to manage memory.
3 Blocks are used in Smalltalk to implement conditional expressions.
4 In C++, a static data members of a class C is shared by all objects of the
class C.
5 In Smalltalk, a instance variable of a class C is shared by all objects of
the class C.
6 The first-class synchronous value event and the related operators in
Concurrent ML can be thought as language features for supporting procedural
abstraction.
7 Java suffers from the “ diamond inheritance problem” because a class may
implement multiple interfaces.
Given the following Prolog facts and rules
edge(a, b).
edge(b, c).
edge(a, c).
edge(b, d).
edge(e, d).
edge(e, f).
connect(X, X).
connect(X, Y) :- edge(X, Y).
connect(X, Y) :- edge(X, Z), connect(Z, Y).
Answer question 8, 9, and 10.
8 Query connect(e, e). returns no.
9 Query connect(a, f). returns no.
10 There are only three solutions to the query edge(X, Y), edge(X, Z), Y \= Z.
(Note: Y \= Z is GNU Prolog for Y not unifiable with Z.)
Part 2. Answer clearly, either in Chinese or English, solutions to the
following questions.
1. In a language with first-class functions and static scope, a function value
is generally represented by a closure, which is a pair consisting of a
pointer to function code and a pointer to an activation record. The
following ML code shows that, in a sense, one can simulate objects by using
colsures.
fun new (x) =
let
val c = ref x
fun f x = c := !c + x
fun g () = !c
in
(f, g)
end
(a) (5 points) Explain the above code, and write a few lines of ML code
which when executed will create two objects. Use the two objects
in some interesting ways, for example, for keeping the score of a
basketball game.
(b) (5 points) How can the above ML code be improved if in addition ML
records are used in the simulation? Rewrite the above code using
records, show how to create two objects, and how to use them in your
example.
(c) (5 points) Criticize this objects-by-closures simulation from the
viewpoint of data abstraction (even if ML records are used).
2. The textbook uses the following C++ code to illustrate the singleton
design pattern.
Class Singleton {
public:
static Singleton* instance();
protected:
Singleton();
private:
static Singleton* _instance;
};
Singleton* Singleton::_instance = 0;
Singleton* Singleton::instance() {
if (_instance == 0) { _instance = new Singleton(); }
return _instance;
}
(a) (5 points) Explain what does the above C++ code do, and how do the
class constructs in C++ help in this design. You must say what public,
protected, private, and static are for, and how do they help in this
design.
(b) (5 points) How can the above class be rewritten to support a poll of
fixed number of instances. That is, at most only k instances can be
used at a time, where k is a constant. You need to consider what shall
be done when a user wants to create an instance, and what to do when
an instance is destroyed. You need not write the complete C++ code, but
must describe precisely what the procedures are, and how the C++ class
constructs are used in your design.
3. (10 points) It is said that "subtyping is a relation on interfaces;
inheritance is a relation on implementations." Explain.
4. (10 points) What is subtype polymorphism, and what is parametric
polymorphism? Of the two languages Java and ML? Which language has which
polymorphism? Explain.
5. Given the following subtype relationships between classes Object, Shape,
Circle, and Square (note: no other subtype relationships exist):
Shape <: Object
Circle <: Shape
Square <: Shape
and the following Java code:
Object o = new Object();
Shape x = new Shape();
Circle y = new Circle();
Square z = new Square();
if (...) (* ... is some condition unknown at compile-time *)
{ x = y; } (*1*)
else
{ x = z; } (*2*)
o = x; (*3*)
x = o; (*4*)
y = o; (*5*)
z = o; (*6*)
(a) (5 points) Of the six lines from (*1*) to (*6*), which will cause
compile-time type errors? Why?
(b) (5 points) Some of lines that cause compile-time type errors actually
will never cause problems at run-time? Which lines and Why? How do you
use explicit type casts to avoid these spurious compile-time type
errors.
(c) (5 points) What does an explicit type cast do at run-time? That is,
what is "run-time type conversion"? Even if explicit type casts are
used at all lines in the above Java code to avoid all compile-time type
errors, some lines may still cause problems at run-time. Which lines?
Explain.
--
※ 发信站: 批踢踢实业坊(ptt.cc)
◆ From: 140.112.5.53
1F:推 wesley10000 :已收录 04/18 21:35