課程名稱︰程式語言
課程性質︰資管系選修
課程教師︰莊庭瑞
開課學院：管理學院
開課系所︰資管系
考試日期（年月日）︰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