Item 3: Use const whenever possible

The wonderful thing about const is that it allows you to specify a semantic constraint — a particular object should not be modified — and compilers will enforce that constraint. It allows you to communicate to both compilers and other programmers that a value should remain invariant. Whenever that is true, you should be sure to say so, because that way you enlist your compilers' aid in making sure the constraint isn't violated.

 

The const keyword is remarkably versatile. Outside of classes, you can use it for constants at global or namespace scope (see Item 2), as well as for objects declared static at file, function, or block scope. Inside classes, you can use it for both static and non-static data members. For pointers, you can specify whether the pointer itself is const, the data it points to is const, both, or neither:

 

char greeting[] = "Hello";

 

char *p = greeting; // non-const pointer,

// non-const data

 

const char *p = greeting; // non-const pointer,

// const data

 

char * const p = greeting; // const pointer,

// non-const data

 

const char * const p = greeting; // const pointer,

// const data

 

This syntax isn't as capricious as it may seem. If the word const appears to the left of the asterisk, what's pointed to is constant; if the word const appears to the right of the asterisk, the pointer itself is constant; if const appears on both sides, both are constant.

 

When what's pointed to is constant, some programmers list const before the type. Others list it after the type but before the asterisk. There is no difference in meaning, so the following functions take the same parameter type:

 

void f1(const Widget *pw); // f1 takes a pointer to a

// constant Widget object

 

void f2(Widget const *pw); // so does f2

 

Because both forms exist in real code, you should accustom yourself to both of them.

 

STL iterators are modeled on pointers, so an iterator acts much like a T* pointer. Declaring an iterator const is like declaring a pointer const (i.e., declaring a T* const pointer): the iterator isn't allowed to point to something different, but the thing it points to may be modified. If you want an iterator that points to something that can't be modified (i.e., the STL analogue of a const T* pointer), you want a const_iterator:

 

std::vector<int> vec;

...

 

const std::vector<int>::iterator iter = // iter acts like a T* const

vec.begin();

 

*iter = 10; // OK, changes what iter points to

 

++iter; // error! iter is const

 

std::vector<int>::const_iterator cIter = //cIter acts like a const T*

 

vec.begin();

 

*cIter = 10; // error! *cIter is const

 

++cIter; // fine, changes cIter

 

Some of the most powerful uses of const stem from its application to function declarations. Within a function

declaration, const can refer to the function's return value, to individual parameters, and, for member functions, to the function as a whole.

 

Having a function return a constant value often makes it possible to reduce the incidence of client errors without giving up safety or efficiency. For example, consider the declaration of the operator* function for rational numbers that is explored in Item 24.

 

class Rational { ... };

const Rational operator*(const Rational& lhs, const Rational& rhs);

 

Many programmers squint when they first see this. Why should the result of operator* be a const object?

Because if it weren't, clients would be able to commit atrocities like this:

 

Rational a, b, c;

...

(a * b) = c; // invoke operator= on the result of a*b!

 

I don't know why any programmer would want to make an assignment to the product of two numbers, but I do

know that many programmers have tried to do it without wanting to. All it takes is a simple typo (and a type that can be implicitly converted to bool):

 

if (a * b = c) ... // oops, meant to do a comparison!

 

Such code would be flat-out illegal if a and b were of a built-in type. One of the hallmarks of good user-defined types is that they avoid gratuitous incompatibilities with the built-ins (see also Item 18), and allowing assignments to the product of two numbers seems pretty gratuitous to me. Declaring operator*'s return value const prevents it, and that's why it's The Right Thing To Do.

 

There's nothing particularly new about const parameters — they act just like local const objects, and you

should use both whenever you can. Unless you need to be able to modify a parameter or local object, be sure to declare it const. It costs you only the effort to type six characters, and it can save you from annoying errors such as the "I meant to type '==' but I accidently typed '='" mistake we just saw.

 

const Member Functions

 

The purpose of const on member functions is to identify which member functions may be invoked on const

objects. Such member functions are important for two reasons. First, they make the interface of a class easier to understand. It's important to know which functions may modify an object and which may not. Second, they make it possible to work with const objects. That's a critical aspect of writing efficient code, because, as Item 20 explains, one of the fundamental ways to improve a C++ program's performance is to pass objects by reference-to-const. That technique is viable only if there are const member functions with which to manipulate the resulting constqualified objects.

 

Many people overlook the fact that member functions differing only in their constness can be overloaded, but this is an important feature of C++. Consider a class for representing a block of text:

 

class TextBlock {

public:

...

const char& operator[](std::size_t position) const // operator[] for

{ return text[position]; } // const objects

 

char& operator[](std::size_t position) // operator[] for

{ return text[position]; } // non-const objects

 

private:

 

std::string text;

};

 

TextBlock's operator[]s can be used like this:

 

TextBlock tb("Hello");

std::cout << tb[0]; // calls non-const

 

// TextBlock::operator[]

const TextBlock ctb("World");

std::cout << ctb[0]; // calls const TextBlock::operator[]

 

Incidentally, const objects most often arise in real programs as a result of being passed by pointer- or reference-toconst. The example of ctb above is artificial. This is more realistic:

 

void print(const TextBlock& ctb) // in this function, ctb is const

{

std::cout << ctb[0]; // calls const TextBlock::operator[]

...

}

 

By overloading operator[] and giving the different versions different return types, you can have const and

non-const TextBlocks handled differently:

 

std::cout << tb[0]; // fine — reading a non-const TextBlock

tb[0] = 'x'; // fine — writing a non-const TextBlock

 

std::cout << ctb[0]; // fine — reading a const TextBlock

ctb[0] = 'x'; // error! — writing a const TextBlock

 

Note that the error here has only to do with the return type of the operator[] that is called; the calls to

operator[] themselves are all fine. The error arises out of an attempt to make an assignment to a const

char&, because that's the return type from the const version of operator[].

 

Also note that the return type of the non-const operator[] is a reference to a char — a char itself would

not do. If operator[] did return a simple char, statements like this wouldn't compile:

tb[0] = 'x';

 

That's because it's never legal to modify the return value of a function that returns a built-in type. Even if it were legal, the fact that C++ returns objects by value (see Item 20) would mean that a copy of tb.text[0] would be modified, not tb.text[0] itself, and that's not the behavior you want.

 

Let's take a brief time-out for philosophy. What does it mean for a member function to be const? There are two prevailing notions: bitwise constness (also known as physical constness) and logical constness.

 

The bitwise const camp believes that a member function is const if and only if it doesn't modify any of the

object's data members (excluding those that are static), i.e., if it doesn't modify any of the bits inside the object. The nice thing about bitwise constness is that it's easy to detect violations: compilers just look for assignments to data members. In fact, bitwise constness is C++'s definition of constness, and a const member function isn't allowed to modify any of the non-static data members of the object on which it is invoked.

 

Unfortunately, many member functions that don't act very const pass the bitwise test. In particular, a member

function that modifies what a pointer points to frequently doesn't act const. But if only the pointer is in the object, the function is bitwise const, and compilers won't complain. That can lead to counterintuitive behavior. For example, suppose we have a TextBlock-like class that stores its data as a char* instead of a string, because it needs to communicate through a C API that doesn't understand string objects.

 

class CTextBlock {

public:

...

char& operator[](std::size_t position) const // inappropriate (but bitwise const)

{ return pText[position]; }         //declaration of operator[]

 

private:

 

char *pText;

};

 

This class (inappropriately) declares operator[] as a const member function, even though that function

returns a reference to the object's internal data (a topic treated in depth in Item 28). Set that aside and note that operator[]'s implementation doesn't modify pText in any way. As a result, compilers will happily generate code for operator[]; it is, after all, bitwise const, and that's all compilers check for. But look what it allows to happen:

 

const CTextBlock cctb("Hello"); // declare constant object

char *pc = &cctb[0]; // call the const operator[] to get a pointer to cctb's data

*pc = 'J'; // cctb now has the value "Jello"

 

Surely there is something wrong when you create a constant object with a particular value and you invoke only const member functions on it, yet you still change its value!

 

This leads to the notion of logical constness. Adherents to this philosophy argue that a const member function

might modify some of the bits in the object on which it's invoked, but only in ways that clients cannot detect. For example, your CTextBlock class might want to cache the length of the textblock whenever it's requested:

 

class CTextBlock {

public:

...

std::size_t length() const;

 

private:

 

char *pText;

std::size_t textLength; // last calculated length of textblock

bool lengthIsValid; // whether length is currently valid

};

 

std::size_t CTextBlock::length() const

{

if (!lengthIsValid) {

textLength = std::strlen(pText); // error! can't assign to textLength

lengthIsValid = true; // and lengthIsValid in a const

}

return textLength;

}

 

This implementation of length is certainly not bitwise const — both textLength and lengthIsValid

may be modified — yet it seems as though it should be valid for const CTextBlock objects. Compilers

disagree. They insist on bitwise constness. What to do?

 

The solution is simple: take advantage of C++'s const-related wiggle room known as mutable. mutable frees

non-static data members from the constraints of bitwise constness:

 

class CTextBlock {

public:

...

std::size_t length() const;

 

private:

 

char *pText;

mutable std::size_t textLength; // these data members may

mutable bool lengthIsValid; // always be modified, even in

}; // const member functions

 

std::size_t CTextBlock::length() const

{

if (!lengthIsValid) {

textLength = std::strlen(pText); // now fine

lengthIsValid = true; // also fine

}

return textLength;

}

 

Avoiding Duplication in const and Non-const Member Functions

 

mutable is a nice solution to the bitwise-constness-is-not-what-I-had-in-mind problem, but it doesn't solve all

const-related difficulties. For example, suppose that operator[] in TextBlock (and CTextBlock) not

only returned a reference to the appropriate character, it also performed bounds checking, logged access

information, maybe even did data integrity validation. Putting all this in both the const and the non-const

operator[] functions (and not fretting that we now have implicitly inline functions of nontrivial length — see

Item 30) yields this kind of monstrosity:

 

class TextBlock {

public:

...

const char& operator[](std::size_t position) const

{

... // do bounds checking

... // log access data

... // verify data integrity

return text[position];

}

 

char& operator[](std::size_t position)

{

... // do bounds checking

... // log access data

... // verify data integrity

return text[position];

}

 

private:

 

std::string text;

};

 

Ouch! Can you say code duplication, along with its attendant compilation time, maintenance, and code-bloat

headaches? Sure, it's possible to move all the code for bounds checking, etc. into a separate member function

(private, naturally) that both versions of operator[] call, but you've still got the duplicated calls to that function and you've still got the duplicated return statement code.

 

What you really want to do is implement operator[] functionality once and use it twice. That is, you want to

have one version of operator[] call the other one. And that brings us to casting away constness.

 

As a general rule, casting is such a bad idea, I've devoted an entire Item to telling you not to do it (Item 27), but code duplication is no picnic, either. In this case, the const version of operator[] does exactly what the nonconst version does, it just has a const-qualified return type. Casting away the const on the return value is safe, in this case, because whoever called the non-const operator[] must have had a non-const object in the first place. Otherwise they couldn't have called a non-const function. So having the non-const operator[] call

the const version is a safe way to avoid code duplication, even though it requires a cast. Here's the code, but it

may be clearer after you read the explanation that follows:

 

class TextBlock {

public:

...

const char& operator[](std::size_t position) const // same as before

{

...

...

...

return text[position];

}

char& operator[](std::size_t position) // now just calls const op[]

{

return const_cast<char&>( // cast away const on op[]'s return type;

    static_cast<const TextBlock&>(*this) // add const to *this's type;

[position] // call const version of op[]

);

}

...

};

 

As you can see, the code has two casts, not one. We want the non-const operator[] to call the const one,

but if, inside the non-const operator[], we just call operator[], we'll recursively call ourselves. That's

only entertaining the first million or so times. To avoid infinite recursion, we have to specify that we want to call the const operator[], but there's no direct way to do that. Instead, we cast *this from its native type of

TextBlock& to const TextBlock&. Yes, we use a cast to add const! So we have two casts: one to add

const to *this (so that our call to operator[] will call the const version), the second to remove the

const from the const operator[]'s return value.

 

The cast that adds const is just forcing a safe conversion (from a non-const object to a const one), so we use a

static_cast for that. The one that removes const can be accomplished only via a const_cast, so we don't

really have a choice there. (Technically, we do. A C-style cast would also work, but, as I explain in Item 27, such casts are rarely the right choice. If you're unfamiliar with static_cast or const_cast, Item 27 contains an

overview.)

 

On top of everything else, we're calling an operator in this example, so the syntax is a little strange. The result may not win any beauty contests, but it has the desired effect of avoiding code duplication by implementing the nonconst version of operator[] in terms of the const version. Whether achieving that goal is worth the

ungainly syntax is something only you can determine, but the technique of implementing a non-const member function in terms of its const twin is definitely worth knowing.

 

Even more worth knowing is that trying to do things the other way around — avoiding duplication by having the const version call the non-const version — is not something you want to do. Remember, a const member

function promises never to change the logical state of its object, but a non-const member function makes no such promise. If you were to call a non-const function from a const one, you'd run the risk that the object you'd promised not to modify would be changed. That's why having a const member function call a non-const one is wrong: the object could be changed. In fact, to get the code to compile, you'd have to use a const_cast to get rid of the const on *this, a clear sign of trouble. The reverse calling sequence — the one we used above — is safe: the non-const member function can do whatever it wants with an object, so calling a const member function imposes no risk. That's why a static_cast works on *this in that case: there's no const-related danger.

 

As I noted at the beginning of this Item, const is a wonderful thing. On pointers and iterators; on the objects

referred to by pointers, iterators, and references; on function parameters and return types; on local variables; and on member functions, const is a powerful ally. Use it whenever you can. You'll be glad you did.

 

Things to Remember

● Declaring something const helps compilers detect usage errors. const can be applied to

objects at any scope, to function parameters and return types, and to member functions as a

whole.

● Compilers enforce bitwise constness, but you should program using conceptual constness.

● When const and non-const member functions have essentially identical implementations,

code duplication can be avoided by having the non-const version call the const version.__

    故事会        >>> 2009年第1期   笑话１３则  作者：佚名  字体：
   【 大  中  小 】 
 
　　炸 薯 条
　　杰克炸薯条的时候油锅突然起火，他急忙打电话向消防局求助。事后，消防员警告他，以后炸薯条时要小心些。可是两星期后，杰克又在炸薯条时引发了火灾，消防队员再次匆匆赶来……
　　第二天，杰克见到自家门前有一个小包裹，包上面贴了张字条：“今后数周本消防局人手不足，敬希合作为盼！”杰克打开包裹一看，里面是一大包炸薯条。
　　 (郝英子)
　　
　　坏消息
　　小杜打算辞职，他兴奋地告诉同事：“终于不用再受这个领导的气了，我一会儿就去递辞职信。”可是，等小杜从领导办公室出来，脸上满是失望。
　　同事问道：“怎么了？领导没同意？”小杜嘟囔道：“比这还糟糕—领导拿到我的辞职信，一看就笑了，说：你跟我跳的是同一家公司。”
　　 （曹炜明）
　　
　　没鱼
　　一位先生大清早来到湖边钓鱼，他等呀等，鱼就是不上钩。到了下午，他肚子有点饿了，就到附近的餐馆吃东西。
　　先生问：“你们这里有什么东西吃？”
　　服务员说：“有糖醋鲤鱼、红烧鲫鱼、干炸带鱼、清蒸鲈鱼，还有……”
　　那位先生听了，自言自语道：“原来鱼都在你们这儿啊，我说湖里怎么钓不到鱼呢？” （田淑琛）
　　
　　浪漫举报
　　小王路过一家花店，看到橱窗里贴着一则广告：“本店情人节当天玫瑰涨至每支50元，若提前预订仍按每支5元结算，欢迎预订。”
　　小王的男朋友在工商局上班，各方面都不错，就是不懂浪漫，小王想趁这个机会点拨点拨他，让男朋友先订好玫瑰，情人节那天再送给自己。于是她拨通了电话，委婉地对男朋友说：“刚才路过一家花店，人家说情人节那天玫瑰要涨到50块钱，但现在预订的话只要5块钱，你看……”
　　电话那头马上说：“哦，知道了，那家花店叫什么名字？在哪儿啊？”
　　小王一听男朋友开了窍，高兴地把花店的名字和地址告诉了他。
　　整个上午，小王都沉浸在幸福中。没多久，她男朋友回电话了：“刚才我把你说的向执法队汇报了，人家说情人节期间玫瑰涨价属于正常价格波动，不违法，我们没法查……”
　　 （佚名）
　　
　　上海话
　　小李来到上海某外企应聘面试，刚坐定，面试官就用英文问他问题。
　　小李愣了一下，说：“请你不要跟我说上海话，我不是上海人。”
　　面试官闻言绝倒。
　　 （曹炜明）
　　
　　霸道的美眉
　　学校里有个美眉，每次上课都要占第一排左边的那个位子，占不到就和别人大吵。久而久之，大家都默认那个位子是她的，不和她争。
　　一次，一个新来的男生坐到了这个位子上，美眉走进教室一看，立刻对着男生嚷嚷，说这座位是她的，她都坐了几个月了。男生愣了一下，冷笑道：“坐了几个月就霸占了？我脚下的地球都踩了快二十年，到现在都不敢说是我的！”
　　 （郝翠英）
　　
　　唯恐太迟
　　一个男人手拿纸袋在路上狂奔，恰巧被一位巡警遇上，巡警怀疑他可能偷了什么东西，于是就上前把他拦住了：“喂，站住！袋子里是什么东西？”
　　男人一惊，答道：“是一套时装。”巡警问：“哪里来的?”
　　男人说：“时装店里刚买的。”巡警问：“到哪里去?”
　　男人答：“回家给我老婆。”
　　巡警奇怪了，问：“那你为什么要这样狂奔?”
　　男人叹了口气，说：“迟了，恐怕她又嫌式样旧了。”
　　 （弯月如眉）
　　
　　你爱嫁谁就嫁谁
　　女孩对爸爸说，她喜欢隔壁的帅哥，结果爸爸小声告诉她：“那是你同父异母的哥哥，你们只能做普通朋友。”
　　几个月后，女孩又对爸爸说，她喜欢上了巷口那家的帅哥。爸爸说：“不行，那是你另一个同父异母的哥哥，你们也只能做普通朋友。”
　　女孩受不了，哭着对妈妈说了一切，妈妈安慰她说：“孩子，你爱嫁谁就嫁谁，你根本就不是你爸的女儿。”  (李从渊)
　　
　　好借口
　　一名男子在公路上超速开车，他从后视镜中看到一辆闪着红灯的警车，就想：我比这家伙开得快，一定能逃脱，于是他把油门踩到底，一场竞赛开始了。两辆车在公路上飞驰，时速越来越快……最后，这名男子还是被警察追上了。
　　警察从巡逻车里出来，走向这名男子的车，对他说道：“听着，先生，我今天非常累，现在只想下班回家。你找个像样的借口，我就放你走。”
　　那男子想了一会儿后说：“三个星期前，我老婆跟一个警察跑了。刚才我在后视镜里看见你的巡逻车，以为你就是那个警察，想要把老婆还给我！因为，没有人能够忍受她超过一个月……” (郝英子)
　　
　　没人磨墨
　　一个富家之子要去参加科举考试，父亲事先考了他一下，成绩很好，满以为一定能录取，不料竟然榜上无名。
　　父亲赶去找考官评理。考官调来卷子查看，只见卷子上面淡淡一层灰雾，看不到有字。
　　父亲一回家便责骂儿子：“你的考卷怎么写得叫人看也看不清？”儿子哭道：“考场上没人替我磨墨，我只得用笔在砚上蘸着水写呀！”  （刘力）
　　
　　多少钱不算贵
　　阿明乔迁新居，朋友送来一个水族箱，阿明便买了二十多条热带鱼放在里面。老婆下班回来后见阿明买了鱼，就指着一对“红剑”，问：“这鱼多少钱买的？”阿明忙说：“5元一对。”谁料老婆一撇嘴：“贵了，最多值3元。这对‘珍珠鱼’呢？”
　　“6元。”
　　“贵了贵了，也就值3元……”
　　老婆一口气问了好几种鱼，都说阿明买贵了，那口气仿佛他是个白痴，让人狠宰了一顿！最后老婆指着一对“小吻嘴”问：“这个多少钱？”
　　阿明心里不痛快，就没好气地说：“一毛钱两条，不贵了吧？”
　　谁知老婆大喝一声：“太贵了！你买了那么多鱼，这对就该白送！”
　　 （史顺利）
　　
　　包子的儿子
　　丽丽有一次问妈妈：“妈妈，我从哪里来的？”妈妈说：“从我的肚子里挖出来的，不信你看，我肚子上还有一个口子呢。”由于是剖腹产，丽丽一看，妈妈肚子上还真有一条伤疤。
　　这天，丽丽在吃肉包子，她不想吃里面的肉馅，就对妈妈说：“妈妈，这个包子的儿子给你，妈妈我留下吃。”说着，她把肉馅放在了妈妈碗里，把包子皮全吃了。
　　 （佚名）
　　
　　
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第1期   芝麻开门  作者：王兴菜  字体：
   【 大  中  小 】 
 
　　 
　　这天，董事长家又出了一点麻烦事：家里的保险箱打不开了，这保险箱放在董事长的卧室里，董事长突然想到要拿一件东西，连输了几遍密码都没有打开，王夫人急着打电话给公司，让他们找人来开，趁着这当儿，为了给董事长解闷，席先生讲了一个开锁的故事……
　　
　　现在科技发达，锁也有各种各样的开法，有家公司，新造了一栋十八层的办公大楼，十分气派，这还不算啥，最特别的是这大楼的“门禁”，采用了一种科技含量极高的声音控制识别系统，也就是说，事先把办公室主人说的一句暗语作为“密码”，录入到电脑主机里，主人只要说一遍“密码”，门禁系统就能自动识别，门就能自动打开，换了别人，除非把门砸烂了，否则就别想进去。这个门禁系统正是公司办公室的小王负责引进的。
　　总经理对这个新系统感到很得意，大会小会没少表扬小王，还美滋滋地选了故事《阿里巴巴与四十大盗》中的暗语“芝麻开门”当作自己的开门暗语。
　　搬进新办公楼的第一天，小王兴高采烈地陪着总经理，坐电梯来到办公室门前，总经理站着，清了清嗓子，很文雅地说了句：“芝麻开门。”出乎两人意料的是，门居然没开！
　　总经理笑着说：“看来这门也有睡着的时候啊！”说完，他把脖子上的领带松了松，脆生生地又喊道：“芝麻开门！”可门依然纹丝不动，这一下小王的脸就挂不住了，总经理耐住性子喊了十几遍，门死活不开，小王早就急得满头大汗了。
　　总经理的脸色不好看了，他要小王赶紧找人看看怎么回事。这门禁系统是一家科技公司开发的，小王连忙打电话过去问怎么回事，接电话的技术员立即采用远程登录，细致地查了一遍这边的子网，说：“奇怪了，从我这边看，你们的声控系统工作一切正常啊，我问一下，是谁在这个房间里办公啊？”
　　小王压低声音说：“是我们总经理，兄弟你好好查查，救个场。”
　　技术员在电话那边想了半天，恍然大悟道：“对了，你们总经理他经常喝酒吧？”
　　总经理三天两头喝得是红光满面，可小王想不通，喝酒跟开门有什么关系，他操着手机，压低声音说：“这还用问吗，公司老总不喝酒的有几个？”
　　技术员兴奋地说：“那就对了，我怀疑那天录音设置密码时他喝了酒，血液里酒精含量高，思维减缓，可能导致音时过长，所以现在打不开门了。你让你们总经理模仿喝醉酒的声音说一遍密码，只要音时对了，门就可以打开了。”
　　小王挂上电话，吞吞吐吐地把对方的意思对总经理说了，总经理听了，脸色立刻晴转多云，他装出一副醉酒的腔调，拉长声音说：“芝……芝麻……开门……”一连说了五六遍，可门还是打不开！
　　小王赶紧又打电话向那个技术员咨询，对方自言自语说：“这就奇怪了……”想了半天，他突然问了一句：“你们总经理说话时是不是带有方言的口音啊？”
　　 
　　小王恍然大悟，可不是嘛，平时总经理的普通话说得还挺好的，但一激动，说起话来乡音就重了，说不定那天录音时他激动了，带了乡音了，于是他赶紧把技术员的话转述了一遍，总经理没办法，嘴唇哆嗦了几下，张了半天嘴，才说出口：“舅妈开门！”
　　小王一听差点笑出声来，怪不得总经理不好意思说，原来他的家乡话里“芝麻”的发音是“舅妈”。总经理对着那扇门，喊了十几遍“舅妈”，可门依然紧紧地锁着！
　　这一下，小王的脸都急白了，他忙把电话又打了过去：“喂，你们究竟能不能把这个门给弄开？再不行，你们过来，把门禁都给我撤了，把技术开发费给我们退回来！”
　　一旁的总经理也十分恼火，他说：“小王，你弄的这个叫什么玩意啊？还高科技，这不是折腾人吗？”
　　小王吓坏了，赶紧让那个技术员过来一趟，不大一会，技术员赶了过来，他把门禁仔细检查了一遍，结果显示一切正常。技术员无奈地说：“现在只有用电脑分析一下原来录进去的那句话了。”经过一番检测，结果很快出来了，技术员拿着分析单，眼睛瞪得像铜铃，小王赶紧问他怎么了，技术员目瞪口呆地说：“不可能，绝对不可能！分析结果显示，你们总经理在录‘芝麻开门’这句话的时候，受到了极度惊吓，音时、音高和音强都变了，这太不可思议了！”
　　不巧这话被站在一旁的总经理听到了，他冷笑道：“开玩笑，受到极度惊吓？在这里我是一把手，我怕什么啊？”嘴里这样说着，可他的脑子里却一下明白了是怎么一回事：那天，在老办公楼录音，正巧女秘书溜到他办公室，两人偷偷鬼混，不巧他老婆临时有事来办公室找他，门卫把电话打过来，说他老婆快到办公室了，总经理吓坏了，他赶紧让女秘书藏到办公桌下面，自己装模作样地坐在老板椅上。老婆前脚进屋，小王后脚带着技术员进门录音，总经理心怀鬼胎，对着录音笔，哆哆嗦嗦地说了“芝麻开门”四个字，那个时候，你说总经理能不紧张吗？可当时是当时，现在是现在，要让总经理恢复当时的心情，这能装得像吗？
　　总经理正要发火，楼道里过来了几个陌生人，指名道姓要找总经理，总经理傲慢地说：“什么事啊？”
　　来人出示了证件，是检察院的，他们说接到举报信，有人前天给总经理送了二十万现金，他们是来调查这件事的。总经理听了冷笑一声：“开玩笑，有人送我二十万，我怎么不知道？”
　　 
　　检察院的人说：“你认识一个叫李远的承包商吧，他前两天有没有送你两箱牛奶？”
　　总经理漫不经心地说：“记得，怎么了，两箱牛奶值二十万？”
　　“牛奶不值二十万，可装牛奶的箱子足够装得下二十万现金。”
　　话音刚落，总经理的脸色就变了，可不是嘛？李远那家伙前两天确实送了他两箱牛奶，结果忙着搬到新办公楼来，他也没顾得上拆开，就直接让搬运工搬过来了。
　　“你现在把那两个箱子放哪里去了？”
　　总经理结结巴巴地指着办公室说：“放……放到这间办公室里了。”
　　检察院的人说：“那你能配合我们一下、把门打开吗？”
　　总经理擦了擦额头的汗，说：“这门现在打不开，它是声控门，现在出了点问题。”
　　检察院的人笑了：“这是迄今为止我们听过的最好的借口，那我问你，既然打不开门，你又是怎么把箱子放进去的？”
　　总经理赶紧解释：“搬东西进去的时候，系统还没有启动，现在系统启动了，就打不开了。”
　　“既然是声控门，你设定的密码是什么？再说一遍试试看。”
　　总经理说：“我设的密码是——‘芝麻开门’……”说到这里，他张大着嘴，却说不下去了，因为那扇门突然打开了，而放在门口正中央的，正是那两箱扎眼的牛奶……
　　这回，总经理真的是紧张了，他得接受检察院的调查了……
　　 （本期作者：王兴菜）
　　 （题图、插图：安玉民 梁 丽)
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第1期   不可告人的梦  作者：小　芦  字体：
   【 大  中  小 】 
 
　　 
　　初三女生乐丹是个开朗活泼的女孩，整天无忧无虑地学习、生活。一天，乐丹的同桌刘雁看到乐丹桌上放着一本精品笔记本，本子上有一个生动的米老鼠卡通图案，封面上还写着三个字：梦记本。只听说过日记本，“梦记本”又是什么呀？
　　乐丹悄悄告诉刘雁，在她小学六年级的时候，就养成了一个习惯：早晨起来，把昨晚做的梦记录下来，渐渐地就记成了一本“梦记本”。乐丹有点得意地说：“如果每天一个梦，一年下来就有365个梦，你想呀，以后翻阅自己的梦记本，就是回忆一个个形形色色的梦，多有意思呀！”的确很好玩！刘雁迫不及待地说：“能让我看看吗？”
　　“没问题，随你看啦！”乐丹大方地把梦记本递给刘雁。刘雁翻开本子，只见每天的“梦记”有长有短，最短的只有两个字：忘了。刘雁饶有兴趣地一页页看下去，呵呵，乐丹这个女孩真是太有意思了，她的梦真是千奇百怪呢：有一次她梦见自己参加了奥运会，上午夺得了跳高冠军，下午把举重冠军也捎带拿走了；还有一次，梦到自己变身为蜘蛛侠，保护着唐僧去西天取经；有时她也会梦到很惨的情况，比如考了全班倒数第一名，吓得不敢回家，四处流浪……
　　乐丹的很多梦都特别有意思，加上她文笔好，语言风趣，看她的梦记本，简直像是在看一本童话故事集。后来，其他同学也听说了乐丹有一本记录了她三年梦境的梦记本，就纷纷来找乐丹借阅。乐丹来者不拒，为了公平起见，还给找她借阅的同学们编上了号，看完就转给下一号……一时间，乐丹的梦记本成了班上最受欢迎的课外读物。
　　一个月下来，几乎班上所有同学都看过了乐丹的梦记本。有些同学还跟乐丹约定，以后记录了什么精彩的新梦，要第一时间给他们看！
　　可是最近，刘雁发现一件怪事，一向落落大方的乐丹，忽然对外关闭了她的梦记本，谁也不借了，她把梦记本拿回了女生宿舍，每天把抽屉锁得严严实实，很明显是担心别人看到。为什么会这样呢？刘雁跟几个同学私下分析后，得出结论：一定是乐丹做了什么不可告人的梦，所以不敢把自己的梦记本给别人看了！
　　刘雁猜得不错，乐丹是做了一个不寻常的梦。乐丹在这天的梦记本里，说这是一个“好奇怪”、“好恐怖”的梦。乐丹真的被自己的这个梦吓坏了，她下定决心，一定要保守好这个秘密，绝不能让任何人知道自己做了这么个奇怪而恐怖的梦！
　　十几岁的孩子，正是充满好奇的年龄，乐丹越是捂紧了自己的梦记本，同学们越是想看。这天中午，乐丹忘了锁抽屉就离开了，刘雁跟同宿舍的几个女生小心翼翼地拿出乐丹的梦记本，几个脑袋凑在一起，瞪大眼睛搜索起那篇“绝密梦记”来。几个女孩很容易就找出了那篇梦记，这篇梦记不长，两三分钟就看完了，看完以后，几个女孩你看看我，我看看你，谁都想说话，可谁都在心里憋着，一副忍着不说出来的样子。这时，有人敲门，是班主任张老师来通知开班会，刘雁赶紧把食指放在嘴唇上，做了个“嘘”的姿势，严肃地说：“谁都不许说—”几个女孩纷纷点头。
　　但是，让小孩子保密是很困难的，特别是十几岁的女孩子。不出一个星期，班上所有同学都知道了那篇“绝密梦记”的内容。虽然同学们私下都传开了，乐丹却还被蒙在鼓里，仍然小心地保护着自己的梦记本。
　　 
　　乐丹太担心别人看到她的梦记本了，还找来了工具，想在梦记本上再加一个锁，却弄不好，还差点弄伤了手指。平时上课，乐丹也会想着这个“恐怖”的梦境，都快有点神经质了，成绩也开始下滑……
　　一个周末，班主任张老师提议，组织全班去郊外春游爬山。这天阳光明媚，山上空气清新，同学都开心极了，一路说说笑笑，乐丹也很兴奋，一年也难得有几次爬山的机会呢！
　　爬山的时候，同学们发起了竞赛，看谁先到山顶。乐丹累得额头冒汗，眼看离大部队越来越远了，这时，旁边递来一块洁白的纸巾。乐丹扭头一看，是班主任张老师。张老师大学刚毕业，去年才应聘到乐丹的学校做老师，他个子很高，人也长得文质彬彬，五官棱角分明，很有点韩国电影男主角的味道呢！不过，张老师戴眼镜，这点可要扣分了……
　　乐丹接过纸巾，莫名其妙地感觉脸上蓦地一热。张老师微笑着问：“累不累？”乐丹点点头，喘着气说：“我、我爬不动了，老师您先走吧。”
　　张老师却笑着说：“来，老师带你！”接着向乐丹伸出了手。张老师他竟然要牵乐丹的手？
　　乐丹一时间都有点发懵了，这……这合适吗？可以吗？
　　毕竟，乐丹是个大方开朗的女孩，稍一犹豫，就伸出手来。她的手被张老师轻轻握在手里，可她的心却紧张不安地跳动着，被一个除了爸爸以外的成年男人牵着手，这可是第一回呀！感觉旁边的人好高，他的手也很大！
　　同学们都看到了张老师牵着乐丹的手，有些同学稍稍露出惊讶的表情，不过，这样的表情转瞬即逝，大家很快就继续各玩各的，似乎觉得这也没什么。
　　就这样，从半山腰到山顶，张老师一直拉着乐丹的手，带着她爬山。渐渐地，乐丹的表情自然了，开始和张老师叽叽喳喳地说起了话。两人很快就赶上了大部队，刘雁和其他几个女孩子看到乐丹，招呼她去看山间的野花，乐丹高兴地跑了过去，而不知什么时候，张老师已经悄悄地松开了手，乐丹甚至都没有感觉到呢，一切都是那么自然……
　　春游回去后，乐丹突然有种松了口气的感觉：自己担忧了很长时间的事情，原来并没有什么可怕。乐丹在梦记本的扉页写下了这样一句话：任何梦都很正常，并不代表什么。其实，那个曾经令乐丹封锁梦记本的梦是这样的：
　　
　　昨天我梦见走了很长的路。起初是我独自一人，后来我开始朝高处走，像是在爬山，很高很高的山。爬着爬着，突然有一个人拉住了我的手，是一个男孩子！他很高大，年纪有二十几岁吧，他的手很有力，把我的手抓得很紧，但我觉得很温暖，很开心……
　　就这样，我被他拉住手，我们走呀走呀，走了很长时间，我抬头看他的脸，刚好，他也在看我，微笑地看着我，我却吓得一下子叫了出来！他—是我的班主任张老师！
　　怎么会这样啊？怎么是张老师啊？一开始我都不知道是他啊！我是不是犯错误了？我难道对张老师……哎呀，好奇怪好恐怖的梦啊！
　　当初，刘雁她们偷看了乐丹的梦记本后，其他同学也渐渐知道了乐丹那个“奇怪恐怖”的梦，再后来呢，张老师也知道了。张老师经过一番思考，没跟乐丹说什么，只是在那天春游爬山时，特意拉了乐丹的手，张老师是想告诉乐丹：即使你真的拉了老师的手爬山，也没什么，何况只是一个梦而已。
　　虽然张老师没有明说，但张老师相信，聪明的乐丹会领悟自己的意思的。
　　 （题图、插图：安玉民 梁 丽)
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第1期   十三个女人和一条项链  作者：木　木　编译  字体：
   【 大  中  小 】 
 
　　 
　　琼奈尔是个收入微薄的小职员，她前不久刚离了婚，一个人带着两个孩子，日子过得紧巴巴的。这天，她准备去超市买些打折的水果，经过一家首饰店时，她不禁停下了脚步—
　　在首饰店展厅的正中位置，摆放着一条钻石项链，项链躺在黑色的天鹅绒上，熠熠生辉。一颗颗钻石被一根细链穿着，连向搭扣，正中的钻石最大，紧挨着搭扣的两颗钻石最小。项链的做工十分精致，设计者似乎摸透了女人的心思。琼奈尔心想：如果把它戴在脖子上，产生的效果一定令人窒息。
　　作为已婚妇女，琼奈尔自然有几件首饰，不过，这样奢华的项链却是她从来没有戴过的，也许以后也不会有机会戴。就在这一念之间，琼奈尔走上前去，指着那条项链，问店员：“我可以看看橱窗里的那条项链吗？”
　　项链戴上了琼奈尔的脖项，她对着镜子转了转身，深深地吸了一口气：太美了！她整个人都因为这条项链变得光彩照人起来。琼奈尔忍不住问道：“多少钱？”
　　“三万七千美元。”店员客气地答道。
　　琼奈尔倒吸了一口凉气，三万七千美元！除了那些有钱人，谁会买这样的项链呢？琼奈尔将项链还了回去，然后快步走出店铺。这一晚，她根本睡不着，店员的话还在她的耳边萦绕：“这根项链上有118颗天然钻石，打磨精细，总重量是15点24克拉。”琼奈尔忧郁地想：如果自己就这样生活下去，是永远不可能买得起这样的好东西的。
　　几天后，琼奈尔和母亲一起去超市购物，路过首饰店，她发现那条项链还在老地方，不过已经打折了，由三万七千美元降到了两万两千美元。琼奈尔忍不住拉着母亲走进店里，让店员将项链拿出来，又一次佩戴在了脖子上。“怎么样？”琼奈尔转了转身，微笑着问母亲。
　　“美！太美了，亲爱的。”老太太满意地点着头，可琼奈尔转过身背对母亲时，分明听到了母亲清晰的叹息声。
　　离开超市后，母亲对琼奈尔说：“这项链真的很好，可是，这么珍贵的珠宝，在什么场合下才适合佩戴呢？一年到头，也不过那么几天罢了。” 老人这么说，是想劝慰自己的女儿，可琼奈尔听了这话，反而眼前一亮：对啊，工薪阶层的人，谁会一天到晚戴着钻石项链到处跑呢？只有在一年中具有重要意义的时刻才会佩戴，这样才能显出那日子的珍贵。自己拿不出两万多美元，可是一千美元总还是有的啊，如果能再找到十一个人，每人出一千，那就是一万二千美元，再上首饰店砍个价，应该也就差不离了。他们能一次降价一万五，为什么不能再降一万美元呢？琼奈尔想到这里，不由兴奋起来：行，就这样干！她赶回首饰店，掏出了一千美元，预订下了那条项链。
　　回到家，琼奈尔给自己的大学同学、朋友、同事们一一打电话，邀请她们和自己共同出资购买项链，可是，绝大多数人都说不行，有人说没钱，有人说没兴趣。尽管费了一番周折，可琼奈尔还是找到了七位伙伴，在首饰店的账单到达之前，她又找到了另外四位，现在，可以按照她最初的想法，十二个人共同去买那条钻石项链了。
　　十一个同伴在琼奈尔的带领下来到首饰店，接待她们的是首饰店的男主人保尔。琼奈尔拿出订单，又将另外的一万一千美元递了过去，目光坚定地说道：“再打个折吧，一万二，怎么样？”
　　保尔呆呆地看着桌上的一大堆现金和这十多个青春不再的妇人，心里忽然升起一阵感动：对这些妇人来说，这条项链代表了一个梦想—对生活中美好事物的梦想。
　　保尔犹豫了片刻，向琼奈尔她们说道：“请稍等一会儿，这间店铺不由我一个人说了算。” 说完，保尔走进里间，给自己的妻子莫里丝打电话，这间首饰店其实是他妻子的产业，保尔不能擅作主张。
　　莫里丝听保尔说明原委后，很是惊诧，她沉吟了片刻，答道：“亲爱的，你要知道，如果降价到一万二，利润太低了，等于我们没进这件货物。”
　　保尔挂上了电话，想了想，把不卖这件首饰的利弊分别写在了纸上：不卖，则意味着压货，现在货物已经压了四个月了；卖，多少还有一些利润，比起压货来，还是赚了。然后他根据这个意思，又给妻子莫里丝打去了电话，莫里丝听了丈夫的意见后，斩钉截铁地回答道：“亲爱的，最低一万三千美元，我们不能再让了。”
　　保尔走了出来，把最后的报价告诉了琼奈尔和她的同伴们，他斟酌着言辞，说道：“一万三千美元，距离你们出的价只差一千美元了。如果你们愿意，那一千美元由我来负担，我替你们找一个合作者。在她本人没有到场之前，你们如何安排这项链的用途，得告诉我一声。”
　　琼奈尔听了保尔的话，欣然同意了，她真的按自己的意愿买到了珍贵的项链！尽管在十一个同伴中，有的只是朋友的朋友，有的她甚至还不认识，但她们都对自己的追求深信不疑，那就够了。她觉得，自己的人生因为这条项链得到了升华：有什么困难不可以克服呢？只要把自己想要的告诉别人，别人也恰好认同你的需要，那坎坷也会变成坦途。
　　 
　　这十二个妇人，包括琼奈尔在内，年龄都在45岁到60岁之间，她们的职业，有的是护士，有的是教师，有的则和琼奈尔一样，是普通的职员。买下项链后，她们在一家咖啡馆坐定，商量佩戴项链的时间，意见很快达成了一致：
　　每人每年可以申请佩戴项链一个月，就是佩戴人生日的那个月。除此以外，合伙人可以根据自己的临时需要，申请佩戴项链，但前提是，那个月没有人过生日，或者过生日的那个人不再想佩戴项链了。不管是何种申请，十二个人必须共同参与对申请的审批，大家得聚在一起，开一个小型的派对。
　　凑巧的是，她们的生日恰好都不在同一个月。第一个月，轮到凯恩娜戴项链，凯恩娜平日里大大咧咧，粗心的她曾惹出过不少乱子。她拿到项链的那天晚上，几乎彻夜未眠，这么贵重的东西，她得让它安然无恙地交到下一个同伴的手里呀！千万不能让小偷给偷走了。当一个月后，凯恩娜把项链归还给保管者琼奈尔时，她不禁喜极而泣，她向参与聚会的十一个同伴说道：“因为这条项链，我平生第一次意识到了责任，说来也怪，我都这么大岁数了，以前还从不知道忧虑是怎么一回事呢。”说着，凯恩娜与其他人热情地拥抱。
　　第二个申请佩戴项链的是丽莎，因为下个月就是她的生日。丽莎平日里有些自闭，她害怕与人打交道。可是，在这个月里，她佩戴着项链，落落大方地向前来祝贺生日的亲朋答谢。丽莎的丈夫说，自己的妻子仿佛变了个人，她现在有着前所未有的自信。
　　就这样，按着月份，项链在一个又一个同伴的手里传递了下去。苔丝没有大学学历，一直很自卑，可她凭着脖子上的项链，找到了好工作；迪安娜是个空巢老人，生活一直很孤寂，她因为朋友凯恩娜的介绍，无意中参与到了购买项链的活动中，定时地参加这十二个人的派对，变得开朗活泼起来……
　　转眼一年将逝，十二个人的人生，竟都因为这条项链发生了积极的变化。她们的故事，也在这个小城里传开了：起初，人们以为合伙买项链不过是爱臭美的女人们迫不得已的行为，可是现在，整个城市的观点都发生了变化。人们认为，这一万多美元，维系的是人与人之间最纯真的东西。
　　只有琼奈尔心里还有些嘀咕，因为她记得，买项链的人中还有一个没露面。直到第二年的春天，琼奈尔忽然接到了一个电话，对方清楚地说道：“琼奈尔女士吗？我是保尔，你记得吧？就是卖给你项链的那个人，对，我入了股，现在我向你申请佩戴那条项链。”
　　琼奈尔问起这第十三个合伙人是谁，保尔毫无保留地说道：“我是为我的妻子入股的。上个月，我们的首饰店因为金融危机，被迫转让了，现在莫里丝和我一文不名。下个月就是她的生日，我知道，她很沮丧，我需要你和你的伙伴们共同的帮助。”
　　莫里丝神情恍惚地被保尔领到聚会中，她的眼神还是十分迷离。看到莫里丝走进房间，琼奈尔她们十二个人一齐站起身来，热烈地鼓掌，欢迎这最后一位合伙人。琼奈尔宣布，下个月由莫里丝佩戴项链。莫里丝一下子愣住了，渐渐地，她的眼睛里闪出惊喜的光芒来，她静静地让保尔为她戴上项链，眼睛湿湿地对丈夫说道：“我终于知道你当初为什么执意要把项链卖给她们了。你在我变得一无所有时，为我留下了爱。谢谢，真的谢谢你！”
　　 （原著：［美］凯维尔·查维斯）
　　 (题图、插图：佐 夫)
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第1期   认亲有奖  作者：陈建勇  字体：
   【 大  中  小 】 
 
　　 
　　张强和小丽两口子是四川人，在广东打工有些年头了，工资虽然不是很高，但单位很稳定，该有的福利他们都有。
　　这天，张强他们所在的工业区贴出了广告，说是晚上要在广场上搞一个四川老乡认亲有奖活动，谁能认出录像上家乡的亲人，奖千元手机一部。
　　这个工业区里四川老乡特别多，是不是谁看中这个商机来搞促销活动？现在搞促销的手段很多，看到这样的广告，谁都会联想到是促销。张强两口子当天晚上来到广场一看，黑压压的到处都是人，到处是四川话，不过广场上没有促销的广告标语，只见主席台上摆着一部大彩电，旁边挂着一副标语：“老乡，你认识自己的亲人吗？”台下的一张桌子上放着一台播放机，旁边坐着一个漂亮的女人，大概是这次活动的组织者。
　　这个女人张强认识，她是一家公司老板的妹妹，叫纪娜丽。那老板也是打工出身，后来创立了一家公司，员工有几百人，多数是四川老乡。
　　一会儿，纪娜丽拿着麦克风走到台上，对“认亲有奖”活动作了说明，这活动挺简单：谁只要把录像里的亲人认出来，就奖一千元的手机一部；认错了，或者是看到自己的亲人不认的，都要上台表演一个节目。
　　接下来就开始放录像，录像上先是他们家乡的风貌，有远景的村落，有清澈的小河，有学校的校舍……有人说，这是他们那里的小河；有人说，这是他读过书的学校，这些无声的镜头，使老乡们倍感亲切。
　　山水风光过后，镜头上出现了一个老人的背影，老人光着背，挑着一担谷子，看样子是刚收完稻谷回来，他光着脚踩在山路上。镜头放到这里停住了，纪娜丽问：“有人认出这个老人没有？”这时，有人说话了：“有财，这老人很像你爹！”
　　那个叫有财的人没吭声，录像继续放，画面又跳到老人身上，老人挑着那担谷，上了一个坡后走不动了，停下来歇息，他坐在路边的石墩上，拿出纸烟来卷，这时是正面的镜头，认识老人的老乡看清楚了：那正是有财他爹！
　　紧接着，画面上出现了这样的镜头：纪娜丽拿着麦克风走上去，向老人问好，和他聊天，知道老人的儿子有财在外打工，几年没回家，就问他想不想儿子，老人说：“想啊，哪有不想的？”说这话时，老人望着远方，眼睛里流露出无限的思念……
　　有财无语，只好上台表演节目，可有财不会唱歌跳舞，他说自己想讲几句话，可不可以？得到纪娜丽允许后，有财对着电视里的父亲说：“爹，对不起你，连你的背影都不认得了！”然后他向爹深深地鞠了一躬，这时，早有人用摄像机把这个镜头拍摄了下来，全场鸦雀无声，老乡们似乎都想起了自己的父亲……
　　接下来的镜头是在教室里，三个小学生，全是女孩，这回不是背影，是正面镜头，她们长得有几分相像，圆脸，大眼睛，有两个酒窝，同样的学生装，同样的短发，她们各自拿着一个号，分别是1、2、3号。纪娜丽指着镜头说：“这三个孩子，她们的家长就在你们中间，现在你们来认，看谁认得出来。”
　　沉默的气氛一下打破了，广场上的老乡议论开来：这是谁家的孩子？
　　张强瞪大眼睛盯着屏幕，觉得这些孩子全像自己的女儿珊珊，但到底哪个才是，他拿不准，他小声问身旁的老婆小丽，可是小丽的语气也十分犹豫，这一下张强来了气：“做娘的连自己女儿也不认得，真是岂有此理！”
　　小丽听了不舒服，造成这种局面的，还不是他张强？原来两口子计划两年回一次家的，可到今年，说不休年休假的，可以拿三倍的工资，两人一算，两口子要是回家一次，三倍的工资再加上广东到四川的路费，可要损失四五千块钱，结果一咬牙，就没回去。这一没回家，就三年没见女儿了，小孩子三年不见，变化可大了，哪里认得准？怎能怪她小丽做娘的不称职？
　　小丽不服气：“我不称职，你称职，你称职你去认！”两人斗气，张强一急就说：“我认就我认，认对了有手机，认错了不过就是表演个节目！”张强的流行歌曲唱得不错，怕什么？于是他就往人群里挤，可是，张强没走两步又回来了，他觉得现在不能认，三个孩子都有点像，把握不大，如果有人认出一个孩子，他再上去在两人中认一个，这样把握就大些。
　　张强没上去，也没有别的老乡上去，大概都是和张强一样的想法，不敢上。看没人上，纪娜丽又把难度降低一些，继续放了几个特写镜头，这几个镜头刚放完，有个中年女人上台了，她指着１号说，这是她的女儿。
　　纪娜丽乐了，说她认对了，马上就拿出一部手机奖给她，可是那中年女人不要，她眼里湿漉漉的，说：“我哪里有脸面要这手机？开始我看到几个孩子的时候，我就没认出来，那一刻我的心像刀在绞，要不是后来的特写镜头，看到女儿耳朵下的那颗小痣，我哪里认得？我上来不是想领手机，我是想说声谢谢，谢谢你让我明白了——做母亲的不仅要为孩子赚钱，如果为了赚钱，连自己的孩子都不认得，赚钱有什么用？”女人说完，掩着脸，泣不成声地冲下台去，消失在人群中。
　　
　　此时此刻，广场上的老乡又是一片沉默，小丽的胸口堵得慌，张强却没有小丽的感觉，他一心想要认出自己的孩子，想得到那份奖品，这时看到台上只有两个孩子了，他来精神了，便冲上台去。张强上台后定了定神，他想了想，觉得２号应该是自己的女儿珊珊，于是就指着２号说：“这孩子叫珊珊，是我的女儿！”
　　可是，纪娜丽明确告诉张强，２号根本就不是珊珊，台下的老乡们哄堂大笑。纪娜丽让张强表演一个节目，张强会唱歌，就唱了一首流行歌曲，歌唱得很好，可就是没人鼓掌，唱完之后，他不好意思地下了台。
　　看到张强下台时的尴尬样子，再也没有老乡敢上来认了，纪娜丽见没人再认，又继续放录像，下面的录像是三个孩子对着镜头报自己的名，说自己是谁的孩子。报出名后，孩子的父亲自然要上台表演节目，但后面的两个孩子，没一个是珊珊，小丽和张强很是失落：怎么不是珊珊呢？
　　小丽想不通，脑子里很乱，后面老乡表演节目，她也没有心思看，只是最后，她听清楚了纪娜丽的话，纪娜丽说：“我们这个活动不是广告，是我回家乡后有意选了一些几年没回家的老乡，做出来的节目，做这个节目当然有目的，目的是什么，大家想必都明白了吧？”
　　活动结束，在回家的路上，老乡们一个个地相互打听着：“你几年没回家了？”小丽和张强两人一直没吭声，默默地走着，而且走得很快，生怕有人认出他们来，可尽管这样，还是有人认出来了，有人在他们背后说：“就是前面那两口子，把别人的孩子当自己的了，哈哈……”
　　听到老乡们这样说，小丽心里怎么也不是滋味，晚上哪里睡得好觉？她想起三年前离村时女儿珊珊哭鼻子的样子，泪水在眼眶里直打转，最后，她流着泪对张强说：“强子，我想明天就请假回去看珊珊……”
　　 (题图、插图：杨宏富)
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第1期   都是转正惹的祸  作者：尹利华  字体：
   【 大  中  小 】 
 
　　 
　　王小宝从广播电视学院毕业后，做了电视台娱乐节目的策划人，可眼看着三个月的试用期将过，他还没有拿出一套让总制片满意的策划方案来，这让他忧心忡忡。
　　这天下午，王小宝上街溜达，随手在报亭买了份晚报，一则新闻入了眼帘。新闻里讲，一名小伙子靠“口技”刷卡逃票，却被公交车的售票员慧眼识破。看完后，一道闪电般的灵感击中了王小宝：如果将这个素材做成一个娱乐节目，肯定有戏！
　　回到住处，王小宝连夜草拟了一份节目策划方案，第二天一大早就将这方案递交给总制片。总制片看后很感兴趣，立刻敲定，将这个节目提到录制日程。
　　眼看转正有望，王小宝十分兴奋，他通过报社联系到了写这篇新闻的记者，从他口中得知，这个靠口技逃票的小伙子叫常庆福，本市人，家住哪里不清楚，只知道他是在田村路西口的988路公交车上逃的票。
　　听了记者的介绍，王小宝决定去田村路西口附近碰碰运气，寻找主角常庆福。运气还真不赖，在一个摆地摊的老头的指点下，王小宝敲开了常庆福的家门，表明了自己的身份以及来意。没有想到，常庆福听后，立刻将王小宝往门外搡，还脸红脖子粗地喊道：“请我录制电视节目？别扯了，是不是嫌我在报纸上丢人没有丢够，你们电视台也来凑热闹？”
　　王小宝急忙解释说：“你别误会，我们这个节目只是一个娱乐节目，如果你同意合作，录制一期，电视台付给你两千块钱酬劳……”
　　常庆福原是话剧团的职工，曾经专门练过几年口技，自从口技逃票的事情被登上报纸后，就被停职在家，他的女朋友也因为这个事情，跟他黄了。他正在为工作的事情发愁呢，听到这么高的报酬，不禁心动，就将王小宝让进了家。随后的一切都在王小宝的预料之中，两人顺利地签订了拍摄合同，常庆福答应明天八点到电视台报到。
　　王小宝策划的这个娱乐节目名字叫“民间高手”，是专门介绍各种民间绝技的，虽然口技这种技艺不算新鲜，但利用口技来模拟刷卡的声音逃票，却很有“噱头”，颇能抓人眼球。录制这样的节目，需要一定的保密性，这样才会让观众觉得更真实、更刺激，所以王小宝决定用微型摄像机秘密拍摄。
　　说拍就拍，随着王小宝的一声“开拍”，风度翩翩的节目主持人开口说道：“口技是一门深受大众喜爱的表演形式，今天，我们有幸邀请到一位口技高手进行表演，看他能不能以假乱真、瞒天过海。如果该嘉宾能成功逃票10次以上，证明他具有模仿天才，我们要给予重奖，下面，开始我们的刺激之旅……”
　　 
　　这时，一辆公交汽车靠站了，常庆福上车，把一个空钱包往刷卡机前一伸，口里配合着发出“嘀”的一声响，随后就走进了车厢。车内的售票员面无表情，显然没有发觉。
　　下车后，主持人欢呼一声：“恭喜常庆福，首次口技表演成功！现在让我们跟着镜头来到下一辆公交车上，看这次，我们的嘉宾能否顺利过关……”
　　摄制组把常庆福带到了下一个拍摄地点：公交988路车站。常庆福一看，脸色就变了，气呼呼地对王小宝说：“这辆车我不去，你们另找别人拍吧！”王小宝笑了笑，说：“我知道，你在这辆车上难堪过，心里难免留下阴影。可是，咱们现在不是在做节目嘛，节目就需要设置特定的场景：假如在这路车上，你遇到了上次抓住你口技刷卡的售票员，而你又必须再次施展绝技，会发生什么事呢？这正是观众最想看到的。至于报酬，领导说了，可以加倍。”
　　常庆福阴沉着脸，点了支烟，狠抽了两口，终于答应下来。
　　摄制组一行人上了988路公交汽车，售票员是位漂亮的姑娘，站在刷卡器旁，提示上车的乘客刷卡。王小宝等人都掏出公交卡来一一刷过，却见常庆福躲躲闪闪的，王小宝拉了一下常庆福，示意他表演口技刷卡，常庆福神色有些慌张，迟疑了一下，竟然做了一个出人意料的动作：他嘴唇一努，冲着漂亮的售票员发出“嘀”的一声，然后一言不发，气鼓鼓地扭头就往车厢里走。摄制组众人看得一头雾水，常庆福这么做，不是有意让售票员逮住自己吗？
　　更加出人意料的是，那位售票员看见他的这个动作后，却视而不见，只是“哼”了一声，将眼睛瞟向了窗外。主持人想了想，对着微型摄像机悄悄说：“刚才嘉宾逃票的举动非常明显，售票员却视而不见，这是为什么呢？我们就这个问题在现场采访一下。”接着，主持人便装做普通乘客的样子，上前问道：“售票员同志，刚才那人……好像没买票吧？”
　　 
　　没有想到售票员脸一红，说：“怎么会呢，他不是刷卡了吗，你没有听见刷卡器响吗？”主持人一下子愣住了，还没等他反应过来，更加离奇的一幕发生了，常庆福从车厢里走过来，冲着售票员大声说：“我就是没刷卡，我逃票了，你还等什么，快去上报呀！”
　　漂亮的售票员默默地看了他一眼，从兜里掏出一枚硬币，投到投币箱里，说：“这票，我替你买了。”
　　这下，整个摄制组都看不懂了，王小宝心想，这里面一定有隐情！他把常庆福拉到一边，低声问他怎么回事。常庆福苦笑了一下，终于道出了自己的隐衷：“还不都是事情逼的吗？她曾经是我的女朋友，好不容易找到份售票员的工作，试用期三个月，要在试用期间表现突出才能转正。我和她商量后，就想了这么一个破点子：我上车用口技刷卡逃票，她发现后马上上报，算作是她的立功表现，这样也好方便她转正。谁想到那天车上还有个报社的记者。事情闹大了，她倒是因为表现突出转正了，可我的工作丢了，她嫌弃我没有工作，我们的关系也就黄了……”
　　王小宝想想，自己也在为转正而拼命工作，不禁一阵感慨。他向那个售票员表明了自己的身份，问道：“你替他刷卡，是不是还旧情难忘？”
　　不料那姑娘一本正经地说：“你瞎说什么啊，我已经转正，可他连个正式工作都没有，我们怎么还能在一起呢？我是看在他帮我转正的份上，给他买次票，也算两清了。”
　　王小宝叹了口气：都是转正惹的祸啊！要不是为了转正，自己也不会在这里拍这样的节目啊……
　　 (题图、插图：魏忠善)
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第1期   调解员的高招  作者：黄宣林  字体：
   【 大  中  小 】 
 
　　 
　　小扣子从盐城来到上海，打工三年，觅着一个老婆，大后天，就要在鸿福酒家举行婚礼。今天晚上，他和新娘子一起布置新房，忙了个通宵，依旧精神十足，连个哈欠都没有。
　　这新房，是单位里同事老胡借给小扣子的。虽说是旧房子，眼下，旧貌变新颜，新漆的墙壁，新铺的地板，新买的家具，新挂的窗帘……他们又添了一只玻璃橱，橱内有两样东西，对小扣子来说，那是无价之宝。一只像盆子形状的瓷器画屏，上面写着：科技发明三等奖。另一个，是用水晶做的奖杯，上面刻有“新上海人新贡献”几个金字。这些都是小扣子岗位成才的记录。小两口将新房里这些摆设，揩的揩，抹的抹，搬的搬，挂的挂，最后，当他们将大红喜字贴到窗玻璃上，东方已现鱼肚白，天亮了。
　　忙了一宿，他俩肚子都饿了，便手搀着手去街上吃早点。谁知，他俩出了大楼，身后便传来了一声巨响，就像炸弹爆炸，又闷又沉，接着就是“噼里啪啦”的玻璃落地声，又脆又响。小两口赶紧回头，只见熊熊大火从他们3号楼201室窗户蹿出来，自己301室的窗玻璃已被震碎，碎玻璃被大红喜字的红纸粘住，悬在了半空。
　　“不好了！”他俩不顾一切往回奔。到了3号楼门口，被里面涌出来的人流堵住：“201室氧气罐爆炸，你们还往里走，找死啊！”
　　小扣子对周围邻居不熟悉，201室住了什么人?怎会有氧气罐？这氧气罐一爆炸，我们301室不等于坐在火山口上了？小两口想起刚布置好的新房，死活要往里冲。
　　那么，居民小区哪来什么氧气罐呢？
　　原来，201室住了一对老人。老太太怕冷，让老头子把电热毯的电阻改大了。老头子呢？患有气喘病，一年四季背了个热水瓶大小的氧气罐。今天早晨，老头子要吸氧，打开了氧气罐，正巧老太太起床，关闭电热毯。谁知,电热毯的电阻改动过了，关闭时冒出了火星，点燃了氧气罐，引起了爆炸，还燃起了熊熊大火。老两口当场被炸死，氧气罐飞上了天，把天花板打穿，弹进了301室。幸亏消防队员及时赶到，把大火灭了，可是，婚房里的东西大多被毁了，玻璃橱里的两件无价之宝，都成了碎片。目睹这一切，小扣子一筹莫展，后天就要举行婚礼，亲朋好友都要来贺喜，面对这样的新房，他不知该怎样收场。
　　这时，房东老胡闻讯赶来，一见这场面，拖了小扣子就走，“找201室算账去。”
　　这时，人群中突然冒出一个小胖子，此人身高1米7，腰围3尺7，体重107——那是公斤！他往老胡身前一站，就像竖起一块排门板，把路给堵死了，说：“201室的老头老太都被炸死了，谁给你算账？”
　　101室的老顾很同情小扣子，他提供了信息：“201室的老人有个儿子。老子闯祸，儿子埋单，这叫父债子还，天经地义。”
　　小胖子却护着201室：“他儿子在服刑，有能力埋单吗？”
　　老胡急了，责问小胖子：“那照你说的，肇事者死了，我们受害者就只好自认倒霉，不赔偿了？”
　　“现在赔了你钱，你就能保证这对新人如期举行婚礼？”
　　小胖子这句话犯了众怒，大家纷纷指责他：“新房炸成这模样，还怎么举行婚礼？你是什么人，真是站着说话不腰疼！”
　　小胖子转身向小扣子招招手，说：“跟我来，我保证让你们如期举行婚礼！”
　　小胖子二百多斤重，他这句话，比他的体重还够分量，一出口就把大家镇住了。他是哪路神仙？敢夸这样的海口？
　　住在202室的小黄消息灵通，他告诉老胡：“小胖子是街道司法科新来的调解员。”
　　小胖子的身份一亮相，3号楼所有受害的居民都围了上去。为啥？这一炸，受损失的邻居，不止新郎新娘一家。常言说，火往上蹿，水往下流。消防队员救火时要放水，这水一放，首当其冲的就是下面101室。火灭了，101室老顾家水漫金山，一片汪洋，所以，他拉住小胖子说：“你是调解员，一碗水要端平，我们的损失你也得埋单啊!”
　　 
　　这时，一位用纱布包着头的过路群众也凑了上来。刚才爆炸时，碎玻璃正巧打在他的脸上，现在他也要小胖子对他负责，赔偿医药费。
　　还有小明家的电脑震坏了，小黄家的防盗门被炸得麻花似的扭了起来……大家围住小胖子，七嘴八舌，说个不停。
　　小胖子叫大家别着急，他把受害的每一家，全记在本子上，说这事他会处理的，眼下火烧眉毛的，是如何安排小扣子的婚礼。“跟我来。”小胖子一挥手，带了小扣子夫妇俩走了。
　　小胖子陪着小扣子来到鸿福酒家，找到了经理，把情况对经理一说。酒家原先提供一夜免费套房作新房，小胖子提出多借三天套房，要求经理照顾，房金打六折。酒家知道了他们的特殊情况，一口答应。这样，小扣子的闹新房，可以在酒家闹，照样闹得风风光光，开开心心。
　　小扣子的婚礼落实了，老胡心里却打起了鼓，这次事故，损失最大的就是他了：小扣子家具毁了，能估、能算；自己的房子，地板炸裂，墙壁烧毁，这价怎么估？这房子本来是租给小扣子结婚用的，是喜房；现在喜房变成了凶屋，当中的损失谁来补偿？
　　老胡正在发愁，突然传来了乒乒乓乓的敲打声，和“突突突”的冲击钻的声音，原来，工程队已经开工在修房了，这小胖子的动作，还真快！
　　这时，老胡看到，小胖子带了一个人从远处走来，仔细一看，这不是201室老人的儿子吗？可他不是在服刑吗？老胡一问才知道，是小胖子特地为他请了假，一来让他料理老人的后事；二来让他参与这起事故的处理。
　　老人的儿子叫三鑫，他一看，自己的家已成了一片废墟，只剩下一个房子的外壳，别说赔偿左邻右舍，就连安葬父母的钱都不知道打哪儿出。
　　“三鑫，炸坏的房子要整修，新房的家具要赔，你父母还要下葬—”
　　小胖子的话刚说开了头，就被三鑫拦了回去：“你要这要那，全是要钱。我没钱，最多回去加刑，我这辈子不想再出来了。”
　　三鑫这个态度，周围邻居不高兴了。老胡忍不住说：“你没钱，这房子就是钱。你把房子卖了，赔我们啊！”
　　“这房子不能卖！” 三鑫还没说话，小胖子先开口了。
　　原来，201室不是产权房，更重要的一点，小胖子说：“三鑫虽在服刑，他的户口没迁，还在这里，把房子卖了，他刑满回家住哪儿？”
　　“刑满回家住哪儿？”
　　这句话，硬把三鑫的眼泪给逼了下来。自己犯罪，服刑是理所当然的，然而小胖子却扳着手指在算我什么时候回来，连我住的地方，他都给我留着，我和他素不相识，他盼我回家，不是敷衍、搪塞，而是真诚的！
　　“房子不能卖，他又没钱，那我们的损失谁来赔？”受害的邻居着急了。小胖子想了想，给大家出了个主意：201室的房子炸坏了，但可以修，修好后把它租出去，用租金来赔偿邻居们的损失。
　　三鑫听了，连连点头：是啊，自己还在服刑，房子空着没人住，完全可以租出去。可再一想，他又担心了：每月租金有限，邻居们一时拿不到全部赔偿款，能接受吗？
　　 
　　小胖子拍拍胸脯，所有的修房款、赔偿款，都由政府垫付，再用租金来偿还。但是，201室能不能出租，小胖子无权决定，三鑫才拥有这房子的居住权，所以，小胖子要三鑫授权给他。
　　“授权？我的政治权利也被剥夺了。”
　　“你的民事权利没被剥夺，你的居住权还受到法律的保护。”
　　三鑫听了小胖子的解释，马上提笔写下一份委托书。邻居们看到了这份委托书，就像吃了定心丸，看来，赔偿有指望了。
　　第二天，小扣子的婚礼如期举行。原定十桌，后来加了五桌，单单3号楼的邻居，就来了四十多人。本来小扣子和大家不熟悉，通过这一炸，彼此成了老熟人，都来给小扣子道喜。那天好热闹，唯独小胖子没到，他躲开了。他怕他一出现，大家围着他讨价还价谈起赔偿的事，冲淡了喜庆的气氛。
　　结婚后的第四天，201室和301室的房子都修好了，小扣子重新买了家具，唯有他的两件无价之宝补不回来了。小扣子说：“邻里间给我的亲情，远比我的无价之宝更值钱！”
　　老胡担心他的房子成了凶屋，没人要住。小扣子说，千金难买邻里情，他不但要住下去，还要给他的同乡介绍，租下面的201室。
　　小胖子看大家的情绪都趋于平静了，这天，他把三鑫领到楼下101室老顾家里。三鑫一进门，就向老顾深深一鞠躬，说：“顾老师，我代表死去的双亲向您赔礼道歉……”
　　小胖子抢着说：“老顾，你们楼上楼下的关系相当不错，你经常照顾三鑫的父母。现在老人走了，你就再照顾他们一次吧……”说着，他把一位师傅推到了老顾面前，说：“老顾，你家电器都进了水，我给你找来一个老师傅，大小家电他都会修，如果修不好，我们再买新的，好吗？”
　　老顾碍于面子，点点头说：“既然这样，那就修修看吧。”
　　就这样，小胖子为三鑫建立了一本账：
　　小扣子的家具补偿是5万2，修房子花费3万元。其他邻居家的修理费和过路群众的医药费总共1万6，三鑫父母的下葬费9千。总计10万7。出租201室，每月按1500元算，一年1万8，6年就可以把政府垫付的10万7全部还完了。
　　“到那时，三鑫，你也可以刑满回家了。”
　　通过这次事故的处理，三鑫深有感触，他对小胖子说：“我回去一定好好改造，争取提前回来。”
　　这真是：意外事故毁新房，受灾居民心里慌，司法调解小胖子，情法两全面面光。
　　 (题图、插图：谢颖)
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第1期   穷人与富人  作者：彭晓风  字体：
   【 大  中  小 】 
 
　　 
　　老马与老王以前不认识，自从买了同一小区的房子后，两人成了邻居，住门对门。不过两家的境况却大相径庭：老马买房花光了夫妻俩半生的积蓄，之后他和妻子又双双下岗了，靠给别人打零工过活；而老王两口子都有稳定的工作，收入不菲，他们买房用的是炒股挣来的闲钱。在老马看来，老王是富人，自己是穷人。
　　刚搬家的时候，老马和老王相互不了解底细，两人经常在一起寒暄，可慢慢的，不知是有意还是无意，别说聊天，就连见面也不怎么多了，即使偶尔碰上，也只是相互点点头而已，到后来，两人十天半个月都见不上一面。
　　老马对这样的邻里关系并不在意，在他眼里，富人的生活和穷人的日子原本就搅和不到一块去。就在老马以为要和老王老死不相往来的时候，一天早上，老王敲开了他的家门，身后还跟着个警察。老王说，他家昨天晚上失窃了，想到老马家了解点情况。
　　两家关系虽然说不上好，但毕竟是邻居，老马把老王和警察让进屋，关心地问他家里都丢了什么。面对老马的热情，老王好像并不买账，他面如寒霜地说:“丢了三千块现金。昨晚我和老婆孩子回岳父家了，老马，你在家吗？听到什么动静没有？”
　　老马似乎没注意到老王的异样，回答说：“昨天是周末，我们一家都去看电影了，散场后都半夜了。”老马想了想，又接着说：“也真巧了，回来后我发现家里门虚掩着，东西也被翻得乱七八糟，知道是进贼了，不过我家穷，没什么值钱东西，大件贼也拿不走，所以就没报案，没想到贼还去了你们家！”
　　听罢老马的叙述，老王像是不大相信，表情古怪地说：“你家也进了贼，怎么这么巧？”
　　这时，警察又询问了老马几个问题，然后让他按了指印，就和老王告辞离去了，临走前，老王还怪怪地看了老马好几眼。两人离去不久，老马把刚才发生的事情连起来想了想，忽然明白过来：看老王的神情，他并不相信自己家也进贼了，莫非老王怀疑自己是小偷？警察让自己按手指印，估计也是把自己当成了怀疑对象，想和盗贼留下的痕迹作比对！
　　老马家是穷，可他这人硬气，买菜连别人的小便宜都不占，现在被人怀疑是小偷，心里当然不舒服。为了向老王表明自己的清白，此后一段时间，老马有空就站在自家大门的猫眼前，一看到老王经过，就出门装作偶然相遇的样子，借机询问他家的案子是否破了。老马是这样想的：我要是心里有鬼，躲都躲不及，还会主动问你吗？
　　几个月过后，老王家被盗的案子一直没进展，面对老马紧追不舍的询问，开始老王还跟他说一些情况，后来就有些不耐烦了，只摇头了事，有一次还没好气地说：“老马，我丢了钱，找不到就算了，你怎么比我还上心？”
　　老王的话让老马心里咯噔一下，随后便不再询问他家丢钱的事了。可此后老马总觉得，老王看他的眼神有点怪，细一咂摸，分明带有鄙视的味道！
　　开始老马也没多想，但在老王几次用这样的目光看他后，他恍然大悟：老王原本就怀疑他是贼，他再三询问破案进程，自认为是在表明清白，可在老王看来，却是在打探消息，是此地无银三百两！老王故意那样看他，是想用目光把他钉在耻辱柱上！
　　 
　　事情发展到现在，老马的处境很尴尬。这天他出去倒垃圾，刚下楼，迎面就碰上了老王，见老王还是用那样的目光看着自己，老马顿时气不打一处来，沉着脸对老王说：“老王，都是大老爷们，又是邻居，有什么话就直说，你这么做有劲吗？”
　　“我怎么做了？”老王愣了一下，随即就明白了老马话里的意思，也不点破，反唇相讥说，“我倒想问你，你那样做，就顾及了邻居之情吗？”
　　两人虽然都没点破，但彼此都明白对方的所指.老马提高了声音说：“老王，我们认识也不是一天两天了，你看我像做那种事的人吗？再说，我若是真的做了,现在还能安心呆在家里吗？”
　　老马的意思是,如果他偷了钱，警察早把他抓走了，谁知老王却不以为然，嘴一撇,说：“有些痕迹可以抹掉，但有些马脚却藏不住！你家的景况一向是入不敷出，两月前的房贷你拖了好些日子，但这两个月却按时还了，你当别人都是傻子呢！”
　　老王撂下这句话，头一扬，转身走了，老马却傻在了当地:这个老王，看来他是真怀疑自己啊，把自己家的经济情况都摸了个一清二楚。说起老马还房贷，也真巧了，他平时爱买些彩票，老王家丢钱那个月，他买的彩票中了几千块钱，正好补了房贷，可这么巧的事，说出去老王能相信吗？
　　老马有嘴说不清，只好继续忍受老王的鄙视，暗自祈祷公安局早点破案。日子过得很快，不知不觉一个月过去了，老王家丢钱的案子仍然没破，但事情却出现了转机。倒不是老王改变了对老马的态度，而是老马运气不错，他买彩票又中奖了，而且中了五十万，他一夜之间成了富人！
　　以前老马之所以能忍受老王的鄙视，除了他没偷老王的钱外，还有一个原因，那就是相对老王而言，他是穷人，富人丢了东西，当然会怀疑是穷人偷的，尤其是身边的穷人。现在老马有钱了，腰杆就硬了，他不想再忍气吞声了，他想：你老王不是怀疑我偷了你家的钱吗？那好，现在我有钱了，非让你改变看我的目光不可！
　　老马想来想去，想出了个自以为绝妙的主意，他去邮局汇了三千块钱给老王，还以小偷的口吻写了封匿名信，说自己是外地来本市打工的，当时因为没钱给家人治病，才走上偷盗的路，现在有钱了，想还钱赎罪。
　　过了几天，老马确信老王已经收到那三千块钱和信了，他故意找机会与老王碰了个面，还主动打了个招呼。出乎他意料的是，老王看他时还是那副神情，目光里的鄙视不仅没变，甚至还多了丝嘲讽！
　　老马百思不得其解：老王怎么还这样看自己？就在他为如何摆脱老王的鄙视苦恼万分时，几天后的一个夜晚，老马家进贼了，这回，放在家里的两万现金被盗了。
　　两万不是小数，老马报了案。上次办老王家那案子的警察来他家勘察了现场，也到老王家询问了一些情况。让老马大吃一惊的是，这案子几天就破了，小偷不是别人，竟然是老王！
　　听到这个消息，老马简直不敢相信自己的耳朵，他问办案的警察：“你们是不是搞错了，老王是个有钱人，他怎么会偷我家？”
　　 
　　“有钱？那是以前！”办案的警察不以为然地说，“他挪用公款炒股，赔了好几万，现在欠了一屁股债。你家有他留下的指纹，他自己也承认了。”
　　“那他为什么要偷我？兔子还不吃窝边草呢。”老马还是半信半疑。
　　“去年他家丢了三千块钱，他一直怀疑小偷是你。”办案警察面无表情地说，“前几天他收到三千块钱汇款和一封自称是小偷寄来的信，开始他还以为是小偷良心发现了，可后来却发现那信上的字迹与你的很像。为了证实他的猜想，他在你家垃圾袋里找到了留有你笔迹的纸张，一比对，更加肯定了猜想，就想，既然你是小偷，即使偷了你，你也不敢报案。”
　　“原来是这样！”老马先是目瞪口呆，既而又急忙表白说，“可我真的没偷他家的钱啊！”
　　“那案子也是我们经手的，经过调查，我们排除了你作案的可能。”办案警察看了老马一眼，费解地问，“老王收到的那三千块钱是不是你汇的？如果是，你为什么要以小偷的名义汇钱给他呢？”
　　“不是我……我又没偷他家的钱，怎么会给他汇款？”老马原想说出为什么汇款给老王，话到嘴边却又咽了下去，他想，即便自己说了汇款给老王的理由，谁又会相信呢？
　　 (题图、插图：安玉民 梁 丽)
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第1期   车上的人都没长眼睛  作者：朱永军  字体：
   【 大  中  小 】 
 
　　 
　　这天黄昏时分，一列行驶中的火车快要进站了。火车上的广播也不知调到了哪个频道，主持人讲了个让乘客心里发毛的故事，这事有名有姓的，是国外一家媒体报道的，故事大概是这样的：
　　前几日，国外一个小镇上发生了一场严重的车祸，一辆长途汽车和火车撞上了，汽车上的人员全部死亡，无一生还。要说车祸天天都有，没什么奇怪的，可这次车祸发生前却出了一件奇事。那天，等长途汽车的人里面，有一个年近八旬的老人带着他四岁的小孙子，汽车来时，小孙子死活不愿上车，还硬把爷爷也拉住，哭闹着说：车上的人都没长眼睛，样子好吓人，还说车上到处都是血。等车的人中有一个是小孙子的远房堂叔，小孙子也哭喊着非让他下车。爷爷气得要揍小孙子，可平日里乖巧的小孙子这时却异常倔强。那位远房堂叔急着要进城办事，觉得这是小孩子调皮耍性子，就没理他。可小孙子死死地拉着车门，非让堂叔下来，最后，其他乘客硬是把小孙子的手给掰开了，汽车才得以出发。小孙子回去后一路哭闹，说再也见不到堂叔了……后来发生的车祸证明，汽车上的人确实像是没长眼睛一样：汽车在道口出了点故障，停下后，司机下去修车，其他人都乖乖地坐在车厢里，没一个人离开。火车来时，声音那么大，也没人看一眼，就这么等着死神的降临……
　　天哪！真的假的？莫不是那孩子有什么特异功能？难道这世上真会有鬼不成？这则故事听得乘客们一个个毛骨悚然，大家都竖起耳朵，想知道究竟是怎么回事，只听广播里说道：“后来，科学家就这件事进行了调查，原来……”这时，广播突然中断了，喇叭里传来了列车播音员的声音：“旅客们！阳河车站到了！有在阳河车站下车的旅客，请做好下车准备！”
　　哎呀！正听到关键时刻却要下车了，许多旅客都有点不情愿地站了起来。说实话，这样的奇闻最能勾起人们探寻奥秘的好奇心，谁都想弄明白后事如何。下了车出站时，不少旅客还在就这事议论纷纷。有的说，这是小孩儿眼睛纯净，可以看到大人看不到的灵异世界；有的说，自己也遇到过类似的怪事；还有人说，或许科学家调查后发现，这根本就是个恶作剧……虽然大家都将信将疑，可心里都对这件事百般猜测。
　　 
　　出了火车站，人们蜂拥着往附近的公交站点赶去。
　　这两年火车提速，在阳河停靠的火车车次减少了，但火车站附近的公交车车次却没有相应调整，这趟公交班车坐不上，得等半个来小时才有下趟车，因此，许多急着回家的人拼命往公交站点拥去。
　　这时候，公交班车刚刚进站，车站上稀稀拉拉地站着几个等车的人，从火车站拥出来的“大部队”一到，立刻把原来等车的那几个乘客挤到了一边。
　　人们正要上车，突然，有个稚嫩的声音在车门口响起：“爷爷，车上有血！这车上的人咋都没长眼睛？”声音不大，但车门附近的旅客都听到了，大家一回头，只见一个肩上背着行李的老头，抱着个四五岁的男童。车门口的几个人犹豫了几秒钟，纷纷一脸惊惧、争先恐后地下了车。老头留着花白胡子，一脸仙风道骨，他像没听到孩子的话一样，竟然抱着孩子就上了车。
　　车上依然挤得水泄不通，那孩子环顾了一下四周，突然又说话了：“爷爷，车上怎么这么多血，车上的人都没长眼睛啊！”车上大多数乘客都是从刚才那列火车上下来的，都听了广播，此刻听到这孩子的话，不少人都露出了惊恐的神色，人们面面相觑，过了片刻，突然，有几个人扭头逃也似的往车下挤，过道上一下子显得宽敞了许多。
　　“爷爷！车上有血！车上的人都没长眼睛！”这时，孩子挣脱了爷爷的怀抱，跳下地来，再次大声对着全车乘客叫了起来。这回，车上大部分人都听到了。不少人想了想，终于起身下了车，陆陆续续地，车上的人下去了一多半，空出了好几个座位。
　　人们下车后都没离开，一脸紧张地对着车子指指点点，议论纷纷。有几个人犹豫着上了车，好奇地看了一眼那个孩子，又赶紧下去了。
　　 
　　这时，司机上车了，他纳闷地看了看宽敞的车厢，把头伸出车窗，对车站上的人大声喊道：“走不走啊？不走开车了啊！”见大家没反应，他果断地发动汽车，关上了车门。
　　车开动了，这时候，那个孩子问老头：“爷爷，刚才你为什么让我说三遍，车上有血，车上的人都没长眼睛？”
　　白胡子老头哈哈大笑，说：“乖孙子，你看车子前边的那排座位。”车里不少乘客也顺着老人手指的方向看去，只见第一排座位上坐着一位白发苍苍的大娘和一个大肚子孕妇，看样子好像是母女俩。老头接着说：“爷爷说第一遍，是因为车上的人如果长眼睛了，就能看到这位老太太和她怀孕的女儿早就等在车站上了，可被火车站出来的乘客一挤，根本上不去车；说第二遍，是因为，如果车上的人长眼睛，就会看到老人和孕妇虽然上了车，可根本就走不进车厢里面；说第三遍嘛，哈哈，车上的人要是长眼睛了，难道看不到她们两个没地方坐吗？哈哈……”
　　在老人的笑声中，前排的母女俩投来了感激的目光。好几个知道怎么回事儿的旅客，都陷入了沉思……
　　 （题图、插图：安玉民 梁 丽)
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第1期   不可取消的任务  作者：芦宏伟  字体：
   【 大  中  小 】 
 
　　 
　　埃特总裁颇费了一番周折，才找到了鲁克。鲁克是信誉最好的杀手，并不是谁都能够请得动鲁克的，只要鲁克接受了委托，就从来不会失手。
　　埃特从包里掏出一沓资料，对鲁克说：“这就是我要你下手的对象。”鲁克看了一眼资料上的照片，抬起头来盯着埃特：“这是你的双胞胎兄弟？”埃特苦笑了一下，说：“不，这就是我——我想请你谋杀的对象，就是我自己！”
　　埃特本以为鲁克会大吃一惊，谁知鲁克眉毛都没皱一下，好像这事没什么稀奇，他冷冷地说道：“我的规矩，事先付一半酬金，事后付另一半酬金。不过，这次情况不同，事后的另一半酬金怎样支付？”
　　很明显，鲁克是担心等他杀死了埃特，另一半的酬金找谁要去。埃特说：“我要你在我的办公室里实行枪杀，那时，我面前的桌上会有一个档案袋，袋子里面有另一半酬金。”
　　鲁克收下五万美元，说道：“在没有完成任务前，我不会动用你预付的酬金，我会把酬金锁进保险柜里。”
　　出了两人见面的咖啡馆，埃特忽然略带好奇地问：“鲁克，你怎么不问问我为什么要杀死自己？”鲁克不吭声，动机问题从来都不是鲁克需要考虑的，他只管完成任务。埃特碰了一鼻子灰，不禁感叹：真是虎落平阳被犬欺啊！要知道，埃特是一家跨国集团的总裁，可这两年由于市场急剧变动，埃特的产品没有了销路，公司负债累累。埃特不忍妻儿以后穷困潦倒地生活，于是，他为自己买了一份巨额保险，再请杀手杀死自己，这样妻儿就可以获得一笔丰厚的保险金了……
　　埃特的计划是，在星期三下午三点半左右，在自己的总裁办公室内，让鲁克实施枪杀。之所以选在办公室动手，是因为埃特想让同事们作证，自己确实死于谋杀，而不是自杀。
　　星期三下午很快就到了，鲁克经过一番乔装打扮，顺利地进入了埃特公司所在的大楼，轻易找到了总裁办公室。他一手推开办公室的门，另一只手伸进衣兜里，抓住了那把微型消声手枪。埃特正对着办公室的门口坐着，办公室里还有四名公司职员，在桌子上果然有一个档案袋。长年的杀手生涯，使得鲁克做事万分谨慎，他抓起档案袋，先朝袋里看了一眼，却没有看到那让人心动的美金，鲁克感到不妙，将档案袋里的东西朝桌上一倒—里面竟是一沓图文资料！
　　埃特，你竟然耍我！一向深沉的鲁克愤怒了，握枪的手紧了一紧，此时只要他扣动扳机，埃特就完蛋了！但是，鲁克强压怒火，将枪放回了自己的衣兜，转身冲出埃特的办公室。
　　埃特正视死如归地等着挨枪子儿呢，没想到鲁克掏出枪又放了回去，正不明所以，几个职员已经大叫起来。
　　鲁克冲出大楼，刚回到家，就接到埃特打来的电话：“伙计，为什么临阵退缩了？”鲁克怒气冲冲地说：“档案袋里没有钱！怎么回事？”
　　“唉！”埃特叹了口气，说，“你太冒失了，我早把装有五万美金的档案袋放在了桌上，说来巧了，有个职员拿了个装着策划书的档案袋来找我，他将档案袋也放在了桌上，而你，拿到的是装有策划书的档案袋！”
　　鲁克仔细想了想，情形似乎真的同埃特所说的一样。
　　“好啦，两个小时后，你在第五大街的第二个垃圾箱里取钱吧。凭你刚才的行动，我相信你不会拿了钱不做事的。”埃特在电话那边说。
　　两小时后，鲁克在垃圾箱里取到了装有五万美金的档案袋，鲁克把这次的五万美金和上次的五万美金，全部锁进了保险柜里。鲁克的老规矩，在没有将目标干掉前，这笔钱不能动用，只是暂存在自己这里。
　　现在，鲁克要策划如何按照埃特的要求，在众目睽睽下将他杀死。对鲁克来说，这并不困难，他策划了两天，一个完美的谋杀计划成形了。
　　然而，就在鲁克要动手时，埃特打来电话，兴奋地说：“太好了，鲁克，你不用杀我了。我公司有个新员工真是怪才，他研究出了改良产品的方案，产品经过改良后，卖得非常好，我不但不会破产，反而要发财了！我要取消你杀我的任务，哈哈……”
　　“抱歉。”鲁克在电话那边淡淡地说，“任务我已经接下，酬金也全部收到，按我的规矩，收到全部酬金后，任务是不可取消的。”
　　埃特很理解地说：“你不要以为在你的杀手生涯中，有一个半途而废的任务会影响你的声誉，毕竟，这个任务是客户主动要求放弃的呀！”可是，鲁克口气坚决地说：“不，对于我来讲，任务接下，酬金收到，不管出现任何状况，都不能放弃任务！”
　　“十万美金我送给你了，就……就当咱们交个朋友嘛！”埃特带着商人特有的口吻说，“你平白得到十万美金，还不用干活，何乐而不为呢？”
　　“这不是钱的问题！”鲁克有点不耐烦了，说道，“我已经接下这个活儿，就要把活儿漂漂亮亮地做完！收到的钱，我也不会再退还给客户，因为至今还没有我鲁克完成不了的任务！”
　　“你真把我搞糊涂了！”埃特也发脾气了，“你这个死脑筋，难道你觉得要杀我就那么容易吗？只要我不想死，没人可以杀死我……”埃特冲着电话吼了半天，才发觉不知何时，鲁克已经挂断了电话。
　　一周后，由于产品大卖，埃特的公司举行了一个庆功宴。宴会上一片喜气洋洋，埃特正在主席台上演讲，一眼瞥到一个端着香槟酒的侍者朝自己走来，突然，埃特觉得这侍者似曾相识……啊，他是鲁克！
　　 
　　埃特心里猛地一震，往台下一跳，就要逃跑。而扮作侍者的鲁克，他手中托盘上的几瓶香槟酒中间，已经伸出了一个黑洞洞的枪口……
　　“砰”地一声，只听得一声惨叫，却是女声。原来埃特反应过来后一个急转身，在千钧一发之际躲过了子弹，子弹射进了他后面一个中年贵妇的胳膊。
　　枪声响起，人群发出一片尖叫声，埃特立刻矮下身子，混在乱成一团的人群中。鲁克紧盯着埃特，又开了一枪，可这时埃特的身影已经被人群挡住，这一枪仍没打中。接着场面越来越乱，鲁克再也找不到埃特了。
　　这个狡猾的家伙！鲁克骂了一句，只好急忙离去了。
　　鲁克没能在宴会上杀掉埃特，很是扫兴。而埃特也气得半死，他躲在家里，把门窗都关得严严实实，再次拨通了鲁克的电话：“鲁克，我给你五十万美金，你不要杀我，怎样？”
　　“我只杀人，不保护人，也不会因为钱放弃自己的任务！”鲁克说完，就挂断了电话。
　　埃特无奈极了，好在现在埃特有了钱，一不做二不休，他决定以牙还牙，出高价请杀手干掉鲁克。然而，令人恼火的是，埃特把价钱抬高到了六十万美金，也没有一个杀手愿意接下这活儿。据知情者讲，有人对本国的杀手做了个排行榜，不管从技能、还是从信誉上讲，鲁克这几年一直稳居杀手排行榜的榜首—谁吃饱了撑的，敢去杀杀手排行榜的老大啊！
　　埃特想破了脑袋，也想不出什么办法，无奈之下，只好逃跑：我满世界地乱跑，看你上哪儿找我！埃特随身带了四名保镖，坐上了飞机，到了一个机场后，再转机到另一个机场，一连跑了好几个国家。半个月来，埃特和四个保镖的飞机票就花掉了好几万美金。埃特心想：鲁克你来撵我吧，就我付给你的那十万美金，还不够你追踪我的路费呢，看你还杀不杀我了！
　　这天，埃特辗转到一个偏僻的岛国，他稍稍松了口气，心想这下可以轻松几天了。埃特打听到岛国最大的宾馆，叫了出租车，和四名保镖一起进了宾馆。宾馆的大堂服务台前，一名服务员正低头写着什么东西。
　　埃特上前大声说道：“给我开最好的房间！”说着就要登记，那名服务员却说道：“不用报国籍姓名了，埃特先生，我们又见面了。”埃特一愣，抬头朝服务员看去，那名服务员也抬起头，微笑着迎向埃特的目光，同时，一个枪口也伸到了埃特的胸前。
　　是鲁克！这个阴魂不散的鲁克，他竟然算准了埃特会来这个岛国、来这个宾馆，事先打晕了服务员，然后自己穿上服务员的衣服伪装起来！
　　等埃特想通了这一切，已经晚了，鲁克开枪了！鲁克冲埃特的胸口，一共连开了三枪！四名保镖反应再快，也来不及了。
　　三发子弹结结实实打在埃特的胸口，埃特被打得一屁股坐在了地上。鲁克知道埃特肯定完蛋了，双手一按身前的柜台，跳了出来，朝外面跑去。
　　可是，鲁克算准了一切，却没算到，狐狸般狡猾的埃特，这段时间一直穿着防弹衣！埃特又一次逃脱了。
　　这几枪虽然没有要了埃特的命，却打散了埃特的魂魄。埃特真的害怕了，恐惧了，他不想死，一点都不想……
　　几天后，埃特回国了，在一个阳光明媚的日子，他敲响了鲁克的家门。鲁克虽然处事冷静，但看到自己正在追杀的埃特送上门来，也不由怔了一怔。鲁克随即就掏出枪对准了埃特，不管埃特有什么诡计，今天他一定得死！
　　“别急别急！”埃特摆了摆手说，“请先别急着开枪，听我说，鲁克，你或许还没发现呢，其实我放进垃圾箱的五万酬金里，有一张假钞。”
　　鲁克没想到埃特会说出这样一句话，他一边用枪指着埃特的脑袋，一边疑惑地打开保险柜。鲁克的老规矩，在没有完成任务前，顾客的钱仍然不属于自己，仍然好好地锁在保险柜里。
　　“从上面数第十三张，你看一看。”埃特说。鲁克拿出埃特说的那张钞票，仔细辨别，果然是一张假钞。鲁克顿时愤怒了，他气得满面通红：“混蛋，你竟敢拿假钞骗我！太可恶了！”
　　 
　　埃特笑着说：“假钞不算钱是吧？我少付了你一百美金，也就是说，你其实并没有收到全部酬金。”
　　“我是个很严谨的人！”鲁克叫道，“就算顾客少付我一美金，也是酬金没有付完，就休想让我帮他做事。对你来说，如果你不补齐那剩下的一百美金，我就会放弃你的任务，而你已经付给我的九万九千九百美金，也不会退还给你——你听清楚了没有？”
　　“真是太有意思了。”埃特笑得很开心。
　　“请你马上离开！”鲁克收起了枪，指着门外说，“还不走，难道想留在我家里吃晚饭吗？”
　　埃特走了，他觉得浑身轻松，甚至不由自主地吹起了口哨，埃特想，有一句话说得真好：天才和呆子往往只有一线之隔。
　　原来，有一位高人给埃特出了个主意，埃特花重金请侦探找到了鲁克的家，又花重金请了一位开锁专家。当鲁克在外面追杀埃特时，开锁专家进入鲁克的家，打开鲁克的保险柜，然后，神不知鬼不觉地，将档案袋里的一张钞票换成了假钞。
　　 (题图、插图：佐 夫)
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第1期   夜车生死劫  作者：吕浩峰  字体：
   【 大  中  小 】 
 
　　一时间，车子过道中间响起了“噼里啪啦”的啤酒瓶子的撞击声，八九个乘客把手里的酒瓶全部击碎在了床栏杆上，玻璃碴子满车乱飞。两个大学生这时也像明白了什么，都站起来，“啪啪”地击碎了属于他们的三个啤酒瓶子，玻璃的碎片扎到他们的手上，血无声地流到了地板上。小夫妻里的丈夫也拿起一个空的啤酒瓶子，他怕碎玻璃溅到妻子和孩子身上，所以没把空瓶子打碎，他用身体挡住身后抱着孩子的妻子，准备做最后一搏。
　　一瞬间，车里的空气似乎凝固了，时间就像停止了，只听见孩子撕心裂肺的哭声。忽然，远远地，传来了“呜啊呜啊”的警笛声，声音越来越近、越来越近……
　　多年后，一个大年初二的晚上，当我跟二大爷喝着二大妈给烫的老酒，说起这件往事，二大爷哭了。
　　二大爷说，这件事最让他难忘的，不是车里那么多乘客对他的信任；不是一夜成名的英雄卧铺车给他带来的滚滚财源；不是他从那以后娶了小饭店的老板娘，做了我的二大妈；而是他深深的后怕——二大爷说：“当年小子你才二十岁，还没结婚啊，那两个小伙子是刚刚拿了奖学金的大学生啊，那对小夫妻刚有了孩子，要回家见他们的爹娘啊……”
　　“我把那两个大学生灌醉，就是想让他们吐的时候吵醒全车人，这样我就能叫上大家一起下车撒尿，跟乘客们通个气，大家心里都有数，早作准备。”
　　“小子，我让你憋着尿，是让你别睡着了，没想到那些劫匪也要撒尿，我只得停车啊。他们三个人下车撒尿，三个人在车上留着，这是他们动手的最好时机，你个小子，非要跟他们一起下车撒尿，还背着那个装钱的包！我都快吓死了，我不是担心那些钱，我是担心他们要对你动手啊……”
　　我已经无数遍地听二大爷说起这事的细节，但还是装作疑惑地问：“二大爷，那他们车外三个、车里三个时怎么没动手啊？”二大爷哈哈笑着说：“后来公安局审他们时，他们交代说，我开得太快了，他们下车撒尿，发现前不着村后不着店，动了手也没地方跑，就决定上车，等快到下一个城市了再动手……哈哈，这就是你二大爷的本事了，当时我不但开得快，还抄了近路，故意往荒村僻壤开……”
　　二大爷喝醉了，二大妈做的酒菜还像当年一样好吃。二大爷真有福气，当年没有电话，二大妈在大年初二的晚上一口气花了五个多钟头，跑了七十多里地，到县公安局报案，要求警察出警，而她的证据就是：二大爷和她说过，他四年才过一个二月二十九的生日，出事前一年刚过了，怎么会第二年大年初二又过？还请坐车的人喝生日酒？再说二大爷从来都不赊账，二大爷说过，一个女人家开饭店，做的饭菜又这么好吃，谁欠账谁就是王八蛋，二大爷他是绝对不会当王八蛋的。二大妈还说，二大爷爱车就像爱他的命一样，没事绝对不会使劲踩十几脚油门，才把车开走。二大妈最后说，如果警察追上了二大爷的车，发现根本就没事，她就把饭店赔给公安局，值班警察这才相信她，同意出警。
　　这时候，我想起一个多年来的疑问，就问二大妈：“其实二大爷怀疑那些人，也只是出于他的经验和直觉，您就这么相信他，把饭店都押上了？”
　　二大妈笑了，说：“小子，其实那时候，我已经喜欢上了你的二大爷。多亏了那次共患难，才让我们捅破了那层窗户纸……”
　　 (题图、插图：刘斌昆)
　　 
[ 1 ] 2        
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第1期   夜车生死劫  作者：吕浩峰  字体：
   【 大  中  小 】 
 
　　 
　　这是一个发生在上世纪80年代的真实故事。
　　我当时刚二十岁，是一个长途卧铺客车的售票员，车主兼着司机，是我二大爷。二大爷以领先时代的眼光买了辆豪华卧铺大客车，从河南南阳跑到江苏盐城，一趟下来，通常要跑近三十个小时。
　　那是二大爷开大客车的第三个大年初二，我这时才跟着跑了几个月车。大客车跑到漯河，才上了一半的人，二大爷有些着急，如果接下来的路程还是这样，这一趟就赚不了多少钱了。
　　傍晚，车到了一个县城的郊外，在那里有家小饭店，是我们固定休息的点。二大爷早年丧偶，一直是一个人过，他和饭店的女老板关系很不错。女老板做的饭菜特别好吃，我几天不吃就想得慌。二大爷告诉我说，女人饭菜做得好是聪明的表现，聪明的女人才能自己开一个饭店而不靠男人。二大爷还说，女人开饭店，如果饭菜做得不好，她就需要做更多其他的事。
　　吃完晚饭，二大爷和往常一样小睡一觉，而我没什么困意，就溜达着回到车里。
　　车里很多人都睡了，那时候的人出门在外，基本上都不舍得花钱到饭店吃饭。尽管我们这车是当时最豪华的大客车，车里坐的也并不全是大款。车子前排的两个小伙子，看上去也就二十来岁，像是兄弟俩，这会正在啃凉馒头呢；后排四个江苏口音的，像是做生意的，正就着窗外饭店的灯光打扑克；一对小夫妻轮换抱着他们的孩子，在哼不知名的摇篮曲；最后一排的几个乘客，全都蒙着头盖着被子睡了。
　　我沿着车里的走道，习惯性地走到车尾再走回来，忽然发现车里多了几个人。我记得加上孩子是十七个人，怎么数出二十三个人？于是我又仔细数了一遍，没错，是二十三个人，于是我抬高嗓门，问：“哪位是刚上车的？”
　　车尾有个北方口音的人“唔”了一声，说：“那啥，多少钱啊？俺们六个人。”我一阵狂喜，心想这下二大爷可要高兴坏了，车子跑了一半了，又上来六个人，这不是白捡钱吗？那人也没怎么讲价，把钱给了我，就自顾自蒙头睡了，其他五个人也睡得鼾声四起。
　　我悄悄走回车前，想等二大爷睡起来给他个惊喜。我这么坐在车里等啊等，竟然迷迷糊糊睡着了。忽然，我听见车子发动起来了，一睁眼就看见二大爷笑眯眯地正看着我。我高兴地说：“二大爷，刚刚上来六个人，也没怎么讲价,就把钱给了，哈哈！”
　　二大爷一愣，悄声问我：“他们去哪？”我说：“去盐城啊，怎么了？”
　　二大爷皱了皱眉，又悄悄问：“他们要票了没有？”我说：“就一个给钱的醒着，其他五个都睡着了没说话，没要票，付钱可爽快呢！”
　　二大爷呆了一呆，自言自语地说：“六个人，半路上来，都睡着了没说话，没讲价，也没要票……”
　　二大爷沉吟了片刻，脸色渐渐变了，显得很苍白，我奇怪地问：“二大爷，你怎么了？”
　　二大爷看了看我，眼角一眯，突然哈哈大笑起来：“小子，你不说我都忘了，今儿是我生日啊！”他抬高嗓门说，“你去咱吃饭的小饭店买两捆啤酒，今天我生日，在我车上的就是一家人，咱们这大年初二的都不在家过，我请大家喝酒，大伙儿一块高兴高兴。”
　　我一愣，二大爷眼一瞪：“快去！”我刚下车，二大爷又在车里喊我：“小子，跟老板娘说记账啊，我下趟车还账。”
　　我跑进饭店，跟老板娘说：“婶，给我来两捆啤酒。”老板娘笑着说：“都上车了，谁又要你回来买这么多酒？”我说：“今儿二大爷过生日，刚才又新上来几个客人，二大爷一高兴，就要请客，说记账，下趟给钱。”
　　 
　　老板娘死盯着我，看了好一会，才问：“车上新上来客人了？你二大爷过生日？他说的？”我点点头，老板娘搬出啤酒，又问了一句：“你二大爷说这酒赊账？”
　　我顾不上回话，点点头，一手提着一捆啤酒，一路小跑上了车。二大爷把车门关上，说：“一人一瓶，都得喝，你们谁不喝，就是不愿坐我的车，哈哈！”说着话他从工具盒里拿出两把大尖头螺丝刀，递给我一把，让我把捆啤酒的绳子捅断，自己一手拎两瓶啤酒，一手拿螺丝刀，从前往后发给车里的人。
　　车上睡着的人迷迷糊糊被吵醒了，小夫妻的孩子也醒了，哇哇哭起来。二大爷哈哈笑着说：“孩子他妈妈这瓶酒不喝就拿着，回去给孩子他爷爷姥爷喝，大过年的，都喜庆喜庆！”坐车的人从没见过车主请乘客喝酒的，纷纷高兴起来，二大爷见酒分得差不多了，大声地模仿着电影里的日本话吼着：“开路—马斯！”油门“轰轰轰轰”踩了十几脚，车子上路了。透过车窗，我看到老板娘跑到饭店门口，默默地目送我们的车子离去……
　　地上还有几瓶没分完的酒，因为后排新上的那六个人一直在睡觉，所以没喝上。二大爷看来心情很好，一边开车，一边从后视镜里看谁喝了酒、谁没喝。结果那两个像是兄弟的年轻人说，他们今年刚评上优秀大学生，实在不太会喝酒。二大爷不依不饶，坚持要他们一人喝两瓶，还板起脸来说，不喝就把他们从车上扔下去。两人没办法，皱着眉头每人勉强喝下一瓶半，眼看就要吐了，二大爷才罢休，逗得那四个江苏生意人哈哈大笑。
　　车子快到徐州时，已经凌晨一点多钟，大学生兄弟中有一个突然“哇”的一声吐了，呕吐的气味瞬间传遍全车。二大爷把车门打开，让他俩下车。不少乘客被惊醒了，二大爷就问谁跟他一起下车撒泡尿。喝了啤酒的乘客们早就憋得慌了，三三两两地下了车。车子前不着村后不着店地停在路边，二大爷和八九个乘客跑到几十米外的一个玉米秸秆堆，背着风撒尿。风像刀子一样地刮，二大爷和那八九个乘客去了好几分钟，回来后都冻得瑟瑟发抖。
　　车子在夜色中开得飞快，二大爷看来一点儿也不困。凌晨三点多，我也憋不住了，就跟二大爷说要撒尿。没想到二大爷火了，大声吼道：“尿什么尿，这车里有点热气都让你给放没了！”
　　这时，最后一排一直没说话的那个北方人突然搭腔说：“师傅，你就停停车吧，正好我们也要撒。”
　　我和三个后排新上车的人一起下了车，站成一排朝着黑夜撒尿。这时地上已经盖了薄薄一层雪花，这三个人撒尿撒了足足有3分钟，我都上车了他们还没撒完。撒完尿回来，雪花慢慢大了起来，二大爷减慢了车速，眼看天快亮了，快到江苏宿迁了，我困得不停地打盹，二大爷却有一搭没一搭，不住跟我找话说。这时，一个北方口音在车子后面大声喊：“停车！”
　　
　　二大爷用更大的声音猛吼了一嗓子：“你们还有完没完？”北方口音说：“你他妈的跟谁说话呢？再不停车，他妈的剁了你！”
　　我一下子吓醒了，二大爷把车停住，猛地拉开车门，紧接着，把车里的灯也全打开了。冷风“嗖”的一声灌满了车厢，车里一下子亮如白昼，全车人都醒了。只见车子后面的过道上站着高高矮矮的六个人，脸上都蒙着面罩，每人手里都拿着一把或长或短的刀。
　　我咽了口唾沫，心想：天啊，遇上抢劫的了！怪不得他们一直蒙着头，不让我看见他们的脸……
　　领头的劫匪往前走了一步，对全车人说：“明人不做暗事，今天哥们就是要钱，有多少拿多少，要命的就别要钱，要钱的就别要命！”说完刀尖指着我说，“卖票的小屁孩，你包里有多少钱我有数，一会你要是敢藏起来，看我怎么收拾你。”
　　他后面跟着个瘦脸的小个儿，手里拿着一个大布包，也嘿嘿笑着说：“手表啊、金银首饰啊啥的，也别搁家里憋坏了，换换风水，大家都发财啊！”
　　就在这时，二大爷从座位上站起来，他手里拿着那把老长的螺丝刀，我这才想起来，捅啤酒绳的时候，二大爷也给了我一把螺丝刀，就赶紧顺手抄起来。二大爷站在车门前的宽阔地带，眼睛瞪得像铃铛一样，看着六个劫匪，吼了一声：“酒瓶子伺候着！”
　　只见车里呼啦啦站起来八九个手拿啤酒瓶的乘客，那四个江苏人也在其中。二大爷从吓呆了的大学生脚下抄起一个啤酒瓶子，手腕一摆，“啪”的一声把啤酒瓶的底部砸在上下床的铁栏杆上，砸烂的啤酒瓶顿时成了一件尖锐的武器。
　　 
 1 [ 2 ]       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第1期   魔瓶  作者：施竹筠　翻译　王思青　改写  字体：
   【 大  中  小 】 
 
　　 
　　纪威是个海员，有着丰富的航海经验。一天，他来到一个从未到过的小岛，上岛去散步。突然，他被眼前一座童话似的别墅吸引了，只见那屋前的鲜花像宝石一样盛开，阶梯像银子一样闪光，窗户像钻石一般明亮，纪威惊奇地看着这一切，心想：多么漂亮的房子啊！住在里面的人一定很有钱，很幸福！就在这时，他发现别墅里有个男人透过窗户也在看他，这个男人上了岁数，脸上神色悲哀。
　　男人招呼纪威进屋去，邀请他参观了整幢别墅，从地窖到屋顶露台，没有一处不完美。纪威羡慕地对男人说：“这是我见过的最美丽的房子，要是我住在这样的房子里，我会整天欢笑，你怎么还在叹气呢？”
　　“你想要这样的房子吗？这并不难。”那男人说，“你有钱吗？”
　　纪威摸了摸口袋，说：“我带了50块钱。”
　　那男人计算了一下，说：“好，50就50吧，你花50块钱，就能得到这一切。”
　　男人告诉纪威，别墅里的一切，都来自于一个魔瓶。瓶子里住着个小魔鬼，谁买了这个瓶子，小魔鬼就听他的指挥；瓶子主人渴望的一切：爱情、名誉、金钱，像这幢别墅一样的房子……只要他一说出来，就全是他的了。
　　纪威将信将疑，他不明白那男人为什么要卖掉这个瓶子。
　　那男人说：“我想要的全都有了，可是我渐渐老了，有一件事情这魔鬼没法做到：他不能延长生命——而且，这瓶子还有个致命的缺点，如果一个人在卖掉瓶子以前死去，他死后就得永远在地狱的烈火里受煎熬。”
　　纪威有点心动了，但他还是不很明白：为什么这个魔瓶会卖得这么便宜？
　　那男人解释道：“很久以前，当魔鬼初次把瓶子带到人间的时候，它卖得极其昂贵；可是这瓶子有个特点，只有亏本出售，才能把瓶子卖掉。如果你按原价或者高于原价出售，它就会像信鸽一样又回到你那儿。因此，几百年来瓶子的价钱一直在下降，眼下这瓶子便宜得出奇。我本人只花了90美元就从邻居手中买了下来，我最高可以卖到89美元99美分，再贵1美分也不行。”
　　纪威还是不能完全相信这是真的。
　　“你可以马上试试。”那男人进一步解释道，“把你那50块钱给我，拿起瓶子，祈求这笔钱回到你的口袋里。要是瓶子连这一点都做不到，我向你保证把钱还给你。”
　　纪威想了想，决定冒一次险。他把钱付给了那男人，那男人把瓶子递给了他。纪威拿着瓶子，张口说道：“我要收回那50块钱。”话音刚落，纪威的口袋又像先前一样沉甸甸的了。
　　纪威拿了瓶子，在回船的路上，又试了两次。一次他将瓶子抛弃在街上，一次是以60美元卖给一家古董店，但都没有成功，结果瓶子反而神不知鬼不觉地比他先回到船上。
　　纪威有个好朋友叫罗帕卡，也是个海员。纪威将瓶子的故事原原本本地告诉了罗帕卡，还承诺说，等自己拥有了一座梦想中的房子，就让罗帕卡买这瓶子。
　　船一回到纪威的家乡，便有律师告诉纪威，他的叔叔和侄儿都死了，给他留下了一大笔财产，足够他造房子的了。纪威得到房子后，兑现了自己的诺言，将魔瓶转让给了罗帕卡，这样他就没有后顾之忧了。他终日欢天喜地住在新建的别墅里，附近的人们都把这幢美轮美奂的房子叫做“光明宫”。
　　一天，纪威去看朋友，在海边邂逅了一位姑娘，她叫柯库娅，两人一见钟情，很快订下了婚事。婚礼举行的前一天，纪威兴高采烈地吩咐佣人准备洗澡水，他一边洗澡一边唱歌，歌声在光明宫里回荡。不一会儿，歌声突然停止了，原来，纪威在洗澡的时候，发现自己身上有一块斑，好像石头上的苔藓，他意识到，自己得了麻风病。
　　 
　　那一夜，纪威一刻也没有合眼。他想得很多，他不愿意伤害柯库娅，不愿意给她带来危险。第二天，他给柯库娅写了一封信，说要推迟婚礼，然后登上了航船，去寻找罗帕卡，希望能再一次得到那瓶子，治好自己的病。
　　几经周折，纪威终于找到了那个瓶子的下落，瓶子现在的主人是一个脸色苍白的青年，纪威一问价钱，青年竟然是用2美分买来的瓶子；换句话说，纪威只能用1美分去买它；纪威不由打了一个寒噤：这意味着，他买了瓶子后就再也卖不出去了，那个魔鬼会一直跟他在一起，直到他死，他死后，魔鬼会把他带到地狱的火坑里去受煎熬。然而，纪威很坚决，他已顾不得这么多了，他爱柯库娅，他现在只想和她在一起。
　　瓶子又回到了纪威手中，他的手刚抓住瓶脖子，就说出了那个愿望：他想成为一个健康的人。他回到船上，对着镜子脱光了衣服，发觉身上的皮肤竟像婴儿一样细腻光洁。
　　纪威回到光明宫，把柯库娅娶回了家。柯库娅把全部身心都交给了纪威，她一见到他就心跳，在光明宫里，她的歌声不断，像小鸟一样欢唱。纪威高兴地瞧着她，听她唱歌；可是，当他一人独处的时候，他却蜷缩一旁，惶恐不安，似乎听到地狱的火焰在噼啪作响……
　　终于有一天，柯库娅发现了丈夫的秘密，在柯库娅的请求下，纪威将瓶子的事完完全全告诉了她。柯库娅听后，告诉丈夫，在法国有种硬币叫生丁，1美分相当于5个生丁，何不到那些法属群岛去想法卖掉瓶子呢？纪威激动地拥抱着柯库娅，说：“亲爱的，你是个天才！”
　　于是，两人马不停蹄地行动起来，他们赶到了法属岛屿，可那里的人们不相信他们说的话，是啊，谁会用4个生丁的低价出售能带来财富的瓶子呢？夫妻两人感到了前所未有的绝望。
　　然而，柯库娅是个聪明的姑娘。一天晚上，在纪威睡着后，她溜出了门，在一个街道拐角处，她见到一个乞讨的老头儿。她对老头说了许多好话，求老头答应她，花4个生丁从她丈夫手中把瓶子买来，随后她再花3个生丁买进。最后，老头儿答应了她的请求，不久，老头带着瓶子回来了，他告诉柯库娅，她丈夫卖出瓶子后，像小孩似的哭了起来。
　　柯库娅回到家里，纪威已经像孩子似的睡着了。她凝视着丈夫的脸庞，想：“我的丈夫，现在轮到你睡了，可对我来说，唉！再也睡不好觉，再也不会欢快地唱歌了。”她痛苦地在丈夫身边躺下，沉沉地入睡。
　　第二天早上，纪威叫醒了柯库娅，告诉她瓶子已经卖出去了的好消息。柯库娅只是淡淡地微笑着，纪威在狂喜中一点儿也没觉察到她的痛苦。他感谢妻子救了他，称她是世上少有的贤内助，同时他嘲笑那个买下瓶子的老头儿：“他还以为自己捡到了便宜，真够傻的。”柯库娅却低下头，说：“我的丈夫，他的用心也许是好的。你和我一起为可怜的瓶子的新主人祈祷吧。”
　　接下来的时间，柯库娅推说病了，常常独个儿呆着，她整天都在想着有什么机会能以2个生丁卖掉那个瓶子。她坐卧不安，一会儿拿出瓶子，一会儿又把它藏起来；纯洁的她连想也没有想过，要靠这瓶子捞点什么好处。
　　 
　　由于柯库娅总是一个人呆着，不愿意和纪威一起逛街，也不再和他快乐地聊天，纪威感到很不高兴；他觉得柯库娅变了，说她只为那个买了瓶子的老头儿着想，没有考虑到自己的丈夫，对他不够忠实。于是，纪威常常在城里游荡，渐渐结识了一帮坏朋友，其中有一个是城里出名的无赖，这无赖朋友唯一关心的，就是怎样骗光纪威的钱给自己买酒喝。
　　有一次，纪威已经醉得迷迷糊糊了，无赖朋友唆使他说：“女人都是虚伪的，你老婆也许有什么花样，你得看着她。”这话打动了纪威，于是，他带着这个朋友，蹑手蹑脚地回到旅馆，从后门朝里张望。这一看，他惊呆了：只见柯库娅坐在地上，身旁点着一盏灯，她的面前就是那个可怕的瓶子，她正没精打采地瞅着它。
　　“是她买了那个瓶子！” 纪威感到毛骨悚然，双膝发软，酒也给吓醒了。他想了想，决心把事情搞个清楚。于是他关上后门，轻轻地绕到前门，然后和以往一样，装成喝醉了的样子，吵吵嚷嚷地从前门进了屋。只见柯库娅坐在椅子上，瓶子也不见了；纪威又在以前放瓶子的箱子里找了找，也没见着瓶子。于是，他告诉柯库娅，自己是回来拿钱的，还要出去和朋友们一起痛饮。
　　走出家门，纪威来到那个无赖朋友跟前，镇静地说：“我老婆有个瓶子，能满足人的各种要求。除非你帮我搞回瓶子，否则以后我都不会再请你花天酒地了。这儿有2个生丁，你去找我老婆，说要买那个瓶子，把钱给她，她会马上给你瓶子的；我再从你那儿花1个生丁买回瓶子。我只有一个条件，就是决不能对她说，是我让你去买瓶子的。”
　　朋友照纪威说的去做了。不久以后，他就回来了，那个魔瓶就扣在他的外套上，他晃晃悠悠地走到纪威身边，说：“这是个挺好的瓶子，既然我花2个生丁买到了它，我就不会只要1个生丁就卖掉它。”
　　“你是说你不卖了？”纪威着急地问，他的心已经跳到了嗓子眼。
　　“不卖了！”无赖朋友叫道。
　　“我告诉你。”纪威说，“有这瓶子的人是要下地狱的。”
　　“哈哈，你以为我是傻瓜吗？”无赖朋友大笑着回答，“我听说，你的所有财富都是从这个瓶子里来的，上哪去找这么好的瓶子？你想只出1个生丁买回它？做梦！”无赖朋友说完，就带着瓶子扬长而去……
　　这就是魔瓶的故事。从此，纪威和柯库娅过上了平静安宁的日子。
　　 (题图、插图：安玉民 梁 丽)
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第1期   共有一个家园  作者：张东兴  字体：
   【 大  中  小 】 
 
　　 
　　有个房地产开发商，看中了一块地方。那地方是一处坡地，坡上有一株高大挺拔的松树，风水风景俱佳，开发出来建造高级住宅区，肯定赚大钱。可是这松树下仅有的一户人家，却说啥都不肯搬家。
　　开发商一看，这好办，反正强拆强建咱也不是头一回了，于是停电、停水、破窗、砸墙，好话说尽，坏事做绝，那户人家不堪其扰，男主人一跺脚，说：“我家世代生活在这个地方，地下埋着我们祖辈的骨头，所以我说什么都不会搬的。你们再骚扰，我找我哥去！”
　　开发商见男主人手握至尊宝似的，赶紧问手下：“他哥是干什么的？”手下大大咧咧地说：“肯定不是什么大不了的官，要不我们肯定早知道了。”
　　开发商却不放心，当即叫过一个精明能干的员工，让他跟着男主人去看看。
　　第二天，男主人背着个背篓，里面装些菌子笋干，出门去找他哥。那个员工不远不近地在后面跟着。男主人一路向北，最后竟买了去北京的火车票。开发商不由有些心虚，指示手下先停工。万一他哥大有背景，自己弄个半拉工程搁那儿，那可惨了。
　　男主人下了火车，七拐八拐，来到一个地方。这儿的房子低矮拥挤，街道上污水横流，那一路跟着的员工一边皱眉捂鼻子，一边打手机向老板报告情况。老板一听，手一挥，说：“开工！这个乡巴佬以为他哥在北京就了不起了！北京也有要饭的！”
　　男主人进了一间简陋的板房，一会儿和他哥一块出来了，都是胡子拉碴、窝窝囊囊的，还真像哥俩。
　　两人走到一个大排档前，大排档老板一看见那男主人的哥，立即抛下其他顾客，满脸堆笑跑过来殷勤招呼。哥俩吃喝一通，临走给钱，老板却说什么都不要。
　　员工跟在后面一看，又赶紧给开发商打电话。开发商听了也皱眉：“看这样子，别是黑道上的吧？” 穿鞋的怕光脚的，要是男主人的哥哥不管不顾地给他来一下，开发商还真有点顾虑，于是他指示员工：“我先停工，你想办法摸清他哥的底。”
　　员工来到大排档买了点花生米猪耳朵，然后悄悄问老板：“刚才那两人是干什么的？我看您挺巴结他们啊！”
　　老板看着那哥俩走远，才小声说：“不巴结不行啊，人家手下有三千飞虎军，随随便便给我来一下，我这生意就不用做了。”
　　员工手一哆嗦：“啥？三千飞虎军？你说那人是特种部队的？”说着赶紧给老板上了支烟，又给他点上。
　　老板深吸了一口，慢条斯理地品了半天，这才说：“嗯，这烟不错。这人刚来时我不认识，看他怪窝囊的就多收了他几块钱开瓶费，人家也不和我理论，一边慢条斯理地往外拿钱，一边吹起了口哨。不一会儿天边就来了黑压压的一群鸽子，到我这儿就噼里啪啦一通屙，桌上菜里全是白点子。你说我还怎么卖？”
　　员工大奇：“有这种事？可真稀罕哪！他怎么能召唤鸽子？”老板把烟头使劲掐灭，说：“何止是鸽子！过后我才听说，敢情人家是马戏团的驯兽师，懂得禽言兽语，天上飞的指挥不了飞机，地上跑的指挥不了火车，剩下的全行！这样的人咱哪惹得起呀！”
　　员工听了，赶紧又向开发商汇报，开发商顿时又来了胆气：“开工！露天大排档怕他哥，我可不怕！他要能召来鸽子给我的工程来一通，我还得谢谢他呢，那不就省得粉刷了吗？”
　　话虽这样说，他还是叮嘱秘书：往后不管是在办公室还是在车里，一律不准开窗，免得重要文件被鸟儿叼走了。
　　 
　　过了两天，男主人和他的驯兽师哥哥从北京回来了。驯兽师找到开发商，开发商没等他自我介绍，就说：“哟！驯兽师来了，久仰久仰。听说你懂禽言兽语，佩服啊佩服！”
　　驯兽师不卑不亢：“听说你希望我召来鸽子帮你粉刷，还安排手下不准开窗，真可谓煞费苦心，可惜啊可惜！”
　　开发商说出对方身份，本意是想震震对方，不料对方竟把自己的部署也摸得一清二楚，不禁开始重视起对手来，问：“可惜什么？”
　　驯兽师说：“我只想明白告诉你，你在这儿投多少就会赔多少，到时别怪我没提醒你。”
　　开发商笑了：“谢谢你的忠告。我也明白告诉你，我怕神怕鬼怕风水，唯一不怕的，就是人。只要是活人，我就能摆平他。”说罢一挥手，推土机、搅拌机、打桩机等设备隆隆开进，沙子水泥石子钢筋一车车运来，工程正式开始，那小屋顿时成了波涛汹涌的海洋上一条随时可能沉没的小舟。
　　双方摊牌后，驯兽师神秘消失了，可是那户人家却好像吃了定心丸一样，男主人给屋后的大松树松了松土、施了点儿肥，女主人在房前的篱笆旁种了些丝瓜眉豆。开发商看到这些，隐隐感到不安：这家伙肯定还有一张厉害的底牌我不知道，可是他一个穷困潦倒的驯兽师，能泛起多大的水花来呢？开发商坏心眼不可谓不多，可是他想破了脑袋，也想不出驯兽师会怎么对付自己，他只好自我安慰：我这么坏的人都想不出什么好点子，他们这些善良的老百姓更想不出了。
　　过了一个多月，开发商的房子已盖起了三层，推土机也推进到了那户人家的篱笆边。这时开发商的投资已近亿，想抽身已不可能，他准备和那户人家摊牌了：他要强行拆迁。
　　就在这时，沿着推土机推出来的土路上，来了两辆越野吉普。驯兽师领着一个老头和几个戴眼镜的年轻人从车上下来，在那户人家房前支起了高倍望远镜和摄像机。
　　开发商一看那个老头的气质，就知道大事不好。有道是腹有诗书气自华，甭看老头青衣布鞋，一看就知道是大学者。这种人论权势倒没什么，可是说一句话，往往整个世界上都有回声啊！
　　开发商顺着望远镜看上去，才发现那户人家屋后的松树顶上，不知什么时候多了个直径一米多的大鸟巢。开发商顿时明白了，那个驯兽师一个多月没露面，原来是招鸟儿去了。也没见他的影子，他怎么指挥的？可真神了。
　　甭管神不神，有一点开发商是坚信不疑的：人窝都挡不住我的推土机，难道这鸟窝能挡得住？但他还是问了那些年轻人一句：“那是个啥鸟窝呀？”
　　一个戴眼镜的兴奋地说：“金雕！这可是国家一级保护动物，很少见的！”
　　驯兽师充满同情地对开发商说：“你不听我良言相劝，这工程只怕要白搭了。根据有关规定，金雕栖息地周围183米内不得有任何大型建筑。”
　　 
　　开发商知道，如果没有这种规定，这家伙肯定不会费这么大劲儿，搞这么个东西，还请来了专家。开发商环视了一下盖了一半的楼、开了一半的场地、堆成小山的沙子石子……难道这一亿多资金真扔在这儿了？想到这儿，开发商眼一黑，晕了过去。
　　等他醒过来，第一眼就看见自己的律师站在面前。律师说：“老板，现在我有两个消息，一个好消息，一个坏消息，您想先听哪个？”
　　开发商想了想，说：“先说好消息吧！”
　　律师说：“我查询后发现，那个驯兽师说的规定确实有，不过，那是外国的规定！看来这家伙是个半瓶醋，不知从哪儿听说这种规定，也不查证查证，就来和您押宝了！”
　　开发商听了，高兴得来了个鲤鱼打挺，拽掉输液的针头，刚想给饭店打电话，大摆筵席庆贺一番，突然又想起了什么，赶紧问律师：“那坏消息呢？”
　　律师叹了口气，说：“市长听说本地发现了金雕，十分激动，连夜召开紧急会议，决定要在环境保护的力度上和国际接轨。您的原有项目停建，项目更名为‘共有家园展览馆’，高薪聘请驯兽师及其弟弟一家为展览馆员工，专门负责召唤和保护珍稀鸟类。原开发商享有开发展览馆项目的优先权。”
　　开发商足足愣了半个小时，才反应过来：自己被打败了。自己会过无数高手，想不到竟败在一个穷困潦倒的驯兽师手里。
　　后来，共有家园展览馆成了这个城市的著名景点，为此，绿色和平组织特地颁发了一批奖章，其中还有一枚是颁给开发商的呢……
　　 (题图、插图：佐夫)
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第1期   泣血送珠人  作者：大刀红  字体：
   【 大  中  小 】 
 
　　 
　　浙东临海有一个象山湾，此处盛产珍珠，小的如樱桃，大的如龙眼，光滑圆润，珠光熠熠，是富贵人家争相抢购的高档奢侈品。
　　象山湾的居民大多以采珠为生，平日驾船出海，潜入海里，寻找珠蚌，然后取出珍珠，把珍珠卖给本地收购珍珠的大户钱如友。钱如友以前也是一个采珠人，有一次，他采到一颗大珍珠，不甘心贱卖，就独自来到扬州，找到扬州富商柳自在，卖了个好价钱。从这以后，他觉得做珍珠生意，钱远比采珠来得快，就和柳自在商量好，他收购象山珍珠，由柳自在包销。
　　刚开始的时候，钱如友的确赚了不少钱，但自从枯木岭上出了强盗，打劫珍珠，他便亏得一塌糊涂。
　　从象山湾到扬州，途中得越过一座叫枯木岭的高山，不久前岭上聚集起一伙土匪，领头的叫“独龙”。“独龙”占山为王，虽不伤人性命，却劫掠过往客商的财物，尤其是珍贵的象山珍珠。
　　钱如友也想过对策，可是他叫人夹带的珍珠，总是被“独龙”搜身搜出。一年下来，钱如友只送出了几粒珍珠，其他的全被“独龙”所劫，为此，他黔驴技穷，几次想关门大吉。
　　这天，有个外乡人找到钱如友，说他名叫胡亦云，有办法帮钱如友送珍珠去扬州，不过，送一颗珍珠，他要提十两银子。钱如友心想：一般的珍珠，一粒我只能赚十五两银子，他就要提十两，心可够黑的，但转念一想，这总比一颗珍珠也送不出去好呀，便问胡亦云：“你有什么法子可以躲过抢劫？”
　　胡亦云见桌上有一串葡萄，就摘下一粒，扔入口中，整粒吞下，说：“就是这样。”
　　钱如友说：“不行，我曾经试过，珍珠入腹即化，万万行不得。”
　　胡亦云却笑着说：“非也，非也，你只知其一，不知其二。”说完，把钱如友拉过来，附耳轻言。钱如友听了，连连点头称是。
　　胡亦云的方法果然不错，不出三天，他就将钱如友交的几粒珍珠，顺利地送到扬州柳自在的手上。
　　胡亦云回到象山后，钱如友便按事前约好的，将银子交给他。胡亦云的方法百试不爽，但令钱如友不快的是，胡亦云一直不愿将最重要环节的秘方说出来，钱如友只能由他摆布。随着时间的推移，钱如友越来越对胡亦云不满。终于有一天，钱如友想出了自己的法子，便解雇了胡亦云，换了新的送珠人。
　　钱如友新雇的送珠人，只用外乡人，从不用本地人，而且，为了提防“独龙”，这些外地的送珠人，他只用一次，从不让他们跑第二回。
　　整整半年，“独龙”没有抢劫到珍珠，钱如友的送珠渠道让“独龙”非常困惑。每次，他把那些送珠人脱得一丝不挂，甚至连发根、贲门都检查过，但都没能找到珍珠，只好放了他们。“独龙”为了找出钱如友送珠的秘密，也曾让喽罗去充当送珠人，但钱如友一听他们的本地口音，就把他们赶出家门。
　　这天，山寨里来了个外乡人，说要投靠“独龙”。“独龙”问他为什么要当土匪，外乡人叹了口气，说：“黄河决堤，家冲没了，一路乞讨到这里，受够了白眼，想想还不如当土匪来得自在，就是被官府抓了，也是个饱死鬼。”
　　外乡人的话，让“独龙”有些犹豫，他怕这人是官府的暗探，就问外乡人叫什么名字，外乡人一副顺从的样子，说他名叫符豫子。突然，一个计划在“独龙”的脑海里形成：这符豫子是个外地人，干脆就让他去给钱如友当送珠人。这样，一来可以打听钱如友是怎么送珍珠的，二来，也可以试探符豫子是不是官府中人。
　　听了“独龙”的话，符豫子毫不犹豫地答应下来，说就是肝脑涂地，也要把送珍珠的秘密打听出来。
　　符豫子来到钱如友的家，说他要当送珠人。听说符豫子是逃难的外乡人，又见符豫子面黄肌瘦，一副营养不良的样子，钱如友就信了他的话。钱如友对符豫子说：“你一次给我送二十粒珍珠，每粒给你一两银子，银子我可以预先支付。”
　　符豫子问怎么送。
　　钱如友拿出四十粒半圆形的陶丸，又拿出二十粒象山珍珠。当着符豫子的面，钱如友把珍珠装进陶丸里，然后用蜜蜡、松香制成的粘胶封住陶丸。待把二十粒珍珠封好，钱如友拿出一碗水，让符豫子就着水，把陶丸吞下。
　　见符豫子一脸惊讶，钱如友说：“只有这样，才能保证珍珠被送到扬州。到了扬州，你再把珍珠排出。”
　　符豫子一听，原来是这么回事，就把陶丸吞进肚里。钱如友叮嘱说：“三日内，一定要将珍珠送到柳自在那里，只有柳自在那里有秘制解药，否则……”
　　 
　　见钱如友吞吞吐吐的样子，符豫子忙问：“否则什么？”
　　钱如友说：“否则，三天过后，陶丸堵住你的贲门，你将会肚胀而死。”
　　符豫子肚里藏着珍珠，回到“独龙”的山寨，把实情告诉了“独龙”。“独龙”听罢，笑着说：“原来如此，难怪我没有搜出珍珠。钱如友说珍珠不能从腹内排出，定是怕你自己想法排出珍珠，是在讹你！”说完，就让喽罗取来些巴豆，熬成汤药，让符豫子服下。
　　符豫子喝下巴豆汤，一会儿，就觉得腹内疼痛，想要排泻，但过了半个时辰，虽然肚内如刀割一般，但什么也没排出来。看着符豫子越来越苍白的脸，“独龙”知道，钱如友说的是实话，没有柳自在的独家秘方，符豫子根本排不出陶丸来。
　　这时，有个喽罗附着“独龙”的耳朵说：“要不然，我们就剖腹取珠，反正他是个外乡人，也没人会追究。”
　　“独龙”听了，一个巴掌过去，将喽罗打出一丈开外。“独龙”说话声如洪钟：“我上山当强盗，实为奸人所逼，我发过誓，决不害人性命，更不会做这种剖腹取珠的勾当，来人，叫一辆马车，把符豫子送到扬州去。”
　　马车夫快马扬鞭，不出两日，就将符豫子送到扬州城柳自在的家里。柳自在见新的送珠人到了，忙吩咐下人把符豫子抬到后院的一间僻静小屋，接着吩咐所有人回避，自己架起一个火罐，慢慢地熬起解药来。
　　等解药熬好，柳自在倒出药，端到符豫子面前，对符豫子说：“喝了这碗药，你就会排出陶丸。”符豫子忙一口把药喝下。片刻，符豫子只觉得全身瘫软，动弹不得，他问柳自在：“你给我下的是蒙汗药？”
　　柳自在阴笑道：“不错，喝了蒙汗药，等你睡着后，也少些痛苦。”说完，从袖子里取出一把尖刀。
　　符豫子问：“你想怎么样？”
　　柳自在说：“你在象山湾时，难道没有听说过‘杀蚌取珠’这么一句话吗？珍珠藏在蚌壳里，要取出里面的珍珠，只能将蚌壳剖开。你放心吧，我下刀会很快，让你死得毫无痛苦。”说完，柳自在向符豫子的腹部刺去。
　　符豫子闭上眼睛，暗暗叫苦，却听柳自在怪叫一声，他睁开眼一看，柳自在的手上着了一镖，匕首掉在了地上。这时，有个人闯进屋内，符豫子一看，原来是化装成马车夫的“独龙”。“独龙”把符豫子送来，主要是想弄到解药的秘方，谁知道所谓的秘方竟然是剖腹取珠，他不忍见符豫子送了性命，就发镖救了符豫子。
　　柳自在的嚎叫引来了家丁，他赶忙吩咐家丁，说符豫子和“独龙”是强盗，只管出手，打死一个，赏银百两。听了柳自在的话，家丁个个奋勇当先，饶是“独龙”武艺高强，也架不住对方人多，渐渐落了下风。
　　就在这时，从门外冲进一队捕快，打散家丁，把柳自在和“独龙”都抓了起来。领头的捕快见符豫子被麻翻在地，忙把他扶起来，给他服下解药。等符豫子醒过来，领头的捕快冲符豫子一拱手，说：“总捕头，接到你的红粉传信，我们就寻着红粉来了。来晚半步，差点害了你的性命。”
　　 
　　听了捕快的话，柳自在和“独龙”一惊，他们怎么也没有料到，符豫子竟然是总捕头！符豫子拈须一笑，说：“我在路上已将陶丸用内力逼出，进扬州城时，我在马车经过的地方撒了红粉。近来总有外乡人在象山一带失踪，朝廷派我来查此案。”
　　符豫子说，他开始调查的时候，听说枯木岭上有一伙强盗，还以为那些失踪的外乡人是被强盗所害，就化装上了枯木岭，没想到竟然让“独龙”看中，让他去钱如友家探取秘密。
　　符豫子对柳自在说：“没想到，强盗都没做出的事情，竟让你们这些奸商做了。杀人取珠，天理不容，快交代，你们怎么想出这个方法，杀了多少人？”
　　柳自在忙跪在地上，讨饶说：“这全是钱如友让我做的。”柳自在说，钱如友对胡亦云非常不满，但又没有什么好主意。有一天，钱如友收到一颗珍珠，大如龙眼，价值千两白银，就让胡亦云吞入肚中。由于这颗珍珠价值不菲，钱如友怕胡亦云拐带走，就跟着胡亦云来到扬州。
　　谁知，到了扬州，胡亦云喝了自制秘方，也排不出陶丸。钱如友忙问胡亦云怎么了，胡亦云说：“陶丸太大，堵住了贲门，排不出来。”钱如友忙问胡亦云有什么解法，胡亦云说：“等到三天后，陶丸自然会在腹中消溶，我就会将残渣排出。”
　　钱如友听说三天后，陶丸会在腹内溶化，那价值一千两银子的珍珠也就没了，不由心急如焚。这时，他突然想到了“杀蚌取珠”的方法，就找到柳自在，两人一拍即合，用蒙汗药麻翻了胡亦云，剖开胡亦云的肚子取出珍珠。两人杀了胡亦云，过了很长一段时间，见没人追查胡亦云的下落，也就心安理得。从这以后，他们逐渐摸索出经验，那些四处流浪的外乡人，因为没有亲属追问，最适合给他们当送珠人。到现在为止，已有二十二个外乡人死在他们手里。
　　符豫子当下把柳自在打入死牢，又命人去象山抓了钱如友。过了段时间，柳自在、钱如友、“独龙”全被判了死刑，只等秋后处斩。
　　行刑那天，符豫子带着酒肉，来到“独龙”的牢房，说感谢他的救命之恩。“独龙”问，自己救了符豫子一命，可符豫子为什么不放自己一马，帮自己开脱罪责呢？
　　符豫子摇了摇头，说：“你怎么到现在还不明白呢，要不是你占山为王，抢夺珍珠，钱如友和柳自在又怎么会想出剖腹取珠的主意呢？你虽然没有杀人，可那些人全是因你而死。”
　　“独龙”想了想，觉得符豫子说得很对，便心甘情愿地伏法。
　　 (题图、插图：黄全昌)
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第1期   一小时之前  作者：郭振宇  字体：
   【 大  中  小 】 
 
　　
　　这回，他们一路顺风，很快到了海边，女孩面对大海，拉住了父母的手，说：“爸爸妈妈，我看到了，大海真美呀！”孩子的父母顿时泪流满面。小安看着他们，觉得一切都是值得的：毕竟，这可能是孩子人生的最后一眼呀！
　　接着，小安吃下黑色药丸，回到了现在，匆忙赶到了期货公司，可这次又晚了。小安暗想，最后一次机会一定要把握住。
　　
　　收获爱情
　　
　　晚上，小安刚回到家中，黄老板打来了电话：“今天晚上我请你吃饭，酒和烧鸡都买好了，我去你家，在家吃氛围好，我马上过去。”小安只好告诉了黄老板自己的住址。
　　不一会，黄老板来了，大包小包拎了不少好吃的，还有两瓶白酒。黄老板不停地劝酒，小安酒量不行，不一会就醉了。这时，黄老板提出，要看看小安的后悔药，小安把药拿了出来，黄老板问：“这药怎么用？”
　　小安头很晕，嘴皮子也不利索了：“把药吃下去就、就行了，先吃白的，后吃黑的，这样就可、可以了。”说完，他一头栽倒在床睡了起来。
　　直到次日中午小安才醒来，他睁眼一看，黄老板已经走了，桌上有个纸条，纸条上压着张银行卡。小安拿起纸条一看，是黄老板留下的：“你的药我拿走了，银行卡里有十万元钱，算是我买药的钱，我怕你又拿药去干别的事。”
　　小安大惊，黄老板也太黑了，他拿了药，转眼就能赚几百万，却只给自己十万，不行，得把药要回来。他给黄老板打电话，对方却关机了。他跑到期货公司，也未见黄老板的踪影。
　　小安暗叹，这回完了，他心里不断地骂着黄老板，无精打采地回到了家。刚到家门口，他就惊喜地发现，门口站着两个人：一个是他的女友，女友后面还跟着一个人，就是那个海边遇到的出租车司机！女友指着司机说：“我给你介绍一下，这是我父亲。”
　　小安先是一愣，接着忙不迭地问好。
　　司机说：“昨天我回家后把你的名片给女儿看了，这才知道，原来你就是她的男朋友。”
　　女友盈盈一笑，告诉小安：“爸爸同意我们的关系了。”
　　小安高兴得几乎要跳起来：“真的？”
　　司机说：“当然是真的，我看中的，是你的人品，为了让一个素不相识的小女孩看看大海而放弃赚上百万的机会，这样的人不多了，把女儿嫁给你，我放心！原先看你没正经工作，我还以为你是个混混呢。她妈妈的思想工作我已经做通了，她在家里给你做饭呢，走，咱们回家吃饭去！”
　　小安高兴得合不拢嘴，三个人欢欢喜喜地正要出门，小安的手机响了，一看，竟然是黄老板打来的：“小安啊，我吃了你的药，怎么没到一小时之前啊，我不知道我来到了什么地方，这地方好可怕，一个人都没有。”
　　小安先是一愣，随即赶紧问：“你吃的是黑药还是白药？”
　　“我按你说的吃的，先吃白的，后吃黑的，没错呀！”
　　“你是不是吃完白药马上就吃黑药了？”
　　“是啊！”
　　“哎哟，这下完了，应该先吃白的，这样你就会回到一小时之前，想回来时再吃黑的，黑的就会把你带回来。根据说明书上写的，如果一起吃了，白的就不起作用了，而黑的会把你带到一小时之后，你现在是在我们的一小时之后了。”
　　“那、那我怎么回来呀？”
　　“你永远都回不来了，药已经没有了，你就在未来的时空里给我们探路吧。”
　　“可这里一个人都没有，我好害怕。”黄老板声音发颤。
　　“一个人好，这样你就不用再贪钱了，整个世界都是你的了！”
　　 (题图、插图：谭海彦)
　　 
[ 1 ] 2        
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第1期   一小时之前  作者：郭振宇  字体：
   【 大  中  小 】 
 
　　 
　　后悔药
　　
　　小安失恋了，他痛苦万分，一天到晚像丢了魂似的。
　　小安没钱没房，也没个正经工作，女友的父母强烈反对女儿与小安恋爱。女友虽然很爱小安，但还是迁就父母，向小安提出了分手。
　　这天，百无聊赖的小安在网上闲逛，他看到一个帖子，说是卖后悔药，小安觉得很有趣，便打了帖子上所留的电话，问后悔药是什么意思。对方告诉小安，他们是一家搞药物科研的私人公司，后悔药是他们最新的科研成果；所谓后悔药，就是谁吃了这种药，就可以回到一小时之前，这样他就可以把一小时前做的后悔事情重新做过。
　　小安觉得好笑，随口说了一句：“这年头骗子真多。”对方听了，不但没生气，反而笑了起来：“对，大家都是这样想的，我们在网上发帖子已经一个多月了，只有你一个人打来电话。这药我们还在实验阶段，现在白送给你，一分钱也不收，这样你不会说我们是骗子了吧？”
　　“既然如此，你就把后悔药寄给我一些吧。”小安把地址告诉了对方。他很好奇，想看看后悔药到底是什么东西。那人记下了地址，叮嘱道，这后悔药很珍贵，千万不要随便吃，而且一定要按说明书上的方法服用。
　　过了几天，小安果然收到了一盒东西，他打开一看，是八粒药片，四粒白的，四粒黑的，还附有说明书，上面写着后悔药的用法：吃白的可以回到一小时之前，想回来时再吃黑的。小安觉得可笑，说得跟真事似的，他随手把说明书揉成一团扔到了窗外。
　　下午，小安和几个朋友喝酒，他心情不好，多喝了几杯，有些醉了。回到家后，他看见了后悔药，心里合计：我吃一片看看会发生什么。仗着酒劲，小安按着说明书所言，拿出一粒白色药片吃了下去。神奇的事情发生了，他真的回到了一小时之前！他发现自己正坐在酒桌边，几个哥们正在推杯换盏。小安惊呆了，他赶紧又吃了一粒黑色药片，很快，他回到了现在。
　　好神奇！小安想再多要一些药，他给卖药的人打去了电话，却是空号，上网一查，卖药的帖子也不见了。小安看着剩下的六片药，暗暗庆幸，多亏没有扔掉，现在还有六片药，有三次回到一小时之前的机会，一定要好好利用，发几笔横财，到那时，也许女友的父母就不会反对自己和他们的女儿恋爱了。
　　
　　发财有道
　　
　　如今最快的赚钱方法自然是炒期货，看哪只期货品种涨的多，回到一小时之前去买，那就可以大大赚一笔。小安没有本钱，不过这没有关系，可以去找有钱人。小安在期货公司找到了一个姓黄的老板，黄老板手里的资金有几百万，小安把自己的想法和黄老板说了，黄老板半信半疑，不过他表示愿意合作，事后五五分成。商人嘛，不会轻易放过任何一个赚钱机会。
　　黄老板告诉小安，要等行情有大的波动时再买，到时他会给小安打电话，小安就赶过来实施计划。黄老板卖了手中的所有期货品种，等待时机，两天过去了，没有什么好机会。
　　这天，小安路过证券公司，他走了进去，想看看行情怎样。刚进证券公司，就听到喊声：“有人晕倒了！”小安挤进人群一看，只见一个四十岁左右的男子直挺挺地躺在地上，人事不知。小安一打听，晕倒的人姓刘，今天上午买了一只股票，快到涨停板时买的，结果一会就跌停板了，一天损失20%，他一急，心脏病突发，晕倒了。
　　不一会，救护车来了，医生检查了一番，对证券公司的工作人员说：“不行了，人已经死了，赶紧通知家属吧。”
　　小安很惊讶，他挤过去问医生：“这人没救了？”医生点了点头，叹了口气：“太晚了。”
　　这时，小安的手机响了，是黄老板打来的，他告诉小安有行情了，让小安赶紧过去。小安看看倒在地上的刘先生，心想：不行，得先救人。小安把这里发生的情况告诉了黄老板，然后挂了电话，立刻吃了一片药，回到了一小时之前。
　　在一小时前的时空里，小安找到了刘先生，刘先生正准备买股票呢，小安上前一把拦住了他：“千万不要买！”
　　刘先生一愣，小安说：“这只股票买不得，我是从一小时之后来的，那时你因为买这只股票突发心脏病而死，所以你不能买。”
　　 
　　刘先生哈哈大笑，他根本不信小安的话。小安急了，一把抓住刘先生，大喊：“抓小偷，这人偷了我的钱！”保安闻声急忙跑来，刘先生气得把衣兜里所有的东西都掏了出来，对保安说：“我没偷，你看，哪有他的钱包，这小子胡说八道，八成是个疯子。”
　　保安又询问了一番，见小安也没证据，就让他们离开了。等保安走远了，小安对刘先生说：“对不起，其实我根本没丢钱包，我只是不想让你买那只股票，不信你看，它已经大跌了。”
　　刘先生来到电脑前，只见他想买的那只股票已经飞流直下，眼看就要跌停板了，刘先生冷汗都下来了，他看了看小安：“你真是从一小时之后来的？”
　　“当然，一会你就知道了。”
　　小安吃了黑药，回到了现在，只见刘先生两眼迷离，还在想着刚才发生的事。
　　这时，黄老板也赶来了，他想看看小安是否真的能回到一小时之前，他看见刘先生死而复生，知道小安所言非虚，不由对着小安连连摇头：“这次时机已过，可惜可惜，只能等下一回了，以后切不可为了别人浪费了咱们的机会啊！”小安点了点头。
　　
　　又失机会
　　
　　第二天，小安陪着一个亲戚去海边玩，就在他们要回去的时候，一辆出租车开到了海边。车停了下来，从车里下来三个人，一男一女带着一个小女孩，小女孩四五岁的样子。那女的一下车就问小女孩：“前面就是大海，你看见了吗？”
　　小女孩说：“我看见了，大海真漂亮！”小女孩虽这样说，但她的眼睛所注视的方向根本不是大海！女的见状脸色一变，她一手把女孩抱了起来，另一只手伸向了女孩眼前，女孩却毫无反应，原来她根本看不见！女的哭了：“都怪妈妈，连你这个小小的愿望都实现不了……”
　　女孩说：“妈妈不哭，看不见没关系，我可以听，我听见大海的声音了。”
　　看样子女孩是失明了，小安看着挺揪心，便想离开，他和亲戚钻进了那辆出租车，可司机却还在愣愣地看着那三个人，许久他才回过头来，拍拍自己的脑袋说：“没有来得及，遗憾啊遗憾！”
　　小安好奇地问怎么回事，司机边开车边向小安讲了事情的经过。
　　原来，这个小女孩患了眼疾，眼睛就要失明了，她最后的愿望就是想看看大海。父母带着她跑了几百公里来到这里，女孩上出租车的时候还能模模糊糊地看见东西，哎，就差了一会儿啊！小安问道：“是什么事耽误了？”
　　司机重重拍了拍自己的头：“这事都怨我，我财迷心窍啊！我是在火车站遇到他们的，当时有一个乘客已经上了我的车，他们一家三口说想去海边，我便想并客。其实他们和那个乘客去的是两个方向，我送完那个乘客再送他们，路上又堵车，这一来就耽误了很多时间。要是我早知道他们的情况就好了……”
　　小安心头一动，自己何不用后悔药帮小女孩实现愿望？这样，自己还能剩最后一次机会。
　　不巧的是，这时黄老板的电话来了，他告诉小安，有行情了，赶快过来，越快越好。小安有些犹豫，黄老板听他说话吞吞吐吐，就问：“是不是又想管闲事？我跟你说，天天有死人的，你管得过来吗？赶紧过来吧。”
　　“可这次是个孩子，我要帮她实现看大海的愿望。”
　　“你疯啦？为了看一眼大海就浪费一次机会，你不想找你的女朋友了？”
　　这句话说得小安心里一动，他愣了愣，还是断然告诉黄老板，自己不过去了，再等下次机会吧。黄老板还要再说什么，小安挂断了电话。
　　小安告诉司机，他有办法让女孩实现愿望，让司机马上载自己去女孩上车的地方，司机半信半疑，但他还是向小安要了一张名片。
　　车子很快开到了火车站，小安吃下药丸，时间回到了一小时之前，只见那一家三口正走出车站，出租车也来了，正是刚才的那个司机，他的车上还拉着另一个乘客。小安立刻走了过去，向司机把小女孩的情况说了，问能不能让他们先走，那乘客通情达理，立刻下了车，一家三口上了车，小安怕路上出什么事，也跟着上了车。
　　 
 1 [ 2 ]       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第1期   一定要抓到你  作者：刘祖光  字体：
   【 大  中  小 】 
 
　　 
　　这天中午，马青峰开着车，来到新华派出所，正好看到姜涛走出来，两人见面，分外眼红，马青峰二话不说，拉起姜涛就往外走。赵明慧在办公室里听说这事，连忙赶出来，刚走到派出所门口，就看见姜涛上了马青峰的车，一转眼，车子就开出去老远。
　　赵明慧连忙站在路边拦的士，拦了老半天，总算拦到一辆，一路追过去，终于在郊外一个废弃的停车场看到了马青峰的车子。赵明慧下车一看，只见马青峰和姜涛都靠在车上，大口大口地喘着气，两个人都满身是泥，姜涛的眼角破了，马青峰的鼻孔在淌着血。马青峰指着姜涛，说：“好小子，真有你的，想不到你倒有几下真功夫。今天不分胜负，下次再来过。谁输了，谁就从她身边滚开！”
　　赵明慧见他们这副模样，又气又急，不禁冲他们嚷道：“你们把我当什么了？拿我当赌注？我还以为你们有多了不起，一个年度先进，一个优秀刑警，原来都跟街头小混混一个德性！”
　　姜涛连忙站直身子，张口结舌地想要解释，赵明慧手一扬，说：“你啥也别说了，还有你，马青峰，以后，你们都离我远远的，一年之内，你们谁也不要跟我搭讪。让我安静点儿，花点时间看看你们究竟是怎样的人！”说完，坐上的士走了……
　　姜涛和马青峰都愣在了原地，过了好一会，姜涛问：“哥们，还赌不？”
　　马青峰脖子一梗：“赌！谁不敢赌，就不是爷们！”
　　姜涛大喝一声“好”，说：“既然赌，我们干脆再赌大点，来一场豪赌！赌注也加大，不仅是赵明慧，还有自己的前途，甚至身家性命。赌好了，利国利民，能铲除洪武市的巨奸大恶；赌输了，可能连自己怎么死的都不知道……”
　　马青峰听出一点味道来了，他沉吟了片刻，说：“你是说，谁先破大案、立大功，谁就可以和赵明慧交往？不过，听你的意思，又好像并不仅仅为了赵明慧……你说的洪武市的巨奸大恶，是指谁？”
　　姜涛意味深长地看了马青峰一眼，说：“现在还不能说得太多。这本来就是我们的工作，你要是敢赌，我们两人合作，成功的机会就大得多。我希望，在赵明慧给我们的这一年时间里，我们协同配合，让她看看我们的真本事！”
　　“真来劲！你给我从头说起……”
　　
　　3. 一场豪赌
　　
　　在姜涛和马青峰的这次谈心后不久，市公安局刑警队突击行动，打掉了一个黑社会犯罪团伙，可是，首犯张明远却逃过了缉捕。
　　这个案子是由马青峰负责的，他正在为如何找到张明远的藏身之处发愁，突然接到了姜涛的电话。
　　电话那头，姜涛微笑着说：“听说你正在找张明远，我建议你到曙光街46号招待所看看……”
　　马青峰难以置信，这么多刑警都没查出来的线索，姜涛他一个普通的户籍警怎么知道？只听姜涛继续说：“张明远有个同母异父的姐姐，户籍就在新华派出所，她的前夫的堂弟，是曙光街46号招待所的经理，张明远如果没外逃，那里可能是他比较理想的藏身之地……”
　　两个小时后，马青峰兴冲冲地给姜涛打电话，兴奋地说：“哥们，我刚才带着几个人去了曙光街46号招待所，一去就逮住了正准备外逃的张明远，真有你的！你是怎么知道的？”
　　姜涛笑呵呵地说：“你别小看我们户籍警，我曾对新华区有案底的人进行过排查，他们的亲友关系和家庭住址，在我的心里都有一本账呢。”
　　马青峰钦佩地说：“了不起，你简直是张‘活地图’！”
　　接下来几个月的时间，马青峰利用姜涛提供的户籍信息，又接连破了两起大案。马青峰立了功，也引起副局长冯保平的关注。他把马青峰叫到家里，拍着马青峰的肩膀，笑呵呵地问：“你最近成绩很不错啊，说说看，用了什么好办法？”
　　在冯保平家里，马青峰用不着像在单位那么受拘束，他喝了一口水，说：“其实也没啥，主要是我有了一个得力的帮手，这人真不简单，不光是本‘活地图’，还很有思路，有想法。他要是能来刑警队，真是个可造之材，可惜，局里把他分到派出所，做了名户籍警。”
　　冯保平装作不知道的样子，问：“哦？还有这种事？他叫什么名字？”
　　马青峰说：“他叫姜涛。他在完成本职工作的同时，发现了不少对我们破案有用的线索。他对我说，最近他正在调查前几年那件杀害女记者的案子。那个凶手常四的户籍就在他的辖区，他几次走访常四的家属，找到了不少线索呢。”
　　冯保平一听，吓了一跳，又强装镇定，不动声色地说：“杀害女记者的案子早已结案了，他还找什么线索？做得太多余了吧？”
　　马青峰说：“他这人很细心，可能是在走访时发现了什么破绽，怀疑这案子另有隐情吧。”
　　冯保平点点头，不再吱声。马青峰一走，他马上给林建荣打了电话，说起了刚才的事。到了下午，两人在一间茶楼见了面。林建荣说：“马青峰最近连破几个大案，我也听说了，没想到是姜涛在背后支持他。这小子，做户籍警都做得不太平！”
　　冯保平问：“姜涛怎么和马青峰走到一块去了？真是莫名其妙。”
　　林建荣点燃一支烟，说：“我一接你的电话，就派人去查了，姜涛果然去过常四家好几次了，虽说没问出什么实质内容，可常四他娘现在一说到儿子就哭，还说什么‘我那四儿好可怜，连婚都没结，我还想抱孙子，哪天能盼到啊’，显然是受了姜涛的影响，再这样下去，只怕迟早要出事。”
　　冯保平点点头，说：“这样看来，姜涛并没安心做一个户籍警，他一直没放弃调查他姐姐的死因。他帮助马青峰，也许是为了以后能借用马青峰的刑侦手段。虽说他成不了事，但也不能再让他这样下去。要不，调他去做交通警察？”
　　林建荣摇摇头，说：“交警涉及面广，跟各阶层都能发生密切联系，让姜涛干这个，他还是会借职务之便，内查外调，给我们添麻烦。我看，不如把他调到与世隔绝的监狱去，让他去做一名狱警！”
　　冯保平说：“不行吧？常四正关在监狱里，姜涛这一去，不正给他一个接触常四的机会吗？”
　　林建荣笑笑，说：“你只知其一，不知其二。常四那里，我几次托人，让他由死刑变成死缓，后来又由死缓减为无期，可这小子还不知足，这段时间，他老催着我想法子再为他减刑，看来他心里发急了。这种人活在世上，就是多一根引燃炸药包的引线。趁现在姜涛还没把这个案子掀起来，我们赶紧派两个人进去，把常四弄掉……另外，金发集团的郭子非老跟我们抢生意，也该给他一点教训了。现在，这两件事正好可以一起做。只要常四一消失，姜涛当了狱警又能怎么样？狱警是个肥差，我们再给他一个受贿的机会，把他喂肥，等他一中招，到时候一查一个准，他自己一身绿毛，看他还敢说谁是妖精……”
　　冯保平听了，连连点头称妙。他稍加活动，市郊监狱便给市公安局发来请调人员的报告，公安局一纸调令，姜涛马上就从位于繁华市区的新华派出所，来到了偏僻的市郊监狱，成了一名狱警。
　　姜涛一到监狱，便得到一个美差：经办犯人立功减刑材料的申报。不到一星期，姜家便热闹起来，犯人家属接二连三地上门，在姜涛身上下起功夫来，连姜涛的爸爸每天早上到公园里打太极拳，一路上都有人向他打招呼。过了不久，姜涛家里的空调、冰箱，一件件都添置起来，连那台用了好多年的旧彩电，也换成了一台大尺寸的液晶电视。姜涛成天坐着监狱的班车出城进城，一门心思忙着监狱里的工作，再也顾不上其他事了。
　　这天，冯保平又跟林建荣见了面，说起姜涛，他呵呵一笑，说：“林老板，你真是神机妙算！姜涛那小子现在是老鼠掉进了米缸里，美死他了……”
　　林建荣得意地说：“让他再多吃点甜头，把他的胃口撑大了，再给他几个够分量的，让他吃得进，吐不出……”
　　
　　4. 一石二鸟
　　
　　在姜涛调到监狱的同时，马青峰所在的刑警队又遇上了一件大案：这天晚上，金发集团的老板郭子非在洗浴中心洗浴，突然冲进来两个人，挥刀就砍，然后迅速离去。歹徒手法老练，郭子非连凶手的面目都没看清，就被砍成了重伤……
　　 
[ 1 ] 2 [ 3 ]
               
                [ 4 ]       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第1期   一定要抓到你  作者：刘祖光  字体：
   【 大  中  小 】 
 
　　 
　　马青峰自告奋勇，请求接手这个案子。经过调查，他发现两个凶手目标明确，不为钱财，很可能是受雇于人的老手……马青峰灵光一闪，他想到了已经调去监狱的姜涛，马上给姜涛打了电话。
　　姜涛听完案情介绍，也同意马青峰的分析，他想了想，又补充说：“这几年，金发集团的生意越做越大，雇凶的很可能是郭子非商业上的竞争对手。在咱们这个城市，有谁敢对郭子非下手？”
　　“林建荣！”马青峰忍不住叫了出来，但他随即又叹了口气，“问题是，我们没有任何证据。”
　　姜涛却胸有成竹：“作案手法如此老练的凶手，一定有案底，何不从这里入手呢？”
　　马青峰大喜，说：“咱们想到一块去了，我就是为这事来找你的，我想请你查查监狱的档案，看有没有线索。”
　　姜涛笑了，这段时间，他早就把监狱近几年的档案摸了个遍。杀害姐姐的凶手常四的档案，他更是调了出来反复研究，看得都能背下来了，但姜涛没有急于行动，他不动声色，暂时没有跟常四正面接触。
　　现在，姜涛把仔细研究了几十遍的档案在心里过了一遍，终于对马青峰报出了两个名字：陆五、曹建。
　　在这个城市，作案高手就那么几个，大多数都被关在监狱里，但是去年，有两个高手离开了监狱，他们是屡次减刑被提前释放的，这两个人便是陆五、曹建。他们以前就是林建荣的手下，而且和常四一样，都住在新华区。两人离开监狱后都没和家人联系，没人知道他们去哪里了。从作案的手法特征看，他们很可能就是洗浴中心伤人案的凶手。
　　听了姜涛的分析，马青峰佩服地点点头，说：“如果真是这两个家伙做的，那么，他们的幕后主使一定是林建荣。只是我不明白，凭他们两个的身手，一个人就足以成事了，多派一个人，就多一分累赘，不是多此一举吗？”
　　“这个，我现在还没想明白……”听了马青峰的话，姜涛陷入了沉思。
　　其实，老奸巨猾的林建荣哪里会做多此一举的傻事呢，这正是他的一石二鸟之计：他向陆五、曹建许以重金，先让他们打伤郭子非，然后再故意把他们的藏身之地透露给警方，让他们回到监狱，好在监狱里杀死常四灭口……
　　果然，几天后，马青峰就接到了冯保平打来的电话，说有人举报，一幢烂尾楼里这几天住进了两个人，躲躲闪闪，形迹十分可疑，说不定与洗浴中心伤人案有关，让马青峰马上带几个人去看看。
　　马青峰放下电话，带着人马来到那幢烂尾楼，冲到四楼一个套间，里面两个男人还在呼呼大睡，马青峰一瞅，乐了，拿脚尖把他们一一踢醒，哈哈笑着说：“陆五，曹建，你们可真会挑地方，快起来，跟我走吧！”
　　在审讯室里，陆五和曹建倒也爽快，承认洗浴中心的案子是他们干的，但不承认有幕后主使。他们说，自己是拆迁户，因为对金发集团野蛮拆迁的行为不满，才攻击郭子非的，两个人口径十分一致。案子审结后，移送检察院，到法院审理，都十分顺利，陆五和曹建很快被判了刑，送入姜涛所在的监狱。姜涛坐在办公桌前，正等着给陆五和曹建办入狱手续，他见到陆五、曹建走进来，便笑呵呵地说：“二位出去才一年时间，又故地重游了，欢迎！”
　　两个家伙摆出一副见过场面的样子，一点也不怵，还给姜涛鞠了一个躬，说：“政府，请多关照，给我俩安排个好点的监室吧！”
　　姜涛故意翻了翻面前的簿子，说：“你们是重刑犯，只能‘吃小灶’，常四那间，昨天刚好走了两个人，你们就住进去吧。三个人住一间，够照顾你们的了，可别给我闹事！啊？”
　　陆五、曹建一听，跟常四住一起，那是正中下怀啊，两人对望一眼，连连点头，一连声地说着“当然，当然，肯定，肯定”，换了囚服，便跟着监管人员去了监室。
　　他们走进监室时，常四正在床上躺着，见他们进来了，也不起身，懒洋洋地说：“哥们，这就来陪我了？老板可真关心我，四年都过去了，他现在反倒怕我孤单，又派你们来了……”
　　陆五瓮声瓮气地说：“老四，你别瞎想，这回是我们运气不好，做完事刚躲起来，便让条子逮住了。老板是真对我们好，他很惦记你，前不久还去你家看望你妈……”
　　常四长叹了口气，说：“上回我妈来看我，说她还没抱上孙子，不甘心。我现在对老板毫无用处了，不知啥时候他能活动一下，帮我再减减刑，也好让我有个盼头，遂了我妈的心愿……”
　　陆五听常四这样说，乐了，哈哈笑着说：“真是士别三日，要刮目相看了。当年豪气冲天的常老四，变得这么儿女情长了，哈哈哈！”
　　不一会，吃饭的时间到了，三个人到了食堂，每人领了两个包子，一碗稀饭。常四排在曹建身后，轮到曹建时，炊事员特意从边上挑了两个大个的包子给曹建，常四在一边看着，没吭声。三个人坐在了同一张桌子上，常四突然伸出手，将自己的包子跟曹建的换了，说：“今天我好饿，你的包子大，跟我换换吧。”曹建急忙伸手抢，却只抢回一只，常四拿着曹建的一只包子，走到边上……
　　不一会儿，常四两手空空地走回来，忽然端起桌上滚烫的稀饭，全都泼到了曹建身上。曹建被烫得嗷嗷叫，骂道：“常四，你他妈疯了！看我晚上怎么收拾你！”
　　常四却在一旁叫道：“管教，我伤人了，快关我禁闭……”
　　眨眼工夫，站在不远处的姜涛就跑了过来，严肃地问：“怎么回事？你们闹腾个啥？”一旁的陆五连忙说：“没事，没事！常四不小心把稀饭洒了……”
　　常四大声说：“怎么没事？我就是故意泼他的，你关我禁闭吧！”
　　姜涛看了看曹建身上的稀饭，瞪了常四一眼，说：“你没发烧吧？好好的想坐禁闭？给我老实点，从明天开始，罚你打扫图书室一星期……”说罢，转身就走。
　　常四只得回到监室，跟陆五、曹建同处一室。他根本不敢躺下睡觉，只好蹲在床角，紧张地盯着陆五和曹建的动静。陆、曹两人却像没事一样，蒙上被子呼呼大睡。可越是这样，常四越是紧张。十点一过，监室就熄灯了，只有走廊上的灯光隐隐照进来。又过了片刻，曹建停止了打呼，他从床上坐起来，轻咳了一声，紧接着，陆五也从床上坐了起来。
　　曹建哼了一声，说：“姓常的，看在从前的情分上，你把今天用稀饭泼我的道理讲清楚，只要有道理，我姓曹的绝不为难你。”
　　陆五跟着说：“老常，你发的哪门子癫狂？大庭广众的，你让老曹下不来台，他以后怎么在江湖上混？”
　　常四两个眼睛瞪得圆圆的，盯着陆、曹两人的一举一动，好像根本没听见他们在说什么。曹建再也忍不住了，轻声吼道：“妈的，你吭声呀！你哑了？再不吭声，老子整死你！”
　　此时的常四，正陷入极度焦虑的精神状态，别的话没听见，“老子整死你”这五个字却听了个一字不漏，他大吼一声，把被子一掀，从床上跳下来，直扑门边，把铁门捶得“咣咣”直响，边捶边喊：“管教！快来，我交代，我有重大问题要揭发！”
　　陆、曹二人一见，顿时慌了手脚，曹建扑过去，一把卡住常四的脖子，常四喘不过气来，还是拼命挣扎，使出全身气力，狠狠地踢监室的门。
　　这时，值班警察闻讯赶来，扯开曹建，把他关进禁闭室，又把常四带出了监室。
　　
　　5. 无言结局
　　
　　值班室里，姜涛正等着常四。
　　常四一见是姜涛，身体又筛糠似的抖起来。常四知道，安排监室是姜涛的工作，陆五和曹建能跟自己住在一室，那姜涛多半是林建荣的人了。
　　姜涛示意常四坐下，说：“我有办法让你相信我。前不久我还是名户籍警，去过你家好几次，你母亲很牵挂你，担心你被人杀人灭口。我告诉她，要想保你的性命，只有依靠公安机关。我之所以现在才告诉你，是想让你看清林建荣的真面目，不要对他心存幻想。”
　　常四听了，心里一块石头落了地，说：“前几天我妈看我时，就提醒我当心林建荣杀人灭口，我还没当回事。那两个家伙一进来，我马上就明白他们是冲着我来的。我为姓林的扛了四年多，现在没有利用价值了，就想置我于死地呀！”接着，他把四年前受林建荣指使、杀害女记者姜薇薇的事全盘供述。
　　 
[ 1 ]
               
                [ 2 ] 3 [ 4 ]       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第1期   一定要抓到你  作者：刘祖光  字体：
   【 大  中  小 】 
 
　　 
　　常四刚讲完，那边监室里又叫起来，陆五拍着门，说有重要情况，要立刻上报。
　　姜涛请陆五坐下，陆五见是安排监室的姜涛，嗫嚅着不肯开口，姜涛拿出录音机，放了常四的一段话，说：“常四都信任我了，你还有什么好犹豫的？”
　　陆五这才点点头，说：“报告政府，曹建不止想杀常四，他的算盘是先和我联手害死常四，再顺手干掉我，造成我和常四斗殴而死的假象。”
　　姜涛笑笑，问：“你这样说，有证据吗？”
　　陆五拿出一张纸条，上面写着：“今晚动手，先灭常，再灭陆。”陆五解释说，他看到常四故意把稀饭泼在曹建身上，马上感到有蹊跷，就趁他们争吵之际，偷偷地把常四没换走的另一个馒头给换了过来，打开一看，里面藏着这张纸条。原来林建荣不光要灭常四，也要向自己动手呀！
　　接下来，陆五把林建荣如何指派他和曹建砍伤郭子非、混进监狱、准备灭掉常四的事全抖了出来。
　　安排好陆五，姜涛终于轻松地舒了一口气。原来，当冯保平故意把陆、曹两人的行踪透露出来时，姜涛就产生了怀疑，他和马青峰一致认为，这很有可能是林建荣的“一石二鸟”之计。于是，他们将计就计，姜涛先是通过常四母亲之口，让常四疑心林建荣要对他动手，接着又故意把三人安排在同一间监室。那位给罪犯发包子的炊事员是姜涛的好朋友，他在曹建的两个包子里都塞了张写有“今晚动手，先灭常，再灭陆”的纸条，在发包子时，故意让常四感觉包子有蹊跷，常四果然上当。其实，就算今天的计划不能成功，姜涛也早想好了其他的办法让他们内讧，因为，常四早已疑心重重，紧张得神经过敏了。
　　果然，事情的发展与预想完全一致，姜涛拨通了马青峰的手机，说：“证据到手了，你可以行动了！”
　　林建荣是在睡梦中被抓捕的，他看着自己手上的铐子，老半天都回不过神来，问马青峰：“你抓我？你怎么就能抓了我？”
　　马青峰笑呵呵地说：“不错，是我抓的你，抓捕你证据确凿，合理合法！要是还让你继续为非作歹，恣意妄为，那才是天理难容……”
　　林建荣还是直摇头，说：“就凭你，是不可能有证据抓住我的，一定还有别人，一定！”马青峰这才明白林建荣的话外音，说：“不错，发现你的犯罪事实、把你送上审判台的，是另外一个人的功劳！”
　　林建荣像头不服输的困兽，吼道：“谁有这么大本事？谁能在我的眼皮底下与我为敌？他是谁？”
　　马青峰淡淡地说：“他是一个从警校毕业不久的小警察，先做户籍警，后来又当了狱警，听说，这些都是你的主意，你替他安排好的。可笑的是，正是你的安排，把你自己送上了法庭……”
　　林建荣顿时委顿下来：“是姜涛？我还是小看他了！”
　　马青峰哈哈大笑：“你不仅小看了姜涛，还太高看了你自己。姜涛所坚持的东西，你永远也理解不了……”
　　三天后，林建荣在看守所离奇死亡，经过法医鉴定，最后确认为自杀。他的死讯传出后，全城大街小巷都放起了鞭炮……
　　与此同时，姜涛也被停职检查，因为有人举报他当了狱警后，非法收受犯人家属的钱财。没想到，关键时刻，马青峰却出面为姜涛解围，原来，犯人家属送的财物，姜涛都一一登记造册，由刑警队出具收条，暂时存放在刑警队，而姜家新买的那些家电，每一分账目都清清楚楚。为了迷惑林建荣，让他以为自己已经同流合污，放弃了追查，姜涛几乎花光了家里所有的积蓄……
　　这天，正是姜涛和马青峰“单挑”满一年的日子，赵明慧、姜涛和马青峰又在那个废弃的停车场见面了。赵明慧瞧瞧这个，看看那个，老半天不知说什么好，最后还是姜涛开了口，说：“这一年，我和马青峰打了一场赌，一场充满刺激的豪赌！”
　　赵明慧好奇地问：“谁取胜了？”
　　马青峰无奈地摇摇头，指指姜涛，说：“我承认，这小子鬼点子比我多，耐心也比我好……”
　　姜涛双手乱摆，说：“不，这场豪赌还没结束，我们之间没有胜利者。”
　　马青峰眼睛一亮：“你是说，冯保平？”
　　姜涛点点头，说：“林建荣死了，很多事死无对证，谁也不能把冯保平怎么样。我们只有继续赌下去，直到把他揪出来……”
　　马青峰一把握住姜涛的手，说：“好，我们继续赌下去！”
　　赵明慧也伸出手，跟他们的手握在一起，响亮地说：“一言为定！”
　　 (题图、插图：杨宏富)
　　 
[ 1 ]
               
                [ 2 ]
               
                [ 3 ] 4        
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第1期   一定要抓到你  作者：刘祖光  字体：
   【 大  中  小 】 
 
　　 
　　我们的主人公是个刚从警校毕业的年轻人，面对种种打压和诱惑，他从未动摇，因为他背负的是亲人的血海深仇；面对逐渐揭开的巨大黑幕，他从未畏惧，因为他心中有信念，眼中有光明……
　　
　　1. 势同水火
　　
　　事情得从四年前讲起。那年年底，洪武市出了件大案，一位名叫姜薇薇的女记者，在下班回家的路上被人杀害了。案子很快就侦破了，杀人凶手是当地的小混混常四，常四交代说，自己是为了劫财。案子到了这个时候，本来应该画上句号了，没想到，受害者家属死活不同意结案。他们一口咬定，这个案子另有幕后主使，并且直接指出，幕后主使就是建荣房地产集团的老板林建荣！
　　原来，建荣集团在双桥小区的建设中，为了降低成本，大搞非法拆迁，对不接受他们拆迁条件的动迁户采取了黑社会手段：轻则断电断水，装神弄鬼，重则大打出手，毁房拆屋。拆迁户四处上访，却无济于事。姜薇薇得知这一情况后，通过明查暗访，采写了一篇深度报道。没想到，这篇论据充分、有极强社会意义的稿件在最后一关被毙了。姜薇薇一气之下，将这篇深度报道放到互联网上。很快，一石激起千层浪，报道在网上引起了强烈反响，建荣集团在巨大的社会舆论压力下，被迫按国家法规提高拆迁补偿标准，拆迁户的利益得到了保证，而建荣集团却为此多支付了两千多万。这件事过后不久，姜薇薇便被杀害了……
　　姜薇薇的父亲痛失爱女，发誓一定要为女儿讨回公道。他连工作都不要了，四处上访，但由于他举报的情况查无实据，加上杀人凶手常四已经缉拿归案，证据确凿，他的举报和投诉材料被连连退回。在一连串的打击下，他整天借酒浇愁，姜家平静祥和的好日子从此一去不复返了。
　　那时，姜薇薇的弟弟姜涛正读高三，他成绩优异，向往着考入名牌大学学习建筑设计，将来做一名出色的建筑设计师。眼看不久就要高考了，姐姐却惨遭毒手，为了找到杀害姐姐的幕后凶手，给姐姐讨回公道，姜涛毅然放弃自己的爱好，报考了警校，并被顺利录取。姜涛一跨入警校的大门，便朝天高喊：“姐姐，我一定要将杀害你的幕后凶手找出来，我一定要抓住他，为你讨回公道！”
　　姜涛这一喊，惊动了一个人。谁？建荣集团的老板林建荣。这林建荣本是痞子出身，心狠手辣，又工于心计，黑白两道都走得顺风顺水，渐渐就发了大财，赚了个盆满钵满。本来双桥小区的拆迁他已用黑道手段基本摆平，没想到，姜薇薇发在互联网上的一篇文章，让他白白损失了两千多万，如果以后记者都像姜薇薇这样给他捣蛋，生意就不好做了。他一狠心，指使常四杀害了姜薇薇。常四进监狱后，他又四处打点，制造机会让常四“立功”，使他由“死刑”改判成“死缓”，同时，又给常四家里一大笔钱，封住了常四的嘴。现在，林建荣听说姜薇薇的弟弟考上了警校，发誓要找出幕后凶手，先是心里一惊，接着就仰起脖子，哈哈大笑起来。
　　一个手下连忙凑上来，说：“老板，那小子留着是个祸害，要不，干脆来他个斩草除根？”
　　林建荣摆摆手，说：“那小子已经披了身老虎皮，算是吃公家饭的人了，不到万不得已，先不要动他。再说，就算他从警校混出来又怎么样？还不是让我死死捏在手掌心里，听我的摆布！”话虽这样说，林建荣毕竟是个谨慎的人，他吩咐手下，严密关注姜涛的一举一动。
　　时间一晃就过了四年，姜涛马上就要从警校毕业了。四年大学生活，姜涛把所有时间都花在了学习和训练上，成绩门门优秀，擒拿格斗也十分出色。毕业前，他在刑警队实习，刑警队长对姜涛印象很好，决定留下这个各方面都很优秀的小伙子，就把相关表格送到局里，只等着局里盖最后一个公章。姜涛意气风发，跃跃欲试，准备在刑警队大显身手。
　　这时候，林建荣行动了，他直接找到市公安局副局长冯保平，说：“老冯，你还记得四年前死去的那个女记者吗？她弟弟马上要从警校毕业了，你安排一下，让他去做个户籍警吧！”
　　冯保平早就被林建荣拉上了贼船，对林建荣言听计从，现在他听林建荣这么说，不解地问：“干脆不让他干警察，不就得了吗？”
　　林建荣摇摇头，说：“那小子四年来下了苦功，学到不少本事，如果不让他进公安队伍，没准他会跟我玩阴的。他在暗处，我在明处，说不定哪天他就会从一个犄角旮旯里蹦出来，猛地给我一刀，还是放在看得到的地方安全。再说，他进了公安队伍，法律这根弦就会一直绷在他头上，让他不敢轻举妄动，更不敢肆意妄为、知法犯法……”
　　冯保平恍然大悟，冲林建荣竖起大拇指：“行！真有你的！”
　　林建荣仍然沉着脸，说：“光做户籍警还不够，工作上也不能为难他，各项荣誉时不时地给他一两个，让他在这个岗位上过得滋润、满足，慢慢地消磨他的意志。再过个一两年，等他谈了恋爱，娶了媳妇，生了孩子，就会安安生生地过日子，再也不会找我们的麻烦了……”
　　
　　 
　　2. 互不相让
　　
　　因为林建荣的插手，姜涛果然被分配到了户籍警的岗位上，他心里纵有一百个不情愿，也只能忍气吞声，到新华派出所报到。
　　新华派出所位于繁华闹市，管辖人口很多，这阵子又正赶上国家第二代身份证换证，户籍室整天门庭若市。姜涛忙得根本没闲工夫想别的，精力全投入到工作中。同事们看在眼里，都觉得这个新来的小伙子踏实肯干，为人诚恳，对他颇有好感。
　　转眼大半年过去了，年终总结这天，姜涛被评为“年度先进个人”，副局长冯保平出席了新华派出所的总结会，亲自给姜涛颁了奖。晚餐时，冯保平又特意安排姜涛坐在自己身边，鼓励他立足基层，从小事做起，多为群众办实事。姜涛得到冯副局长的表扬，心里非常激动，觉得自己的工作很有意义，这大半年的付出，值！
　　从此，姜涛的工作更主动了，他把辖区的户籍资料，分门别类，细心地整理了一遍，还逐门逐户上门拜访，搜集第一手资料。有些不太清楚的小问题，他就向熟悉情况的同事请教，同事们在他面前都不保守，把知道的情况毫无保留地告诉姜涛。
　　工作顺了，连桃花运也接着来了。坐在姜涛旁边的是一位美女同事，叫赵明慧，跟姜涛处得很好，大半年下来，姜涛不知不觉对她产生了感情。赵明慧呢，虽然心里觉得姜涛这小伙很不错，但她前不久刚认识了一位男孩子，是市局刑警队的，叫马青峰。据说，马青峰的父亲跟冯保平是生死之交，他能像家里人一样在冯保平家进进出出，冯保平在工作和生活上对他都比较照顾，前途光明。赵明慧对马青峰的印象也不错，姑娘的心在两个小伙子之间晃来晃去的，定不下来。姜涛心里着急，表面上却装得若无其事，充分利用天时地利，抓住一切机会向赵明慧表示关心，试图一点点拉近两人的距离，好来一个“近水楼台先得月”。
　　赵明慧感情上的微妙变化，没逃过马青峰的眼睛，不愧是刑警，他稍稍一调查，马上发现了姜涛的存在，心里的火腾腾地直往上蹿，马上拿起手机，拨通了姜涛的电话：“喂？你就是前些时在我们队实习的那个姜涛？哥们，做人要仗义，我和明慧认识在先，你在我们中间横插一杠子，算什么意思？”
　　姜涛接电话时正好在外面，一听情敌找上门来了，顿时来了精神，他哈哈大笑，问：“‘我们’？你现在和赵明慧能称得上‘我们’吗？有什么法律依据吗？”
　　马青峰压住火，说：“干啥都得讲个先来后到，这是规矩！”
　　姜涛毫不示弱：“对不起，要是别的事，我一定讲个先来后到，但在这件事上，我得加塞儿！加定了！”
　　马青峰气坏了，吼道：“兔子还不吃窝边草呢，你连兔子都不如吗？”
　　姜涛镇定地说：“看来我真把你看高了，你听清楚：我不是兔子，赵明慧也不是草，她是人，是值得我拿性命去换的人，懂吗？”
　　一场对话就这样崩了，事情却没有完。马青峰说不过姜涛，又失了天时地利，心想，再这样下去，只怕要一败涂地了。他再也沉不住气：既然都是爷们，道理上摆不明白，那就拳脚上分高低吧！
　　 
 1 [ 2 ]
               
                [ 3 ]
               
                [ 4 ]       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第1期   ３分钟典藏故事  作者：佚名  字体：
   【 大  中  小 】 
 
　　 
　　好儿子
　　一所监狱的牢房中关了数名重刑犯。有一天，大伙儿翻着杂志闲聊，其中一名犯人指着杂志上的珠宝图片，感叹地说：“我母亲如果能戴上这些首饰，一定会很高兴。”
　　一个犯人指着房屋图片说：“如果我母亲有这么一间漂亮的房子多好。”另一个犯人则说：“要是我母亲有一辆车子，就可以常来看我了。”
　　最后，杂志又传到一个犯人手中，他拿着杂志良久未言，然后流下眼泪，说：“如果我母亲有个好儿子，那就好了。”
　　不让父母操心，才是最大的孝顺。
　　（作者：佚名；推荐者：类兴涛）
　　
　　再多一个“请”字
　　乔伊遭遇裁员，失去了工作。他向一家公司寄去了求职信，信中只简单地写了一句话：“请给我一份工作。”
　　老板收到信后，让手下人回信：“公司目前没有空缺。”但乔伊不死心，又给老板写了第二封求职信，只在第一封信的基础上多加了一个“请”字：“请请给我一份工作。”此后，乔伊一天给公司写两封求职信，每封信都比前一封多加一个“请”字。
　　三年间，乔伊总共写了2500封信。见到第2500封求职信时，老板再也沉不住气了，他亲自打电话告诉乔伊，公司可以给他一份处理邮件的工作，因为他“最有写信的耐心”。
　　有记者听说了这事，就问乔伊，为什么每封信都只比上一封信多增加一个“请”字。乔伊平静地回答：“因为信是用打字机打的，我每次多加一个字，是想让他们知道，这些信没有一封是复制的。”
　　只要心里的灯火不曾熄灭，即便道路再曲折，前途也是一片光明！
　　（作者：王均；推荐者：雁归来）
　　
　　冷静的代价
　　一支科考队进入中非考察。当地有一种毒蛇，一旦被它咬伤，若20分钟内得不到救治，必死无疑。因此，在科考队营帐里有一台冷柜，里面备有抗蛇毒血清。
　　科考队长是一名博士，他要求队员一旦被蛇咬，应该冷静地回到营帐处理伤口，千万不可激动，否则会使蛇毒更快地流向心脏。
　　几天后，一个队员在距营地400米的地方被蛇咬伤。他惊恐地大声呼救，闻讯赶来的博士处理完伤口，把小伙子狠批了一顿。后来，博士制作了一些卡片，上面写着大大的“冷静”，发给队员们挂在脖子上。
　　几天后，队员们正在准备晚餐，突然听到一声呻吟。大家跑出去一看，只见博士躺在营帐门口，他身边有一根木棍、一条奄奄一息的毒蛇。
　　博士告诉大家：数分钟前，他被毒蛇咬了脚踝。他用木棍将蛇打死，正准备返回，发现蛇很肥壮，就想带回来做一道蛇羹。可没想到，用木棍挑在肩头的蛇并未完全死去……
　　因为第二次蛇咬中的地方接近心脏，博士最终不治身亡。队员们都说，博士如果在第一次被咬后就呼救或快速返回，他就不会被蛇第二次袭击。其实，他死于过度冷静。
　　（作者：赵功强；推荐者：马树强）
　　
　　击倒世界冠军的苍蝇
　　一场世界台球冠军争夺赛正在举行，名将路易斯一路领先，突然，他看见一只苍蝇停在主球上，便挥手将苍蝇赶走。可当他俯身击球时，那只苍蝇又飞回到主球上，他只好再一次起身撵走苍蝇。
　　就在路易斯第三次击球时，苍蝇又停到了主球上，观众不由哄堂大笑。路易斯的情绪糟到了极点，顿时失去理智，愤怒地用球杆去击打苍蝇。
　　球杆碰到了主球，裁判判路易斯击球，他因此失去了一轮机会，这使他方寸大乱，连连失利，而他的对手则愈战愈勇，最终夺走了冠军。
　　第二天早上，人们在河里发现了路易斯的尸体，他投河自尽了！
　　这是一场不该发生的悲剧。本来，路易斯完全可以别管苍蝇，当主球飞速滚动起来时，那苍蝇肯定不赶自走了。这桩悲剧令人深思：千万别在冲动情绪下做出决定！
　　（作者：林大有；推荐者：雅琴阁）
　　 （本栏插图：安玉民梁丽）
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第1期   地上冒出的灾难  作者：范大宇　改编  字体：
   【 大  中  小 】 
 
　　 
　　和平街道的张阿姨三十多岁就守寡，在她七十三岁时，有个王老爹看上了她，死活非要和她结成百年之好。鬼怕缠，人怕磨。张阿姨思前想后，笑了，唉，俗话说得好：“满堂儿女，不如半路夫妻。”为了老年能有个依靠，能有个宁静的家，张阿姨就点头答应了。
　　老年人办婚事比年轻人要简单，这天，王老爹陪张阿姨去一家大商场买婚礼时穿的衣服。在三楼，张阿姨相中了一件红呢子的外套。张阿姨打年轻时就梦想着有一天能穿上呢子衣服，但是经济条件不允许呀，没想到老了老了，才有希望。可是一看价码，天，要二千多元，她心里就直打鼓。售货小姐看出了张阿姨的犹豫，立即走上前，一口一个“奶奶”，小嘴甜极了：“奶奶，您老要是穿着这件衣服和爷爷补照一张结婚照片，那可是盖了！”说得张阿姨的心里别提多舒坦了。张阿姨就想穿上试一试，可就在她转身时，出事了……
　　也许是过节的原因，这天商场人很多，人一多，空气就不太好，有个八九岁的小男孩在张阿姨身后突然呕吐起来，这时候，张阿姨正好转身，她只感到脚下一滑，一个趔趄，“砰”的一声，重重地摔在了地上。张阿姨“哎哟”了一声，就感到左大腿痛得厉害。她想站起来，但是站不起。那售货小姐挺有经验，一把揪住了那个小男孩，怎么呢，她眼尖，她看到张阿姨之所以滑倒了，是因为踩到了那个小男孩的呕吐物。
　　张阿姨被送到了医院，一拍片子，得，左大腿粉碎性骨折，治病要多少钱？医生说，至少10万！
　　王老爹倒是一个好人，他并没有因为张阿姨出了事儿而脚底抹油，但是他和张阿姨要负担高昂的医药费，显然很困难。好在王老爹是见过世面的，而且他的儿子就是律师，他让老父亲走法律程序。经分析，他们决定起诉商场和那个小男孩儿。因为这事儿发生在商场，商场负有保护顾客人身安全的责任：而那个小男孩儿的呕吐物导致了张阿姨的骨折，是事故的直接原因。
　　因为那小男孩只有八岁，不负法律责任，要起诉只能起诉他的监护人，也就是他的父母。一查一问，王老爹的心凉了。怎么呢？那小男孩家在农村，因为患了白血病才到城里来治病的。这样的家庭，能掏出多少钱呢？死马当活马治吧！总要讨个说法嘛。
　　王老爹跑前跑后，写好了起诉书，要求小男孩和商场各赔付6万块钱。法院择日开庭，因为案情简单，很快就宣判了：小男孩儿的监护人负有管教不严的责任，应对这起事件负有百分之八十的责任，责成赔付张阿姨3万元，而商场却不负责任。
　　这个结果张阿姨不能接受，王老爹也不服，问为什么商场没有责任，并举出实例，说有个顾客在饭店吃饭，坐的椅子断了，摔成了骨折，法院就判那家饭店赔钱。法官解释说：那饭店赔钱是对的，因为他们对自己的椅子没有认真检查，导致了顾客摔伤；而张阿姨所在的商场，不可能预见到小男孩突然呕吐，而且事故发生在瞬间，根本来不及采取补救措施。
　　最令张阿姨头痛的是：虽然法院判了那小男孩的监护人赔钱，可是他们给孩子治病已经欠了一屁股的债，现在一分钱也拿不出了，所以，张阿姨虽然胜诉，也仅仅是墙上画饼空欢喜罢了。
　　要说王老爹真是个好人，就这样子，还对张阿姨一往情深，天天为她煲汤，给她增加营养，并上诉到了中级人民法院，要求改判商场负有责任，赔付给张阿姨治疗费。二审很快也下来了：维持原判！这下子，张阿姨不仅没拿到一分钱，还白白付出了起诉的手续费。
　　那王老爹也是个倔强脾气，他想不通，见谁和谁说这事儿。那天晚上，当律师的儿子就对王老爹说：“爸，你们可以再上诉，但是这次不要再让商场负什么责任了。在这起事件中，他们是没有责任的。”
　　王老爹没听儿子说完就火了：“你怎么尽帮着人家说话，你还是我的儿子吗？”儿子不急不慢地给父亲出主意，说：“这事不能先让商场承担责任，一定要强调，商场给你们经济补偿和他们负有责任之间没有因果关系。”王老爹糊涂了：“怎么，商场不负责任，也能赔钱？”儿子点点头，说：“这在法律上叫做无过失赔付。”
　　王老爹听从了儿子的建议，再次上诉时，明确了商场不负责任，只说商场是事件发生地，出于人道主义，要求给予伤者经济补偿。当然，这次王老爹将经济补偿的标准提高了。法院的判决是：商场在突发事件中不可能预见，所以不负责，但是张阿姨是在商场购物，对商场的繁荣是有利的，因此判决商场一次性给予张阿姨经济补偿3万元。
　　商场虽然觉得有点亏，可是他们在法律上没有负责，这让他们感到法律的公正；再说，他们给张阿姨一定的补偿，也提高了自己的知名度，美化了商场的形象；更重要的是，这有助于解决矛盾，弘扬社会主义精神文明，所以，商场最终接受了这个判决。
　　当张阿姨接到商场送来的支票时，她哭了，她对王老爹说：“多亏了你呀！”
　　王老爹笑着说：“是我那儿子的‘功劳’！”
　　
　　律师点评：
　　关于“地上冒出的灾难”这个故事，事实上法院适用的是“公平责任原则”。根据《民法通则》第132条规定，“当事人对造成损害都没有过错的，可以根据实际情况，由当事人分担民事责任”。公平责任原则是以公平的观念对适用过错责任原则和无过错责任原则不能归责的情况下，以衡平的方法分摊损失的一切法律原则。它体现的是“济贫扶弱”而非“劫富济贫”。因此，它的适用是有条件的，不能扩张地无限制适用。
　　 （题图：安玉民 梁 丽)
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第1期   别惹美女  作者：马莉莉  字体：
   【 大  中  小 】 
 
　　 
　　惯偷郝大顺最近收了个徒弟，外号“机灵豆”。这天，郝大顺带着“机灵豆”来到步行街上“实践课”。经过一番观察，郝大顺指着一个中年妇女，说：“看，她就是我今天的目标对象！”
　　“机灵豆”朝那妇女看去，只见她肩上背了只坤包，胳膊紧紧地夹住包。“师傅，偷她的包，难度很大啊！”郝大顺却打了个响指，说了句“仔细看”，便朝中年妇女走去！
　　嗨！撞人、割包、夹钱包，一气呵成，郝大顺得手了！“机灵豆”看得目瞪口呆。郝大顺没事人似的走回来，笑道：“看明白了吗？你也试试！”
　　这时，不远处走过来一个高挑、性感的女人，一下子吸引住了“机灵豆”的目光。这美女刚打完电话，把手机随意塞进了外套口袋里，手机挂件还露在口袋外面，随着美女的脚步，一上一下地摆动。“机灵豆”暗想，自己技术不高，就拣容易的上手吧！想罢，就朝着那美女追去了。
　　郝大顺一看，赶紧在后面“哎”了一声，可是“机灵豆”眼里只有手机和美女，没注意到郝大顺的喊声。
　　“机灵豆”紧紧贴在美女身后走着，瞅准了机会，把手伸进她的口袋。美女毫无察觉，眼看就要得手，突然，有人高喊一声：“抓小偷！”好家伙，不知从哪跑出来五六个男人，把“机灵豆”一顿暴打，然后送进了派出所。
　　几天后，“机灵豆”出来了，看到郝大顺，他委屈地说：“师傅，我太倒霉了，那手机看起来多好偷呀，谁想到……唉！是我出手太慢了吗？”
　　“傻徒弟，是你的目标定错了！”
　　“什么意思？”
　　“你想呀，这美女走在街上，难道只有你一个人盯着吗？满大街的男人都盯着呢！出手再快，也逃不过那么多双眼睛啊！为师告诫你：偷谁也别偷美女！”
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第1期   傻哥开店  作者：焦松林  字体：
   【 大  中  小 】 
 
　　 
　　老李家的二儿子李达反应慢，被村里人称作“傻子”。李达的大哥先卖热水器，接着又兼营防盗门窗，开店没两年，就成了全村首富。李达却在大哥店里打零工，一天到晚，浑身脏兮兮。
　　老李看在眼里急在心里：像二儿子这个憨厚劲，以后可怎么办呀！就在这时，李达向老人提了个想法：“爸爸，我也想开一爿店。”
　　老李听了，吃了一惊，说道：“开店？咱家没几个钱，全部拿出来给你，也进不了多少材料。”
　　李达连连摇头，说：“我不用钱，我就想借咱家的房子用用，也不用重新装修，就放一个工具箱，外加两把梯子，您就答应吧。”
　　听儿子把话说到这个份上，老李也不能再阻拦了。他心里可是一点儿底也没有：一个工具箱、两把梯子，能开出什么店来呢？
　　前后不过一天，李达的店铺在一片鞭炮声中开业了。左邻右舍纷纷赶来看热闹，只见屋里除了两把折叠梯、一个工具箱，果然什么都没有。
　　乡亲们看着没意思，正要离开，猛不防屋上垂下一个长长的彩条广告：“专修热水器、防盗门窗，兼售后服务”。后面，是李达的手机号码。原来李达动的是这个心思！
　　还真别说，李达的店面一开，找上门来的顾客还真不少，有热水器漏水的，有防盗门锁坏了的，就这样，李达的生意就红火起来了。老大见弟弟出息了，就问弟弟，怎么想出这主意来的。
　　李达转了转眼珠，慢腾腾地答道：“都是你惹出来的呗。你今天见这个赚钱就弄这个，明天看那个赚钱就弄那个，只管卖，不管修，买东西的人吃够了亏，我、我这是看不过眼去，想替你擦屁股呢。”
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第1期   救你没商量  作者：结庐人  字体：
   【 大  中  小 】 
 
　　 
　　有个老板，又做成了一笔黑心生意，喝高了，踉跄着去卫生间。
　　他走到门边，可是摸来摸去找不着门把手，他就硬推，推不动；拉，也拉不动，再往左一使劲，这回门开了。老板心想：原来卫生间用的是移门。
　　老板想往里走，却发现门槛特别高，一琢磨：这样下水道堵了，水就漫不出来了，周到！想着，他把身子趴在门槛上，先迈左腿，再迈右腿，然后往下一蹦，同时伸手去摸拉链，只待双脚一着地，就可以痛快地方便了。
　　可是左等也不着地，右等也不着地，耳边还呼呼地响。这是咋回事？老板睁开眼一看，咦？这楼呀、窗户呀，怎么全都呼呼地往上跑呢？噢，刚才那哪是卫生间的门啊，那是窗户！自己这是从窗口掉楼外去了！
　　掉了好一会还没着地，看来这楼层不是一般的高。老板正害怕呢，突然腰上被什么东西挡了一下，然后脚底下一实，他着陆了！老板摸了摸头，头在，扩了扩胸，也不疼，站起来走两步，运转正常。看来是平安着陆了！他抬头一看，时值深夜，这幢楼一片黢黑，只有二十几层的一个窗户有灯光，窗户还开着。看来那就是自己刚出来的地方了。
　　老板出来本是找卫生间的，既然安全着陆了，那还得接着找哇！他四处一寻摸，发现两步远的地方有什么东西在冒着火花。到跟前一看，是一根长长的黑黑的线，老板脑子里灵光一闪：导火索！看来恐怖分子要搞恐怖袭击！怎么办？他当下义无返顾地拉开裤子，一泡尿向那团火花浇去。
　　挫败了恐怖分子的袭击，老板心里一松，酒劲儿上来，躺在路边呼呼睡去。
　　第二天他一睁眼，就看到密密麻麻的镜头和麦克风。见他睁开眼，记者们立即问：“先生，请问，你从二十八层楼上跳下来毫发无损，又在十万伏高压线上撒尿，也没事，你是怎么做到的？”
　　老板一听，原来那冒火花的不是导火索啊，他不好意思讲自己的丑事，一句“我是超人”，挡开众人，闪了。
　　其实，老板自己也纳闷：从那么高的楼上跳下来，又在高压线上撒尿，怎么会没事呢？他决定再现一下当时的情形，不过这回他跳楼的时候背了个降落伞，以便到时跳伞逃生。
　　耳边还是呼呼风响，快着地的时候，还是没有奇迹发生。这时老板突然想到一个严重问题，那就是：现在打开降落伞已经太晚了，自己要被摔死了！
　　正当这时，老板突然感到耳朵剧烈疼痛，仰脸一看，一个金甲神人正大头朝下，两手各揪着他的一个耳朵帮他减速。老板这才明白自己上回毫发无损的原因：原来是有神护卫。
　　着陆后，那金甲神人皱着眉头盯着老板，没好气地说：“你怎么老玩这种无聊游戏，你烦不烦？”
　　世界上那么多人跳楼都摔死了，这说明金甲神人并不是什么人都救的。老板想探探他为什么要救自己，就说：“爷就好这一口，怎么啦？谁让你多管闲事，什么地方不好揪，偏揪我的耳朵！我这耳朵只有我媳妇才有权揪！”
　　金甲神人摇摇头，没好气地说：“要不是奉命保护你，鬼才管你呢!”
　　老板一听，不由心花怒放：有金甲神人奉命来专门保护老子，那不是说老子前途无量福大命大？哈哈……
　　自从知道这个秘密后，老板是什么危险玩什么，油库玩过火，越南踩过雷，当着老婆面，赞过人家美。由于有神护着，全都没事儿。
　　有一天，老板从一辆卡车旁走过，卡车爆胎了。车上装了满满一车石子，重心一偏，侧翻了，正好把老板压在底下，外面只露出个脑袋。
　　老板一息尚存，睁眼一看，果然金甲神人就站在自己旁边，立刻说：“看什么看，还不把爷拉出来？就你这服务态度，小心我到玉帝面前告你。”
　　不料金甲神人这回却没有动手，反而如释重负地说：“告去吧，反正我的任务完成了，歇着吧您哪！”说完，拍拍屁股就要走。
　　老板赶紧换了一种口吻，喊住了他：“大仙请留步。小人死不足惜，但有一事不明，还请大仙解答。”
　　金甲神人头也不回，说：“我知道你想问我，这次为什么不救你。告诉你吧，因为你长期贩卖伪劣轮胎，害人无数，上天要你受到应有的报应，死于爆胎。我的任务就是：确保你死于爆胎，而不是别的原因，所以我前面屡次救你，而这次不救。”
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第1期   转嫁死亡  作者：狗尾草  字体：
   【 大  中  小 】 
 
　　 
　　最近这阵子，哈瑞每天都到结核病医院去，专门和肺结核病人在一起，医院的工作人员赶他走，他就说是来做义工的，医院的人没办法，只好由着他。每个星期哈瑞都要做一次检查，看自己是否患上了结核病。
　　不久，在一次“例行”检查后，医生告诉哈瑞，他患上了肺结核，哈瑞高兴得几乎跳了起来。医生说：“你住院吧，这不是大病，很快就会好的。”
　　听说自己的病能治，哈瑞很失望。之后他拼命折腾，过了几个月，哈瑞已经形容枯槁，他踉踉跄跄来到医院。检查后，医生摇摇头说：“上帝也救不了你了。我真不明白，你为什么拒绝治疗，难道你故意想死？”
　　哈瑞可不想死，他之所以这样做，是为了让他的妻子死掉。
　　几个月前，哈瑞学会了一种能转嫁死亡的巫术。那天，哈瑞在一个广场上散步，那里有很多鸽子，一个老者正在喂鸽子。一只鸽子在地上挣扎着，却怎么也飞不起来，显然受了伤。老者看了看地上的这只鸽子，然后抬头向空中看去，像是在寻找着什么，突然，老者用手向空中一指，口中说道：“下来。”就见一只鸽子从空中掉了下来，挣扎几下就不动了，而先前受伤的那只鸽子竟急飞而去。
　　哈瑞很惊奇，他走过去问老者怎么回事，老者说：“先前掉到地上的鸽子翅膀折断了，而这只—”老者用手指着地上的鸽子，“这只鸽子已经很老了，活不了多久了，我就把那只鸽子身上的伤转到它身上来了。”
　　哈瑞听呆了：“你是说你把那只鸽子的伤转到这只鸽子的身上来了？太不可思议了！在人身上也能转吗？”
　　“当然可以。”
　　哈瑞很感兴趣：“太神奇了，你可以教给我这种神奇的方法吗？”
　　“当然可以。”老者爽快地答应了，教了哈瑞转嫁伤病的方法。
　　 
　　哈瑞回到家后，拿出小刀，在胳膊上划了一个口子，然后念了咒语，把伤转给了妻子，咒语念完不久，只见自己胳膊上的伤口马上愈合了。晚上，妻子回到家，胳膊上缠着纱布。哈瑞问妻子怎么弄的，妻子说，突然就有一道划痕，她自己也不知道是怎么回事。哈瑞很高兴，不过，他没有声张。他要用这种转嫁术害死妻子，妻子很有钱，她死了，财产自然就是哈瑞的了。
　　之后，哈瑞又试了两次转嫁术，两次都很灵验，哈瑞觉得万无一失了，就天天去结核病医院，让自己染上了肺结核，直至无药可救。
　　一切都很顺利，现在哈瑞只要把病转嫁给妻子，就大功告成了。他念了咒语，可这次却不灵了！哈瑞吓坏了，他急忙赶到广场，老者还在广场上喂鸽子呢。哈瑞赶紧把自己的情况对老者说了，老者皱了皱眉，问：“你以前在自己身上转过吗?”
　　“转过。”
　　“转过几次？”
　　“一共转过三次。” 哈瑞答道。
　　“哦，我忘记告诉你了，这种转嫁术在一个人身上只能转三次，多了就不灵了。”
　　“天哪！你怎么不早说！”哈瑞觉得天旋地转，一下子瘫倒在地。
　　 （本栏题图、插图：顾子易 王 俭）
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第1期   各行各业说爱情  作者：佚名  字体：
   【 大  中  小 】 
 
　　◆  厨师说：爱情是一颗洋葱头，你一片片剥下去，总有让你流泪的时候。
　　◆ 医生说：爱情是感冒，被爱情病毒感染的人，既瞒不住自己，也瞒不了别人。
　　◆ 考古学家说：爱情如瓷器，碎了难以复原。爱情如文物，既古老又新鲜。
　　◆ 气象学家说：爱情不怕热，即使烈日炎炎，恋人们还要往一块儿贴；爱情不怕冷，冰天雪地里恋人照样“轧马路”。
　　◆ 民俗学家说：情人即仇人，要不，为什么称情人为“该死的”、“冤家”呢？
　　◆ 小说家说：爱情是不能复制的，每一个爱情故事都会有截然不同的情节。
　　◆ 语言学家说：我劝朋友们写情书时，写“爱”字宁可多费点事，多写几笔也要写繁体字，因为繁体的“爱”字里有个“心”。简化字不知为什么把“心”给简化掉了，不过幸亏还有一个“友”字。
　　（作者：肖 敏；推荐者：燕 子）
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第1期   ２００９年上故事中国网看什么？  作者：佚名  字体：
   【 大  中  小 】 
 
　　不知不觉，日历又翻到新的一年，在2009年，故事中国网(www.storychina.cn)将一如既往地陪伴您度过快乐的故事时光。
　　我们会邀请《故事会》编辑讲述更多《故事会》背后的故事、作者的花絮和故事创作的理论，无论是作者还是读者，都能从中获得收益。全体编辑都在论坛开设了在线专区，您可以通过这种最为便捷和直接的方式来向《故事会》投稿。
　　由故事中国网(www.storychina.cn)主办的“2008年‘我最喜欢的《故事会》作品’网络评选”活动进入总评阶段，2008年24篇入围作品将进行最后的大较量，从中评出红、绿版最受网友欢迎故事各一篇，欢迎您来为喜爱的故事投上一票！
　　在2008年广受好评的“故事点评”和“咬文嚼字”活动将延续，前者欢迎大家对每期《故事会》的作品进行点评，凡入选在网站发布的故事评论将获得50到100元的稿费；后者邀你在《故事会》中发现的任何语言文字上的错误，通过网站“举报”，就有机会获得《故事会》系列图书。
　　2009年，我们还为您准备了特别的新年活动，到底是什么？来故事中国网看看就知道了！
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第2期   笑话１２则  作者：赵娜娜等  字体：
   【 大  中  小 】 
 
　　二妮新买了一条漂亮的格子裙。这天，她和老公、儿子一家三口去逛街，穿着新裙子就出门了。
　　走着走着，二妮似乎听到父子俩在自己背后嘀嘀咕咕地说着什么，回头一看，儿子正用手指比划着说得起劲。二妮笑着问道：“说什么呢？”
　　 
　　“没什么，我们在下棋。”
　　“下棋？”二妮好奇道。
　　“是的，”儿子笑着说，“妈妈，你这条格子裙太好玩了，我和爸爸正在上面下五子棋呢。”
　　 （赵娜娜）
　　
　　都不理我
　　这天，小熊猫从学校回家，一脸郁闷地对妈妈说：“妈妈，班上的女生都不理我了。”
　　妈妈不解地问：“为什么呢，她们不是老夸你的‘墨镜’酷吗？”
　　小熊猫叹了一口气，说：“今年流行红色隐形眼镜，她们全都追小白兔去了。”（王丽群）
　　
　　后悔抽烟
　　爸爸和五岁的儿子在客厅看电视。忽然，儿子不看电视了，一动不动地盯着爸爸看了老半天，然后，“咚、咚、咚”跑到妈妈身边，悄悄对她说：“妈妈、妈妈，我发现爸爸好像很后悔抽烟呢！”
　　妈妈不以为然地说：“他向来嗜烟如命，怎么会后悔抽烟呢？”
　　“是真的，”儿子肯定地说，“我亲眼看见他吸一口烟后，又赶紧后悔地把它吐出来！”
　　 （李传胜）
　　
　　合身的衣服
　　一个月前妻子过生日时，大卫给她买了一件价格不菲的衣服。这天晚饭后，大卫想起这事来，就问妻子：“亲爱的，我上次给你买的那件衣服还合身吗？”
　　妻子正在忙着收拾餐桌，就头也不抬地说：“太合身了！咱们家四个孩子也都说穿着正合身。”
　　 
　　大卫有点得意：“我的眼光不错吧，我早跟你说过这是件好衣服嘛！”
　　“那倒不见得，”妻子苦笑道，“这衣服每洗一次就缩一截，咱们只有四个孩子，现在我都不敢再洗了。”
　　 （米米）
　　
　　写 真 画
　　有个画家靠卖画为生，但生意却
　　 总是不太好。妻子给他出了个主意，现在不是追求“眼球经济”吗？如果把他们夫妻俩的“写真画”，挂在门外做个广告，效果肯定不错。画家一听很有道理，马上照着办了。
　　这天，丈母娘过来看女儿，看到“写真画”果然大感兴趣，指着画上的女人就问画家：“这个姑娘是谁呀？”
　　画家说：“妈，她是您女儿啊。”
　　“真是我女儿吗？”丈母娘看了看，皱起眉头说，“那她为什么要和陌生男人手牵手坐在一起？”
　　 （史顺利）
　　
　　愚蠢的小偷
　　汤姆和杰米是两个小偷。这天半夜，他们潜入一家工厂的仓库，发现里面有许多保险箱。
　　汤姆狂喜不已，搓着手对杰米说：“兄弟啊，你踩的点太好啦，我们就要发大财了！”说完，就拿起工具开始撬保险箱。可奇怪的是，他们撬了半天，发现所有的保险箱竟然都是空的。
　　汤姆马上紧张地问杰米：“兄弟，这到底是个什么工厂啊？”
　　杰米恍然大悟道：“我想起来了，这是一家生产保险箱的工厂。”
　　 （谢小英）
　　
　　 
　　目光长远
　　大宝是个不折不扣的“体彩迷”，每隔几天就会忍不住买上一两张彩票。不过，他买彩票和别人还不一样，别人是盯住一个地方买，而他呢，四处打游击，骑着个自行车到处兜。
　　老婆很不理解，就问他：“你买个彩票满世界跑干吗？我们小区不就有个投注站吗？”
　　大宝神秘一笑，悄悄地说：“嘿嘿，这你就不懂了！我这叫防患于未然。你想，如果老是在一家投注站买彩票，万一中了个大奖，那我的身份不就暴露了吗？”
　　 （于少双）
　　
　　原地不动
　　这天，乔治上课迟到了二十分钟，他向老师解释说：“早上，妈妈在家里弄丢了一美元，我帮她找钱，所以迟到了。”
　　老师摸摸乔治的头，说：“是这样啊，我知道了，那你回到座位上听课吧！”
　　课间休息时，老师特意来到乔治身边，关切地问道：“那一美元有没有找到啊？”
　　乔治不假思索地说：“老师，我只花了一分钟就找到了。”老师诧异道：“那你怎么来晚了？”
　　乔治挠挠头皮，不好意思地说：“是这样的，我把那一美元踩在脚下原地不动，等妈妈上班了我才把它拿出来。”（李传胜）
　　
　　多 写 点
　　丹丹陪妈妈去湖边钓鱼。回家后，丹丹很快就把日记写好了：今天我和妈妈去湖边钓鱼，我们钓到了一条两斤重的大鱼，我们可高兴了。
　　妈妈看女儿写得这么简单，生气地说：“多写点！”
　　丹丹低头想了想，把日记又改了一遍：今天我和妈妈去湖边钓鱼，我们钓到了一条五斤重的大鱼……
　　 （赵娜娜）
　　
　　 
　　人 缘 差
　　这天上社会学课，有七八个同学
　　 逃课没来。教社会学的王老师照例点名，点到的同学一个个地应声回答“到”。
　　当叫到“秦明”的名字时，教室里静悄悄的，没有一个人回答。王老师又连叫了三声“秦明”，依然没人回答。
　　王老师稍稍抬了一下头，从老花镜后仔细看了看全班同学，然后很纳闷地说：“这个同学是不是人缘很差？怎么连一个朋友都没有！”
　　 （小凡）
　　
　　酒桶
　　约翰买了一大桶酒放在户外。一
　　 天下来，酒少掉了不少，约翰很气愤，便在桶上贴了几个字：“不许偷酒”。
　　第二天，酒又少了一些，约翰更生气了，他又在桶上加了几个字：“偷酒者杀无赦”。
　　到了第三天，酒桶里只剩下小半桶酒了。有个邻居看见了，便跟约翰说：“笨蛋，你不会在桶上贴‘尿桶’两个字，看谁还敢偷喝！”
　　约翰觉得这主意不错，照办了。结果第四天，桶居然全满了。
　　 （史顺利）
　　
　　难度较大
　　小李不小心吞下了一个乒乓球，赶紧跑去医院救治。医生对他实施了局部麻醉，躺在病床上，小李能清醒地感知手术的全过程。
　　小李觉得医生在手术时，东一榔头西一棒槌的，有点杂乱无章，便小心翼翼地问道：“大夫，乒乓球拿出来了吗？”
　　“难度较大，”医生擦了擦额头上的汗，答道，“乒乓球在你的肚子里跳来跳去的。”
　　 （田春生）
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第2期   家有聚宝盆  作者：徐树建  字体：
   【 大  中  小 】 
 
　　浓浓的乡情，何尝不是一份珍贵的财富……
　　
　　最近，局里刮起了一阵斗蟋蟀的风气，身边的领导、同事一下班就聚在一起斗蟋蟀，局长大人更是乐此不疲，在他的号召下，已经举办了好几次斗蟋蟀大赛了。
　　不过，听说局长一直搞不到一只厉害的蟋蟀，已经找了很久了，我便寻思着去弄几只蟋蟀来送给局长，好好表现一番。
　　 
　　想着想着，我突然眼睛一亮，想起家里的“聚宝盆”来。
　　说起这只聚宝盆，可有些年头了。那年，我还在上大学，爸爸突然离开了我们，家里的顶梁柱一下子塌了，我正想休学回家，妈妈却打来电话说：“东子，你安心上课，妈有办法，能挣到不少钱哩！”
　　妈妈说的办法，其实就是上山去捉些蜈蚣、蝎子、蟋蟀之类的卖钱，老家的人都这样干。可捉毒物虫子是大男人才敢干的事情，我不忍心让妈妈干这个，妈妈却说：“东子，妈没事，妈能捉到好多蜈蚣和蝎子，因为咱家有个‘聚宝盆’！”
　　妈妈说，一天晚上，她把一个装了毒物的瓦盆放在门外，想让毒物在外面吸收露水，村里的人家都是这样做的。可是第二天早上，她打开瓦盆盖子，却发现里面满满当当的。刚开始，她还以为自己数错了，可一连好几天都是这样，妈这才确信这瓦盆是个宝贝。
　　我心想：只要问妈借来这只聚宝盆，就不愁弄不到一只厉害的蟋蟀。打定主意，我立即带着大包小包赶回老家。一进门，我把东西往地上一放，劈头盖脸地就问：“妈，咱家的那个聚宝盆呢？”
　　妈听了一愣，茫然地说：“什么聚宝盆啊？”
　　我说：“妈，您忘了，我才上大学那会儿，爸走了，我正准备休学，您说家里有个聚宝盆，什么蜈蚣、蝎子啊会莫名其妙地多起来，想起来了吧？现在那盆还在吗？”
　　妈恍然大悟地笑着说：“噢，想起来了，你看妈这记性！东子，盆当然在啊，它是咱家的宝贝，妈能丢了吗？你问这个干什么？”
　　我跟妈当然用不着隐瞒，说：“我想把它送给我们局长，年轻人得要求上进是不是？”
　　妈听完一下子笑容全没了，脸上显出沉思的样子来。我忙说：“妈，您放心，我不会算错账的，那盆要真是聚宝盆，我能舍得送出去吗？我想，那只是因为盆里面含有什么成分，才引得蜈蚣、蟋蟀什么的爬进去……”
　　妈突然打断我，斩钉截铁地说：“不，那是真正的聚宝盆，就是给我座金山我也不换！”顿了顿，又说，“还有东子，妈正要跟你说个事，你现在有出息了，可得对乡亲们好点啊，我听说乡亲们进了城，有时找你办点事，你对人家不理不睬的……”
　　我听了，一脸不耐烦地说：“我为什么要帮他们办事？当年爸走的时候，咱家多艰难，您一个女人家要上山捉那些毒物，又有谁帮过我们啊？”
　　妈呆呆地看着我，像是不认识我似的，脸上露出痛苦的表情，说：“东子，你怎么能这样想呢？你根本不了解村里人……唉，这样好了，今天你不要走，明天一早我把聚宝盆给你带走，好不好？”
　　我只好答应在家睡下，妈把被子晒得很香，我一下子就睡着了，就像回到了小时候一样。不知什么时候，妈叫醒了我，一看表，大清早的才五点多钟，我睡眼蒙地说：“妈，干什么起这么早啊？”
　　 
　　妈神秘地说：“你想不想亲眼看看聚宝盆的神奇？想看的话就快起来！”
　　我忙起身，跟着妈出了门。村里的清晨格外宁静，四下里一个人也没有，只有我们娘儿俩一前一后地走着。当走到一户人家的门前时，妈示意我躲在大槐树的后面，还小声问我：“东子，还记得这家吗？”
　　我点点头，说：“好像是李大爷家吧？咱来这儿干什么？”
　　妈的神色看上去十分悲伤，说：“你还不知道，李大爷的儿子前年得病死了，儿媳妇也改嫁了，只留下个孙女跟着他过，孙女现在上初中了，可怜李大爷这么大年纪了还要上山捉蜈蚣换钱……看，有人来了！”
　　我一看，只见远处轻手轻脚地过来一个人，那人径直来到李大爷家的窗户脚下，原来那儿和我家以前一样，也摆着个瓦盆，不用说是放毒物的。我看见那人弯下腰，把一样东西放进了瓦盆里，再盖好盖子悄悄离去。
　　我差点叫出声来，妈妈用眼神止住了我，我惊讶地看到妈的眼睛里满是泪水。
　　这之后，三三两两来的人越来越多，全是乡亲们，每个人都轻手轻脚地把一样东西放进瓦盆内，再无声无息地离去。他们这是干什么啊？
　　这时天已渐渐亮了，没有人再过来了。妈妈推了我一下，说：“东子，你现在过去看看那瓦盆里是什么？”
　　我听了走过去，拎起盖子一看，吓了一大跳，只见瓦盆里蠕动着好多只蜈蚣、蝎子什么的。
　　妈妈的声音在身后响了起来：“妈当年冷静下来后一想，也不相信这世上真有聚宝盆什么的，可我一直想不通这是怎么回事。直到一天早上，我发现原来是乡亲们把自己的毒物放进了我们的瓦盆，这其中就有李大爷。”妈叹口气又说，“乡亲们可怜我们孤儿寡母的，可是他们知道妈为人要强，所以便用这种方式悄悄地帮助我们，这点妈也一直没有说破。”
　　妈妈的眼泪终于流了下来，说：“无论谁家遇到难处，乡亲们都会暗中互相帮助，现在大家又是这样帮助李大爷的，东子你现在知道了吧，一个普普通通的瓦盆就是这样变成聚宝盆的啊！”
　　我一个字一个字地听着，内心一时如潮水般翻涌，平复一下情绪后，我说：“妈，咱家那只聚宝盆，您给我好吗？”
　　妈吃惊道：“你还想送人？你不是已经知道它不是聚宝盆了吗？”
　　我摇摇头，字字用力地说：“不，它是一只真正的聚宝盆，里面凝聚了乡亲们的爱，我要把它放在跟前，时时提醒我怎样做人！”
　　（题图、插图：安玉民梁丽)
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第2期   得空调病的狗  作者：胡忠军  字体：
   【 大  中  小 】 
 
　　司马冰是个工程师，平日里最爱养个小动物什么的，调剂一下生活。最近，他买了一条松狮犬，起名豆豆。豆豆可爱又活泼，司马冰一有空就带着它出去溜达，很是开心。
　　夏天到了，这段时间豆豆又是拉稀又是咳嗽。司马冰赶忙抱它去宠物医院，兽医检查了一番后，问道：“你家开空调了吧？”
　　司马冰点点头：“那还用说，这种松狮犬最怕天热了，一天到晚都赖在空调房间里不肯走。”
　　兽医笑了笑，说道：“这狗没什么大问题，就是得了点‘空调病’。”
　　“空调病？”司马冰瞪大了眼睛，不敢相信，“狗也会得空调病？”
　　 
　　兽医解释说，狗也是很讲究空气质量的，尤其是这种松狮犬，非常娇贵，老是呆在空调房间里，就会得空调病，时间长了，还有可能危及生命。
　　司马冰一听急了，忙问：“这、这可怎么办啊？”
　　兽医摇了摇头，说道：“目前没有什么好办法，唯一能做的，就是把它放在自然环境里，天再热，也只能用扇子给它扇扇风。”
　　这下可把司马冰给难住了。这么热的天，不开空调，人难受点也就算了，关键是自己和老婆都要上班的，总不能请假在家给狗扇扇子吧。
　　晚上回到家，司马冰把这事和老婆说了，夫妻俩一合计，决定忍痛割爱，把狗卖掉。可眼下豆豆病恹恹的样子，谁敢买啊。正在愁眉不展的时候，司马冰忽然想起了自己的老母亲。
　　司马冰的母亲七十多岁了，一个人住在乡下。现在，只能把豆豆送到母亲那里，让她照看一段时间，等豆豆的病全好了，再把它卖掉。
　　第二天，司马冰就把豆豆送到了乡下。老人一个人在家正感孤独，豆豆的到来，给她增添了不少的乐趣。按照儿子的吩咐，母亲每天都悉心照料豆豆，只要一见豆豆张嘴喘气，就用芭蕉扇给它扇风，一边扇扇子，一边还唱着儿歌，那样子，就好像在照顾自己病中的孩子。
　　还别说，母亲的芭蕉扇比啥药都灵验，半个月后，豆豆完全好了。不久，司马冰也为豆豆找到了买主。
　　一听说要卖豆豆，老人一百个不愿意。可司马冰还是不顾母亲的劝阻，把豆豆带走了。
　　豆豆的新主人是个姓王的大老板，对豆豆可喜爱了。可是，没过多久，王老板就打来电话说，豆豆到家以后，一直精神委靡，不肯吃东西，还一个劲地叫唤。
　　司马冰知道，豆豆这是空调病又犯了，他连忙把扇扇子降温的那套方法说了。
　　好在王老板有钱，家里雇了保姆。既然豆豆不能吹空调，就让它住在保姆房间，把里面的空调关掉，让保姆给豆豆人工扇风。
　　然而，半个月过去了，豆豆不但不见好转，反而一天比一天叫得厉害，弄得王老板一家都睡不好觉。
　　王老板没辙了，带着豆豆找上门来，说：“我2万块买的，情愿倒贴5000，你把豆豆收回去吧。”司马冰只好答应了，又把豆豆交给母亲代养。
　　说来也怪，豆豆一回到老人身边，病很快就又好了。
　　可是不久，司马冰又找来了新的买主。司马冰觉得，豆豆在王老板家不适应，可能是因为他家的保姆太年轻，性情急躁，给豆豆扇风不够柔和。而这次的买主是一对老年夫妇，这老两口家里没安空调，可以轮流给豆豆扇风。
　　然而，豆豆到了新家，仍是狂躁不安，不管老两口怎么扇风，就是一直叫唤。
　　这天，老两口带着狗找上门来，老头一副可怜巴巴的样子，说：“这狗再养下去，非把俺折磨病不可，还是还给你吧，至于钱，随你的心意，反正俺是不能再把狗带回去了……”
　　 
　　人家把话说到这个分上，司马冰没法拒绝，只好将钱如数退还，收下豆豆，又一次把它送到了乡下。
　　照例，母亲的芭蕉扇又发挥了作用。司马冰心里感到很奇怪，母亲到底有啥绝招呢？
　　几次卖狗不成，司马冰只好打消了这个念头，打算就把豆豆交给母亲照管。
　　这天，司马冰突然接到乡下打来的电话，说母亲突发脑血栓，被送进了医院，夫妻俩急忙赶去。经过抢救，老人总算脱离了危险，可是，已经神志不清，有时连人都认不得了。
　　这下可忙坏了小两口。两个人都请了假，一个人在医院侍候老人，一个人在家照顾豆豆。老人的病情倒是渐渐有了起色，可豆豆却是一天比一天虚弱，夫妻俩看在眼里，急在心里。
　　这天，司马冰又去医院看望母亲，发现母亲躺在床上，双手四处摸索，好像在找什么东西。突然，她看到司马冰手里有本书，就伸手抓了过来，把书当扇子给儿子扇起风来，嘴里还念叨着什么。
　　司马冰心想：母亲经常给豆豆扇风，对豆豆有了感情，她这一定是想豆豆了。于是，他赶紧从老人手里拿过书，说道：“妈，别扇了，我知道您想豆豆了，明天我就把豆豆带来。”
　　第二天，司马冰向院方说明了情况，考虑到这样对老人恢复神志有帮助，医院破例让豆豆进了病房。
　　司马冰找了一张凳子，放在老人床头，把豆豆放在凳子上，还专门买了一把芭蕉扇，递到老人手里。
　　老人侧过身子，望着豆豆，眼神里充满了慈爱，手里的扇子轻轻晃动着。慢慢地，老人念叨的声音越来越大了，司马冰终于听清了那些字眼。
　　顿时，司马冰惊呆了，原来母亲念叨的不是别的，而是一首他儿时常听的催眠曲—
　　“小冰冰睡觉吧，山猫猴子来到了，红眼绿鼻子，四个毛蹄子，走路叭叭响，要吃活孩子……”
　　豆豆在老人的哼唱声中，就像小孩子一样，安静地闭上了眼睛……
　　这熟悉的儿歌，一下子把司马冰带回了幸福的儿时。他记得，每到夏天的夜晚，自己都是在母亲的哼唱中甜蜜入睡的。
　　他突然明白了，豆豆为什么离不开母亲，因为老人把豆豆当成儿子了，她的一举一动都倾注了感情。
　　想到这里，司马冰突然觉得很愧疚，他凑到母亲的耳边，轻轻地说：“妈，豆豆不离开你，我也再不离开你了……”
　　（题图、插图：安玉民梁丽)
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第2期   非得占个大便宜  作者：波　波  字体：
   【 大  中  小 】 
 
　　阿P在市场里开了一家小商店。这天，阿P正在往店里搬啤酒，突然听到半空中传来一声巨响，就跟爆炸似的。阿P没防备，吓了一大跳，手中的啤酒箱子“哗”的一声摔了下来。接着，那响声一声接一声，整整二十四响，震得阿P脑袋直犯晕。旁边的老婆小兰也吓得够呛，一张小脸刷白刷白的。
　　 
　　好半天，阿P才稳住心神，抓住一个过路人，问到底是怎么回事，有人告诉阿P，对面那家大酒楼有人摆酒席，在放那种能吓破人胆的火铳。
　　阿P听了，低头看看打碎的啤酒瓶，再看看老婆，眼珠一转，计上心来。他赶忙吩咐小兰：“别干活了，快躺下！”
　　小兰觉得奇怪，说：“大白天的，你发什么疯啊？”阿P 却得意地说：“发财的机会来啦！你就说胸口疼，我去找那摆酒席的算账，让他们赔钱，这回非得占个大便宜，给少了我都不干！”
　　阿P跑进那家酒楼，一进门就大声嚷嚷：“不好啦，不好啦！出人命啦！”正嚷得欢，就听背后有人喊了一声：“阿P！”
　　阿P回头一瞧，啊！真的不是冤家不碰头，竟然是他的死对头周科长。这个周科长，是阿P原来单位里的顶头上司，就是他炒阿P鱿鱼的。
　　只见周科长激动地走过来，紧紧握住阿P的手，上下左右不住地摇晃：“阿P啊，我万万没想到你会来！”一边说，一边把旁边的人叫过来，“来来来，我给你们介绍介绍，这是我最最要好的朋友阿P，以前和我是一个科室的。现在人家下海了，都成小老板了，发大财了。”
　　旁边的一伙人都肃然起敬，围着阿P，又是握手，又是递名片，嘴里还老板长老板短地叫着，叫得阿P轻飘飘的，不要说刚才那股火气早就没了，就连自己姓啥都忘记了。
　　阿P就这样稀里糊涂被大家拥着往酒楼里走。路过门口的时候，阿P突然看到每个人都在往周科长的手里塞红包，还有人负责登记人名和礼金数。
　　 
　　阿P一个哆嗦，挺起的身板不由自主地弯了，他一抬眼，恰巧看到周科长正对着自己微笑，在一片老板声中，阿P手伸进衣兜里，把准备进货的五百块拿了出来：“周兄，不成敬意，不成敬意。”
　　旁边的人满脸钦佩，都竖起大拇指直夸：“到底是老板，出手大方啊！”
　　阿P直到喝完酒才闹明白是怎么一回事，他垂头丧气地回到家，一屁股坐在沙发上。
　　老婆小兰以为阿P没讨到赔款，便劝道：“就算人家没赔钱，但总算是白吃了一顿，还不知足啊！”阿P一听，真是哭笑不得：“白吃？整整五百块呀！”
　　阿P把来龙去脉讲了个大概，小兰也觉得冤：“你瞧你，死要面子活受罪！这下好了，一个月的伙食费没了。”
　　两个人长吁短叹，突然小兰眼睛放光，说：“有了，下个月咱爸过六十大寿，咱们也请请周科长，他要来肯定不止送五百，我们不会吃亏的。”
　　没想到，阿P一听这话，头更低了，叹了一口气说：“你知道个啥，随完礼我才知道，敢情周科长摆的是乔迁酒，他们全家就要移民到加拿大去了，这个便宜咱是说啥也找不回来了。”
　　当晚阿P被罚睡客厅，到天快亮时，阿P突然想到：我不是送了周科长五百块吗？周科长不是移民到加拿大了吗？从今往后，我阿P在加拿大就有朋友了。到那时，我去加拿大旅游，这五百块还得要回来。
　　想到这里，阿P又高兴起来了。
　　 （题图、插图：顾子易)
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第2期   资格  作者：黄　冈  字体：
   【 大  中  小 】 
 
　　虽然，这是一份迟到的肯定，但在我们的心里，你早已当之无愧。
　　
　　意外落选
　　
　　 
　　教师节将至，市里要评选全市“十佳教师”，要求每个学校推荐一名候选人。
　　这天，松山镇中学的教师们集中在会议室里，投票选举候选人。青年教师刘春明毫不迟疑地在选票上填写了“张富文”三个字。
　　刘春明虽然是新老师，入校时间不长，但这半年来，他耳闻目睹，知道了张老师不少的感人事迹，他觉得，这个候选人非张老师莫属。
　　然而，结果却出乎刘春明的意料，当选的是另一位王老师，张老师仅仅获得了一票，而这一票，就是刘春明投的。刘春明感到有些愤怒，他觉得大家一定都存了私心，毕竟，这“十佳教师”是人人都想争取的荣誉。可是，学校里不少年轻老师，甚至包括校长，都曾是张老师的学生呢，这不是忘恩负义吗？
　　散会后，刘春明走出会议室，一眼看到前面那个一瘸一拐的落寞身影，心里感到一阵刺痛，要知道，张老师的一条瘸腿，就是当初为了救一个学生落下的残疾。刘春明急忙赶上去，说：“张老师，我觉得这次的投票太不公平了，您才最有资格当选！”
　　张老师抬头看了一眼刘春明，说：“王老师也很好呀，实至名归。”
　　刘春明愤愤地说：“我不明白的是，前几天学校内部评优，您是全票当选，可这次为什么相差这么大？”
　　张老师笑笑说：“没事，这结果我早就想到了，其实我也已经习惯了。”
　　刘春明不解地问：“习惯了？难道这种事经常发生？”
　　张老师苦笑一下，说：“也不知为什么，这些年，每次学校内部评优，我都能高票当选；可是碰到校外更高一级的评选，我每次都榜上无名。”
　　刘春明气愤道：“这事儿明摆着，肯定是学校的那点小荣誉人家根本没放在眼里，所以才不跟您争。不行，张老师，这个荣誉您可不能让！”他盯着张老师，又说，“评选上不是说可以自荐吗？我看，您去自荐吧。”
　　张老师慌忙摆摆手，道：“算了，学校已经有候选人了。再说，我这么大岁数了，能让我上上课就知足了。”
　　刘春明心里明白，张老师一定是怕得罪学校领导和同事，便也没再说什么，心里却暗自打定了一个主意。
　　
　　查无此人
　　
　　这天晚上，刘春明趴在宿舍的台灯下，给“十佳教师”评委会写了一封信。在信中，他细述了张老师从教三十多年来的诸多感人事迹。在信的最后，他笔锋一转，质问道：这样一个为教育事业奉献一生、为学生献出一切的老师评不上“十佳”，公道何在？我郑重地向你们推荐张富文老师，他比谁都有资格获得“十佳”称号！
　　刘春明写完后，又看了一遍信，自己感动得差点掉出眼泪来。他相信，这封信也一定会打动评委的。可是，信寄出去后，却如石沉大海，一直没有回音。
　　不久，全市“十佳教师”的候选名单公布，张富文老师榜上无名。
　　刘春明是个犟脾气，他认准的事情，十头牛也拉不回来。他特意请假去了市教委，决心问个明白。没想到，评委会负责人说，那封信他们收到了，也非常重视。但是，经查，市里的在编教师中，根本没有张富文这个人，所以他没有评选“十佳”的资格。
　　刘春明大吃一惊，说：“我们天天在一起，怎么会没有这个人？”
　　对方说：“你要不信，你过来我再查一遍。”说着打开电脑，调出本市教师名册，输入“张富文”三个字，显示：查无此人。
　　“难道是名字错了？”刘春明想了想，又让对方调出松山镇的教师名单，从头至尾、仔仔细细地查找一遍，仍是没有。刘春明一头雾水，怔了半天，问：“这名单会不会漏掉了人？”
　　 
　　对方笑了，说：“不可能，市财政给教师发工资就是按照这个名单，要是漏掉了谁，人家早就找上门来了。这个人肯定不是在编的教师。”
　　刘春明脑中灵光一闪，问：“那他会不会是民办教师？”对方断然否定：“咱们市十年前就清退所有民办教师了。”
　　刘春明又问：“那代课教师呢？”
　　对方又摇头说：“三年前，市里专门发文辞退了所有的代课教师，你想想，现在正式教师都用不过来，哪里还用得上代课教师？”
　　刘春明不死心，说：“说不定还没辞退光呢？”“不可能，现在所有教师的工资都是按照名单统一发放，代课教师进不了名单，那谁给他出钱发工资呢？”
　　刘春明也觉得不可能，可这到底是咋回事呢？张富文活生生的一个人，怎么会查无此人呢？
　　
　　有情有义
　　
　　刘春明满腹疑惑地回到学校，刚进大门，就看到校长阴沉着脸站在办公室门口。看到刘春明后，校长向他招手：“小刘，你来一下。”
　　刘春明赶紧跑过去，校长不高兴地问：“你是不是去市教委了？”
　　刘春明说：“是呀，不过校长，教委的教师名册里竟然没有张富文老师的名字，您说奇不奇怪？我这就去找张老师，带他去教委。”
　　“去什么去！”校长恼怒地盯着刘春明，“小刘呀小刘，你可坏了我们的大事了。”
　　刘春明感到莫名其妙，很委屈地问：“校长，我哪里做错了？”
　　校长又是摇头又是叹息：“刚才，市教委来电话，问张富文是怎么回事。唉，这个事情本来一直瞒着上面，这下完了，被你一下子给捅出去了。张老师这课恐怕是上不成了！”
　　刘春明心中一沉，更感到云里雾里：“校长，这到底是怎么回事？”
　　校长让刘春明进屋坐下，叹口气说：“说来我也有责任，应该早点告诉你的。其实，张老师是代课教师，并不在编制之内。这事说来话长……”
　　原来，张富文老师从十八岁起，就当了民办教师，因为种种原因，一直没能转正。唯一的一次机会，还让给了一位生活困难的教师。结果第二年，市里取消民办教师编制，学校考虑到张老师的教学水平和生计问题，留他做了代课教师。虽然张老师是骨干教师，但限于政策，待遇比正式教师差多了。可就是这样，张老师也毫无怨言，还是兢兢业业地教书。没想到，三年前，市里又要求清退所有代课教师。
　　听到这里，刘春明问：“那后来怎么没有辞退呢？”
　　校长说：“当时，我也非常为难，一来是舍不得，张老师的水平摆在那里，这样的老师任谁也不舍得放弃；二来呢，如果辞退张老师，他的生活肯定会陷入困境，我也是张老师教出来的，不知怎么向他开这个口。可留用吧，他的工资又没地方出。”
　　刘春明更好奇了：“那后来工资问题是怎么解决的？”
　　校长喝口水，说：“说来也巧，那一年，正好是张老师从教三十周年，我们这些做学生的早就商量好，要聚会庆祝一下。当时，连在北京、深圳的学生都赶了回来，一共来了一百多个人。聚会的时候，正好赶上这事，我就瞒着张老师跟大伙商量。大伙都说，不能让张老师离开他热爱的讲台，工资上面不是不管了嘛，那就我们来管，我们凑钱给张老师发工资。”
　　刘春明吃惊地问：“你们凑钱？”
　　校长点点头：“是啊。我们一商量，老师的工资也不算高，我们这么多人，每人每年少抽几盒烟，省出几百块钱，凑在一起，就足够了。后来，我们干脆成立了一个基金会，谁手头比较宽裕就多拿出一点钱，存在一起给张老师将来用。”
　　 
　　刘春明听了，心中大为震动，由学生凑钱为老师发工资，这事闻所未闻。只有张老师这样有情有义的老师，才会教出这样有情有义的学生啊。
　　
　　资格证书
　　
　　校长顿了顿，接着说：“因为怕张老师不肯接受我们的资助，大伙就决定瞒着他，我也一直没有把辞退代课教师的事告诉他，就这样，一直让他代课到了现在。”
　　刘春明觉得不可思议，问：“难道张老师一直不知道这件事？”
　　校长苦笑道：“张老师除了教学，对其他事情都不敏感。这两年，因为基金会的钱越存越多，我还给张老师涨了两次工资呢。学校里的其他老师也知道这事，大家都特意瞒着他。”
　　刘春明一转念，突然明白了：“所以，评校内优秀老师的时候，大家都选他，到了选市里荣誉的时候，却不投他票，就是因为知道他没有资格，投了票也没有用。”
　　校长点点头：“就是这个道理，没有资格啊！”他的语气非常无奈。
　　刘春明懊悔不迭：“我误会大家了，还以为大家都要抢这个荣誉呢。”说到这里，他腾地站起来，“不行，我这就去市教委，就说是我弄错了。”
　　校长一把拦住他：“算了，没用了，教委的人马上就到了。”
　　刘春明傻眼了：“他们还要调查？校长，您好好解释一下，说说张老师的情况，人心都是肉长的，他们也会通情达理的。”一转念，又说，“再说了，就是把张老师辞退了，你们的基金会也照样可以给他发工资呀。”
　　校长看了刘春明一眼，一脸苦笑道：“小刘，你还是不了解张老师啊！我倒不是怕上面追究，我怕的是张老师如果知道这件事，以他的性格，你以为他会继续接受我们的资助吗？”
　　刘春明不由语塞：是啊，这事万万不能让张老师知道。
　　校长叹口气道：“唉，现在上面肯定是瞒不住了。你说得对，人心都是肉长的，我实话实说，争取他们能理解吧。你现在回去上课吧，其他的事就不要管了，由我来处理。”
　　刘春明松了一口气，校长既然这么说，看来还有挽回的余地。不过，要是张老师真的因此教不了学，自己的罪过可就大了。
　　刘春明出了门，突然想起一事，又回头问：“校长，你们那个基金会的账号是多少？”
　　校长闻听一愣，立即明白了他的意思，说：“算了，你的工资也不高，再说，你也没资格啊。”
　　刘春明不解道：“资格？”
　　校长说：“因为，你不是张老师的学生呀。”
　　刘春明胸口一热，认真地说：“我是，我从你们身上，学到了很多。”
　　说话间，一辆轿车驶进了学校的大门，教委的人到了。校长深吸一口气，迎了上去……
　　一个月后，张富文老师得到一纸通知，经有关部门研究决定，他被破格录取为正式教师，终于获得了教师资格。
　　 （题图、插图：魏忠善）
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第2期   中奖彩票  作者：钱　岩  字体：
   【 大  中  小 】 
 
　　都说买彩票是个撞大运的事情，
　　 谁知，还真让人给撞上了！孙家洼有个孙老汉，从来都是一分钱恨不得掰成两半使的，这些天来，不知咋了，他竟隔三岔五地到镇上买彩票，而且只买了几期，就中了个二等奖，奖金高达20万！
　　孙老汉高兴坏了，这事可不敢告诉别人，但儿子还是要告诉的。
　　孙老汉有两个儿子：大儿子孙孝，和老汉住在一个村上；二儿子孙顺，一家人在外地做生意。孙老汉决定先去告诉大儿子，再叫大儿子打电话告诉二儿子。嘿嘿，没想到吧，你们这老不死的爹，这下可是发大财了。
　　孙老汉来到村西头大儿子家，老大两口子正在吃饭，见爹来了，眼皮都懒得抬。孙老汉也不恼，自己拾个小凳靠墙角坐下，掏出烟袋，一边朝烟窝里装烟丝，一边笑着说：“听说有人在镇上买彩票，中了20万呢！我去看了，那投注点爆竹都炸了一地！”
　　老大听了很不耐烦，骂道：“你没事跑来就是为了说这个？是不是也做梦想吃屎？告诉你，那中奖的家伙，肯定天天吃屎了！”
　　孙老汉这个气呀，说道：“你娃怎么能这么说话呢？怎么能咒你爹是吃屎的人！”
　　老大两口子正在往嘴里扒饭，一听都愣住了，嘴就那么大张着，饭粒“扑落落”直往下掉。好一会儿，才不相信地问：“这么说，你、你就是那、那中20万大、大奖的人？”
　　孙老汉忙摇摇手阻止道：“小声点，这事千万不能让外人知道了！”
　　天哪，爹竟是那中大奖的人！老大两口子忙扔了手里的饭碗，扑过来，一个摇孙老汉的胳膊，一个揉孙老汉的腿，喊道：“爹，爹—”孙老汉听了，真是感慨万分：这声爹要是刚才进门时就听到，那该有多好！
　　老大两口子急着要看那中奖的彩票，说着手就伸进爹口袋里掏，只是掏遍口袋，也没有发现彩票。
　　孙老汉不糊涂，心知这彩票要是落到这两人手中，那就不是他的了，于是笑着说：“彩票我没带在身上。老大，你给老二打个电话，叫他明天一定赶回来，到时我把彩票拿给你们看，大家一起乐呵乐呵。这老二，我都五年没见着他了，怪想他的。”
　　无论怎么哄，反正孙老汉不见兔子不撒鹰，老大两口子很失望。老大媳妇不满道：“爹，你心里只有老二这个儿子，可老二心里有没有你这个老子呢？你想，五六年了，都不和老子照个面，天下有这么做儿子的吗？爹，亏得你有福气，还有老大在身边照顾着你……”
　　孙老汉鼻子哼了一下，没多吭声，就是坚持要给老二打电话。
　　老大心里老不情愿，但表面上还是装作很高兴的样子，拨通了电话：“老二啊，咱爹中大奖了……”
　　 
　　孙老汉在一旁，也想跟二儿子聊几句，可老大捏着电话就是不撒手：“什么，你明天就回来，好啊，我跟爹说，那就挂了啊……”然后，“啪”的一声挂断了电话。
　　孙老汉有些生气了，老大在边上解释说：“爹，这是长途，贵着呢，反正老二明天就回来了，有的是时间，慢慢聊。”
　　孙老汉走后，老大媳妇捶了老大一拳，说：“要死了，你还真打啊！”
　　老大笑嘻嘻地开了口：“我刚才拨的是空号，那是做戏给爹看的，”顿了顿，又说，“明天爹肯定等不来老二的，到时我们就找个人冒充老二给家里打来电话，就说他正在谈一笔生意，实在抽不出时间。还说他现在有钱，不在乎这些，奖金全给大哥吧。”
　　老大媳妇笑着拍手道：“想不到你这笨人，关键时候倒想出个好主意来。”
　　第二天，老大两口子就带着买来的鱼肉，乐呵呵地来到孙老汉那低矮的老屋，说今天老二要回来，一家人难得团圆一次，得庆贺庆贺。
　　在孙老汉这儿，一有机会，老大两口子就在屋子里翻找，只是能找的地方都找遍了，就是没有那张让他们牵肠挂肚的彩票。
　　眼看太阳都快要落山了，也不见老二回来，孙老汉显得有些着急。老大两口子看时机已经成熟，决定让“老二”给家里打电话了。正联系着，忽听见孙老汉欢叫起来，抬头一看，原来，老二两口子风尘仆仆地赶回来了！
　　老大两口子惊得目瞪口呆，正在纳闷呢，只听孙老汉在一旁说道：“昨天从你那里出来，我突然想起有事情要交代老二，就借了个手机打过去，老大，怎么跟你说的不一样呢？”老大听了这话，脸都红到耳根子了。
　　老二瞥了一眼老大，说：“大哥，爹的事怎么能不跟我说呢！这不，我一接到电话，连夜就去买火车票赶回来。”
　　两个儿子全到齐了，两家人都迫不及待地要看那张中奖彩票。这时，只见孙老汉想了想，然后笑嘻嘻地脱了左脚的鞋，又脱了袜子，从袜筒里掏出那张中奖彩票来。老大两口子见了，悔得肠子都青了，心说：这老爷子怎么越活越精怪了。
　　老二咳嗽一声先开了口，说：“这次爹买彩票能中奖，其实是我们做儿子的福气。在爹眼里，手心手背都是肉，所以我建议奖金两家平均分，20万，正好一家分10万。”
　　 
　　此话一出，便遭到老大的反对：“这不公平！你们把爹丢在乡下不管不问的，平时都靠我们两口子照顾爹。分钱可以，但我要多分两万！”
　　兄弟两家都想多分一份，就这么吵来吵去，全然不顾一旁的孙老汉。这时，孙老汉急了，捂紧手里的彩票，说道：“敢情我买的彩票中了奖，自己一分钱没有啊！这不行，我也要分一份！”
　　啥，老头也要分钱，这两份变三份，每家要少三四万！老大、老二两家此时终于达成一致意见，坚决不同意老父亲参与分奖金。
　　“爹，你都这么大岁数了，要这么多钱干什么？放在家里，这不是招小偷、强盗惦记嘛。弄不好，钱丢了，老命也会搭上，我们可不是吓唬你！”
　　孙老汉长叹一声，说：“好吧，我那一份不要也就算了，只是这中奖的号码是用我和另一个人的生日组合的，这个人……”
　　儿子们笑道：“这个人不用猜肯定是老妈了。只是老妈走了这么多年了，我们总不能分几万块钱烧给她吧？”
　　孙老汉摇头苦笑道：“你们猜错了，这个人不是你们老妈，是吴婶……”
　　儿子们一听这话，顿时气不打一处来。原来，这吴婶和孙老汉同住在一个村上，比孙老汉小五岁，是个苦命的女人。早些年死了丈夫，前几年又死了儿子，现在是孤苦伶仃一个人。孙老汉和吴婶是同病相怜啊，平日里互帮互助，慢慢地两人有了感情，就想撮合到一起。可孙老汉的两个儿子坚决不同意，说他们丢不起人。
　　孙老汉说：“这吴婶也真可怜，胆里长满了石头，疼起来直打滚，可就是没钱上医院做手术。这次彩票能中奖，也有她的功劳。这样吧，分她2万块钱，让她上医院把手术做了……”
　　还没等孙老汉说完，儿子媳妇们就吵吵嚷嚷不干了：“凭什么她吴婶生病，要我们拿钱出来？爹你可别犯糊涂，她不是你老婆！”
　　孙老汉见儿子们不同意，几乎是哀求道：“那就分给吴婶1万，行不行？20万哪，就给1万，要不5000块？再少做手术肯定就不够了……”
　　“不要说5000块，就是1块钱我们也不会拿出来！”见老父亲很固执，儿子们很生气。为了怕夜长梦多，老大冲上去，从孙老汉的手里硬生生地把彩票抢了过去。
　　彩票在手，兄弟俩喜笑颜开，正准备出门时，孙老汉在背后喊了一嗓子：“慢着！”
　　两个儿子回过头来，一脸疑惑，只见孙老汉走过来，指了指老大手里的彩票说：“你们以为这张彩票真的中奖了？”
　　兄弟俩心说老家伙一定是在耍什么把戏呢。老二立马掏出手机打给投注站，一边拿过彩票，一边询问：“请问二等奖中奖号码，没错没错……”
　　孙老汉在旁边摇着头，说：“你再问问期数，看仔细喽。”
　　“期数？”老二一脸狐疑，眼睛在彩票上左右移动，找到一行小字，上面清清楚楚印着的是“第24期”。
　　这时，电话里传来一个声音说：“你好，这期开奖的是第25期……”
　　“25期？”老二嘀咕了一句，当即傻眼了。老大上前一把抢过彩票，看了一眼，然后愤愤地撕了个粉碎，拽着老二头也不回地走了。
　　原来，这张彩票虽然号码和中奖号码一模一样，但期数却是上一期的。
　　儿子们走后，孙老汉从右脚袜筒里哆哆嗦嗦掏出一张彩票来，这才是那张中奖的彩票。唉，谁让他们这么贪，连5000块都舍不得拿出来！
　　孙老汉一抹眼泪，决定自己悄悄去领奖，领了奖就带吴婶上大医院去做手术。因为他对吴婶许诺过，他买彩票就是为了中奖，中了奖就带她去做手术。他不能不守诺言。
　　 (题图、插图：谢颖)
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第2期   村里有个伴娘叫小芳  作者：刘江波  字体：
   【 大  中  小 】 
 
　　不是歌里唱的那个眼睛大、辫子长的小芳，这个小芳可大有来头呢!
　　
　　有些人天生爱凑热闹，哪里人多就往哪钻，二柱子就是这样，整天游手好闲，最大的乐趣就是闹洞房。哪家有结婚的让他知道了，准保领着一伙人去闹腾，不把新娘子闹得痛哭流涕不算完，所以在梨树村，新人们一听到此人的名字头都疼。
　　这天，是村里梁子的大喜日子，梁子娶了个城里姑娘回来，听说不光新娘子好看，就连那伴娘也是个大美人，而且还是老师呢。二柱子听到这个信，乐得拔腿就往梁子家跑。到那一看，新娘子花枝招展的自不用说，那伴娘果然身材苗条，脸蛋漂亮。
　　喝完喜酒，二柱子借着酒劲，带着一帮人围住了伴娘。一听伴娘叫小芳，二柱子领头唱起了《村里有个姑娘叫小芳》，然后拦住人家死活不让走，还非要跟小芳交朋友。小芳看他纠缠不休，气得用力一推，差点把二柱子摔了个跟头。
　　看着小芳跟着新娘走了，大家都哄笑起来，二柱子脸上挂不住了，他冲着小芳的背影咬着牙说：“你等着，晚上闹洞房的时候，看我怎么收拾你。”
　　 
　　提起闹洞房，大伙都来了精神，连平时不爱凑热闹的四锁也过来了，说：“柱子，这主意好啊，我看新娘子不太好逗，咱们干脆就逗逗伴娘！”
　　天刚擦黑的时候，二柱子召集了十来个能疯能闹的调皮鬼，呼啦一下就挤进了新房。二柱子一使眼色，四锁清清嗓子说话了：“不说不笑不热闹，闹洞房嘛，凡是新人都得过这一关，按老规矩，一人出一个节目。”
　　闹洞房有几个传统节目，不是挂个苹果让新人一起咬，就是放些糖块在新娘衣服里让新郎翻。一看还是这几个节目，二柱子早烦了，吵吵嚷嚷地打断了：“这不行，都什么年代了还玩这个，咱今天换点新鲜的，给新娘‘挂奶瓶’，给新郎穿‘比基尼’！”
　　一听这话，新郎梁子可傻了，他早就听说这两招是二柱子从城里学来的：“挂奶瓶”就是在新娘胸前挂个孩子吃奶用的奶瓶，叫新郎去喝；而“比基尼”更损，是让新郎穿上女式比基尼走上几圈。这两招是现在城里最流行的，往往能整得新人们苦不堪言。
　　梁子连忙递给二柱子一盒好烟，一个劲地说好话：“柱子哥，这可不行，您就饶了兄弟吧！”
　　但二柱子不依不饶，掏出一个奶瓶就要给新娘挂上，好在四锁这时出来打圆场：“闹归闹，不过咱也得讲究个文明，既然这两招新郎说不行，咱就换换。依我的主意，不如就让新娘学几个简单的动作。学得像呢，咱马上走人，学不上来呢，可有个小小的惩罚，新娘子得挨个亲我们一口。”
　　说着，四锁指了指二柱子，给屋里的人使了个眼色，大家立刻明白了。原来，这二柱子从小就爱舞刀弄棒，也真能亮几个架势，他要摆上几招，棒小伙子都学不上来，何况是文文静静的新娘子。
　　这主意又新鲜又刺激，还有便宜占，这帮小伙子哪有不乐的，屋里的叫好声、鼓掌声响成一片，梁子急得直挠头：“四锁，你这主意也不怎么样，哪有新娘子亲你们的道理。”
　　二柱子可不管这套，撸胳膊挽袖子就叫起来：“新娘子再不同意，我们可给新郎穿比基尼了。”
　　新娘吓得一直没敢吭声，这时候被逼无奈，只好小声说了一句：“不文明的可不能学。”
　　二柱子一看新娘中了圈套，立刻把外衣一甩，双腿跳起来，原地就是一个空翻，站稳后再一抬腿，脚都快踢到肩膀上了，他得意地冲着大家一抱拳，赢得了一片喝彩声。
　　这两个动作虽然够文明，但新娘怎么能做得上来，她涨红了脸，连头都不敢抬。二柱子见了，便嬉皮笑脸地凑上前去，非要让新娘亲他一口不可。梁子怎么哀求也没有用，倒是一旁的伴娘小芳突然站起来，说：“你们这不是存心难为人嘛，新娘子穿着婚纱，怎么能做空翻呢？”
　　二柱子就是想借机把小芳拖下水，听她出来替新娘说话，心里乐开了花，忙说：“新娘穿婚纱，你穿的可不是，要不然你替新娘子做吧。”
　　二柱子以为这句话，肯定能把小芳吓得躲一边去，谁知这姑娘还真有股倔劲：“那我要是替新娘做上来了，你们是不是就不难为她了？”
　　屋里的笑声更大了，二柱子笑得直揉肚子：“你要是做上来了，咱二话不说，走人！但你要是做不上来，惩罚要加倍，每个人都要亲两口。”
　　“行！”小芳马上走过来，示意大伙让开一点地方，然后身子一纵接连来了两个空翻，动作干净利落，毫不拖泥带水。落地后，小芳站直了身子一抬腿，那脚都够到了脑门上的头发，比二柱子踢得还高呢。这一下，把大伙都看傻了，乱哄哄的屋里立刻安静下来。
　　 
　　小芳笑着说：“咱可有言在先，你们不能再难为新娘子。”
　　四锁一扯二柱子，小声说了一句：“这丫头练过，咱们走吧。”
　　二柱子也被小芳给镇住了，可就这么走了，自己也太没面子了，他运了运气，说：“慢着，看来是真人不露相啊！新娘子我们是不难为了，但今天我想难为难为伴娘。我再摆个动作，你要学不上来，还得亲我两口。”
　　小芳一皱眉，说：“我一个女老师，又不是练武的，就因为从小爱翻跟头踢腿的，刚才碰巧做上了，你怎么还没完没了的！”
　　听她这么说，二柱子悬着的心放了下来，原来刚才是碰巧啊！这下他更来了蛮不讲理的劲：“今天我就是没完了，你要学不上来，就得亲我，要不我亲你也行。”
　　说完，二柱子单脚站立，另一只腿举起来，越举越高，一直举到和耳朵都贴上了。四锁带头叫起好来，这个动作二柱子轻易不露，也确实有难度，就是真练过几年功夫的，都未必做得上来。
　　果然，小芳愁眉苦脸地站在那，看样子真把她难住了。二柱子把腿放下来，得意地把脸凑过去让小芳亲。小芳一把推开他，二柱子立刻瞪起了眼睛：“怎么，想赖，兄弟们动手。”
　　一看二柱子要蛮干，新郎新娘脸都吓白了，小芳也说起了好话：“这位大哥，今天是人家大喜的日子，咱们开开玩笑也就算了，别太过分了。”
　　二柱子占了上风，更是得理不饶人，他又把脸凑过去：“要么你就学着做，要么你就亲我两口，别的话你也不用说了。”
　　看二柱子得寸进尺，小芳也有点火了，她提高了声音说：“好，我学，要是学不上来，我愿赌服输，但要是学上来了，你怎么办？”
　　二柱子一听她叫起板来，马上一拍胸脯：“要是学上来，我爬着回家，大伙都是证人。”
　　“好，一言为定！”小芳说完，便走到屋子的中央，试着踢了几脚，活动了一下筋骨。二柱子他们还在边上不断地起哄，小芳也不理会，只见她左脚独立支撑，右脚慢慢地举起，一点一点地抬高，眼看着就扳过了头顶。屋子里一下子就安静了下来，二柱子不敢相信地张大了嘴巴。
　　小芳这个姿势可比二柱子的难多了，不但贴上了耳朵，还能从脑袋那边转过来。她摆了足足有五分钟，看大伙都不吭声了，这才慢慢地放了下来：“这位大哥，你看我学得像吗？”
　　没有人敢接她的话，这个哪里是伴娘，明明就是超人嘛！新娘子到现在终于长舒了一口气，说话也硬气起来：“梁子，快给每人发盒好烟，再给柱子哥找副手套。”
　　二柱子不好耍赖，只得硬着头皮在地上爬了几步，大伙想笑又不敢，都在那强忍着一边笑一边嘀咕：这伴娘哪找来的，一个女老师怎么能有这身功夫？
　　二柱子带着人灰溜溜地出了梁子家，走出好一段路了，突然间，二柱子一拍脑袋说： “哥几个，这事不对，哪有这么巧的事，这主意从头到尾都是四锁一个人出的，他人呢？”
　　大伙这才发现四锁没跟来，心说这里面一定有问题，几个人一合计，顺着原路又回去了。快走到梁子家的时候，远远地就看见四锁把一个女人送上了出租车。借着路灯，早有眼尖的人认出来了，那女人就是伴娘小芳！
　　这下大家火了，上去就把四锁围住了，个个伸出拳头，吓得四锁抱头求饶：“别打别打，我全招了。这个小芳是老师，一点不假，但她是市里杂技团的老师，是我托朋友请来的。梁子结婚前就跟我说了，说你们闹洞房越来越过分，上次小王结婚，把新娘都闹哭了。他不想咱们兄弟在大喜的日子撕破脸伤了感情，不让你们闹又不行，所以我就给他出了这个主意。”
　　二柱子听完，上前一把揪住四锁：“你小子太不地道，梁子到底给了你什么好处，统统交出来，不然我饶不了你。”
　　四锁苦笑一声：“哪有什么好处呀！下个月我也要结婚了，我这是给自己留条后路，说实话，你们这样的闹法，谁不害怕？”
　　 (题图、插图：魏忠善)
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第2期   拆不掉的送奶箱  作者：谢元清  字体：
   【 大  中  小 】 
 
　　一只小小的送奶箱，也是一份情感的寄托，看着上面那红彤彤的“福”字，就仿佛看见了一张慈祥的笑脸……
　　 
　　老卢家住在六楼，他家的大门口挂着一只送奶箱，箱子已经十分陈旧了，上面还贴着一张褪了色的剪纸“福”字。
　　这送奶箱是许多年前，牛奶公司为了配送袋装鲜奶给安装的。如今城里人早都改喝盒装奶了，送奶箱自然派不上用场，大家都相继拆除了。可不知为啥，老卢家的送奶箱仍孤零零地挂在楼道里，显得有些碍眼。
　　这天，物业公司的潘经理找到老卢，婉转地说：“老卢，你家那只送奶箱没用了吧，为什么不拆掉它呀？都快成古董了。”
　　老卢“嘿嘿”一笑，说：“用是没啥用了，不过你先别拆它，需要拆时，我自己会动手的。”
　　哪知，老卢说归说，压根儿就没有拆的意思，日子一天天过去，送奶箱仍然纹丝不动地挂着，潘经理每次从那儿经过，都不由得皱起眉头来。
　　过了几个月，小区安排统一粉刷楼道内墙，潘经理灵机一动，贴出了一张告示：为了方便粉刷涂料，请各住户在三日内将春联、送奶箱等自行拆除，逾期者将由工人统一拆除。潘经理特意在“送奶箱”三个字下划了横线，这是有专指的，因为整个小区里，只剩下老卢一家有送奶箱了。
　　哪知，三天过去了，老卢家却没有一点动静。这下，潘经理火了，对着刷墙的工人说：“把送奶箱给我拆了，有事我负责。”工人也不含糊，三下五除二把东西拆了，扔进了门口的垃圾桶。
　　不料，潘经理前脚刚走，老卢后脚就提着大包小包回来了，他往告示栏里瞄了一眼，眉头一皱，加快脚步往楼上走去。不一会儿，只见老卢又急冲冲地跑下楼，指着正在刷墙的工人嚷道：“你们谁把我家的送奶箱拆了？它挂在那里又不妨碍谁，干吗要拆？”
　　这时，潘经理正和一个工头在不远处商量事情，听了这话，他赶忙接过话茬，开玩笑似的说：“是我叫工人拆的，老卢，不就一只破塑料匣子嘛，还当宝贝了，你没看到告示呀？”
　　老卢急得直跺脚：“我去儿子家住了几天，自然没看见！送奶箱现在在哪里？快还给我！”
　　见老卢如此着急，潘经理心里“咯噔”一下：难道这送奶箱里还有什么名堂……糟了，报纸上不是曾经登过有人把送奶箱当“红包箱”搞腐败的事吗？老卢在政府里头上班，听说也是一个小头目，难道有人往他送奶箱里塞红包什么的？
　　想到这里，潘经理感到事情非同小可，一溜烟跑到门口，幸好运垃圾的车没来，送奶箱还在垃圾桶里，他拾起送奶箱摇了摇，可是怪了，里头空空的，没有任何东西。糟糕！要是真有人塞红包，那可就说不清楚了！
　　 
　　潘经理心里嘀咕着，忐忑不安地将送奶箱交给老卢：“刚卸下来还没半个小时，现在完璧归赵！”哪知，老卢接过送奶箱，看也没看，说了声：“谢谢。”就提着送奶箱，一摇三晃地上楼去了。
　　望着老卢的背影，潘经理挠挠头皮，有些闹不明白了：看样子又不像是这送奶箱有“问题”呢。
　　第二天，潘经理吃过午饭，就到小区里征求住户安装电子防盗门的意见。经过老卢家时，他抬眼一瞧，那只送奶箱又挂出来了。
　　这下潘经理纳闷了：这只送奶箱到底派什么用场呢？难道里头真有什么秘密？
　　潘经理太好奇了，便想摘下来看个究竟，哪知，他刚伸手，门“吱呀”一声推开，老卢出来了。
　　潘经理猝不及防，两只手定格在送奶箱上，尴尬好一阵，才结结巴巴地解释说：“安装电子防盗门的事，想征求一下你们家的意见……你、你怎么又把送奶箱挂上啦？”
　　老卢脸一红，轻轻叹了一口气，说：“这只送奶箱其实有一个特殊用场，只是怕你见笑，我一直不好意思告诉你，既然你多次过问，我还是告诉你好了。”
　　老卢把潘经理让进屋坐下，倒了一杯水递过去，一本正经地说：“我有一个八十多岁的老母亲，她不识字，刚来我这里时，经常会走错楼层。后来，妈灵机一动，想起自己不是会剪纸嘛，以前每年春节，家里贴的红彤彤的窗花都是她剪的，妈就亲手剪了一个‘福’字贴在送奶箱上，从此她认准了这只送奶箱，就再也没有找错家门。”
　　想不到一只小小的送奶箱竟有这样的故事，潘经理听了好不感动，不禁对老卢肃然起敬，竖起拇指说：“老卢，你真是个孝子啊！”
　　老卢一听这话，神色黯淡下来，他走到一张小方桌前摇头叹道：“孝子我是愧不敢当，母亲一个人含辛茹苦把我拉扯大，不知吃了多少苦，可是她住不惯城里的高楼，执意要回乡下老家，每年只有过年时，她才肯来这里住个十天半个月……想来她一个人孤零零的，我实在是没有尽到孝道啊！”
　　潘经理走过去一瞧，不禁大吃一惊，只见小方桌上摆满了各式供品，两根蜡烛忽闪忽闪地点着，台上端端正正摆着一张慈眉善目的老太太遗像。潘经理疑惑了，忍不住问道：“老、老人家……”
　　老卢眼圈有些红了：“母亲去年过世了，那时我工作忙，侍奉母亲少，现在有时间了，她又走了……今天是她的忌日，按老家的说法，这一天，新故的亲人会回家看看，所以，我准备了些她生前爱吃的饺子、面馍、芋粉……如果门口没有挂送奶箱，她老人家会找不到家门的……我知道，人死万事空，这只是一种寄托……我保证，今天一过就把送奶箱拆下来好好地珍藏……”
　　潘经理听了这话，有些哽咽了：“老卢，请你原谅，我差一点拆了你的一片孝心和真情啊！”
　　 (题图、插图：刘斌昆)
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第2期   救命之恩  作者：刘自忠  字体：
   【 大  中  小 】 
 
　　宏光制鞋厂是一家不大的企业，老板宾大壮原来也是一个打工仔，多年打拼后，终于开了一家属于自己的厂子，生意还算过得去。
　　这天刚下班，宾大壮还在办公室里忙，突然听到一阵惊呼声，只见会计慌慌张张地跑进门来，叫道：“不好了，咱们厂起火了！”
　　 
　　宾大壮一惊，急忙冲下楼去，果然生产车间里冒起了浓烟，大伙正提着水不断地去浇，可火势太大了，水泼过去，一点用也没有。
　　宾大壮急忙一面叫人报火警，一面迅速指挥抢救。厂子里乱作一团，突然，有个人跑了过来，抢过工人手里的水盆，往自己头上一淋，然后转身就想冲进冒着火的车间。这人叫张小强，是车间里的一个小组长。
　　大伙都吓坏了，急忙将张小强拉住，叫道：“你不要命了，进去会被烧死的。”张小强却一把推开拉他的人，喊道：“不行，我一定要进去！”
　　好在又有几个工人过来，强行将他拉住了。宾大壮一看，火已经将车间入口都封住了，就算冲得进去，也未必能出得来，便也过去劝说张小强：“里面没有人，东西就算再重要，也不会比自己的命更珍贵。”张小强这才罢手。
　　这时，众人将水管拉来了，正对着里面喷水。突然，只见一条人影一闪，飞快地冲进了车间，原来张小强趁人不注意，又冲了进去。宾大壮急得大叫：“张小强，快出来！”工友们也一边大声叫着，一边不断地往门口喷水。
　　过了好一阵，才见张小强踉踉跄跄地从里面冲出来，手中还抱着一个人，他刚冲到门外，就一下昏倒在了地上。大伙立即上去，将他和抱着的人一起抬到了安全的地方。宾大壮上前一看，吓了一跳，躺在张小强怀里的，竟然是自己八岁的儿子宾冰，原来张小强是进去救人的。
　　宾大壮霎时冷汗就下来了，他也来不及多问，立即让工人将两人送去医院。这时，消防队的车子也到了，很快将大火给扑灭了，由于烧的只是一个加工的车间，损失不算太大。
　　张小强只是被熏晕了，到医院一会儿就醒了，倒是小宾冰头上受了伤，还需要在医院接受进一步治疗。宾大壮连声向张小强道谢，还问他怎么会知道儿子被困在里面，可张小强一声不吭，什么也没有说。
　　宾大壮心里不禁犯疑：从张小强当时急着进去救人的情况看，他是知道孩子在里面的，那他为什么不说出来？看来，他是有事瞒着大家，莫非这次的失火与他有关？想到这儿，宾大壮立即对张小强有了异样的感觉。
　　不久，宾冰醒来了，宾大壮就问他当时的情况。孩子说，他放学后在厂里玩，当时大家都下班了，他就从窗口溜了进去，正好看到地上有个打火机，就拿来玩，却不小心将物品烧着了，他吓得想跑出来，因为一时心慌，竟撞到了一台机器，晕了过去。
　　 
　　这样看来，张小强和这起火灾还真没有关系，唯一能解释的就是，他正好看到孩子进了厂房，火灾发生后，便想自己进去救人抢功劳，所以才不说出来。这个张小强，虽然表面英勇，其实也是有私心的。不过，人家毕竟是冒着生命危险救了儿子，不管怎样都要感激。
　　等儿子出院后，宾大壮特意请张小强到饭店吃了一顿，说了一通感激的话，然后拿出一个红包递过去说：“这是我的一点心意，你就收下吧！”
　　张小强急忙推辞：“这事不管是谁遇上了，都会把人救出来的，我这没什么！”
　　宾大壮心里明白，看来这点钱还不能让人家满意，便说：“那么好吧，我就不为难你了，不过你放心，我一定会回报你的。”他想，过段时间，找个机会将张小强提拔上来，也算是还了一份情。
　　很快，就到了月底发工钱的时候，因为火灾烧掉了很多成品，每个人的工作量没法核算，所以这个月不像往常那样是按件计酬的，大家只拿到一些基本的生活费。
　　这下，厂里炸开了锅，很多工人心里都不服，纷纷来找宾大壮说理。人来多了，宾大壮不禁怒道：“工厂受了损失，大家都有份。再说了，我还没追究你们的责任呢，下班后没将门窗关好，这才让孩子溜进去的。”
　　宾大壮是铁了心要赖掉这个月的工钱，尽管他从前也是打工仔，知道打工仔的辛苦，但他更体会到钱的来之不易，不能轻易放出去。
　　这时，张小强也来了，宾大壮看见他，说：“放心吧，你对我有恩，你的钱我一分不少，但其他人的事你就不要管了，谁做了多少工，我已经算不清楚了，怎么给大家钱？”
　　张小强吃惊道：“厂里应该有统计吧！就算被烧掉的部分没法计算，可还有出厂的产品啊，这部分工钱应该发给大家吧。”
　　宾大壮摆摆手说：“我说过，你的钱我一定给，你就别来帮人家说话了，能给他们发些生活费，已经是仁至义尽了，我的损失谁又来赔我？”
　　张小强无可奈何，只得低头离开。走到办公室门口时，他突然回过头来，问：“老板，你不是想知道，我那天为什么会进去救你儿子吗？”
　　宾大壮愣了一下，忙问：“为什么？”
　　“其实，我进去并不是为了救你儿子，”张小强说，“因为，我当时并不知道孩子在里面。”
　　宾大壮吃了一惊，不解地看着张小强，问：“那你为什么还非要进去呢？”
　　张小强叹了口气，说：“我在几家厂子打过工，遇过很多的老板，他们会找各种各样的理由来克扣民工的钱。当时，车间一着火，我马上就想到里面有一本账本，上面有每次生产数量的统计，还有大家的签字，这才拼了命进去的。可等我进了火场，突然发现一个孩子倒在地上，情急之下，只好先救人，也没心思去抢账本了。可以这么说，其实孩子不能算是我救的，应该是那个账本救了他。”
　　宾大壮实在没想到，张小强冲进火场的原因竟然是这个，就是怕他赖了大伙的钱，而自己偏偏真的做了。
　　看着张小强离去的背影，宾大壮呆立许久都没回过神来。他突然想起自己做打工仔时，每到月底拿着工钱时的情形……
　　 (题图、插图：谢颖)
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第2期   给恶人下个套儿  作者：小　可  字体：
   【 大  中  小 】 
 
　　这个恶仆胆大包天，他竟要倒打一耙，状告主子!
　　
　　恶仆欺主
　　
　　北宋时期，山东登州府有一个举人，名叫刘知圣，家境富裕，学业也甚是优异。这年秋风刚起，父母就打发他动身进京，预备来年春天参加朝廷科考，还特地让家仆刘士喜随同前往，服侍左右。
　　 
　　一路辛苦自不必细说。到达京城后，主仆两人便找了家旅馆安顿下来。同旅馆住的，有不少也是进京赶考的书生，刘知圣在埋头用功之余，就和他们聚在一起，或探讨学业，或吟诗赋词。而那些随同的仆人们呢，一来二往地自然也熟了起来，嘻嘻哈哈插科打诨，什么话都说。
　　刘知圣开始倒也没觉得这有什么不妥，可有一天他突然发现，刘士喜晚上没回来，第二天一问，原来是和那些仆人们一起去妓院逍遥了。刘知圣挺生气，数落道：“你怎么能到那种地方去呢？”
　　刘士喜嘀咕说：“公子啊，考状元是你们的事，我们这些做下人的，反正闲着也是闲着，那地方他们都去得，我为什么就去不得呢？”
　　刘知圣更生气了：“再怎么闲着，总不能闲到妓院去吧？听说妓女都是刮骨的刀呢！”
　　刘士喜嘻嘻笑了：“那是吓唬人的。公子，你不知道，妓院那小娘子……嘿嘿，嘿嘿……唉，我们这些下人天天要伺候你们，不去放松放松，只怕是早晚有一天要累死。”
　　刘知圣一时说不过他，只好随他去了。谁知这一来，刘士喜胆子越发大了，只要瞅着空儿，就往妓院里钻，有时候自己吃得满嘴流油，却用两三只冷馒头打发刘知圣。
　　这天早上，刘知圣起床，连叫了数遍，都没见刘士喜应声。一直到了晌午，刘士喜才摇摇晃晃地和几个仆人带着一身酒气回来。
　　刘知圣瞅他那红扑扑的脸，就知道昨夜准是又在妓院宿下了，不由恼怒地大骂道：“天下有你这样做奴才的吗？看来，不把你送开封府找包大人治罪，是万万不成了！”
　　刘士喜没想到刘知圣这回动了真怒，害怕了，再三求饶。但刘知圣怒气难消，一边骂一边真就取来纸笔，当下写了状子，把刘士喜来京城后的种种恶行罗列出来，要将他送开封府。
　　这时，旅馆里那些平日和刘士喜一起厮混的仆人们闻声都围了上来，得知刘知圣要把刘士喜送开封府，想想此例一开，他们今后的日子也不会好过，便纷纷替刘士喜说情，刘士喜也再三发誓保证一定悔改，刘知圣这才作罢。
　　人群散开后，刘知圣瞅瞅写好的状子，想想自己这些日子的遭遇，觉得即使不送刘士喜去开封府，自己且在纸上治他一回，也好消消肚里的气。于是大笔一挥，在状子上判道：该恶奴所犯罪行属实，着打三十大板。写罢，还觉不过瘾，就又“刷刷”一签：包拯。然后将笔一扔，拿起状子左看右看，着实兴奋了一番。
　　
　　反咬一口
　　
　　按说，这事情过去也就过去了。可没想到的是，第二天，刘士喜收拾房间时，看到了这个判词，见主人要打他三十大板，心里很不舒服：不就这么点事吗？三十大板，能把人打死啊！
　　 
　　刘士喜把这事儿在仆人中一说，就有人告诉他，私下以官府名义写判词那是犯罪，告到官府，是要挨板子的。刘士喜昨儿个被刘知圣怒骂后，正为回去以后如何向老爷交差而犯愁呢，听此一说，心想：这不正好是个机会吗？用这事治住了主人，没准他回去就不会再告自己的状了。可这仆人说的到底当真不当真呢？他心里也没底。
　　为了保险起见，这天上午，刘士喜特地悄悄带着那张状子上街，想找个什么人问问。正巧看到一家茶馆门口插着一杆幌子，上写三个字“算如神”，幌子下坐着一位先生，脸瘦瘦的，下巴上有一绺长长的白须，细长的眼睛眯缝着，很有几分仙风道骨的样子。
　　刘士喜心里一喜，就过去给先生作了个揖，说：“先生，小的有礼了！小的想请先生算一卦，看看近日是有灾呢，还是有喜。”
　　那先生上上下下打量了刘士喜一番，捋了捋白须，说：“你是陪家里小主人来京城赶考的吧？”
　　刘士喜大惊：怎么这先生只一眼就看出了自己的身份？于是赶紧回答：“在下正是，还望先生给算上一算。”他边说边从怀里摸出一锭银子，递给先生。
　　先生把银子拿在手里掂了掂，鼻子里“哼”了一声：“你想做大事，这点银子怎出得了手？”
　　刘士喜心里越发惊讶：他怎么连我心里正在琢磨的事都知道？是啊，仆人要告主人，这事情还不大吗？于是赶紧又掏出一锭银子，恭恭敬敬地递上，说：“区区碎银，不成敬意，求先生给在下一颗定心丸。”
　　先生这才“嘿嘿”一笑，手捋白须，缓缓说道：“你现在印堂半边发青、半边发亮，成败皆在两可之间，看在这银子的面上，老夫决定推你一把。你且把事儿从头说来老夫听听。”
　　刘士喜大喜，立即就把状子递上，把刘知圣要送他见官打板子的事情，和仆人告诉他的话，都一五一十地说了，至于他自己的那些事儿，自然不提。
　　先生把状子仔仔细细看了一遍，点头道：“私自写下此等判词，的确有违朝制，送到官府，挨板子无疑。开封府包拯从来嫉恶如仇，如若你真是被冤枉的，告上去，只怕你家小主人的屁股会被板子打烂！”
　　刘士喜闻听此言喜笑颜开，迫不及待地抢过先生手里的状子，就一路狂奔来到开封府，摘下大门口的鼓棰，把个鸣冤鼓敲得“咚咚”响。
　　
　　顺水推舟
　　
　　 
　　此时，包拯正在府内批阅公文，一听大堂外鸣冤鼓响，立即命人将击鼓人传上堂来。刘士喜进门给包拯一跪，双
　　手高高举着状子，说：“青天大老爷，小人有冤啊！”
　　包拯道：“有何冤屈，快快说来。”刘士喜说：“大人啊，我家小主人刘知圣是个进京赶考的举人，小的一心一意侍奉他，可他却私冒大人之名，要打小人三十大板。小人冤枉啊！”
　　包拯命人把状子呈上来，从头到尾看了一遍，沉吟片刻，将惊堂木一拍，大声喝道：“胆敢私冒本官下判，简直岂有此理！来人呀，把他给我带来，本官要细细查问！”喝毕，见师爷公孙先生踱上堂来，便和他耳语起来。
　　说话间，刘知圣就带到了。刘知圣一个举人，哪里见过这种阵势，他刚才正闭门诵读四书五经，突然开封府来带人，还以为是搞错了呢。此刻，他见刘士喜跪在一边，满脸得意之色，方知是这奴才告了自己。只是，他好生迷惘，不知刘士喜为何告自己，告的又是什么？
　　包拯命人把状子给刘知圣看：“这可是你亲笔所写？”刘知圣接过一瞅，点头说：“正是小人所写。”
　　包拯脸色一沉：“你身为举人，可知道私下判人有违朝制？”刘知圣吓得脸都白了：“大人，小人并不知道！否则，哪里敢做出此等违法之事？”
　　包拯瞅瞅一副书生模样的刘知圣，继续追问：“你为何如此重判你的下人？”刘知圣直摇头：“大人啊，只因他太不像话……”于是，便一五一十把刘士喜的不是说了一遍。
　　包拯转眼瞪着刘士喜：“你家小主人说的可是实情？”刘士喜忙喊道：“大人啊，陪同主人来赶考的仆人何止上千，哪个不是这般行事？又不单我一个。可冒充大人您私下处罚仆人的，大概除了我家主人，不会有第二个了吧？大人，您要不处罚他，小的可是万万不服啊！”
　　包拯微微一笑：“那按你的意思，该如何处罚他啊？”刘士喜兴奋地回答说：“那就请大人把他判我的三十大板，仍然打回到他屁股上去吧！”
　　“哈哈哈哈！”包拯朗声大笑起来，转而对刘知圣点点头，说：“你眼下虽说还是待考的举人，可下的判词却正中我意，看来，你很有办案的天赋啊！”
　　说着，包拯把那张状子递给师爷公孙先生，嘱道：“你且照此念一遍吧！”公孙先生立即应声照念起来。
　　念到后面“着打三十大板”时，包拯对刘士喜道：“其实本官早就风闻你等恶仆欺凌主人甚是嚣张之事，有心想压压此等歪风，只是苦于没有合适的机会，所以本官便派师爷和手下一干人，乔扮各色人等出去查探。没想今天‘踏破铁鞋无觅处，得来全不费工夫’，你自己送上门来了！”
　　包拯说到这里把黑脸一沉，喝令左右：“还不快快动手，把这恶仆给本官结结实实地打三十大板？”
　　刘士喜一下瘫倒在地，正好对上公孙先生的眼睛，发现这师爷可不就是那个“算如神”先生吗？怪不得刚才听他的声音好生耳熟，原来他是故意装成算命先生，去打探情况的，自己是中了圈套了。
　　三十大板可不是吃素的！待两边衙役将刘士喜按倒，亮出屁股，“噼噼啪啪”三十响之后，刘士喜已经哭不动、嚎不动，身子更不能动了。
　　包拯放眼瞅瞅，道：“你这恶仆，回答本官，回去之后改不改了啊？”刘士喜头点得跟鸡啄米似的：“小的记住了，小的以后再也不敢了……”
　　包拯又转过脸，对刘知圣道：“日后万不可再私下里写这种判词了，不知者不为过，这次本官就不责罚你了。只要你一心向学，将来有你断案的时候。不过，你也得记住本官一句话：当官要以民为天，万万不能徇私枉法啊！”刘知圣连连点头称是。
　　 (题图、插图：黄全昌)
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第2期   偷天陷阱  作者：刘振涛  字体：
   【 大  中  小 】 
 
　　一次浪漫的邂逅，让她重新找回了少女的情愫，不想这却是一场生死较量的序幕……
　　
　　欲擒故纵
　　
　　世上总没有十全十美的事情。美智子虽然年轻、漂亮又有钱，可她觉得自己很孤独，丈夫忙于工作应酬，常常没有时间陪她。一个人的时候，她经常去酒吧打发时光。
　　这天，美智子来到一家酒吧，刚找了张空位子坐下，就有一个醉醺醺的小平头走过来，大大咧咧地坐在她的对面：“啊！蛮漂亮的！我陪你喝一杯怎么样？”说着就动手动脚的。
　　这时，一个高个子男人走过来，大声对美智子说：“老婆，我等你半天了，怎么才来？”小平头见来人比自己高出半个脑袋，知趣地慌忙离开。
　　高个男人自我介绍说：“我叫伊藤，刚才多有得罪。”美智子不禁怦然心动，这男人不但英俊潇洒，还带着种武士般的彪悍，很有男人味，自己正因为丈夫去神户出差一个月而无聊呢，没想到碰上这么一出。她嫣然一笑，颇为感激地请伊藤坐下，说：“怎么会呢？刚才还要谢谢你呢。”
　　 
　　聊起来才得知，伊藤不但单身，而且兴趣爱好竟和美智子那么的相似。两个人一直聊到深夜，俨然是一对老朋友了。相互留了电话后，伊藤提出送她回家，美智子没有拒绝。当送到住处的楼下时，伊藤吻了她。
　　接下来几天，伊藤却神秘地失踪了，美智子顿时有一种强烈的失落感。就在她忍不住要给伊藤打电话时，伊藤却突然出现在她的楼下，美智子仿佛受了委屈一般扑进他的怀里。这天，两人都喝了不少酒，美智子本以为伊藤会拥抱、亲吻她……然而，伊藤却很有礼貌地离开了她的房间，这下美智子更爱慕他了，但又羞于开口把他留下来，只好企盼下一次的相逢。
　　美智子却不知道，伊藤从她家出来，就和小平头碰了面，商量了一会，他带着诡秘的笑，和小平头分开……
　　深谙女人恋爱心理的伊藤，吊足了美智子的胃口。第四天，他给美智子打电话，约她到著名的海滨山庄去游玩，美智子欣然应允。
　　虽然她隐隐感觉有些对不起丈夫，丈夫当初发达时，为了以示忠诚，为自己买下了近千万日元的意外保险，受益人是妻子！美智子着实感动了一阵子，可没过两年，丈夫居然在外面有了私生子，美智子的心伤透了，想到这，她仿佛有了底气，理直气壮地踏上了旅程……
　　海滨山庄位于一处偏僻的海湾，是情侣幽会的最佳栖息之所。白天，他们爬山、嬉水；晚上，更是无尽的缠绵……
　　数日后，回到家里，伊藤俨然成了男主人，看着美智子忙前忙后的，自己则耳朵里塞着音乐播放器的耳机，一边听《索兰调》，一边打着拍子……
　　
　　蓄谋已久
　　
　　伊藤离开后，美智子每次回忆时都会轻笑出来。不过，伊藤没有再找她，只是偶尔通下电话，说几句就挂了。
　　隔了几天，美智子突然收到一封信，里面装有二十多张照片，竟是她和伊藤在海滨山庄里幽会的画面。美智子顿时花容失色，她急忙给伊藤打电话。不一会儿伊藤就赶来了，气呼呼地把一个信封摔在桌子上，美智子打开一看，信封里装的和自己收到的一模一样，就连打印的勒索信都一字不差，信上说：
　　 
　　“你是有身份、地位的人士，你比我更清楚这些照片散布到网上是什么后果！只有一个小要求，200万日元，这点钱对你来说是小数目。请在明晚十一点，把钱放进深井街的第二个垃圾箱内，如果报警，后果自负。”
　　美智子手足无措，不禁嘤嘤地哭了起来，伊藤却心有不甘：“200万，我们两个加起来就是400万元啊！不行，必须报警！”
　　美智子却猛地抬起头，说千万不能报警，伊藤为难地说：“可……我只有三十多万啊！”说着，他掏出一个纸包放在桌子上。
　　美智子定定地看着伊藤，泪水滚落下来：“我这里有些私房钱，你拿去吧，”说着，回到卧室，拿出一部分现金和两张卡，“我下午就去取出来。”
　　伊藤沉思一会儿：“不能这样听任摆布！这样，到时候你去放钱，我提前躲在暗处，找机会跟踪勒索我们的人，你看好吗？”美智子犹豫了，最后还是点点头：“你可要小心啊，这些人心狠手辣，没有人性的。”
　　看着美智子幽怨的眼睛，伊藤一把抱住她：“钱你暂时先垫上，我一定会还给你的。”美智子依偎在他的怀里，漂亮的嘴角很不自然地抽动了一下。
　　这时，楼下响起熟悉的汽车喇叭声，美智子突然一惊：“我丈夫回来了，你快走！我们再电话联络……”
　　丈夫告诉美智子，公司那边出了点小麻烦，收拾点东西马上就要走。美智子已经习惯了他逼真的谎话，也并不在意，何况自己还有事要处理。
　　忽然，美智子灵机一动，一个蓄谋已久的计划在脑海深处清晰了……
　　
　　工于心计
　　
　　第二天晚上十点左右，美智子打电话给伊藤，让他马上过来。伊藤很快赶到，两个人商量了一下，一切按计划行事。
　　伊藤提前十分钟绕道来到指定的垃圾箱对面，在一处拆迁的废墟后面藏起来。他给小平头打了个电话，小平头这时开着一辆破面包车，已经在另一条街等候了。
　　不久，美智子的车缓缓停在垃圾箱跟前，她四下打量了一下，飞快地把一只黑色的大号皮包扔进垃圾箱里，然后上车急促地开走了。
　　伊藤心里暗自高兴，早知道这么轻松就能拿到钱，真不该通知小平头，他后悔之余，下意识用力地握了下拳头。
　　这时，小平头已经把车开过来停下，动作迅速地抓起皮包，伊藤也从废墟里冲出来，一个健步跳上车，然后车子飞速地驶出市区。在街道另一头，一个身影晃了一下就消失了。
　　在市郊的一个水库大坝上，可以借着月光看到很远的景物，这是伊藤和小平头事先说好的地点。车熄火后，小平头拎着皮包下车，还没走两步远，头上便挨了一下，栽倒在地。
　　 
　　伊藤扬起扳手冷笑道：“混蛋，我一个人花了这么大的心思，却要分你一半的钱，太便宜了吧？”他打开皮包仔细地检查了一遍，都是货真价实的钞票，伊藤的眼睛都绿了。然后，他把小平头弄上车，把车开到了大坝的边缘停住，说：“龟田君，对不起，以后每年我都会拜祭你的。”说完，用力把那辆破面包车推了下去……
　　伊藤回到美智子的住处，沮丧地说自己看到一辆面包车，想跟踪却无法靠近。美智子微笑着，从床下面掏出一把乌黑的手枪对准了他。
　　伊藤慌了，一边大叫着，一边快速移动脚步，想伺机夺门而逃。
　　美智子看出了他的企图，挥着枪口说：“那道门你是打不开的，而且我丈夫把房子全部都装了隔音壁，即使你喊破了喉咙，也是没用的。”顿了下，美智子平静地看着他，“其实，从海滨山庄开始，我就感觉到了你的意图，我故意让你达到目的，你们拿走钱的时候，我就在不远处看着你。”
　　伊藤深深懊悔自己的大意，他这才知道美智子是个有心计的女人。现在，想伺机夺枪不大可能，弄不好这个狠毒的女人真的会把自己干掉。
　　美智子停了一会儿，说：“我知道你还有个同伙龟田君！没想到吧？我从你的手机里追查到并收买了他，想让他干掉你，再把我丈夫的死嫁祸给你，但他一直没有和我联系，我知道，一定是你把他杀了！”
　　伊藤做梦也想不到这个漂亮女人有如此的心机，他突然感觉美智子浑身有一股杀气渗透出来：“美智子，是、是我错了，我、我把钱都还给你，行、行吗？”
　　“行！”美智子回答得很痛快，“只要你帮我一个忙，那些钱还是你的。”
　　“行行行！”伊藤点头如啄米，“只要你放过我，十个忙我都帮！你尽管吩咐！”
　　
　　同归于尽
　　
　　美智子指着高大的衣柜，命令伊藤打开。伊藤照做了，一看却大吃一惊，里面居然是美智子的丈夫，手脚被绳子绑着，嘴上贴着胶带，肥胖的身体被憋得大汗淋漓。
　　美智子痛苦地看着丈夫：“哪个女人能忍受自己的丈夫和别的女人生下孽债？我能接受私生子来分割我的财产吗？你的所有财产都是我的，你的千万意外保险金也是我的，谁也不能拿走一丝一毫！”
　　美智子似乎变了个人，歇斯底里起来，突然，“砰砰”两声，她对着丈夫的心窝连开两枪，枪声震得伊藤耳鼓嗡嗡作响。
　　伊藤从没见过像美智子这样的漂亮女人开枪杀人，那种狰狞不该出现在一张娇媚的脸上。伊藤有些颤抖和恐惧，这是从未有过的惊恐。
　　其实，美智子早就有此打算。当她得知丈夫在外面有了私生子后，她意识到自己的婚姻将会发生质变。首要的事情，是把所有的财产握在自己的手心里。于是，美智子一直在暗暗筹划着……
　　恰巧此时，伊藤闯入了美智子的视线，当她发现伊藤的企图后，便马上买通了龟田，并允诺说，只要干掉伊藤，赃款全归龟田，另外再加200万把骗回来的丈夫杀掉，嫁祸给伊藤。
　　美智子的如意算盘是：等龟田办完了事，一定会出逃，到时把这个活口灭了不会太费事，却不料伊藤见财起意先把龟田干掉了，现在只有自己动手来完成全部计划了，美智子谋算过，应该不会留下破绽……
　　美智子命令伊藤：“快！把他的绳子解开，血如果不流通，会把绳子的勒痕留在上面的。”
　　伊藤用有些发抖的手解开绳子，美智子把枪扔给他：“我打不准，你再补两枪！”伊藤接过手枪后，镇定了许多，狞笑着对准了美智子：“真是最毒妇人心啊，你想嫁祸给我？你太小看我了。”说完，扣动了扳机。
　　“咔”，居然没有子弹了，伊藤刚要扑过去，美智子手里不知何时多了一把小巧的手枪，伊藤的身形顿时定在那儿，一动不敢动，面如死灰。
　　美智子哈哈大笑：“我连丈夫都防，会不防你吗？”说完，一连串的子弹穿进伊藤的胸膛，“谢谢你的勒索，你帮我大忙了，伊藤君！”
　　伊藤紧紧握着空枪，嘴唇翕动着，眼睛直勾勾地看着天花板，高大的身躯向后轰然倒下……
　　美智子把小手枪上的指纹擦干净后，用布裹着，塞到了丈夫的手里。然后，她把头发弄散，打开窗户，便突然凄厉地痛哭起来，边哭边拨打报警电话。
　　警方赶到后，美智子再一次哭得晕了过去，在场的人不由跟着落下同情的泪水。为了防止她再度休克，警方安排美智子住进了医院。
　　然而，让美智子没有想到的是，在清理现场时发现，伊藤衣袋里的音乐播放器还在工作着，那是已经打开的录音状态……
　　 (题图、插图：佐夫)
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第2期   ３分钟典型故事  作者：佚名  字体：
   【 大  中  小 】 
 
　　亲情的力量
　　小宝家有只老山羊，生了二十几只小山羊，便理所当然地成为羊群的头羊。每天，小宝放学后，都要赶着羊群到山坡上去吃草。老山羊总是昂首挺胸地走在最前面，如果有哪只羊脱离队伍了，老山羊严肃地“咩咩”一叫，那只羊准会乖乖地回到队伍里去。
　　不久，小宝家里盖了个新羊圈。这天，小宝打开栅栏，想把羊都赶到它们的“新家”去。
　　谁知老山羊还以为是赶它们去吃草呢，带着羊群出了院门向山坡跑去。小宝一下子急了，跑到老山羊面前，抓住它的角使劲往回拽，可老山羊的力气太大了，它倔强地就是把头扭向山坡的方向。
　　小宝心想：要想把羊群顺利地赶到新羊圈，必须由这个头羊来带领。于是，小宝拽住老山羊的角狠命地拉，谁知老山羊和他较上了劲，四肢用力，一抖脖子，把小宝摔了个仰面朝天。
　　 
　　这时，母亲走过来拍拍小宝身上的土，说：“你不能硬拉！”说着，她指着一边刚刚生下不久的小羊羔说，“你试试看，抱着小羊羔走！”
　　小宝依言抱起一只小羊羔往新羊圈走去。小羊羔“咩咩”地叫着，老山羊一声声答应着紧追不舍，后面的羊群纷纷跟了上来，小宝终于顺利地把羊群领进了“新家”。
　　在力学原理中，力有大小，但再大的力也无法与亲情的力量相比，因为亲情的力量是无穷大的。
　　 （作者：杨启范）
　　
　　积攒温暖
　　儿童福利院里，珍妮正带着十几
　　 个孩子在做游戏，孩子们似乎在向她报告什么，这个说阿姨昨天亲他了，那个说收到小朋友送给他的画。
　　有人问珍妮：“你们在玩什么呢？”珍妮微笑着，说：“我在教孩子们积攒温暖。”
　　“积攒温暖？”
　　“是啊，”珍妮说，“这些孩子小小年纪就成了孤儿，生活对于他们而言就像冬天一样，所以我想教会他们积攒温暖，将平时人们给予的一点一滴的温暖积攒起来，慢慢地心里就会有一轮太阳。”
　　珍妮又说起了自己的故事。原来，她是个私生女，从小在白眼中长大，男孩子欺负她，女孩子孤立她，她的亲人们，总是嫌她是家族的耻辱。
　　但是，珍妮记得更多的，却是那些曾经温暖了她的人和事。
　　她说那个揪她辫子的男孩，有一次竟然在她的衣兜里放了两颗奶糖；
　　总是拿她当出气筒的舅舅，出差带回来两条一模一样的漂亮裙子，一条给表姐，而另一条，竟然是给她的；
　　她的外公，那个爱面子的老人，一看到她就会黑下脸来，临终时，却殷殷嘱咐家人一定要供她上大学。
　　说到动情处，珍妮哽咽了。她说，自己真的很感激生命里的这些温暖，让她慢慢地感到了生活的美好。
　　积攒温暖，这应该是我们听到的最美好的一个词。
　　 （作者：梧桐听雨；推荐者：雨烟）
　　
　　只撞三次钟
　　几个人在风景区游玩，在一处凉  亭歇脚休息时，大家看见这个亭子的正中，悬挂着一口巨钟。
　　小高很是感兴趣，便询问起撞钟的价格来，看钟的老者回答说：“撞一次两块钱，你就撞三次吧！”
　　小高连忙把六块钱交到看钟人的手里，然后运足力气用那根悬挂的圆木撞钟。每撞一次，钟声悠然间，便听看钟人跟着喊一声：“一撞身体棒……二撞保平安……三撞财运旺……”
　　很快，三次钟已经撞完了。这时，小高发现看钟人正在与其他游客闲聊，便乘其不注意，又多撞了一次。
　　小高正在暗暗自喜，看钟人却突然回过身子，对他喊道：“怎么能撞四次呢？这个便宜是不能赚的，你刚才的三次等于白撞了！”
　　小高一脸不解地问道：“为什么不能撞四次，有什么说法吗？”
　　看钟人笑道：“四大皆空嘛！”周围的人听了，全都哈哈大笑起来，只有小高面红耳赤地呆立一旁。
　　贪念产生于一瞬间，如果付诸行动，就有可能在瞬间，把原本拥有的一切输得精光！
　　 （作者：清山；推荐者：阿朱）
　　 (本栏插图：安玉民梁丽)
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第2期   真的不是这块料  作者：书　剑  字体：
   【 大  中  小 】 
 
　　望子成龙的心情固然可以理解，但也要想想，自己的孩子是不是这块料啊！
　　
　　有一户人家，姓马，是方圆百里数一数二的有钱人家，山坡上骡马成群，山庄里佣仆如云，再快的马跑上一袋烟工夫，也跑不出他们马家的地界。
　　 
　　按说这样的人家，过日子还有什么愁的！可偏偏不，你看男主人马大海那张老脸，整天拉得比马脸还长。原因嘛，说起来也简单，是被他的宝贝儿子马雄气的。
　　马雄这名字听起来挺有气势，人却是个草包。打小起文武老师给他请了一大堆，可马雄今年都二十岁了，却还是文不能拿笔、武不能提刀。
　　尤其让马大海发愁的是，这小子胆子特别小，看到山坡上成群的骡马，居然吓得直往人后躲。唉，眼看自己越来越老，保不定哪天就撒手归西，儿子这熊样，偌大的家产怎么放心交给他？
　　马大海想来想去，总觉得要想个狠招儿，让马雄威猛起来。
　　这天，马大海在自家山庄转悠，经过山背后那座屠宰场时，不由心里一动。这个场子才建不久，专门屠宰那些不能再劳作的老牛老马老驴老骡。平日里，这儿畜生的惨叫声不绝于耳，一般人都不会想到这里来，更不用说马雄了。马大海心想：我何不把儿子放到这地方来栽培栽培？
　　于是，马大海把马雄领进屠宰场，绷着脸说：“从今天开始，你天天在这里给我看着他们干活，学学怎么做我们马家的男人。听到没有？”马雄吓得簌簌发抖，可老子的威势根本不容他反抗，只能战战兢兢地答应。
　　不一会儿，马雄就看到一个赤膊大汉提着铁锤，三步两步走到一匹老马跟前，那老马仿佛知道自己就要挨刀子似的，眼眶里溢满了泪水，“扑通”朝大汉跪下来。可大汉脸上毫无表情，扬起手中的铁锤就朝老马脑门砸去。老马还没来得及“哼哼”，就踉跄倒地。随后，那大汉扔了铁锤，换过一柄锋利的钢刀，就开始给老马开膛剖肚、剥皮取肉。
　　马大海不动声色地看着这一切，可一旁的马雄却恶心得“哇哇”吐了一地。马大海呵斥道：“你看也得看，不看也得看。”又吩咐管家说，“你给我盯着少爷，让他天天在这儿看着！”
　　一晃过了十多天。这天，马大海悄悄来到屠宰场，正好有个大汉在杀牛，那场面比杀马更加血腥，马大海偷眼看马雄，发现他正睁大眼睛看着，而且居然还要管家给他泡杯茶来。马大海心里一宽：在这种场合还有心情喝茶，可谓小成了！
　　马雄见马大海来了，屁颠屁颠地跑过来，嚷着：“爹，你让我看到啥时候啊？我都看厌了！”
　　马大海点点头说：“好啊，爹就等着你这句话，从今天开始，你不必再看了。”马雄大喜。
　　谁知马大海接着又说：“不过，你得给我学着动手，什么时候你也会这套功夫了，爹就放你回家。”
　　马雄一听，伤心地哭开了：“爹，动刀子我可不敢啊……”马大海理也不理他，背起手就走了。
　　又过了十多天，马大海叫来管家，问：“少爷怎么样了？”管家苦着脸说：“老爷，畜生没宰成，少爷自己倒尿了一裤子。小的斗胆说一句，少爷他、他真的不是这块料啊……”
　　 
　　马大海一听，猛拍桌子，瞪眼喝道：“你说什么？你敢小瞧少爷？你想让他永远这副熊样，等我老了好让你欺负是不是？”
　　管家吓得叩头如捣蒜，“噼里啪啦”猛抽自己嘴巴：“小的该死！从今往后，小的一定盯紧少爷！”
　　一晃又过了十多天，这天管家得意洋洋地来向马大海禀报，说是少爷现在和以前大不一样了，请老爷过去看看。马大海大喜，连忙赶去屠宰场，果见马雄锤马杀牛都不在话下，动作凶猛彪悍，连眉头都不皱一下。
　　马雄神气活现地对马大海说：“爹，现在我总可以回家了吧？再在这儿待下去，我可真要闷死了！”
　　谁知马大海还是摇头：“你小子真想回家，就得再给我动一次刀子。”
　　马雄不屑地说：“这有什么难的？畜生在哪儿？快快牵来！”
　　马大海一挥手，有人将畜生牵了来，马雄一见，惊得面如土色：“爹，这是我的心肝宝贝，使不得啊！”
　　原来牵过来的是一匹性格温良、长相俊美的小白马，它可是马雄一手喂养长大的。小白马与马雄已多日不见，今天乍一见主人，高兴得就想过来亲热。
　　马雄“扑通”一声跪倒在马大海面前，泪流满面地喊道：“爹，你要我杀什么都可以，就是不能杀它啊！爹，你就饶了它吧！”
　　马大海气得脸色铁青，朝马雄吼道：“你小子太让我失望了！你对畜生都存仁慈之心，将来怎么能打理我们马家的祖业？你给我听着，今天要是不给我杀了这畜生，就再也别想做我们马家的人！”
　　马雄呆呆地站着，好久好久，突然他猛地仰天一声喊，举起手中的铁锤狠狠地朝小白马的脑门砸去……再回转身来的时候，他的眼神已近乎疯狂，咬牙切齿地问马大海：“爹，还要杀什么，你说，我还想杀！杀！”
　　看着儿子这副豁出去的样子，马大海心里非常得意……
　　回家以后，马大海正在考虑接下来该怎么进一步训练马雄，忽听大门外传来管家不要命的喊叫：“老爷，老爷，不好啦！出大事啦！”
　　管家跌跌撞撞地跑进来，见了马大海腿都软了：“老爷，不好啦！刚才您前脚走，少爷后脚就上街去了，没来由地和人家吵架，结果、结果……”
　　“咣啷”一声，马大海手中正拿着的算盘掉到地上，珠子滚了一地。他抓住管家急问道：“结果怎么了？快说！”
　　管家哭丧着脸说：“结果少爷狂性大发，一锤砸在人家脑门上，当场就把人家给砸死了。现在他……他已经被官府逮了去……”
　　 (题图、插图：谭海彦)
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第2期   刺杀少佐  作者：李志明  字体：
   【 大  中  小 】 
 
　　“什么意思？”耿爷不解。
　　只见川岛从怀里亮出一把手枪，在耿爷眼前晃了晃：“今夜若不是先生您在场，他根本就走不出这个屋子！”
　　耿爷一怔，正好与川岛得意的眼神相遇，他心里吃惊不已：这个川岛，看上去温文儒雅，原来竟如此工于心计？自己与他朝夕相处，竟不知他时刻枪不离身。耿爷此时才意识到，川岛其实正是危险的敌人！
　　这一夜，耿爷彻夜未眠。第二天，听说鬼子并未抓到罗大虎，他悬着的心才放下来。此后月余，耿爷依然尽力施救川岛，为他消除肿胀，但效果都不明显。
　　这天，耿爷对川岛说，他想用穴位按摩的办法试试，川岛因为见识过耿爷阻挡罗大虎打枪时的点穴功夫，一听就高兴地说：“太好啦！按摩是中医一绝，我正想请教先生呢！”
　　自此，耿爷一日三次给川岛按摩，一边按摩，一边还给他讲解每个穴位的作用。
　　数天后，按摩作用显现，川岛的肿胀减轻许多，病情明显好转。
　　
　　生死抉择
　　
　　 
　　这天晚上，川岛告诉耿爷，第二天他有任务外出，只能暂时中断治疗了，耿爷一时无语。
　　第二天一大早，接川岛的车还没来，倒是耿爷的儿子带着全家上了马车。川岛问他们要去哪里，耿爷淡淡地说，去后山三清观还愿。
　　耿家人走后，耿爷对川岛说：“你身体还未完全康复，四处奔波定会加重病情。不如趁现在等车的工夫，老夫再
　　给你做一次按摩吧？”耿爷的关切之情溢于言表，川岛心里热乎乎的，欣然同意。
　　也许是因为川岛要走，耿爷显得有些心事重重。川岛问他怎么了，耿爷一声叹息：“川岛，你是个医学奇才，我儿子远远比不上你啊！如果你潜心学医，老夫定会全力成全，你将来的成就决不在老夫之下。你干吗要拿武器杀人呢？你的手本该是替人诊脉开方的啊！”
　　自打结交以来，耿爷从来不和川岛谈论医学以外的话题，所以听了耿爷今天这番话，川岛不由一愣。
　　不过耿爷如此评价自己，川岛还是有点沾沾自喜，便说：“承蒙先生器重！学生这些日子从先生这里获益匪浅，也正想把自己所学传授给我们军……”川岛正说着，突然发现自己说漏了嘴，赶紧打住。他看到，耿爷的脸黑了下来。
　　耿爷在川岛肩上轻轻一按，摇摇头说：“可惜，你没有机会了！”
　　川岛一听这话，顿时汗如雨下。他想站起来，可四肢绵软无力，竟动弹不得，不由惊愕道：“先生要杀我？”耿爷沉脸不答。
　　其实，自打发生罗大虎那件事后，耿爷就已经下定决心，不让川岛活着走出自家院门，但为了全家人的安全着想，他得找个合适的时机。昨晚川岛说要走，耿爷就料定守卫的鬼子会因此放松对家人的看管，于是便让儿子一早带着全家先一步逃离，自己则留下来完成最后的心愿。
　　川岛不懂：“先生既然倾力救我，为何又要杀我？”
　　耿爷回答说：“一来你是老夫的学生，二来你是老夫的病人，全力施救是老夫行医的信条，所以老夫要救你；可你又是老夫的敌人，所以老夫不得不杀你！”
　　川岛愤愤道：“先生，没有我，您全家早已命丧黄泉，您杀我是忘恩负义啊！”
　　耿爷仰天长啸：“可如果让你活着出去，我们的抗日游击队就会蒙受重大损失啊！”
　　……
　　片刻，龟田赶到了，他跳下车，一头扑进屋子，看到川岛正沉沉大睡。龟田大吼着，让川岛赶快起来，然而，任他怎么吼叫，川岛就是一动不动。龟田这才知道大事不好，冲出屋子要找耿爷算账，却发现耿爷神情淡定地站在屋檐下，眺望着远方……
　　 (题图、插图：谭海彦)
　　 
[ 1 ] 2        
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第2期   刺杀少佐  作者：李志明  字体：
   【 大  中  小 】 
 
　　是情义相投的师生，是彼此信任的知己，更是不共戴天的敌人……
　　
　　莫逆之交
　　
　　云山镇有户姓耿的人家，三代行医，深通岐黄。尤其是到了耿爷这第三代，名声更是如雷贯耳，寻常小病自不必说，就是各种疑难杂症，到了他手里无不药到病除。
　　这天，耿爷正在院子里练八卦掌，儿子突然慌慌张张来报，说是驻扎在镇上的鬼子少佐川岛正在前厅等候。耿爷心里一惊，十天前他曾被请去山里，为抗日游击队队长罗大虎治病，莫非此事被鬼子知道了？
　　耿爷心神不宁地来到前厅，不料川岛见了他深深一鞠躬，让随从奉上包装精美的锦缎和醇酒，说：“小小礼物，不成敬意，请先生笑纳。”
　　耿爷吃不准川岛这是什么意思，说：“老夫治病从来只收诊金不收礼物。说吧，你哪儿不舒服？”
　　川岛笑道：“先生，我不是来看病的，而是专程拜访您的！我非常喜欢中医，并一直在研习。但中医实在太深奥了，有很多地方不得要领，希望能得到先生您的指教。”
　　耿爷听了不禁哑然失笑：中医是我们中华民族的国粹，博大精深，你们杀人放火的鬼子懂什么？但川岛根本不理会耿爷对他的蔑视，开始侃侃而谈自己接触过的一个奇怪病例，竟说得头头是道。
　　 
　　耿爷不由来了兴致，说：“看来你对中医的确做过一番研究。不过，中医重在实践，不知你脉切得如何？”说着，有意伸出胳膊试他一试。
　　川岛丝毫没有怯意，像模像样地用食指、中指和无名指分按耿爷胳膊上的寸、关、尺三部，轻按一下，又重按一下。在查看了耿爷的舌苔后，颇有把握地说：“先生舌苔薄白，脉象浮紧，症状应为外感风寒，所以现在可能会感到头痛，身体发冷。不知我说得对不对？”
　　耿爷轻捻长髯不语，心里却暗暗吃惊。因为他昨晚的确受了凉，早晨起床后就感到头有点沉，刚才在院子里练八卦掌，就是为了发汗驱寒。看来，这家伙肚子里还真有些东西呢！
　　不过，耿爷可不想和鬼子交往。川岛似乎看出了耿爷的心思，也不说穿，却掏出一张发黄的纸，恭恭敬敬奉上。
　　耿爷疑惑地问：“这是……”
　　川岛说：“先生，这是我从长白山一位药农手里买来的，是专治跌打损伤的秘方，送给先生，万望笑纳。”
　　耿爷一听立刻摇头：“既是秘方，不可轻易向人展示，请阁下带回珍藏。”
　　谁知川岛淡淡一笑：“秘方本来就是治病救人的，知道的人越多，救的人不也就越多吗？我还有其他几种秘方，改日带来给先生。”
　　川岛这番话，在耿爷心里掀起一阵涟漪。医家从来都把秘方视为生命，就是耿爷自己，可以施医、施药、施金钱，但决不会把秘方施与他人。川岛的话，让耿爷自愧不如。耿爷不觉在心里对他生出一份好感。
　　从此，川岛就经常来耿爷这里登门拜访。每次来，他都不穿军装，完全是一副青年学者的儒雅作派。据川岛自己说，他十二年前毕业于东京医科大学，到中国后，一次偶然的机会领略到中医的神奇，从此便迷上了。
　　因为既懂西医又对中医颇有研究，所以谈吐之间，川岛的不少见解都令耿爷有“耳目一新”之感。耿爷从中获益匪浅，渐渐地，也就真把川岛视为门生，悉心加以指点。
　　
　　以毒攻毒
　　
　　这天早上，耿爷正在前厅整理自己的行医资料，就见日军司令官龟田带着一队鬼子兵抬着副担架匆匆进来，耿爷一看，躺在担架上的人竟是川岛，他头肿如斗，蜷曲着身子，一副痛苦不堪的样子。
　　原来川岛昨夜突然发病，鬼子军医给他打针、吃药折腾了一夜，却丝毫不见好转，川岛便要求将他送到耿爷这里来。
　　耿爷立即为川岛诊脉，对他说：“你现在的脉象十分杂乱，当不止一种病，除了急性痹症外，还有不明原因的肿胀。当务之急，先治痹症，减轻疼痛，然后再对付肿胀。你以为如何？”
　　川岛不住地点头：“我信任先生，先生只管放手治吧！”
　　耿爷又凝神细细思索一番，然后开了一个方子，让儿子去抓药，抓来后，又亲自下厨煎熬。正要端给川岛去喝时，儿子神色紧张地进来对耿爷耳语道：“爹，鬼子在咱家门口设了岗哨，不准外人进，也不准咱家人出。”
　　耿爷心里不由一沉，看来治好川岛的病便罢，万一治不好，一家老小难逃一死。
　　耿爷正要对儿子说啥，不料龟田后脚也走了进来，阴森森地对耿爷说：“少佐如此信任你，你不会在这汤药里做手脚吧？”
　　耿爷冷冷回道：“凡上门求医者，我都会尽心医治，更何况他还是我的学生呢！”
　　龟田点点头：“这就好！我可以告诉你一个秘密，你曾给游击队长看过病，我们本来要抓你的，是少佐坚决不让，他说留着你不会影响我们的圣战，但杀了你世上就少了一个名医，所以你们全家才能活到今天。现在，你还坚持让他服这碗药吗？”
　　 
　　龟田这番话的言外之意，耿爷自然能听出来。其实，龟田的怀疑不是多余的，耿爷确实在药里下了毒，而且是“草乌”和“乌头”两种大毒，用量之大足以致人死命。但耿爷下这样的猛药，不是要川岛死，而是想救他活。依川岛目前的症状，耿爷认为只有用这种“以大毒攻恶毒”的办法博命一试。所以他稍一犹豫后，还是将药端给了川岛。
　　果然，药服下后不一会儿，川岛就有了明显反应，汗如泉涌，全身骨骼“啪啪”作响，两袋烟过后，就沉沉睡去，等醒来时脸上已经完全没了痛苦的表情，只是肿胀如故。川岛拉着耿爷的手，感激地说：“先生真乃扁鹊重生、华佗再世啊！”
　　耿爷也十分感慨：“重病需用猛药，但毕竟是险中求胜，老夫也是冒死一博啊！”
　　川岛深为感动：“先生救命之恩，学生永生不忘！”
　　耿爷朝他摆摆手：“仁者救人，这是医家的信条。再说了，你不愿杀老夫，老夫也一样，不愿一位医学才俊就这么死去。眼下的问题是，你肿胀的原因老夫尚未明白，一时也不敢贸然用药，容老夫仔细斟酌后再作一二。”
　　此后几天，耿爷殚精竭虑想弄清川岛肿胀的原因，可总也不得要领。
　　
　　敌我两难
　　
　　这天夜里，耿爷坐在川岛床前，一边陪他聊天，一边观察他的气色。忽然，耿爷听到身后有轻微的声，他心里一惊，猛回头，只见一个蒙面人举刀直向川岛冲来。耿爷伸手一挡，喝问：“什么人？”
　　蒙面人答：“中国人！前来讨还血债！”
　　耿爷一怔，觉得这声音有些耳熟，问道：“你到底是谁？”蒙面人摘下面巾，耿爷一看，原来是自己进山救治过的游击队队长罗大虎。
　　罗大虎神色激动地说：“耿爷，你知道你救活的是什么人吗？他是鬼子特务长，是专门对付我们抗日游击队的，我们一直想干掉他，今天正是天赐良机！”
　　耿爷沉声道：“你别乱来！他是老夫的病人，又是老夫的学生。你今天若当着老夫的面，闹出什么动静来，老夫不会答应。”
　　罗大虎眼一瞪：“耿爷，你说什么？不行，今天就是死，我也要除掉这个祸患！这是我的任务！”说罢，举刀就向川岛砍去，可又被耿爷一把挡住。罗大虎急了，拔枪就要扣动扳机，耿爷用手指朝他胳膊肘上一点，罗大虎只觉一阵酸麻，“咣当”一声枪掉在了地上。
　　这时，从前院传来鬼子兵的说话声，耿爷眼疾手快“呼”地拾起地上的枪，把它塞到罗大虎手里，然后推开后窗，轻声催促：“快，从后院翻墙出去。”罗大虎恨恨地瞪了耿爷一眼，跺跺脚，只得拔腿而去。
　　耿爷怔在原地，半晌没动。躺在床上的川岛此时却感激得涕泪直流：“先生，谢谢您，您又救了我一次！”
　　耿爷冷冷道：“你怎么不喊你的兵来救你？”
　　川岛回答：“我不愿失去先生。”见耿爷一脸疑问，他解释说，“先生，既然您已经出手相救，如果我再当着您的面，让人将您的同胞逮走，您以后还会拿我当学生吗？”
　　耿爷惊愕道：“你怎么肯定老夫定能救你？”川岛微微一笑：“先生一出手，我就看出先生身手不凡。”
　　川岛话音未落，突然远处传来一阵激烈的枪声，耿爷心头一紧：不会是罗大虎遇难了吧？不想川岛在身后轻声安慰道：“先生，其实，他如果能逃脱的话，倒是您救了他一命啊！”
　　 
 1 [ 2 ]       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第2期   贵妇的谎言  作者：五　行  字体：
   【 大  中  小 】 
 
　　本作品根据美国作家彼得·拉弗西的同名小说改编。
　　
　　这天夜里，勋爵夫人丹尼斯在睡梦中突然惊醒，她感觉有只手搭在自己的肩上，不禁“哇”的大声尖叫起来，紧张地问道：“谁？”
　　“是我，别怕，亲爱的！”那人说着扭亮了床头的台灯。
　　 
　　原来是丈夫艾德里安勋爵！丹尼斯长长地出了口气，埋怨道：“你回家来为什么也不先打个招呼？”
　　丹尼斯知道，近来英国经济不景气，丈夫在董事会忙得不可开交，老是要到伦敦出差。而她呢，则住在乡下的庄园里，与丈夫是聚少离多。由于他们没有孩子，丹尼斯在家里过得相当冷清。她曾把妹妹贾尼斯邀来庄园作伴，没想到妹妹个性太嚣张，没多久，姐妹俩就分道扬镳了。
　　“我……”艾德里安吞吞吐吐的，听起来还有点紧张，这引起了丹尼斯的警觉，她问道：“生意有麻烦了？”
　　“不是生意问题，我、我今晚开车撞了人！”艾德里安重重地叹了一口气，把事情的经过讲了一遍，说在A337公路上有个家伙想搭便车，冲到了马路中央，他一时来不及刹车，撞了上去，那人当场毙命。
　　丹尼斯惊呆了：“人撞死了？”
　　“是的。”艾德里安低下了头，“但我没敢报警。和那人在一起的，还有个女孩，吓得晕过去了。我下了车，见那人死了，就赶紧开车逃了。”
　　丹尼斯两眼瞪得滚圆：“你把他们扔下了？”
　　“唉，怪就怪我开完会后喝了不少酒。你知道这意味着什么！如果警察做酒精测试，那我肯定要坐牢的！”
　　丹尼斯抬头瞪着丈夫：“那你把那女孩也丢在路边不管？”
　　艾德里安苦笑一声，说：“她不会认出我的，她吓傻了。我注意到当时有好几辆车经过，可没有一辆停下来，但我担心有人会记下我的车牌号码，然后报警。”
　　艾德里安抬起头，声音变得异常的温和：“你明白，我这么做也是为了我们这个家。如果警察来了，”他顿了一下，“亲爱的，你愿不愿帮助我，说我整晚都和你待在家里？”
　　丹尼斯倒吸了一口冷气：“你是要我帮你撒谎？”
　　艾德里安哀求道：“亲爱的，求求你了，看在上帝的份上，如果连你都靠不住，那我还能指望谁？”
　　丹尼斯沉默了，她脑子里折腾了好一会儿，最后才下定了决心，说：“好吧，我答应你，不过你得带我去检查一下车子，看有没有留下什么蛛丝马迹。警察如果来查问，肯定要先检查车子的。”
　　“车子没有问题！那人撞在保险杠上，就像皮球一样弹开了。我检查了车身，没有划痕。如果警察来问，他们什么也得不到。全靠你了！你对警察说，我七点钟到的家，然后足不出户。”
　　丹尼斯提醒道：“为保险起见，我们还是去看看车子吧，艾德里安，你酒喝多了，未必能发现车子上的痕迹。”
　　艾德里安听听也有道理，就说：“那好吧。”丹尼斯赶紧披上外衣，拿了个手电筒和丈夫一起下了楼。
　　车就停在庄园外的车道上，丹尼斯仔细检查了一下车子，发现丈夫说得没错，上面果然没有明显的痕迹。丹尼斯揿灭了手电筒，说：“把车停回车库里吧。”
　　艾德里安忙点头，道：“说得对！你开进去吧，我现在手脚不利索，会刮伤车子的。”说着，把钥匙递给了丹尼斯，自己则去打开车库。
　　丹尼斯坐进车，一股浓烈的气味扑面而来，她感到有点儿不对劲，再深吸一口，女人的敏感使她感觉出了什么问题，顿时脸色大变……
　　回到屋子里，艾德里安说想再喝一杯。丹尼斯没有理睬他，独自上了楼上的卧室，拿起了床边的电话……
　　等艾德里安手里拿着杯威士忌进了卧室，丹尼斯劈头就问：“那女的是谁？”
　　“你说什么？”艾德里安手一抖，酒杯里的酒差点泼了出来。
　　“别装聋作哑了！你回答我，今晚和你一起呆在车里的那个女的是谁？刚才我闻到车里全都是廉价香水的味道。”
　　艾德里安呆住了。他开始装起糊涂来，说董事会散会后，有位女同事顺便搭了他的车。
　　“我才不信你的鬼话呢！你说那个娼妇到底是谁？”
　　“根本不是那么回事，亲爱的。”
　　 
　　“你是准备和她过夜的吧。你回家是因为出了事，想让我给你作不在现场的伪证！”
　　“你冷静点。”
　　“冷静点？告诉我她的名字！”
　　“不记得了。”
　　“你当我是什么？你这个没良心的蠢货！”
　　“你冷静点，好不好？”
　　“我在庄园里独守空房，一守就是一个星期，而你却在外面和别的女人风流快活。‘在伦敦开会’，见鬼去吧—是在旅馆开的吧？”
　　“丹尼斯，不说这些好不好，警察随时都会来的。”
　　“他们已经往这儿来了。”
　　“什么？”艾德里安瞪圆了通红的双眼。
　　“我刚才给他们打了电话，和他们说了你的事。”
　　艾德里安听了，似乎还不相信。
　　“要不了几分钟，警察就会赶到这里，到时你就能看到一闪一闪的蓝色警灯。”
　　艾德里安这下全傻了，跌跌撞撞走到阳台上，两手抓住栏杆，远处，警笛声隐约可闻。他转过身，怒吼起来：“女人疯了真可怕！告诉你吧，那女的是你亲妹妹贾尼斯，我们已经好了几个月了。”
　　丹尼斯一听，血直往头上涌，她像发怒的狮子般一边叫着，一边狠命地撞过去，艾德里安猝不及防，向后倒去，整个人从阳台上翻落，重重跌了下去……
　　这时，丹尼斯也彻底清醒了。
　　警笛声越来越近，丹尼斯想了想，一口气灌了两杯白兰地，然后，揉乱了头发，一步一步走下楼梯，来到丈夫身边，号啕大哭起来。
　　不一会儿，警车就开到了。上面下来几个警察，围了过来。丹尼斯哭诉道：“你们来得太晚了。我试图阻止艾德里安，可他还是自杀了。”
　　一个警察蹲下身子摸了摸脉搏，确认艾德里安已经死亡，便转向丹尼斯问道：“这一切是怎么发生的？勋爵夫人。”
　　丹尼斯答道：“今天，我丈夫回到家时，状态非常糟糕，告诉我说他出了车祸，撞死了人，一时惊惶失措逃离了现场。我试图使他冷静下来，可他还是控制不了自己的情绪，就从阳台上跳了下去。”
　　“他说是他出的车祸，是吗？”
　　“是的。他还说那个男的已经死了。”见警察迟疑了一下，丹尼斯又追问了一句，“是这样吧？”
　　“我们接到报告，说一个男的今晚在A337公路上被撞死了。有人记下了肇事车号，我们查到，注册的是你丈夫的名字。”
　　这样看来，她的故事真的天衣无缝了，丹尼斯又假装悲痛地说：“太可怕了！这么突然，真是个悲剧。”
　　“是的，尊敬的勋爵夫人，现在我想看看车子。”
　　丹尼斯告诉警察，车子已经被艾德里安停进了车库。
　　二十分钟后，警察回到了屋子里，问：“您和艾德里安勋爵之间一切都还好吧，夫人？”
　　“很完美。”她不假思索回答道。
　　“婚姻很幸福？”
　　“绝对幸福。”
　　“您今晚喝了多少？”
　　丹尼斯心中掠过一丝不安，想了想说：“早些时候喝了点白兰地，压压惊的。我现在很清楚我在说什么。”
　　“抱歉，我们要对您进行酒精测试。”
　　“为什么？我今天没开车来着，我一个晚上都没碰过车。”
　　“请您听我把话说完。是这样的：撞人逃逸的车子是一个女的驾驶的，有两位目击证人都可以证明。那个和受害人一起的女孩也说，车上有个男的下来，可那个女的就坐在驾驶位上没动。”
　　女的？丹尼斯脑子里一闪而过，艾德里安一定是让妹妹贾尼斯开的车，这个该死的！
　　“如果那个女的不是您，也就没有什么问题了。我们会提取车门和方向盘上的指纹，和您作个对比。嗨，车子里的香水味可真浓啊！”
　　丹尼斯这下矛盾了，眼下她有两种选择：一是供出贾尼斯。可这么一来，自己杀死艾德里安的动机也就暴露了，那将犯下谋杀罪啊！还有一个是……因为是她把车开进车库的，方向盘上都是她的指纹。
　　想到此，丹尼斯装作十分忏悔的样子，痛哭道：“人是我撞死的！是我开的车！艾德里安深感绝望，他知道我会因此而坐牢，不能忍受和我分离的痛苦。这是他自杀的原因。”
　　没多久，法院做出了判决，丹尼斯因开车过失杀人，被判蹲两年的监狱。
　　 (题图、插图：佐夫)
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第2期   逃兵  作者：叶林生  字体：
   【 大  中  小 】 
 
　　就是死，也情愿做个逃回家的亡灵!
　　 
　　解放初期，国民党有一个团的败兵，从云南边境逃到了缅甸境内。后来，残军头目李建接到台湾指令，要他立即将所有人马撤往台湾。
　　就在这时，有人密报，说一营有两个士兵当了逃兵，被一营营长皮定元抓了回来，但没有按军法处置。
　　李建听了，不由心中一怔。他知道，眼下是非常时期，如果让此苗头传染蔓延，事情就会非常麻烦。于是，他当即叫来一营营长皮定元，劈头问道：“听说你抓回了两个逃兵，为什么不斩立决？”
　　皮定元已跟随李建十多年，不仅性格刚强，一身义气，而且治军严明，当年在淮海战役中，身为连长的他就曾亲手枪毙过部下的五个逃兵。因此，他深得李建的赏识和重用。
　　可如今面对李建的责问，皮定元却有些忧虑地说：“司令，逃兵按军纪该杀，不过在眼下这节骨眼儿上，如果再杀逃兵，只怕更会引起军心混乱。是不是先放他们一马……”
　　然而，一向杀人如麻的李建摇了摇头：“不行！正因为是在这节骨眼儿上，才更需要杀一儆百。明天，我要让全体官兵亲眼看到这两个逃兵的下场！”接着，他直截了当地问皮定元，“你看，刑场选在哪儿最好？”
　　皮定元略一迟疑：“那……阴阳坡，怎么样？”
　　“阴阳坡？为什么选在那个地方？”李建有些疑惑地闪了闪鹰眼。因为他知道，阴阳坡是个很诡异的地方，人如果由东往西经过那里，常常会不知不觉地偏离了方向，甚至还会莫名其妙地往回倒走。
　　皮定元不慌不忙解释道：“这样可以告诫所有人，谁想当逃兵，就像走阴阳坡一样，往前是没有路的。”
　　李建点了点头：“嗯，有道理，就这么定了！”
　　阴阳坡不远，就在营地后面一道坐南向北的山坡边。第二天一早，残军官兵全体紧急集合，齐刷刷列队在刑场一侧。
　　李建杀气腾腾地训完了一通话，正要朝旁边的执行兵挥手，却见皮定元跨步上前：“报告司令！这两个逃兵出在我们一营，我身为营长难辞其咎，为了严明军法，还是由我来亲自执行吧！”
　　看来这又是皮定元的效忠之举，李建欣然赞许：“好，好样的，不愧是我的爱将！”
　　皮定元面色如铁，两眼血红，他先朝队伍缓缓扫视一遍，接着一声喝令，两个五花大绑的逃兵被押上前来，面朝山坡跪在地上。
　　这两个逃兵，一个叫张二顺，一个叫吴腊狗，都是当年被抓出来的壮丁，和皮定元还是同乡。此时此刻，皮定元似乎已变得毫无表情，他拔出手枪跨上前去，冷冷地打量着他们：“谁当逃兵，一律枪毙，这你们是知道的！你们不怕死吗？”
　　张二顺和吴腊狗都挺起胸来：“要说死，这些年我们在枪林弹雨里早就死过多少回了，还怕死这一回吗？一辈子在人家的地盘上东游西荡，人不人鬼不鬼的，我们算什么？就是死，我们也情愿做个逃回家的亡灵！”接着，两人又凄然地笑了笑说，“营长，事情已经到了这一步，别再犹豫啦，你就快动手吧。我们虽然没能逃成，可也算是试过了，这辈子不后悔。”
　　皮定元咬了咬牙：“既是如此，那就对不住你们两位弟兄了。不是我皮定元不讲交情，实在是军法难容啊！”说着，他“咔嚓”一声将子弹顶上了枪膛，忽又冷冷地下令，“给他们松绑。”
　　两人的绑绳被松开了，皮定元接着吩咐：“端酒来。”
　　酒端来了，是烈酒，满满的两大碗，皮定元横眼一瞪：“怎么是两碗？再端一碗来！”
　　“再端一碗？”端酒的士兵看了看张二顺和吴腊狗，又不解地看了看皮定元：“营长，这酒是、是给他们两人的……”
　　 
　　“听见没有？再给老子端一碗来！”
　　列队的官兵们先是你看看我，我看看你，随即许多人都暗自点点头。这情景，李建也一下子看明白了。
　　想当年，在一次惨烈的交战中，皮定元身负重伤，倒在地上奄奄一息，是张二顺和吴腊狗舍生忘死，背起他杀开一条血路，最后冲出了包围圈。此时此刻，重义气的皮定元是要陪一碗酒，送送他这两个曾救过自己性命的弟兄。
　　又一大碗酒端上来了，皮定元亲自将酒一人一碗端给张二顺和吴腊狗，然后接过刚端来的第三碗酒，仰起脖子与他们同时一饮而尽。
　　陪完送行酒，皮定元“啪”地将碗摔碎在地上，接着，他拿枪托在沙地上画了两个间隔五米的圆圈，让张二顺和吴腊狗站进去，两人就这么一东一西面对面地分开站立。然后，皮定元指着旁边两个士兵说：“把你们手里的枪顶上火，交给他们。”
　　“这……”两个士兵更糊涂了，“营长，这枪怎么能给……”
　　皮定元吼道：“这是命令！老子再说一遍，把你们的枪顶上火，交给他们，听见没有？”
　　此刻，身后的李建也有些诧异，但随即又露出了狠毒的狞笑—显然，皮定元这是要让两个逃兵互相开枪射杀。想当年，自己也曾采用过各种让逃兵相互残杀的手段。李建觉得，如此别出心裁地正法逃兵，会更具有触目惊心的震慑力！
　　果然，两支顶上火的步枪分别递了上去，皮定元让张二顺和吴腊狗互相朝前端平了枪。
　　张二顺和吴腊狗扭头望着皮定元，握枪的双手都有些颤抖，接着，他们丢下枪，“扑通”跪倒在地：“营长，你这……这让我们怎么下得了手啊？”
　　“没种的东西！”皮定元凶狠地骂着，命令士兵拿来黑布，索性给他们全都蒙上了双眼，“现在，你们横也是死，竖也是死，死到临头了连这都下不了手，你们还算是条汉子吗？给老子爬起来站好，端枪！”
　　“好，我们听你的……”张二顺和吴腊狗面对面站起了身，慢慢地再次端起枪来。
　　皮定元一左一右盯着他们两人，站到一旁，然后斩钉截铁般吼道：“你们听着！活着做了鬼事，死要死得像个人样儿！现在老子开始报数，老子数到三，你们就开火！”吼罢，他侧身闪开大声喊道，“预备— 一、二、三……”
　　枪同时响了，“乓乓乓”三声，三声枪响来自三个不同方向。枪响之后，张二顺和吴腊狗倒下了，令人惊异的是，皮定元也同时中弹倒下。
　　大家这才猛然发现，原来皮定元也开了一枪。刚才，皮定元让张二顺和吴腊狗站在两个圆圈里，自己则站在一侧，这看似不经意，其实是皮定元早就算好了的。这样，他们三个人同时向前开枪的位置，竟然就成了一个奇特的长三角形——皮定元的一枪打中了与他平行的张二顺；张二顺的一枪打中了他对面的吴腊狗；而面朝着西的吴腊狗那一枪，则由于身体和端枪方向的偏位，子弹没有打中张二顺，却打中了与他斜对面的皮定元！
　　李建呆住了。
　　这时，有人跑步送来了一封信，李建忙打开一看，竟是皮定元写下的遗书：
　　李司令：现在你该明白了，其实我也是个逃兵，因为我家中有个双眼失明的老母，还有新婚不久的妻子……当我们的逃跑计划失败时，张二顺和吴腊狗为了能保住我，让我演了一出亲手抓回逃兵的“苦肉计”。我本想利用营长的身份，再设法大事化小，留住他们的性命，可惜我已经没有办法实现了。既然如此，我皮定元也决不苟且偷生，只有用生死弟兄的子弹，让我陪着他们一起上路……
　　李建如梦初醒，一种莫名的悲哀使他感到不寒而栗，埋葬三个逃兵的时候，他站在旁边一言不发，神情十分沮丧。
　　当三座新坟垒好之后，李建盯着看了很久，突然又吩咐士兵说：“把那坟头都掉个向，让他们朝着北吧。”
　　 (题图、插图：安玉民梁丽)
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第2期   生死假期  作者：唐雪嫣  字体：
   【 大  中  小 】 
 
　　这男人的表情让高明飞心里一震，他这才意识到，自己身处险地，这个男人看上去像个老实巴交的农民，可谁知道他和开枪的人是不是一伙呢？
　　高明飞心里这么想着，嘴上却说着早就编好的理由：“我是大学生，趁着假期出来玩的，没想到在这儿迷了路，我也不知道为啥有人开枪打我。”
　　男人皱了皱眉头，刚要开口，这时，外面传来了喊声：“老江子，有个人跑到这边来了，你看到他了吗？”
　　 
　　高明飞回头一看，只见一个满脸杀气的汉子，提着一支步枪正大步走来。他吓坏了，求救似的看着老江子。老江子犹豫了一下，迎了出去，拦住那人，一面嘀嘀咕咕说着什么，一面不住地回身指着屋里。
　　过了一会儿，那汉子绷着脸进了屋，阴森森地瞪了高明飞一眼，挤出一声冷笑：“迷路了？算你幸运，没挨着枪子，我还以为是什么牲口呢。”那人说罢，把枪往背上一背扬长而去。
　　老江子叹了口气说：“这个大虎，打猎也不看清楚，这要是一枪打中了你，你可死得够冤枉的。没事了，你赶紧走吧。”
　　高明飞觉得，老江子说这话的时候，表情十分怪异，分明是在帮大虎撒谎。自己当然不能揭穿他，但又不甘心就这么离开，正想着找什么借口留下来，继续寻找谜底。突然，他感到小腿一阵疼痛，低头一看，原来是被荆棘划开了一个大口子，刚才光顾紧张了，没感觉出来，如今却火辣辣的疼。高明飞抚着伤腿，叫道：“哎哟，大叔，我受伤了，天色又这么晚，您就让我在这儿住一宿吧！”
　　老江子脸色一变，断然说道：“不行，我这儿又不是旅馆，你赶紧走！”
　　没想到他会这么说，高明飞倒是一愣，他低头挽起裤腿，见伤口又深又长，赶紧从背包里拿出纱布包了起来。做完这一切，他站起身来，装作一个踉跄差点摔倒，然后痛苦地说：“大叔，我的腿疼得厉害，走不出这山了。您行行好，让我住下来吧，等伤一好我就走，我会给您钱的。”
　　老江子脸色木然，也不知道在想些什么，过了好半天才叹口气说：“你的腿确实不适合再走路了，唉，那你就留下来吧。”
　　
　　3. 神秘山村
　　
　　老江子虽然把高明飞留了下来，但态度依然冷冰冰的，高明飞几次想借聊天从他嘴里探听一些消息，但老江子都不理他。
　　吃过晚饭，高明飞就躺下了。这几天他跋山涉水，早已经疲惫不堪，但回想起刚才的事情，却怎么也睡不着。半夜的时候，他听到身边的老江子爬起身来，轻轻地喊他，高明飞觉得不对劲，就闭着眼睛，还故意打出呼噜声。
　　老江子悄悄下了床，随后传来一阵拉拉链的声音。高明飞偷偷把眼睛睁开一条缝，看到老江子拿着手电筒，正在翻自己的背包，接着又搜查自己的衣服口袋。高明飞暗暗庆幸，多亏了早有防范，将地图藏了起来。
　　老江子的行为，更让高明飞心里疑虑重重，直到快天亮时，他才迷迷糊糊地睡着。
　　第二天，高明飞醒来时，发现老江子已经不在屋里了。他信步来到厨房，发现厨房旁边有扇门，里面隐隐传来说话声。高明飞刚想走进去，却见老江子从里面出来。
　　看到他，老江子愣了一下，随即手忙脚乱地关上门，用一把大锁锁好，勉强笑着说：“我女儿住在这里，不过，她精神不好，见人又咬又打的，所以只好把她锁在里面。走走走，咱们吃饭去。”
　　可能是从高明飞身上，没发现什么值得怀疑的东西，老江子比昨天明显热情了一些。吃过早饭，他叫高明飞跟他一起去地里。高明飞心里明白，他是不想让自己一个人呆在家里，在厨房后面的那扇门里，一定藏着什么秘密。
　　 
　　高明飞一瘸一拐地跟着老江子出了门，来到地里时，已经有几个人在干活了。这些村民看到高明飞，都隐隐露出些敌意。
　　正在这时，有两个人说笑着抬着一只山鹿从山上下来，两人看到高明飞，不约而同停下了脚步，大声喝问：“你是什么人？为什么在这里？”
　　老江子急忙上前说：“是个迷路的大学生，腿受伤了，伤好了就会离开这儿。”
　　那两人怀疑地互相看了一眼，抬着山鹿走了。高明飞瞪大了眼睛，想了想，似乎明白了什么。
　　他想这里是大山深处，人迹罕至，更是政府难以管理的地方。于是，山里的各种野生动物就成了村民们捕猎的对象，而那个刀哥，肯定就是这些野生动物的买家。为了防止在深山里迷路，刀哥特意绘制了那份地图。没想到地图丢了，他们担心事情被人发现，所以才会那么紧张……
　　高明飞的脑子里飞速转过这些念头，表面上却不露声色。老江子打着哈哈说：“大学生，你看到了，我们这儿的人，本来就靠打猎赚两个零花钱，不这样，我们活不下去啊，你……你不会说出去吧？”
　　高明飞连忙说：“不会，不会。”老江子仔细看着高明飞，说：“其实，这不算什么，就是有几头鹿，没啥珍贵的保护动物。再说了，这深山老林的，就算有人报警，也不会有人来管的。”
　　高明飞明白，老江子说这番话，是想提醒自己，就算他出去后报了警，警察也不会管这件事。他一边随口敷衍着老江子，一边却在想：既然秘密已经识破了，再呆下去也没什么必要，还是明天就离开吧。
　　当天晚上，高明飞还是睡在老江子的床上，这回他睡得很沉，直到半夜，被尿憋醒，才爬起身来，找到手电来到门外。当高明飞转身准备回屋时，突然听到一个女人的哭泣声，声音不大，却悲怆凄苦，好像有着无穷的委屈，在这寂静的夜里，听来分外凄楚。
　　声音是从厨房里面传出来的，高明飞想起老江子说过，他那精神不好的女儿，就住在里面。高明飞起了好奇心，便悄悄来到厨房那扇门前。门板的做工十分粗糙，有很多缝隙，高明飞用手电对着门照过去，只见一个女孩子坐在床上，见光线照进来，她惊慌地叫了声：“谁？”
　　高明飞看清楚了，这女孩虽然满是泪水，却遮不住一脸的清秀之气，身上完全是城里女孩的时尚打扮。她双手垂在身前，却被绳子牢牢地绑在一起。见此情景，高明飞疑心顿起：这个女孩根本不像山里人，她怎么会是老江子的女儿？再说，就算女儿精神不好，做父亲的怎么会绑住自己的女儿呢？除非她是被老江子绑架的。
　　这么一想，高明飞心里顿时腾起一股怒火，真没想到，老江子原来是这种人。他随即小声对女孩说：“你等我，我来救你。”说着，便想找家伙撬开门锁，却听身后突然传来老江子愤怒的声音：“半夜三更你不睡觉，想干什么？”
　　高明飞见自己被发现了，不由大吃一惊。但事到如今，他索性横下一条心，转过身来，大声吼道：“我要是睡觉，还能看到你犯下的罪行吗？你这是非法绑架啊！”
　　老江子瞪着他，眼里喷出火来：“谁说我绑架她？她是我女儿，她有病，我这也是没办法。”
　　高明飞还是不信，老江子气得直喘粗气，霍地从口袋里掏出钥匙，把门打开冲进屋里，指着高明飞对女孩说：“玲玲，你告诉他，是不是因为你有病，我才把你关起来的？哭哭哭，你早晚得把所有人都给害死。”
　　玲玲有些激动，她看了看高明飞，又看了看老江子，然后气愤地说：“爸爸，我有病，我病得还不轻呢，你干脆弄死我得了，你能绑我一天，还能绑着我一辈子吗？”
　　高明飞愣了，虽然他不明白玲玲说的是什么意思，但那种语气，清清楚楚说明了她就是老江子的女儿。高明飞有些尴尬，不好意思地说：“大叔，抱歉，我还以为……”老江子沉着脸一把将他推出门去。
　　第二天，天刚放亮，老江子就把高明飞送出村子，给他指了一条小路，说：“大学生，山里的生活你不懂，就别瞎琢磨了，赶紧回城里过你的快活日子吧。”
　　老江子表情茫然地望着高明飞离去，直到高明飞走出老远，他还像根木头站在那里。高明飞呢，在走出老江子视线后，绕了个圈，来到自己埋藏东西的地方，取出了地图。
　　高明飞根本就没打算回去，他越想越觉得事情奇怪，老江子为什么要说玲玲“你早晚得把所有人都给害死”？他这话的意思，是不是暗示女儿别乱说话？而玲玲看来也有所顾虑，所以没有透露任何信息给自己。
　　 
[ 1 ] 2 [ 3 ]
               
                [ 4 ]       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第2期   生死假期  作者：唐雪嫣  字体：
   【 大  中  小 】 
 
　　高明飞百思不得其解，不过可以确定一点，这个小山村里，绝非非法狩猎那么简单，一定有着什么惊天的大秘密。而自己似乎已经越来越接近真相了。于是，高明飞决定等到夜里，悄悄潜回去把玲玲救出来，从她嘴里就可以知道全部的秘密了。
　　 
　　4. 落入魔掌
　　
　　高明飞在山里躲了一天，赶到老江子家时，已是深夜。屋里静悄悄的，估计老江子已经睡着了。他知道关押玲玲的屋子有个破木板钉成的窗户，只要悄悄用水果刀把木板拆了，就可以神不知鬼不觉地带走她。于是，他绕着屋后，趴在木板上小声喊道：“玲玲，我是来救你的。”
　　屋里没人回答，高明飞觉得有些奇怪：难道玲玲睡得这么死吗？他正准备再喊一遍，突然听到身后有动静，没等他反应过来，手上的水果刀已经被人夺去。他回头一看，不由惊呆了。面前站着的除了那个开枪打他的大虎和老江子，居然还有四个人：刀哥、三郎，还有另外两个保镖模样的打手。
　　刀哥阴沉着脸，对老江子说：“你不是跟我说，这小子肯定不会有问题的吗？”
　　老江子脸涨得通红，一个劲地点头，也不敢回嘴。高明飞被推进屋里，三郎马上动手对他全身搜了一遍，幸亏高明飞将地图塞进了鞋里，没有被他发现。
　　见没搜出可疑的东西，刀哥恶狠狠地说：“天堂有路你不走，偏偏又赶回来送死。说，你到底是什么人？为什么到这儿来？”
　　高明飞知道，无论如何不能说出真相，便说：“我就是迷路误闯进来的，我看老江子非法关押个女孩，所以想救她走。”
　　老江子说：“刀哥，我搜过他的包，没发现什么特别的东西，估计他只是迷路的人。”
　　刀哥突然一抬手，“啪”的一下扇了老江子一记耳光，恶狠狠地骂道：“都是你惹的祸，你要是听大虎的话，管他看没看到什么，早把他干掉，哪会有今天的事情？滚，去挖个大坑，一会儿就把这小子埋了。至于你女儿的事，我慢慢再和你算账！”
　　高明飞惊呆了，在这天高皇帝远的地方，真把自己埋了也没人知道啊！这么一想，他恐惧地大叫一声，转身想逃。三郎骂了一声，挥起枪托狠狠地砸在他的头上，高明飞只觉得天旋地转，晕了过去。
　　不知道过了多久，高明飞被肩上一阵钻心的疼痛痛醒。睁眼一看，见玲玲趴在自己身边，拼命咬自己的肩膀。高明飞惊得滚到一旁，这才发现自己的双手被紧紧绑着。
　　没等高明飞发问，玲玲焦急地小声说：“我怎么叫你也不醒，我的手又被绑着不能动，只好用嘴咬你了，他们要活埋你，你快想办法逃吧。”
　　玲玲的话刚说完，屋外“哈哈哈”传来大虎的狂笑：“老子守在这儿呢，就算给这小子解开绳子，他还能逃到哪去？就乖乖地等死吧。”
　　高明飞知道，这次恐怕是在劫难逃了，他索性豁出去了，不过死之前，他想先把心里的疑问弄清楚。于是他问玲玲：“你爸爸为什么要把你绑起来？你知道了什么秘密？”
　　玲玲叹息一声，把事情原原本本说了一遍：原来，玲玲的母亲早逝，老江子为了让女儿能够接受教育，在她九岁的时候，就把她送到山外的亲戚家读书。几天前，玲玲放暑假回家，一次上山去玩，无意中在山里隐秘之处，发现那儿种植了大片罂粟。她惊呆了，因为这是违法的。同时，她也明白了，为什么家里这么穷，爸爸却能供得起她念大学，原来，他在干这种罪恶勾当。玲玲想劝老江子悬崖勒马，老江子却说，他是为了让她读书才这么做的，再说，跟刀哥这样的人合作，不是说不干就可以不干的。
　　玲玲劝不动爸爸，就跟他大吵起来，并且威胁说她要报警。这一切被赶来的大虎听到了，大虎担心事情败露，便命令老江子妥善处理此事。老江子也害怕玲玲真的报警，那样，所有的村民都将受到法律的惩罚，没办法，只好把玲玲软禁起来。
　　高明飞不由苦笑起来，自己还以为是什么金矿、什么野生动物呢，原来是罂粟。那天，大虎一定是以为他发现了罂粟，才开枪想要灭口的。现在，他终于全知道了，这地图果然藏着大秘密，可现在知道这些又有什么用呢？
　　“哈哈哈，”外面又传来大虎的冷笑，“说吧，尽管说吧，反正你小子也是快死的人了，就让这些秘密陪着你进棺材吧！”就在这时，刀哥带人进来了，大虎上前一把揪起高明飞，冷笑着说：“小子，你该上路了。”
　　玲玲大声喊道：“你们这是犯法，你们不能这么做……放了他……”
　　没等她说完，刀哥恶狠狠地骂道：“你还是想想你自己吧，这时候还敢替别人操心？”说着一指玲玲，“把她也给我带去，让她看看反对我会是什么下场！”
　　 
　　高明飞被带到一个挖好的坑旁，清冷的月光，照在老江子满头大汗的脸上，他凑到高明飞身边，小声说：“对不起，是我害了你，你做鬼也别来找我算账啊……”他的声音越来越低，可没等他说完，大虎就一把推开他，冷笑道：“跟一个快死的人，哪有那么多话可说的？”
　　老江子还要往高明飞身旁凑，刀哥大喝一声：“老江子你不动手，还等什么？”老江子哆哆嗦嗦地拿起铁锹，嘴里却哀求说：“刀哥，可千万别滥杀无辜啊，你们刚才也搜过他的身，他真是个迷路的学生，咱们就是想赚点钱，又不是土匪，可不能沾上人命啊！求求你了，刀哥……”说着，老江子朝刀哥跪了下去。
　　刀哥鄙视地看着老江子，狞笑着说：“就算我改变主意，现在也都晚了，你的宝贝女儿把什么都跟他说了，你说我能放过他吗？”
　　玲玲突然挣脱了身边的人，冲到刀哥面前，也“扑通”跪在地上，满脸泪水哀求说：“都是我的错，求求您放过他吧！我们不会把这里的事说出去的。您要是不相信，我可以不再上学。我本来就是这大山里的孩子，不该去见识外面的花花世界，以后我再也不离开这里半步。求求您了！求求您了！”说着，给刀哥磕起头来。
　　突然，一个打手“咦”了一声，弯腰捡起一样东西，用力一扯，竟扯起一溜浮土，一根长长的塑料管子被他从坑底拉了上来。刀哥吃了一惊，凶狠地瞪着老江子，骂道：“你埋这根管子干什么？是想给这小子呼吸用的吗？”
　　老江子吓得面无血色，小声哀求道：“刀哥，我、我只是不想杀人啊，你……大人有大量放过他吧……”
　　刀哥抬腿一脚将老江子踹开，怒吼道：“你好大的胆子，要不是看你是种大烟的好手，现在我就宰了你。”他又指着玲玲对老江子说，“我对你已经格外开恩，她要不是你的女儿，早死了八遍了。现在，我要让她亲眼看着这小子死，记住这个血的教训，以后再想胡说八道时，就先想想。”
　　说着，刀哥慢慢地拔出手枪，把枪顶在高明飞的脑袋上：“小子，这不能怪我，要怪就怪你自己吧，下次投胎转世，千万不要再迷路了。”
　　就在刀哥要扣动扳机的瞬间，玲玲忽然大喊：“你不是人，你是畜生。”接着，她猛地从地上跃起，一头撞在刀哥身上。刀哥没有防备，被撞得连连退了几步，仰面倒了下去。大虎连忙冲上前，一脚把玲玲踹倒。
　　刀哥爬起身来，目露凶光，二话不说，冲着玲玲“砰”的一声，玲玲的额头出现一个血洞，“扑通”一声栽倒在挖好的坑里。
　　
　　5. 绝处求生
　　
　　老江子惊呆了，半天才发出一声撕心裂肺的惨叫，他跳进坑里，搂着玲玲的尸体痛哭失声，边哭边说：“孩子，是爸爸对不起你！爸爸是真想让你过上正常人的生活，可是我没有钱供你读书，没有钱给你买漂亮的衣服，我什么都没有啊。我本想用我的命换来你的好日子，可、可没想到反而害了你呀……”老江子哭诉着猛地抬起头，冲着刀哥大喊一声，“我跟你拼了，王八蛋！”
　　可老江子刚爬上坑，就被气势汹汹的刀哥一脚又踹了下去，他摔倒在坑里，脑袋撞在坑角上，挣扎了几下就不动了。
　　刀哥骂道：“就你也配和我拼？既然你们都不想活了，我就成全你们。”说着，他上前一脚将高明飞踹下土坑，冷笑道，“坑虽然浅了点，埋三个人没问题，尝尝被活埋的滋味吧。”
　　 
[ 1 ]
               
                [ 2 ] 3 [ 4 ]       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第2期   生死假期  作者：唐雪嫣  字体：
   【 大  中  小 】 
 
　　大虎他们便拿起铁锹开始填土。在这巨大的恐惧下，高明飞脑子里突然灵光一闪，大喊道：“刀哥，你知道我是怎么来到这儿的？告诉你，是我捡到了你们的地图。你不是担心地图会泄漏出去，暴露这儿的位置吗？那你就先放了我。”
　　刀哥愣住了，随即命人把高明飞拉出土坑，问道：“地图在哪里？还有谁知道这张地图的事？”
　　高明飞大声说：“你把老江子放了，我就告诉你。”
　　刀哥狞笑道：“胆子不小啊，敢跟我讨价还价？我让你尝尝我的手段，我就不信你敢不说出来。三郎，你先把那个老不死的埋了。”说罢，他和大虎几个押着高明飞回屋去了。
　　到了屋里，高明飞知道，如果不说出点东西来，自己就会遭受皮肉之苦。他强压下悲愤，一股脑儿地把捡到地图的经过说了一遍。大虎从他鞋里搜出地图交给刀哥。刀哥扫了一眼，突然抡起一张小板凳朝高明飞的头上砸去，鲜血立刻流了下来。刀哥用地图在高明飞的脸上一抹，眨眼间，地图变成可怖的血色。
　　刀哥看了眼地图，阴森森地说：“为什么是复印件？原件在哪里？还有谁知道这件事？”
　　“原件在我家的床下，如果我死了，就会有人将原件送给警察。你可以去我家，将原件先拿到手，”高明飞装作害怕的样子继续说，“这件事我没告诉别人，不过，我在电子邮箱里设了一封自动发信，里面也有地图扫描件，再有几天如果我还没回去，这封信就会自动发给我的同学，警察也就会知道这里的一切。”
　　刀哥瞪了高明飞一会儿，说：“你家的地址、电子邮箱和密码，要是敢骗我，我会让你死得很难看。”
　　这样，正中高明飞的下怀，他的目的就是要拖延时间，虽然他不知道自己还有没有生还的机会，但现在首要的是先保住命。于是，高明飞爽快地写下了这一切，不过，他却编了个假的电子邮箱名，他想只要找不到那封预设的信，刀哥肯定不敢杀他。
　　刀哥拿了高明飞写的东西，派了一个手下连夜出山去处理事情。
　　之后，刀哥就走了，留下大虎和三郎看守高明飞。高明飞手脚被绑着，像只待宰的羔羊，被扔在墙角落里。此时，高明飞是又悔又恨，没想到这次冒险会送掉自己的小命！
　　一天过去了，高明飞正想着如何逃出虎口，刀哥怒气冲冲地冲进屋里，二话没说，就对他一阵拳打脚踢。高明飞知道，肯定是假邮箱的事情被发现了，便大喊道：“别打、别打，我告诉你真正的邮箱……”
　　刀哥像没听见一样，继续踢打他，直到打累了，才拔出匕首，贴在高明飞的脸上，说：“这次你再敢骗我，我就用刀把你身上的肉一块一块割下来喂狗。”
　　高明飞知道，一旦刀哥取消了那封邮件，自己的死期也就到了，所以，他一边表示保证不敢再骗刀哥，一边又写了一个假邮箱给刀哥。
　　刀哥走后，高明飞想下次刀哥再来，肯定不会放过他了，说不定这个恶魔真的会割了他的肉喂狗。这么一想，高明飞不由打了个寒噤，决定逃出去。
　　这时，大虎和三郎在厨房喝酒，门关着，高明飞做什么那两个人都看不见，正是逃走的好机会。但他的手脚都被绑住了，没法挣脱。情急之下，高明飞突然想到曾经玩过的解绳扣游戏，于是他两只脚轮番用力前蹬，想将绳扣弄松，可是只蹬了一会儿，他的脚踝就磨破了。但求生的渴求让他咬紧牙关坚持，大约过了二十多分钟，脚踝已经鲜血淋漓，幸好绳子一点点松了下来，他用一只脚蹬掉另一只脚上的鞋，然后把那只脚拉出绳扣。他成功了。
　　高明飞记得自己被抓的时候，窗子上撬开的那个洞没被封上，便小心翼翼地爬出破洞，轻手轻脚刚跑出了几步，突然听到一声大喝：“什么人？站住。”
　　此时天已大亮，高明飞吓得一激灵，抬头一看，原来是一个早起的村民，正戒备地看着他。村民的喊声惊动了大虎和三郎，两人冲了出来，高明飞双手被反绑在背后，根本就跑不快，很快就被大虎追上一把揪住。
　　高明飞差点气炸了肺，人都说村民朴实，可这儿的人咋都是刀哥的帮凶呢？他一边挣扎着，一边冲那个村民大喊：“他们是罪犯，你帮他们就是同谋……老江子被他们活埋了，玲玲也被他们杀了，早晚也得轮到你们……”
　　 
　　下午的时候，刀哥又来了，他冲高明飞嘿嘿冷笑着说：“小子，你到底又骗了我一次，不过不要紧，我不再需要你了，你的邮件已经被取消了。”
　　高明飞听了，吃惊地瞪大了眼睛，心说：这怎么可能啊？
　　这时，一个大汉得意地补充说：“我们找到了你的同学，骗他说出了你的邮箱，然后找电脑高手破解了你的密码。小子，你的死期到了。”
　　高明飞彻底傻了，他还是低估了刀哥，没想到他能想出这样的办法。
　　
　　6. 柳暗花明
　　
　　刀哥等人推着高明飞走出了屋子，就在高明飞以为自己必死无疑的时候，突然听到一声大喝：“刀哥，你不能再杀人了。”
　　随着这个声音，七八个村民迎面跑来，他们的手里都拿着棍棒斧头等武器，一个个面露敌意，拦住了刀哥一行人的去路。刀哥停下脚步，大喝道：“你们要干什么？想造反呀？别忘了，我是你们的财神爷。”
　　一个村民大声喝问：“他说你活埋了老江子，杀了玲玲，是不是真的？”
　　刀哥狞笑道：“是又怎么样？他们胆敢背叛我，死有余辜，你们要是敢背叛我，也会是一样的下场。”说着，他一挥手，三郎等人不约而同拔出手枪，对准那些村民。
　　村民们你望着我，我望着你，突然，一个村民愤怒地喊道：“老江子那么好的人，你都忍心杀他，你还是人吗？玲玲还是个二十来岁的女孩啊，你们怎么能下得了手？我们为了生活，昧着良心帮你种罂粟，但决不能看着你作孽杀人！你放了他。”
　　“放了他？让他出去举报我们吗？别忘了，罂粟是你们种的，你们也是犯法的，我们是一根绳子上的蚂蚱，出了事谁也跑不了。”刀哥嘴里叫嚷着，举起手里的枪，“这个人我一定要杀，你们要是不想活，就跟他一起上路吧！”
　　高明飞紧张地看着这一切，他不想死，他希望村民们能坚持到底，救他出去。可是，他也害怕刀哥真的下令开枪，那些村民就完了……
　　就在双方一触即发的瞬间，只听得后面传来一声大喊：“不许动，放下武器，我们是警察。”
　　所有的人都惊呆了，只见大批荷枪实弹的警察出现在眼前，黑洞洞的枪口对着刀哥他们。刀哥见势不妙，第一个扔下枪举起双手。
　　这时，只见一个浑身泥土的人冲了出来，在所有人还没反应过来前，他已经冲到刀哥身前，一把揪住刀哥的衣领。刀哥定睛一看，吓得七魂丢了六魄，一边拼命挣扎，一边大叫：“老江子，你、你死了也别来找我啊……”
　　眼前的这人，竟然是被活埋了的老江子。
　　老江子疯狂地大笑起来，边笑边说：“你以为我死了吗？我死了，我女儿的仇谁来报？！”老江子的笑声又变成了呜咽，“我怎么那么蠢，蠢得居然跟你这样的禽兽合作？你想埋掉高明飞，我没办法，又不能眼睁睁看着他死，就埋了根管子准备让他借此保命，却被你们发现了，就对我下毒手。幸好我挖坑的时候，挖出一个老鼠洞，这个鼠洞直通地面，所以才救了我。天意啊，是老天要我来为女儿报仇，惩罚你们这帮恶魔啊！”
　　听了这话，大家才明白，原来是老江子的好心救了他自己一命。
　　刀哥恶狠狠地对老江子破口大骂：“你这老不死的，命倒挺好，还挨千刀地带来了警察，我真该一枪打烂你的脑袋……”
　　老江子突然迅速从地上捡起刀哥扔下的那把枪，在所有人都没反应过来之前，他把枪顶在刀哥的胸膛上，扣动了扳机。刀哥看着自己胸前的血喷洒出来，接着颓然倒地。
　　老江子瞪着血红的眼睛，哈哈狂笑起来：“玲玲，爸爸亲手为你报仇了……是爸爸害了你呀……是爸爸把这些魔鬼引到这儿的……”喊着喊着，他突然回身向村民们跪倒，“我不该怂恿你们种罂粟，我被金钱吞掉了良心，我对不起你们，我有罪啊……”
　　两个警察冲上前想去抢下老江子手里的枪，他却突然调转枪口，对准自己的太阳穴，随着“砰”的一声枪响，老江子像截木头一样栽倒在地。
　　三郎、大虎等人束手就擒，那些村民们也将接受法律的惩罚。警方一举破获了这个地区禁毒史上最大规模的非法种植罂粟大案，那间“黑森林”迪厅也被查封了，从里面搜出了大批的毒品，原来那里是刀哥的大本营。
　　高明飞终于如愿以偿地做了一件惊天动地的大事，可他却丝毫高兴不起来，玲玲和老江子的影子，总是出现在他的脑海中。破获这场惊天大案所付出的代价，对高明飞来说，实在是太过沉重了。
　　高明飞又来到那片种植罂粟的山区，在群山环绕中的一片谷地里，四周林木掩映，十分隐蔽。谷地上，种着大片的罂粟，接近一米高的罂粟茎上，顶着无数妖艳的罂粟花，随风轻轻摇动。
　　看着这些给人们带来灾难的鲜红花朵，高明飞仿佛看到了玲玲和老江子的鲜血。想着这些天九死一生的经历，他真的希望，这些罪恶之花能永远在这美丽的大山中枯萎，在那些贪婪的人们心中枯萎。
　　 (题图、插图：杨宏富)
　　 
[ 1 ]
               
                [ 2 ]
               
                [ 3 ] 4        
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第2期   生死假期  作者：唐雪嫣  字体：
   【 大  中  小 】 
 
　　一幅神秘的地图引出一场惊天的阴谋，大山深处的山村里，除了冷漠、猜疑和敌视，究竟还隐藏着怎样的秘密……
　　
　　1. 迪厅奇遇
　　
　　 
　　高明飞是大学三年级的学生，今年二十一岁，长得又高又壮，是个胆大机敏，充满冒险精神的小伙子。去年假期，他跟几个朋友去攀岩，虽然差点摔下来，但那种惊险和刺激让他激动不已，至今难忘。
　　明天学校就要放假了，晚上闲来无事，高明飞就一个人上街闲逛，走着走着来到了一家名叫“黑森林”的迪厅。这个另类的名字，立刻引起了他的兴趣，便迈步走了进去。迪厅里面的客人不多，但气氛很好，都是些年轻男女，在舞池里尽情地扭动着身体。高明飞没有跳舞的心情，就在门边的一个角落里坐下自顾喝酒。
　　迪厅里灯光忽明忽暗，高明飞坐的位置很隐蔽，几乎没人注意到这儿还有人。在响亮铿锵的鼓点中，高明飞看见一个人匆匆离开舞池，朝门口走去，在推门离去时，他顺手一甩，一团黑东西恰好落到离高明飞不远的桌子下面，同时有一张巴掌大的纸片，晃晃悠悠地飘落在高明飞面前。
　　开始，高明飞也没当回事，他正在寻思去哪里度假呢。可是就在这时，一束强光扫过那张纸，高明飞依稀看见，上面竟然像是一副手工绘制的地图。他马上想到刚才离开的那个人，衣着古怪，染着黄色的长发，看上去像个痞子，他手上怎么会有这种东西？高明飞不由得好奇，便弯下腰捡起纸片。地图上的地势蜿蜒曲折，好像挺复杂，迪厅的光线昏暗，一时间也看不清楚，他就顺手揣进了口袋。
　　高明飞正想去看看那包被扔掉的黑东西。突然，震耳的音乐戛然而止，所有的灯光亮了起来。舞池里的人们都停了下来，面面相觑，不知道发生了什么事。
　　正在猜疑之间，只见两个大汉急匆匆地冲进来，守住了门口，还有几个人走上了舞台，其中一个满脸横肉的大汉咬牙切齿，一副愤怒的样子。在他前面，是一个西装革履的中年人，面色阴沉、目露凶光，让人见了不由发冷。在他俩身后，还跟着几个凶神恶煞一般的大汉。
　　穿西装的中年人拿过麦克风，用低沉的声音说：“不好意思，耽误各位的雅兴了。我是这儿的老板，认识我的人都叫我‘刀哥’。”
　　一听说刀哥，人群中一阵骚动，大家都小声议论起来。高明飞也兴奋起来，他早就听说过刀哥这个名字，据说此人十三岁就出来混了，是个心狠手辣、翻脸无情的角色，现在更是黑道上无人敢惹的煞星。
　　只见刀哥回身拍了拍那个怒气冲冲的大汉，冷冷地说：“我的兄弟刚才进门的时候，不小心把钱包丢了，里面的钱是小意思，尽管拿走，但钱包却有点重要意义，所以我们一定要拿回来。我可以向各位保证，只要拿回钱包，我决不再追究，为了表示我的诚意，现在我让人把灯关了，谁拿了钱包，把它扔在地上就行。”
　　难道，刚才的痞子是个小偷？他偷了大汉的钱包后，拿走了钱却扔掉了钱包？高明飞急忙低头朝那张桌子下面看去，可那里空荡荡的什么也没有。这时，刀哥的一个手下正准备跑去关灯，一个把守大门的大汉突然叫了起来：“刀哥，钱包在这儿。”
　　原来，舞池里的人们回到座位时，不知是谁无意中将钱包踢到了空地上。那大汉跑过去捡起钱包双手递给刀哥，刀哥忙打开翻了翻，突然暴怒起来，狠狠地将钱包摔在地上，大吼起来：“东西不见了，三郎，你们给我搜，一个都别放过！”
　　说着，刀哥骂骂咧咧地带人冲下舞台，场面顿时一片混乱。高明飞心头火起，大声抗议道：“凭什么搜我们？这是侵犯人权，犯法的！”其他人也纷纷附和。
　　可是，那些四肢发达、头脑简单的打手才不管这些，竟然强行进行搜身。高明飞知道跟刀哥这种人，是无法讲理的。于是他不再叫喊，而是迅速转动脑子，他想那个小偷应该只是拿走了钱，钱包里除了那张地图，其他的东西都还在。一张地图值得刀哥如此大动肝火？莫非里面有什么见不得人的秘密？
　　这么一想，高明飞激动起来，他决心不交出地图。
　　 
　　这时，那帮家伙已经搜了过来，高明飞觉得地图藏在身上的任何地方，都会被搜出来，这可怎么办呢？
　　高明飞把心一横，决心豁出去了，即使挨顿揍，也得打电话报警。可当他掏出手机刚要拨号时，又不由灵机一动。他把手机放在桌下，借着身体的掩护，悄悄地卸下了手机的电池，把地图折成小块塞了进去，再迅速扣上手机盖。完成这一切后，他才长出了一口气。
　　不久，警察也赶来了，有人偷偷发送手机短信报了警，警察带走了刀哥等人。不过，大家也没有心思蹦迪了，纷纷诅咒着离开了迪厅。
　　高明飞回到自己租住的房间，从手机中取出地图仔细察看，原来，这是本省一个偏远山区的地图，其中的一个地方，还用红笔标出了记号。高明飞断定，这张地图里面一定包含着一个大秘密，所以刀哥才不惜代价也要拿回去。可是，这个秘密是什么呢？
　　高明飞兴奋得一夜没睡，他知道这个假期该怎么过了。他决定要去寻找这地图上神秘的地方，他想，或许可以凭着自己的机敏破获一个惊天大案呢，这样的冒险机会简直是可遇而不可求啊。
　　当然高明飞不是一个鲁莽的人，为了稳妥起见，他将地图扫描进电脑，写了一封关于整件事情经过的电子邮件，然后设置成自动发信。万一自己出了什么意外，十天后，这封信就会自动发送到一个同学的邮箱。他又把地图复印了一份，原件藏在床下，自己则带着复印件，收拾好行囊，然后怀着激动而又忐忑的心，踏上了行程。
　　
　　2.深山探险
　　
　　高明飞按着地图，顺利地来到了那片山区，可越走下去路越窄，人烟越稀少，到了最后，连手机都没有了信号，也找不到任何交通工具，只能靠着双腿步行。
　　高明飞一边按照地图指引的方向前行，一边拿着指南针校正前进的方向。走到后来，山里已经找不到路了，他只能艰难地在茅草荆棘中跋涉，累得筋疲力尽，衣服裤子也都刮破了。这些困难，都是高明飞出发前没有想到的，可是开弓没有回头箭，现在要是退回去，连自己都会瞧不起自己的。于是他咬着牙，坚持走下去。
　　这张地图里到底藏着什么秘密呢？高明飞边走边猜测着，突然他想起不久前看到的一则新闻，说这一带发现了金矿。莫非是有人发现了矿藏，在偷偷开采吗？这可是违法的啊，要真是这样，自己单枪匹马将此事大白于天下，该是多么刺激的一件事呀！想到这里，高明飞又劲头十足起来。
　　高明飞在树林里钻了大半天，终于来到一座大山脚下。这座山脉由南向北，然后以半圆形又向南延伸出去。按地图上面的标记，翻过这座山，就应该到达目的地了。高明飞不由兴奋起来。不过，他又想，如果真的有人在偷开金矿，肯定会有人把守，一旦被人发现，身上的地图会暴露他的目的。他想了想，找了个隐蔽的地方，从包里拿出水果刀，把地图用塑胶袋封好，埋了起来，上面做了记号。
　　此时太阳已经落山，阵阵雾气弥漫开来，山里不时传来野兽的嚎叫声。高明飞不由加快了脚步，在经过一片稀疏的林区时，他看到前面有个小山村，但周围静悄悄的，并没有他想象的采矿迹象。
　　高明飞决定先到村里借宿一夜，趁机打听一下情况。不料这时，突然听到“砰”的一声枪响，他身旁的一个枝丫被枪击中，掉在了地上。
　　高明飞惊得慌忙钻进林子，拼命朝前奔跑。
　　此时，天色已经完全暗了下来，黑暗中他不知道开枪人在哪里，更不知道隐藏着什么样的危险，他什么都顾不得了，气喘吁吁地奔到一间屋子前，想都没想就一头冲了进去。
　　屋子里有个五十来岁的男人正在吃饭，见有人冲进来，不由地一愣。高明飞连忙大声说：“大叔，救我，有人要杀我！”
　　那个男人惊疑不定地上下打量高明飞，好半天，才露出一丝奇怪的笑意，说：“有人要杀你？为什么？你是什么人？”说着，他向外面望了一眼。
　　 
 1 [ 2 ]
               
                [ 3 ]
               
                [ 4 ]       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第2期   游戏空间  作者：佚名  字体：
   【 大  中  小 】 
 
　　本期游戏难度指数：★★★★☆
　　
　　福尔摩伍的问题露了马脚
　　两名武装歹徒冲进一家银行，抢了钱后，立即乘一辆“福特”车逃跑了。一个银行职员记下了车子的号码，报了警。
　　一刻钟后，福尔摩伍就和警官克勒姆等人赶到了现场。正当他们谈论案情时，突然发现了要找的那辆“福特”车，它刚好从警车旁边开过。
　　警官克勒姆叫了起来：“这不可能，车子的颜色、车号都对！”他们马上驱车赶了上去，将那车拦下。
　　 
　　开车的是一个男子，叫西格马尔。福尔摩伍对西格马尔进行了审问，可是他有不在现场的证据，警方只好将他放了。
　　事后调查，歹徒从那家银行一共抢走了7.5万欧元的新钞票。
　　没过几天，又发生了一起银行抢劫案。案发不久，西格马尔开车通过一个检查站，径直往前开。警察拦下他说：“你没有看见停车牌吗？罚款10欧元！”
　　“下次一定注意。”西格马尔递过去一张10欧元的纸币。
　　两天后，警方逮捕了西格马尔，理由是他与两起银行抢劫案有关。“不可能，”西格马尔说，“我根本就不在现场！”
　　福尔摩伍笑道：“但你是主谋。你找了两个朋友，又弄了两辆完全相同的车。每次抢劫银行，你故意将警方的注意力吸引到自己身上来，同伙则趁机逃跑。但是，你却犯了个小小的错误，结果露了马脚！”
　　你能猜出西格马尔在哪里露了马脚吗？
　　
　　世界500强面试题
　　分 袜 子
　　有两个盲人，他们买了同款的黑袜和白袜各一对，一共是四对，而每对袜子都有一张商标纸连着。两个盲人不小心将这四对袜子混在了一起。请问，他们怎样才能取回各自的黑袜和白袜呢？（推荐者：开心）
　　
　　超级视觉
　　
　　奇怪的窗户
　　看看这幅画，有什么不合适的地方吗？
　　
　　答案
　　福尔摩伍的问题
　　西格马尔交罚款的那张10欧元的钞票号码，是被抢劫的7.5万欧元中的一张。
　　世界500强面试题
　　拆开所有的袜子，每人分一只。
　　超级视觉
　　有三处错误：画中窗户的组合是错误的；坐着的人手中拿的立方体是不可能存在的；纸上画的三角形也是错误的。
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第2期   开卷故事  作者：佚名  字体：
   【 大  中  小 】 
 
　　绿手指与金手指
　　约翰和汤姆是一对好朋友，两个人都是花匠。一天，报纸上登了一则消息，说是重金悬赏能种出黑色郁金香的园艺好手。
　　 
　　郁金香有金黄色或者红色的。黑色的，怎么可能？不过，两个年轻人都想试试看。
　　约翰撒下了种子，每天都精心侍弄。当花开了，他挑选了其中颜色最深的一朵，取得了它的种子。第二年，约翰把这些种子栽下去，然后再从中选出颜色更深的，如此一年一年地循环往复。
　　汤姆也撒下了种子，同样精心侍弄。当花开了，他从中选了颜色深浅不同的花。第二年，汤姆也将这些不同颜色的种子再栽种下去，然后，同样如此，循环往复。
　　很多年过去了。一天早上，约翰来到花园，他看到一朵黑色的郁金香，欣慰地笑了。尽管因为时间太久，当年承诺的重金已经不可能兑现，但约翰没有失望，很多人专程来订购他的黑色郁金香，几乎供不应求。人们称他是“绿手指”，这是对好园丁的称赞。
　　而汤姆却一直默默无闻。有一天，报上却刊登了对汤姆的采访，还附了照片，上面有各种颜色的郁金香，不仅有黑色，竟然还有蓝色、白色……
　　用了同样的时间，约翰种出黑色的郁金香，而汤姆却种出了五颜六色的郁金香。人们好奇地问汤姆：“怎么会想到种这些不同颜色的郁金香呢?”
　　汤姆腼腆地笑了：“我想：既然能培育出黑色的郁金香，也一定能培育出别的颜色，那么何必要等到黑色的郁金香种出来，再去种别的呢？”后来，人们称汤姆是“金手指”。
　　我们身边，有多少人只能做“绿手指”，而不能做“金手指”呢？在实现目标的过程中，附带完成那些能够一并达到的事情，收获会多得多，谁说不是呢?
　　（作者：陈艳；推荐者：沈士心）
　　关键词：金手指
　　 （本栏插图：安玉民梁丽）
　　
　　拇指在上
　　 
　　一家啤酒公司发布了一则消息： 面向社会诚征宣传海报，开价是五十万美金。
　　消息一出，许多人趋之若鹜，不到半个月，就收到了上千幅广告作品。但是，大都不尽如人意，负责人只得从中选择了一件较为满意的作品。
　　这幅作品的大致内容是这样的：一只啤酒瓶的上半身，瓶内啤酒汹涌，在瓶颈处紧握着一只手，拇指朝上，正欲顶起啤酒瓶的瓶盖，旁边配上的广告标语是：“忍不住的诱惑!”
　　但是，老总仅仅看了两秒钟就否决了这幅作品，理由是：用拇指来开瓶盖，这种做法十分危险，若是有消费者因为模仿广告而受伤的话，那就得不偿失了。
　　看到老总如此挑剔，许多人都望而却步。这时，一个学生却自信地走进了老总的办公室。同样是两秒钟的时间，老总突然从座位上蹦了起来，说：“太棒了，这才是我想要的!”
　　第二天，这幅海报就铺天盖地般见诸各大平面媒体，内容其实很简单：一只啤酒瓶的上半身，瓶内啤酒汹涌，在瓶颈处紧握着一只手，用拇指紧紧地压住瓶盖，尽管这样，啤酒还是如汩汩清泉般溢了出来。这幅海报的广告标语是：“精彩按捺不住!”
　　同样是一只拇指，仅仅是向上位移了一厘米，变换了一下姿势，就赢得了五十万美金！这在许多人看来，未免也太投机取巧了，然而，你可曾想过：这短短一厘米的背后，境界的差距有多少米呢?
　　其实，一个真正富有创意的人，就是能从废墟中发掘到金矿的人!
　　（作者：李丹崖；推荐者：沈士心）
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第2期   为了出口窝囊气  作者：柴兴志  字体：
   【 大  中  小 】 
 
　　大刘和小刘是铁哥们儿，大刘膀大腰圆、孔武有力，小刘瘦小伶俐、脑筋活络，两个人优势互补、默契十足，经常凑在一起捞点儿外快。
　　这天，小刘听说国家要限量发行一套奥运邮票，便约了大刘一起来到邮局。到那儿一看，乖乖，排队的人围着邮局都绕了三圈。
　　小刘朝大刘一使眼色，大刘心领神会，上去一肩膀撞开排队的人群，趁着一时混乱，小刘在人缝里三钻两钻就排到了前面。
　　 
　　小刘刚想喘口气，忽觉腰里被什么东西划了一下，一摸衣袋，不好！衣袋被划开了一条口子，里面的五百块钱没有了，急忙回头看时，一个戴棒球帽的家伙已经转身挤出了人群。
　　小刘一声没吭，退出人群拉了大刘一把，说：“那个戴棒球帽的小子把我的钱偷了。”
　　大刘急了：“我去抓他，你赶快报警！”说着，抬腿就要追上去，小刘一把拉住他：“报警有啥用，咱又没抓住他的手腕，不如找个没人的地方收拾他！”大刘马上会意，两个人若即若离地跟上了棒球帽。
　　棒球帽走进了一条僻静的小巷，大刘、小刘快步跟了进去，看看小巷里没有行人，大刘一个箭步扑上去，勒住棒球帽的脖子把他拖到了墙角，小刘冲上来就是一个大耳光：“偷到老子头上了，瞎了你的狗眼！”
　　棒球帽不知道他们是哪路神仙，做贼心虚又不敢叫唤，只好假装被勒得喘不过气来，两腿发软就要昏倒。大刘赶紧把胳膊一松，棒球帽猛地从他的腋下钻出来，兔子似的朝巷口蹿去。大刘、小刘急忙追赶，忽见巷口跳出来两个小伙子，一左一右扭住了棒球帽。其中一个小伙子亮出了警官证。原来便衣警察也发现棒球帽有盗窃嫌疑，他们还怀疑大刘、小刘是同伙，所以一直跟在后面，正好堵住了逃跑的棒球帽。
　　警察把他们一起带到了派出所，所长亲自进行了查问，大刘、小刘说明了被盗的经过，可是，提到那丢失的五百多块钱，棒球帽连连叫冤，就是死不认账。俗话说：抓贼抓赃，你说被盗，你得有证据，得证明棒球帽袋里的钱是你的，现在棒球帽死不认账，所长只好先让大刘、小刘回家，留下棒球帽继续审查。
　　大刘、小刘不服气，扯开嗓子嚷嚷起来，一定要讨回被盗的钱，所长火了：“我们办案讲证据，你拿出证据来，我就把钱给你！”
　　两人无话可说，只好垂头丧气地出了派出所，回来一想真是吃了哑巴亏，越想越窝囊……
　　过了几天，奥运会足球比赛门票要发售了，又一个发财的好机会来了。大刘和小刘照样没有提前去排队，到了当天早晨才来到了体育场，没想到这里的安保措施很严，没有提前领到顺序号的人根本不许进售票厅。
　　看到凭号排队的人像一条长龙，两个人傻了眼，正在东张西望找空子钻的时候，小刘眼前一亮，看见棒球帽竟然排在队伍的前面。一个小偷懂什么足球，肯定又是来趁乱掏腰包的！
　　小刘眼珠一转有了主意，倒卖门票又费力又担风险，不如就在外边守株待兔，等棒球帽办完了事出来，给他来个黑吃黑。小刘跟大刘咬咬耳朵，两个人也不去夹塞买票了，躲在对面的花坛后面，紧紧盯住了售票大厅的出口。
　　 
　　大刘、小刘等了不到一个小时，就见棒球帽乐呵呵地走了出来。棒球帽在前面走，大刘、小刘隐蔽在后面紧跟，当棒球帽转弯经过一个大花坛时，小刘看看附近没有人，急忙一推大刘，大刘一个箭步蹿出去，猛地勒住了棒球帽的脖子，把他拖到了花坛后面。
　　棒球帽刚要装昏倒，一看原来是老相识，赶紧摊开手表白：“我是来买票的，没偷东西。”
　　大刘伸出拳头在他眼前一晃：“少废话，还钱！”棒球帽一个劲地摇头：“我、我没欠你钱呀？”
　　大刘想起上次的窝囊气，狠狠一拳把棒球帽打了个四仰八叉，小刘扑上去压住棒球帽，从他身上搜出了一叠钱和球票，从中拿出五百元放进了自己的口袋。钱要回来了，可大刘、小刘想想在派出所受的窝囊气，火气难消，上去又给了棒球帽几脚。
　　大刘、小刘出了心里的窝囊气，刚要开路，突然有两个人拦住了他们的去路，定睛一看，正是上次那两个便衣警察！警察问明情况，当时就拿出手铐，把他们和棒球帽铐在一起，带回了派出所。
　　所长当然还记得他们，自从上次放了棒球帽以后，便派了两个便衣跟踪准备抓现行。棒球帽被带进了审讯室，他知道这次是瞒不过去了，便竹筒倒豆子，交代了刚才在售票大厅的偷窃行为，但他怎么也不肯承认偷了大刘他们的钱。
　　那边，大刘、小刘还在洋洋得意，问所长：“我们帮你抓了个盗窃犯，怎么着也得给点奖金吧。”
　　所长一拍桌子：“想得美！你们刚才干了什么？那是抢劫！”
　　小刘赶紧辩解：“我们没抢劫，我们要回来的是被偷的钱。”
　　所长喝道：“证据呢？你们抢劫倒是有人证、物证。别嗦了，我宣布，依法刑事拘留！”
　　大刘、小刘一齐叫起来：“这、这真是冤枉啊！”
　　没等所长说话，一个正在看案卷的女士“扑哧”笑了出来，所长一拍脑袋：“怎么把你这个大律师忘了，正好，请你给他们讲讲吧！”
　　
　　律师点评
　　大刘、小刘主观上有通过黑吃黑占便宜的目的和动机，客观上又以勒脖子、挥拳头等暴力手段相威胁，强行从“棒球帽”身上摸出现金和球票，符合抢劫行为的构成要件。所以，根据我国刑法第263条之规定，他们的行为已明显构成抢劫罪，处以三年以上十年以下有期徒刑，并处罚金。
　　至于“棒球帽”到底是不是小偷，应当对他如何处置的问题属于公检法司职权范围，作为公民只有报案，提供线索，扭送执法机关的权利和义务。
　　 （题图、插图：安玉民梁丽）
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第2期   《只有三两重》等４篇  作者：明　强等  字体：
   【 大  中  小 】 
 
　　记者很奇怪：“难道是有人逼着你听吗？”
　　 
　　那人点点头：“人家天天唱，咱能有什么办法呢？跟你这样说吧，因为歌声骚扰，我这两年就没睡过一个好觉，都神经衰弱了。”他低头看了一眼怀里的钞票，眉开眼笑，“不过，现在看来，也值了！这笔钱算是补偿吧。”
　　记者趁机问：“这笔钱你准备怎么花？”
　　那人毫不犹豫：“我准备去买房子，搬家，马上搬家！”
　　“你家是住在……”
　　那人伸手指指头顶，痛心疾首地说：“就在楼上！我早在这里住够了，这歌厅的噪声，我可一天也受不了了！”
　　
　　另类贺卡
　　■夏绪乾
　　
　　这天一大早，海波从邮  局出来，忙不迭地给在邻市的女友打电话：“小雯，明天是你生日，我刚用特快专递给你寄了一份贺卡，你一定要及早处理，不要搁太久了！”
　　小雯在电话那头笑道：“你太夸张了吧！一张薄薄的贺卡犯得着用特快专递寄吗？”
　　海波不无得意地说：“孤陋寡闻了吧？你肯定想不到，我寄的不是一般的贺卡，而是最新潮、最时尚的‘另类贺卡’。”
　　 
　　小雯好奇地追问：“别卖关子了，到底是什么宝贝？我都快急死了！”
　　可海波就是不肯透露，还说：“急什么呀？到时候，绝对会给你一个大大的惊喜！”
　　第二天，海波估摸着东西应该寄到了，可等了整整一天，小雯怎么没有一点动静呢。海波实在忍不住，摸出手机一看，这才发现，原来手机早没电关机了。
　　海波慌手慌脚地换上电池，打开手机，一下子涌进来好几条小雯发的短信，都是一个意思，就是问海波到底遇到什么事了，千万不要想不开做傻事。
　　海波傻了：到底发生什么事了？小雯怎么会发这么奇怪的短信呢？
　　海波连忙拨打小雯的手机，接听的却是小雯的妈妈。她告诉海波，东西中午就到了，是自己帮着收的。可等小雯下班回家，看到那些东西，一下子就慌了，连拨了好几个电话，都没打通，又一口气发了好几条短信，也没回音。最后，小雯竟一下子晕倒了，现在还躺在床上呢。
　　海波一听慌了神，马上挂掉电话，开车赶过去。等他赶到时已是半夜了，小雯还昏昏沉沉地躺在床上，一见到海波，她露出又惊又喜的表情，连连说：“真的是你，原来你没有、没有……”
　　 
　　海波忙问：“怎么会这样，你收到我寄的苹果了吗？”
　　小雯费力地用手指了指旁边的桌子。海波一看愣了，忙问：“我寄的可是五个苹果，怎么少了一个？”
　　小雯妈妈听到了，随口答道：“哦，那个苹果啊，我中午吃了！”
　　海波惊诧道：“啊？您怎么能给吃了呢？”
　　原来，海波听说，最近流行印字的“苹果贺卡”，就早早地到苹果园定制了五个艺术苹果寄给小雯。那五个苹果上各印着一个字，连起来就是：“我想死你了”。
　　可没想到，小雯妈妈随手把印着“你”字的苹果吃掉了。结果，小雯看到的“另类贺卡”便成了：“我想死了”。
　　 
[ 1 ] 2        
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第2期   《只有三两重》等４篇  作者：明　强等  字体：
   【 大  中  小 】 
 
　　只有三两重
　　■ 明强
　　
　　 
　　从前有个大财主，家财万贯，可  财主夫人的肚子不争气，只生了三个女儿。三个女儿都出嫁了，其中大女婿和二女婿又奸又猾，三女婿却傻里傻气的。财主担心将来分家产时，三女婿要吃亏，就想帮他一把，可又不能明着给，只好暗地里想办法。
　　这天，财主偷偷找来三女婿，拿出一块黄金说：“明天你大姐夫、二姐夫来了之后，我问你这块黄金有多重，你就说三两，明白吗？”
　　三女婿忙点头说：“知道了。”
　　第二天，三位女婿都来了，财主拿出一块红布包着的黄金，说：“谁能说准这块黄金有多重，我就给谁。”
　　大女婿马上就说：“起码有一斤。”二女婿摇着头说：“不对，只有八两。”财主望了望三女婿说：“你估计呢？”三女婿想了一下，说：“三两。”
　　财主让丫环找来秤一称，果然是三两。大女婿和二女婿心想：老三平日里傻傻的，怎么今天这么准？肯定有问题！
　　眼看黄金就要归三女婿了，两个女婿连忙说：“这不算数，再比一次。”
　　这时，财主夫人正巧进屋，大女婿说：“我们来估计岳母大人有多重，谁说准了就给谁。”财主只好依着他。
　　大女婿打量了岳母一番，胸有成竹地说：“有一百八十斤。”二女婿用手比划着说：“应该有一百五十斤。”两人说完都望着三女婿，三女婿想都不用想，冲口而出道：“三两。”
　　大家哈哈大笑，财主只能在一旁摇头。可三女婿不依不饶，非要称一次定输赢。财主只能让丫环找来一杆大秤，还有箩筐和绳子，打算把秤架在树杈上称。可刚把财主夫人放进挂在秤上的箩筐里，绳子忽然断了，吓得财主夫人屁滚尿流。
　　三女婿喊叫起来：“我说是三两嘛，你们不相信，还要往里面掺水。”
　　
　　先要说清楚
　　■ 天一
　　
　　老谭是一家银行的信贷科长。找  他贷款，说难真难，一般人申请个三五十次，他也不见得搭理你；可说容易也真容易，一句话，只要填饱他的胃袋子和钱袋子，一切都好说。
　　这天晚上，老谭从“喝得美”大酒店里摇摇晃晃地走出来。看他那红光满面的样子，不消说，这顿酒喝得相当成功，肯定又是宾主尽欢、各取所需了。
　　 
　　老谭跟主人道了别，嘴里哼着小曲，一步三晃地往家走。刚晃了没几步，就被一个人拦了下来，对方恭恭敬敬招呼道：“谭科长。”
　　老谭斜着醉眼一看：“啊呀，刘经理，这么巧啊。”
　　刘经理满脸堆笑：“不是巧，我是特意在这里等您的。谭科长，我那个贷款……”
　　老谭张嘴打了个酒嗝，道：“我说刘经理，你不要着急，我们正在研究呢。不过，先要说清楚……”他一边说，一边摸了摸扣子。
　　刘经理心领神会，这是要回扣呢，忙说：“清楚、清楚，谭科长，您明天有没有空？我想请您吃个便饭，顺便汇报一下工作。”说着，伸手搀扶了一下老谭，顺手把一张银行卡塞进了他的口袋里。
　　真是上路！老谭酒醉人不醉，佯装不觉，哈哈一笑：“好吧，咱们明天再说。”
　　刘经理知道事情成了一半，喜道：“那咱们一言为定，明天见。”刚想转身，忽又想起什么，殷勤地问，“谭科长，要不要我送您回家？”
　　老谭大着舌头：“不、不用，这点、点、点酒，小意思。”说着右手一甩，把刘经理撇在身后，接着又踉踉跄跄继续往前走，可走出没多远，又被一个人拦了下来。
　　对方毕恭毕敬：“您好，打扰一下。”
　　老谭抬眼一看，不认识，心想肯定又是求自己贷款的，就问：“你是谁？找我要钱吗？”
　　对方大吃一惊：“我没说，您都知道了？”
　　老谭哼了一声，不屑地说：“你们找我，除了要钱，还能干什么？”
　　对方深鞠一躬，说：“大哥，我是从外地来这里出差的，没想到钱包让人给偷了，连回去的火车票都买不起了。我人生地不熟的，在这里求了半天，还差十八块钱才够。您行行好，就帮我一把吧。大哥，您留下名字和地址，我保证，回去以后一定把钱还给您……”
　　老谭酒意上涌，头昏脑胀的，一听这长篇大论就不耐烦：“真嗦，要钱是吧，要多少？”
　　那人看这糊涂酒鬼这么痛快，心中窃喜，伸过手来，说：“十八块，大哥，您多给点也行，我都一天没吃饭了。”
　　老谭就伸手去兜里摸钱。这时候，周围有几个闲人围过来看热闹，有人见老谭喝高了，小声提醒说：“别上当，他是骗子，都在这里要了两天钱了。”
　　老谭才不听他的，从口袋里摸出一张二十元的钞票递过去：“给，拿去吧。”
　　眼看着钞票就要到骗子的手里，关键时刻，老谭总算悬崖勒马，手一缩，把钱又收回来，说：“别着急，我可没喝多，不糊涂。”
　　那人以为露馅了，急了：“大哥，我真的不是骗子，您就好心帮帮我吧！”
　　老谭摇晃着脑袋说：“给你钱可以，不过，先要说清楚。”说着，他一摸衣服扣子。
　　那人茫然不解：“大哥，说清楚什么？”
　　老谭又摸一遍扣子，见对方还傻乎乎地装糊涂，火了：“真是不懂规矩，想从我手里借钱，先要说清楚—给我的回扣是多少？”
　　 （本栏题图、插图：顾子易王俭）
　　
　　 
　　我爱记歌词
　　东关
　　
　　最近，“唱翻天”歌厅组织了一个
　　 “我爱记歌词”比赛，这个比赛一不比歌喉，二不比唱功，就是比你的记忆力。只要能连续唱对一百首歌的歌词，就可以捧走二十万元巨奖。
　　可是，活动举行了快半年，愣是没人能拿走那笔奖金。为什么？太难了！这一百首歌都是随机产生的，要想把这些歌词全部唱对，一字不差，可不容易哪。
　　尽管如此，前来挑战的人还是天天爆满，连几十、几百公里以外的高手都给吸引来了。不过，他们无一不是高兴而来、遗憾而走。
　　“唱翻天”的老板刘麻子却是乐得合不拢嘴。想当初，歌厅生意清淡，刘麻子无意间从电视里学到这个点子，只是想吸引一下人气来着。没想到，竟让“唱翻天”声名远扬，自己更是赚得盆满钵溢。
　　这天晚上，歌厅里依然人头攒动，众人争相上台一试身手。刘麻子看看时间不早了，正想宣布今晚的比赛结束，却见一个人走上台来，四十多岁的样子，看着有几分面熟。
　　那人略显紧张，拿过话筒后，红着脸说：“开……开、开始吧。”竟有几分口吃。
　　刘麻子暗暗好笑：口齿都不清，你还想拿走大奖？
　　不料，十首歌过后，刘麻子不由刮目相看，此人虽然讲话口吃，但唱起歌来却相当流利，记忆力也不错，观众群里已经有人开始欢呼了。
　　三十首歌过后，观众们疯狂了，拼命跺脚、尖叫，若不是歌厅在一楼，楼上还有几层住宅房压着，只怕房顶都要被掀翻了。
　　五十首歌过后，刘麻子头上开始冒汗。他抬表一看，已是凌晨两点了，忙上台宣布暂停比赛，后面的五十首歌等晚上再继续接上。
　　天亮后，有高手冲击“我爱记歌词”比赛大奖的消息不胫而走。当天上午，歌厅的门票就被抢购一空了。电视台更是派出了摄制组，准备进行现场直播。
　　当晚，歌厅里人山人海。在观众们的助威声中，那人一首接一首地唱，势如破竹，等到第一百首歌唱完，全场一片静默，过了两秒钟，突然爆发出惊天动地的欢呼声。
　　刘麻子傻眼了，没办法，只好强装欢颜，亲手将二十万元现金捧到对方怀里。
　　记者自然不会放过这激动人心的时刻，现场采访大奖得主：“你能记住这么多歌曲，一定经常唱歌吧？”
　　那人摇摇头：“没有，我只是天天听人家唱歌。”
　　记者感叹道：“那你的记忆力一定十分超群！”
　　那人谦虚地说：“不是，关键是我天天听、夜夜听，时间一长，自然就记住了。你要是每天听十几个小时，你也会记住的。”
　　记者万分佩服：“一天要听十几个小时？真是太刻苦了！你是不是为了拿这次的大奖，专门这样练习的？”
　　那人白了记者一眼：“练习？你想象力可真够丰富的！你以为我愿意听啊？我是不得不听！”
　　 
 1 [ 2 ]       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第2期   漫画故事  作者：李传胜  字体：
   【 大  中  小 】 
 
　　冤枉儿子
　　(文：李传胜；图：包丰一）
　　马大哈把自己的胡子剃掉了，回到家中，考问儿子马小哈：“儿子，看得出爸爸有什么不一样吗？”
　　 
　　马小哈上下看了看爸爸，竟一口答道：“没什么不一样啊。”
　　马大哈不乐意了，指指下巴说：“看清楚点，我的胡子没了！”
　　“胡子没了又怎么啦？”马小哈像受了天大的冤枉似的，说，“又不是我拿的！”
　　 
       
整理者：绝情谷  2009年03月 TOP              故事会           
    故事会        >>> 2009年第2期   快乐辞典  作者：佚名  字体：
   【 大  中  小 】 
 
　　越来越怪的歌名
　　
　　如今，很多流行歌曲都给人似曾相识的感觉，看看下面的几组歌名，排列在一起，是不是让你捧腹大笑呢？
　　
　　◆王心凌《爱你》，S·H·E《我爱你》，Beyond《真的爱你》，李宗盛《我是真的爱你》，言承旭《我是真的真的很爱你》。点评：有这么复杂吗?
　　◆王菲《如果你是假的》，邓丽君《假如我是真的》，萧正楠《假如我是假的》，孟庭苇《真的还是假的》。点评：能退货吗?
　　◆朴树《我爱你，再见》，丁薇《再见，我爱你》。点评：不送……
　　◆姜育恒《爱我你怕了吗》，孙燕姿《害怕》，王力宏《不要害怕》，潘玮柏《我不怕》，赵薇《不怕》，郭美美《不怕不怕啦》，郑伊健《怕什么，什么也不怕》。点评：真是人多胆子大!
　　◆萧亚轩《一辈子做你的女孩》，龙梅子《下辈子做你的女人》。点评：不错，成熟了！
　　◆苏永康《男人不该让女人流泪》，陈小春《女人不该让男人太累》。点评：多么体贴的小夫妻啊！
　　◆成龙《我是谁》，蟑螂《忘了我是谁》，蔡依林《你是谁》，许志安《忘了你是谁》。点评：你们都需要补脑！
　　◆董文华《春天的故事》，杨千桦《夏天的故事》，陈艾玲《秋天的故事》，马天宇《冬天的故事》。点评：小红帽，来！听狼外婆给你讲故事！（作者：王尚；推荐者：桓学然）
　　 
       
整理者：绝情谷  2009年03月 TOP        

Chapter 7. Basic Template Terminology

So far we have introduced the basic concept of templates in C++. Before we go into details, let's look at the terms of the concepts we use. This is necessary because, inside the C++ community (and even in the standard), there is a lack of precision regarding concepts and terminology.

7.1 "Class Template" or "Template Class"?

In C++, structs, classes, and unions are collectively called class types. Without additional qualification, the word "class" in plain text type is meant to include class types introduced with either the keyword class or the keyword struct. Refer to notes below. Note specifically that "class type" includes unions, but "class" does not.

Note: In C++, the only difference between class and struct is that the default access for class is private whereas the default access for struct is public. However, we prefer to use class for types that use new C++ features, and we use struct for ordinary C data structure that can be used as "plain old data" (POD).

There is some confusion about how a class that is a template is called:

·         The term class template states that the class is a template. That is, it is a parameterized description of a family of classes.

·         The term template class on the other hand has been used

- as a synonym for class template.

- to refer to classes generated from templates.

- to refer to classes with a name that is a template-id.

The difference between the second and third meaning is somewhat subtle and unimportant for the remainder of the text.

Because of this imprecision, we avoid the term template class in this book.

Similarly, we use function template and member function template, but avoid template function and template member function.

7.2 Instantiation and Specialization

The process of creating a regular class, function, or member function from a template by substituting actual values for its arguments is called template instantiation. This resulting entity (class, function, or member function) is generically called a specialization.

However, in C++ the instantiation process is not the only way to produce a specialization. Alternative mechanisms allow the programmer to specify explicitly a declaration that is tied to a special substitution of template parameters. As we introduced in Section 3.3 on page 27, such a specialization is introduced by template<>:

template <typename T1, typename T2>    // primary class template 

class MyClass { 

  … 

}; 

template<>                             // explicit specialization 

class MyClass<std::string,float> { 

  … 

}; 

Strictly speaking, this is called a so-called explicit specialization (as opposed to an instantiated or generated specialization).

As introduced in Section 3.4 on page 29, specializations that still have template parameters are called partial specializations:

template <typename T>                 // partial specialization 

class MyClass<T,T> { 

  … 

}; 

template <typename T>                 // partial specialization 

class MyClass<bool,T> { 

  … 

}; 

When talking about (explicit or partial) specializations, the general template is also called the primary template.

7.3 Declarations versus Definitions

So far, the words declaration and definition have been used only a few times in this book. However, these words carry with them a rather precise meaning in standard C++, and that is the meaning that we use.

A declaration is a C++ construct that introduces or reintroduces a name into a C++ scope. This introduction always includes a partial classification of that name, but the details are not required to make a valid declaration. For example:

class C;        // a declaration of C as a class 

void f(int p);  // a declaration of f() as a function and p as a named parameter 

extern int v;   // a declaration of v as a variable 

Note that even though they have a "name," macro definitions and goto labels are not considered declarations in C++.

Declarations become definitions when the details of their structure are made known or, in the case of variables, when storage space must be allocated. For class type and function definitions, this means a brace-enclosed body must be provided. For variables, initializations and a missing extern lead to definitions. Here are examples that complement the preceding nondefinition declarations:

class C {};        // definition (and declaration) of class C 

void f(int p) {    // definition (and declaration) of function f() 

    std::cout << p << std::endl; 

} 

extern int v = 1;  // an initializer makes this a definition for v 

int w;             // global variable declarations not preceded by 

                   // extern are also definitions 

By extension, the declaration of a class template or function template is called a definition if it has a body. Hence,

template <typename T> 

void func (T); 

is a declaration that is not a definition, whereas

template <typename T> 

class S {}; 

is in fact a definition.

7.4 The One-Definition Rule

The C++ language definition places some constraints on the redeclaration of various entities. The totality of these constraints is known as the one-definition rule or ODR. The details of this rule are quite complex and span a large variety of situations. Later chapters illustrate the various resulting facets in each applicable context, and you can find a complete description of the ODR in Appendix A. For now, it suffices to remember the following ODR basics:

·         Noninline functions and member functions, as well as global variables and static data members should be defined only once across the whole program.

·         Class types (including structs and unions) and inline functions should be defined at most once per translation unit, and all these definitions should be identical.

A translation unit is what results from preprocessing a source file; that is, it includes the contents named by #include directives.

In the remainder of this book, linkable entity means one of the following: a noninline function or member function, a global variable or a static data member, including any such things generated from a template.

7.5 Template Arguments versus Template Parameters

Compare the following class template

template <typename T, int N> 

class ArrayInClass { 

  public: 

    T array[N]; 

}; 

with a similar plain class:

class DoubleArrayInClass { 

  public: 

    double array[10]; 

}; 

The latter becomes essentially equivalent to the former if we replace the parameters T and N by double and 10 respectively. In C++, the name of this replacement is denoted as

ArrayInClass<double,10> 

Note how the name of the template is followed by so-called template arguments in angle brackets.

Regardless of whether these arguments are themselves dependent on template parameters, the combination of the template name, followed by the arguments in angle brackets, is called a template-id.

This name can be used much like a corresponding nontemplate entity would be used. For example:

int main() 

{ 

    ArrayInClass<double,10> ad; 

    ad.array[0] = 1.0; 

} 

It is essential to distinguish between template parameters and template arguments. In short, you can say that you "pass arguments to become parameters." Refer to notes below. Or more precicely:

Note: In the academic world, arguments are sometimes called actual parameters whereas parameters are called formal parameters.

·         Template parameters are those names that are listed after the keyword template in the template declaration or definition (T and N in our example).

·         Template arguments are the items that are substituted for template parameters (double and 10 in our example). Unlike template parameters, template arguments can be more than just "names."

The substitution of template parameters by template arguments is explicit when indicated with a template-id, but there are various situations when the substitution is implicit (for example, if template parameters are substituted by their default arguments).

A fundamental principle is that any template argument must be a quantity or value that can be determined at compile time. As becomes clear later, this requirement translates into dramatic benefits for the run-time costs of template entities. Because template parameters are eventually substituted by compile-time values, they can themselves be used to form compile-time expressions. This was exploited in the ArrayInClass template to size the member array array. The size of an array must be a so-called constant-expression, and the template parameter N qualifies as such.

We can push this reasoning a little further: Because template parameters are compile-time entities, they can also be used to create valid template arguments. Here is an example:

template <typename T> 

class Dozen { 

  public: 

    ArrayInClass<T,12> contents; 

}; 

Note how in this example the name T is both a template parameter and a template argument. Thus, a mechanism is available to enable the construction of more complex templates from simpler ones. Of course, this is not fundamentally different from the mechanisms that allow us to assemble types and functions.

 

Chapter 6. Using Templates in Practice

Template code is a little different from ordinary code. In some ways templates lie somewhere between macros and ordinary (nontemplate) declarations. Although this may be an oversimplification, it has consequences not only for the way we write algorithms and data structures using templates, but also for the day-to-day logistics of expressing and analyzing programs involving templates.

In this chapter we address some of these practicalities without necessarily delving into the technical details that underlie them. Many of these details are explored in Chapter 10. To keep the discussion simple, we assume that our C++ compilation systems consist of fairly traditional compilers and linkers (C++ systems that don't fall in this category are quite rare).

6.1 The Inclusion Model

There are several ways to organize template source code. This section presents the most popular approach as of the time of this writing: the inclusion model.

6.1.1 Linker Errors

Most C and C++ programmers organize their nontemplate code largely as follows:

·         Classes and other types are entirely placed in header files. Typically, this is a file with a .hpp (or .H, .h, .hh, .hxx) filename extension.

·         For global variables and (noninline) functions, only a declaration is put in a header file, and the definition goes into a so-called dot-C file. Typically, this is a file with a .cpp (or .C, .c, .cc, or .hxx) filename extension.

This works well: It makes the needed type definition easily available throughout the program and avoids duplicate definition errors on variables and functions from the linker.

With these conventions in mind, a common error about which beginning template programmers complain is illustrated by the following (erroneous) little program. As usual for "ordinary code," we declare the template in a header file:

// basics/myfirst.hpp 

#ifndef MYFIRST_HPP 

#define MYFIRST_HPP 

// declaration of template 

template <typename T> 

void print_typeof (T const&); 

#endif // MYFIRST_HPP 

print_typeof() is the declaration of a simple auxiliary function that prints some type information. The implementation of the function is placed in a dot-C file:

// basics/myfirst.cpp 

#include <iostream> 

#include <typeinfo> 

#include "myfirst.hpp" 

// implementation/definition of template 

template <typename T> 

void print_typeof (T const& x) 

{ 

    std::cout << typeid(x).name() << std::endl; 

} 

The example uses the typeid operator to print a string that describes the type of the expression passed to it (see Section 5.6 on page 58).

Finally, we use the template in another dot-C file, into which our template declaration is #included:

// basics/myfirstmain.cpp 

#include "myfirst.hpp" 

// use of the template 

int main() 

{ 

    double ice = 3.0; 

    print_typeof(ice);  // call function template for type double 

} 

A C++ compiler will most likely accept this program without any problems, but the linker will probably report an error, implying that there is no definition of the function print_typeof().

The reason for this error is that the definition of the function template print_typeof() has not been instantiated. In order for a template to be instantiated, the compiler must know which definition should be instantiated and for what template arguments it should be instantiated. Unfortunately, in the previous example, these two pieces of information are in files that are compiled separately. Therefore, when our compiler sees the call to print_typeof() but has no definition in sight to instantiate this function for double, it just assumes that such a definition is provided elsewhere and creates a reference (for the linker to resolve) to that definition. On the other hand, when the compiler processes the file myfirst.cpp, it has no indication at that point that it must instantiate the template definition it contains for specific arguments.

6.1.2 Templates in Header Files

The common solution to the previous problem is to use the same approach that we would take with macros or with inline functions: We include the definitions of a template in the header file that declares that template. For our example, we can do this by adding

#include "myfirst.cpp" 

at the end of myfirst.hpp or by including myfirst.cpp in every dot-C file that uses the template. A third way, of course, is to do away entirely with myfirst.cpp and rewrite myfirst.hpp so that it contains all template declarations and template definitions:

// basics/myfirst2.hpp 

#ifndef MYFIRST_HPP 

#define MYFIRST_HPP 

#include <iostream> 

#include <typeinfo> 

// declaration of template 

template <typename T> 

void print_typeof (T const&); 

// implementation/definition of template 

template <typename T> 

void print_typeof (T const& x) 

{ 

    std::cout << typeid(x).name() << std::endl; 

} 

#endif // MYFIRST_HPP 

This way of organizing templates is called the inclusion model. With this in place, you should find that our program now correctly compiles, links, and executes.

There are a few observations we can make at this point. The most notable is that this approach has considerably increased the cost of including the header file myfirst.hpp. In this example, the cost is not the result of the size of the template definition itself, but the result of the fact that we must also include the headers used by the definition of our template梚n this case <iostream> and <typeinfo>. You may find that this amounts to tens of thousands of lines of code because headers like <iostream> contain similar template definitions.

This is a real problem in practice because it considerably increases the time needed by the compiler to compile significant programs. We will therefore examine some possible ways to approach this problem in upcoming sections. However, real-world programs quickly end up taking hours to compile and link (we have been involved in situations in which it literally took days to build a program completely from its source code).

Despite this build-time issue, we do recommend following this inclusion model to organize your templates when possible. We examine two alternatives, but in our opinion their engineering deficiencies are more serious than the build-time issue discussed here. They may have other advantages not directly related to the engineering aspects of software development, however.

Another (more subtle) observation about the inclusion approach is that noninline function templates are distinct from inline functions and macros in an important way: They are not expanded at the call site. Instead, when they are instantiated, they create a new copy of a function. Because this is an automatic process, a compiler could end up creating two copies in two different files, and some linkers could issue errors when they find two distinct definitions for the same function. In theory, this should not be a concern of ours: It is a problem for the C++ compilation system to accommodate. In practice, things work well most of the time, and we don't need to deal with this issue at all. For large projects that create their own library of code, however, problems occasionally show up. A discussion of instantiation schemes in Chapter 10 and a close study of the documentation that came with the C++ translation system (compiler) should help address these problems.

Finally, we need to point out that what applies to the ordinary function template in our example also applies to member functions and static data members of class templates, as well as to member function templates.

6.2 Explicit Instantiation

The inclusion model ensures that all the needed templates are instantiated. This happens because the C++ compilation system automatically generates those instantiations as they are needed. The C++ standard also offers a construct to instantiate templates manually: the explicit instantiation directive.

6.2.1 Example of Explicit Instantiation

To illustrate manual instantiation, let's revisit our original example that leads to a linker error (see page 62). To avoid this error we add the following file to our program:

// basics/myfirstinst.cpp 

#include "myfirst.cpp" 

// explicitly instantiate print_typeof() for type double 

template void print_typeof<double>(double const&); 

The explicit instantiation directive consists of the keyword template followed by the fully substituted declaration of the entity we want to instantiate. In our example, we do this with an ordinary function, but it could be a member function or a static data member. For example:

// explicitly instantiate a constructor of MyClass<> for int 

template MyClass<int>::MyClass(); 

// explicitly instantiate a function template max() for int 

template int const& max (int const&, int const&); 

You can also explicitly instantiate a class template, which is short for requesting the instantiation of all its instantiatable members. This excludes members that were previously specialized as well as those that were already instantiated:

// explicitly instantiate class Stack<> for int: 

template class Stack<int>; 

// explicitly instantiate some member functions of Stack<> for strings: 

template Stack<std::string>::Stack(); 

template void Stack<std::string>::push(std::string const&); 

template std::string Stack<std::string>::top(); 

// ERROR: can't explicitly instantiate a member function of a 

//        class that was itself explicitly instantiated: 

template Stack<int>::Stack(); 

There should be, at most, one explicit instantiation of each distinct entity in a program. In other words, you could explicitly instantiate both print_typeof<int> and print_typeof<double>, but each directive should appear only once in a program. Not following this rule usually results in linker errors that report duplicate definitions of the instantiated entities.

Manual instantiation has a clear disadvantage: We must carefully keep track of which entities to instantiate. For large projects this quickly becomes an excessive burden; hence we do not recommend it. We have worked on several projects that initially underestimated this burden, and we came to regret our decision as the code matured.

However, explicit instantiation also has a few advantages because the instantiation can be tuned to the needs of the program. Clearly, the overhead of large headers is avoided. The source code of template definition can be kept hidden, but then no additional instantiations can be created by a client program. Finally, for some applications it can be useful to control the exact location (that is, the object file) of a template instance. With automatic instantiation, this may not be possible (see Chapter 10 for details).

6.2.2 Combining the Inclusion Model and Explicit Instantiation

To keep the decision open whether to use the inclusion model or explicit instantiation, we can provide the declaration and the definition of templates in two different files. It is common practice to have both files named as header files (using an extension ordinarily used for files that are intended to be #included), and it is probably wise to stick to this convention. (Thus, myfirst.cpp of our motivating example becomes myfirstdef.hpp, with preprocessor guards around the code inserted.) Figure 6.1 demonstrates this for a Stack<> class template.

Figure 6.1. Separation of template declaration and definition

stack.hpp:

#ifndef STACK_HPP
#define STACK_HPP

#include <vector>

template  <typename T>
class Stack {
private:
    std::vector<T> elems;
public:
    Stack();
    void push (T const&);
    void pop();
    T top() const;
}

#endif

stackdef.hpp:

#ifndef STACKDEF_HPP
#define STACKDEF_HPP

#include “stack.hpp”

template <typename T>
void Stack<T>::push (T const& elem)
{
    elem.push_back (elem);
}
…

#endif

Now if we want to use the inclusion model, we can simply include the definition header file stackdef.hpp. Alternatively, if we want to instantiate the templates explicitly, we can include the declaration header stack.hpp and provide a dot-C file with the necessary explicit instantiation directives (see Figure 6.2).

Figure 6.2. Explicit instantiation with two template header files

stacktest1.cpp

#include “stack.hpp”
#include <iostream>
#include <string>

int main()
{
    Stack<int> intStack;
    intStack.push(42);
    std::cout << intStack.top() << std::endl;
    intStack.pop();

Stack<std::string> stringStack;
    stringStack.push (“hello”);
    std::cout << stringStack.top() << std::endl;
}

stack_inst.cpp:

#include “stackdef.hpp”
#include <string>

// instantiate class Stack<> for int
template Stack<int>;

// instantiate some member functions of Stack<> for strings
template Stack<std::string>::Stack();
template void Stack<std::string>::push (std::string const&);
template std::string Stack<std::string>::top();

 6.3 The Separation Model

Both approaches advocated in the previous sections work well and conform entirely to the C++ standard. However, this same standard also provides the alternative mechanism of exporting templates. This approach is sometimes called the C++ template separation model.

6.3.1 The Keyword export

In principle, it is quite simple to make use of the export facility: Define the template in just one file, and mark that definition and all its nondefining declarations with the keyword export. For the example in the previous section, this results in the following function template declaration:

// basics/myfirst3.hpp 

#ifndef MYFIRST_HPP 

#define MYFIRST_HPP 

// declaration of template 

export 

template <typename T> 

void print_typeof (T const&); 

#endif // MYFIRST_HPP 

Exported templates can be used without their definition being visible. In other words, the point where a template is being used and the point where it is defined can be in two different translation units. In our example, the file myfirst.hpp now contains only the declaration of the member functions of the class template, and this is sufficient to use those members. Comparing this with the original code that was triggering linker errors, we had to add only one export keyword in our code and things now work just fine.

Within a preprocessed file (that is, within a translation unit), it is sufficient to mark the first declaration of a template with export. Later redeclarations, including definitions, implicitly keep that attribute. This is why myfirst.cpp does not need to be modified in our example. The definitions in this file are implicitly exported because they were so declared in the #included header file. On the other hand, it is perfectly acceptable to provide redundant export keywords on template definitions, and doing so may improve the readability of the code.

The keyword export really applies to function templates, member functions of class templates, member function templates, and static data members of class templates. export can also be applied to a class template declaration. It implies that every one of its exportable members is exported, but class templates themselves are not actually exported (hence, their definitions still appear in header files). You can still have implicitly or explicitly defined inline member functions. However, these inline functions are not exported:

export template <typename T> 

class MyClass { 

  public: 

    void memfun1();      // exported 

    void memfun2() {     // not exported because implicitly inline 

        … 

    } 

    void memfun3();      // not exported because explicitly inline 

    … 

}; 

template <typename T> 

inline void MyClass<T>::memfun3 () 

{ 

     … 

} 

However, note that the keyword export cannot be combined with inline and must always precede the keyword template. The following is invalid:

template <typename T> 

class Invalid { 

  public: 

    export void wrong(T);      // ERROR: export not followed by template 

}; 

export template<typename T>    // ERROR: both export and inline 

inline void Invalid<T>::wrong(T) 

{ 

} 

export inline T const& max (T const&a, T const& b) 

{                              // ERROR: both export and inline 

    return a < b ? b : a; 

} 

6.3.2 Limitations of the Separation Model

At this point it is reasonable to wonder why we're still advocating the inclusion approach when exported templates seem to offer just the right magic to make things work. There are a few different aspects to this choice.

First, even four years after the standard came out, only one company has actually implemented support for the export keyword. Refer to notes below. Therefore, experience with this feature is not as widespread as other C++ features. Clearly, this also means that at this point experience with exported templates is fairly limited, and all our observations will ultimately have to be taken with a grain of salt. It is possible that some of our misgivings will be addressed in the future (and we show how to prepare for that eventuality).

Note: As far as we know, Edison Design Group, Inc. (EDG) is still that company (see [EDG]). Their technology is available through other vendors, however.

Second, although export may seem quasi-magical, it is not actually magical. Ultimately, the instantiation process has to deal with both the place where a template is instantiated and the place where its definition appears. Hence, although these two seem neatly decoupled in the source code, there is an invisible coupling that the system establishes behind the scenes. This may mean, for example, that if the file containing the definition changes, both that file and all the files that instantiate the templates in that file may need to be recompiled. This is not substantially different from the inclusion approach, but it is no longer obviously visible in the source code. As a consequence, dependency management tools (such as the popular make and nmake programs) that use traditional source-based techniques no longer work. It also means that quite a few bits of extra processing by the compiler are needed to keep all the bookkeeping straight; and in the end, the build times may not be better than those of the inclusion approach.

Finally, exported templates may lead to surprising semantic consequences, the details of which are explained in Chapter 10.

A common misconception is that the export mechanism offers the potential of being able to ship libraries of templates without revealing the source code for their definitions (just like libraries of nontemplate entities). Refer to notes below. This is a misconception in the sense that hiding code is not a language issue: It would be equally possible to provide a mechanism to hide included template definitions as to hide exported template definitions. Although this may be feasible (the current implementations do not support this model), it unfortunately creates new challenges in dealing with template compilation errors that need to refer to the hidden source code.

Notes: Not everybody considers this closed-source approach a plus.

6.3.3 Preparing for the Separation Model

One workable idea is to prepare our sources in such a way that we can easily switch between the inclusion and export models using a harmless dose of preprocessor directives. Here is how it can be done for our simple example:

// basics/myfirst4.hpp 

#ifndef MYFIRST_HPP 

#define MYFIRST_HPP 

// use export if USE_EXPORT is defined 

#if defined(USE_EXPORT) 

#define EXPORT export 

#else 

#define EXPORT 

#endif 

// declaration of template 

EXPORT 

template <typename T> 

void print_typeof (T const&); 

// include definition if USE_EXPORT is not defined 

#if !defined(USE_EXPORT) 

#include "myfirst.cpp" 

#endif 

#endif // MYFIRST_HPP 

By defining or omitting the preprocessor symbol USE_EXPORT, we can now select between the two models. If a program defines USE_EXPORT before it includes myfirst.hpp, the separation model is used:

// use separation model: 

#define USE_EXPORT 

#include "myfirst.hpp" 

… 

If a program does not define USE_EXPORT, the inclusion model is used because in this case myfirst.hpp automatically includes the definitions in myfirst.cpp:

// use inclusion model: 

#include "myfirst.hpp" 

… 

Despite this flexibility, we should reiterate that besides the obvious logistical differences, there can be subtle semantic differences between the two models.

Note that we can also explicitly instantiate exported templates. In this case the template definition can be in another file. To be able to choose between the inclusion model, the separation model, and explicit instantion, we can combine the organization controlled by USE_EXPORT with the conventions described in Section 6.2.2 on page 67.

6.4 Templates and inline

Declaring short functions to be inline is a common tool to improve the running time of programs. The inline specifier indicates to the implementation that inline substitution of the function body at the point of call is preferred over the usual function call mechanism. However, an implementation is not required to perform this inline substitution at the point of call.

Both function templates and inline functions can be defined in multiple translation units. This is usually achieved by placing the definition in a header file that is included by multiple dot-C files.

This may lead to the impression that function templates are inline by default. However, they're not. If you write function templates that should be handled as inline functions, you should use the inline specifier (unless the function is inline already because it is defined inside a class definition).

Therefore, many short template functions that are not part of a class definition should be declared with inline. Refer to notes below.

Notes: We may not always apply this rule of thumb because it may distract from the topic at hand.

6.5 Precompiled Headers

Even without templates, C++ header files can become very large and therefore take a long time to compile. Templates add to this tendency, and the outcry of waiting programmers has in many cases driven vendors to implement a scheme usually known as precompiled headers. This scheme operates outside the scope of the standard and relies on vendor-specific options. Although we leave the details on how to create and use precompiled header files to the documentation of the various C++ compilation systems that have this feature, it is useful to gain some understanding of how it works.

When a compiler translates a file, it does so starting from the beginning of the file and works through to the end. As it processes each token from the file (which may come from #included files), it adapts its internal state, including such things as adding entries to a table of symbols so they may be looked up later. While doing so, the compiler may also generate code in object files.

The precompiled header scheme relies on the fact that code can be organized in such a manner that many files start with the same lines of code. Let's assume for the sake of argument that every file to be compiled starts with the same N lines of code. We could compile these N lines and save the complete state of the compiler at that point in a so-called precompiled header. Then, for every file in our program, we could reload the saved state and start compilation at line N+1. At this point it is worthwhile to note that reloading the saved state is an operation that can be orders of magnitude faster than actually compiling the first N lines. However, saving the state in the first place is typically more expensive than just compiling the N lines. The increase in cost varies roughly from 20 to 200 percent.

The key to making effective use of precompiled headers is to ensure that梐s much as possible?files start with a maximum number of common lines of code. In practice this means the files must start with the same #include directives, which (as mentioned earlier) consume a substantial portion of our build time. Hence, it can be very advantageous to pay attention to the order in which headers are included. For example, the following two files

#include <iostream> 

#include <vector> 

#include <list> 

… 

and

#include <list> 

#include <vector> 

… 

inhibit the use of precompiled headers because there is no common initial state in the sources.

Some programmers decide that it is better to #include some extra unnecessary headers than to pass on an opportunity to accelerate the translation of a file using a precompiled header. This decision can considerably ease the management of the inclusion policy. For example, it is usually relatively straightforward to create a header file named std.hpp that includes all the standard headers. Refer to notes below.

Notes: In theory, the standard headers do not actually need to correspond to physical files. In practice, however, they do, and the files are very large.

#include <iostream> 

#include <string> 

#include <vector> 

#include <deque> 

#include <list> 

… 

This file can then be precompiled, and every program file that makes use of the standard library can then simply be started as follows:

#include "std.hpp" 

… 

Normally this would take a while to compile, but given a system with sufficient memory, the precompiled header scheme allows it to be processed significantly faster than almost any single standard header would require without precompilation. The standard headers are particularly convenient in this way because they rarely change, and hence the precompiled header for our std.hpp file can be built once. Refer to notes below. Otherwise, precompiled headers are typically part of the dependency configuration of a project (for example, they are updated as needed by the popular make tool).

Notes: Some committee members find the concept of a comprehensive std.hpp header so convenient that they have suggested introducing it as a standard header. We would then be able to write #include <std>. Some even suggest that it should be implicitly included so that all the standard library facilities become available without #include.

One attractive approach to manage precompiled headers is to create layers of precompiled headers that go from the most widely used and stable headers (for example, our std.hpp header) to headers that aren't expected to change all the time and therefore are still worth precompiling. However, if headers are under heavy development, creating precompiled headers for them can take more time than what is saved by reusing them. A key concept to this approach is that a precompiled header for a more stable layer can be reused to improve the precompilation time of a less stable header. For example, suppose that in addition to our std.hpp header (which we have precompiled), we also define a core.hpp header that includes additional facilities that are specific to our project but nonetheless achieve a certain level of stability:

#include "std.hpp" 

#include "core_data.hpp" 

#include "core_algos.hpp" 

… 

Because this file starts with #include "std.hpp", the compiler can load the associated precompiled header and continue with the next line without recompiling all the standard headers. When the file is completely processed, a new precompiled header can be produced. Applications can then use #include "core.hpp" to provide access quickly to large amounts of functionality because the compiler can load the latter precompiled header.

6.6 Debugging Templates

Templates raise two classes of challenges when it comes to debugging them. One set of challenges is definitely a problem for writers of templates: How can we ensure that the templates we write will function for any template arguments that satisfy the conditions we document? The other class of problems is almost exactly the opposite: How can a user of a template find out which of the template parameter requirements it violated when the template does not behave as documented?

Before we discuss these issues in depth, it is useful to contemplate the kinds of constraints that may be imposed on template parameters. In this section we deal mostly with the constraints that lead to compilation errors when violated, and we call these constraints syntactic constraints. Syntactic constraints can include the need for a certain kind of constructor to exist, for a particular function call to be unambiguous, and so forth. The other kind of constraint we call semantic constraints. These constraints are much harder to verify mechanically. In the general case, it may not even be practical to do so. For example, we may require that there be a < operator defined on a template type parameter (which is a syntactic constraint), but usually we'll also require that the operator actually defines some sort of ordering on its domain (which is a semantic constraint).

The term concept is often used to denote a set of constraints that is repeatedly required in a template library. For example, the C++ standard library relies on such concepts as random access iterator and default constructible. Concepts can form hierarchies in the sense that one concept can be a refinement of another. The more refined concept includes all the constraints of the other concept but adds a few more. For example, the concept random access iterator refines the concept bidirectional iterator in the C++ standard library. With this terminology in place, we can say that debugging template code includes a significant amount of determining how concepts are violated in the template implementation and in their use.

6.6.1 Decoding the Error Novel

Ordinary compilation errors are normally quite succinct and to the point. For example, when a compiler says "class X has no member 'fun'," it usually isn't too hard to figure out what is wrong in our code (for example, we might have mistyped run as fun). Not so with templates. Consider the following relatively simple code excerpt using the C++ standard library. It contains a fairly small mistake: list<string> is used, but we are searching using a greater<int> function object, which should have been a greater<string> object:

std::list<std::string> coll; 

… 

// Find the first element greater than "A" 

std::list<std::string>::iterator pos; 

pos = std::find_if(coll.begin(),coll.end(),                // range 

                   std::bind2nd(std::greater<int>(),"A")); // criterion 

This sort of mistake commonly happens when cutting and pasting some code and forgetting to adapt parts of it.

A version of the popular GNU C++ compiler reports the following error:

/local/include/stl/_algo.h: In function 'struct _STL::_List_iterator<_STL::basic 

_string<char,_STL::char_traits<char>,_STL::allocator<char> >,_STL::_Nonconst_tra 

its<_STL::basic_string<char,_STL::char_traits<char>,_STL::allocator<char> > > > 

_STL::find_if<_STL::_List_iterator<_STL::basic_string<char,_STL::char_traits<cha 

r>,_STL::allocator<char> >,_STL::_Nonconst_traits<_STL::basic_string<char,_STL:: 

char_traits<char>,_STL::allocator<char> > > >, _STL::binder2nd<_STL::greater<int 

> > >(_STL::_List_iterator<_STL::basic_string<char,_STL::char_traits<char>,_STL: 

:allocator<char> >,_STL::_Nonconst_traits<_STL::basic_string<char,_STL::char_tra 

its<char>,_STL::allocator<char> > > >, _STL::_List_iterator<_STL::basic_string<c 

har,_STL::char_traits<char>,_STL::allocator<char> >,_STL::_Nonconst_traits<_STL: 

:basic_string<char,_STL::char_traits<char>,_STL::allocator<char> > > >, _STL::bi 

nder2nd<_STL::greater<int> >, _STL::input_iterator_tag)': 

/local/include/stl/_algo.h:115:   instantiated from '_STL::find_if<_STL::_List_i 

terator<_STL::basic_string<char,_STL::char_traits<char>,_STL::allocator<char> >, 

_STL::_Nonconst_traits<_STL::basic_string<char,_STL::char_traits<char>,_STL::all 

ocator<char> > > >, _STL::binder2nd<_STL::greater<int> > >(_STL::_List_iterator< 

_STL::basic_string<char,_STL::char_traits<char>,_STL::allocator<char> >,_STL::_N 

onconst_traits<_STL::basic_string<char,_STL::char_traits<char>,_STL::allocator<c 

har> > > >, _STL::_List_iterator<_STL::basic_string<char,_STL::char_traits<char> 

,_STL::allocator<char> >,_STL::_Nonconst_traits<_STL::basic_string<char,_STL::ch 

ar_traits<char>,_STL::allocator<char> > > >, _STL::binder2nd<_STL::greater<int> 

>)' 

testprog.cpp:18:   instantiated from here 

/local/include/stl/_algo.h:78: no match for call to '(_STL::binder2nd<_STL::grea 

ter<int> >) (_STL::basic_string<char,_STL::char_traits<char>,_STL::allocator<cha 

r> > &)' 

/local/include/stl/_function.h:261: candidates are: bool _STL::binder2nd<_STL::g 

reater<int> >::operator ()(const int &) const 

A message like this starts looking more like a novel than a diagnostic. It can also be overwhelming to the point of discouraging novice template users. However, with some practice, messages like this become manageable, and the errors are relatively easily located.

The first part of this error message says that an error occurred in a function template instance (with a horribly long name) deep inside the /local/include/stl/_algo.h header. Next, the compiler reports why it instantiated that particular instance. In this case it all started on line 18 of testprog.cpp (which is the file containing our example code), which caused the instantiation of a find_if template on line 115 of the _algo.h header. The compiler reports all this in case we simply were not expecting all these templates to be instantiated. It allows us to determine the chain of events that caused the instantiations.

However, in our example we're willing to believe that all kinds of templates needed to be instantiated, and we just wonder why it didn't work. This information comes in the last part of the message: The part that says "no match for call" implies that a function call could not be resolved because the types of the arguments and the parameter types didn't match. Furthermore, just after this, the line containing "candidates are" explains that there was a single candidate type expecting an integer type (parameter type const int&). Looking back at line 18 of the program, we see std::bind2nd(std::greater<int>(),"A"), which does indeed contain an integer type (<int>) that is not compatible with the string type objects for which we're looking in our example. Replacing <int> with <std::string> makes the problem go away.

There is no doubt that the error message could be better structured. The actual problem could be omitted before the history of the instantiation, and instead of using fully expanded template instantiation names like MyTemplate<YourTemplate<int> >, decomposing the instance as in MyTemplate<T> with T=YourTemplate<int> can reduce the overwhelming length of names. However, it is also true that all the information in this diagnostic could be useful in some situations. It is therefore not surprising that other compilers provide similar information (although some use the structuring techniques mentioned).

6.6.2 Shallow Instantiation

Diagnostics such as those discussed earlier arise when errors are found after a long chain of instantiations. To illustrate this, consider the following somewhat contrived code:

template <typename T> 

void clear (T const& p) 

{ 

    *p=0;   // assumes T is a pointer-like type 

} 

template <typename T> 

void core (T const& p) 

{ 

    clear(p); 

} 

template <typename T> 

void middle (typename T::Index p) 

{ 

    core(p); 

} 

template <typename T> 

void shell (T const& env) 

{ 

    typename T::Index i; 

    middle<T>(i); 

} 

class Client { 

  public: 

    typedef int Index; 

}; 

Client main_client; 

int main() 

{ 

    shell(main_client); 

} 

This example illustrates the typical layering of software development: High-level function templates like shell() rely on components like middle(), which themselves make use of basic facilities like core(). When we instantiate shell(), all the layers below it also need to be instantiated. In this example, a problem is revealed in the deepest layer: core() is instantiated with type int (from the use of Client::Index in middle()) and attempts to dereference a value of that type, which is an error. A good generic diagnostic includes a trace of all the layers that led to the problems, but we observe that so much information can appear unwieldy.

An excellent discussion of the core ideas surrounding this problem can be found in [StroustrupDnE], in which Bjarne Stroustrup identifies two classes of approaches to determine earlier whether template arguments satisfy a set of constraints: through a language extension or through earlier parameter use. We cover the former option to some extent in Section 13.11 on page 218. The latter alternative consists of forcing any errors in shallow instantiations. This is achieved by inserting unused code with no other purpose than to trigger an error if that code is instantiated with template arguments that do not meet the requirements of deeper levels of templates.

In our previous example we could add code in shell() that attempts to dereference a value of type T::Index. For example:

template <typename T> 

inline void ignore(T const&) 

{ 

} 

template <typename T> 

void shell (T const& env) 

{ 

    class ShallowChecks { 

        void deref(T::Index ptr) { 

            ignore(*ptr); 

        } 

    }; 

    typename T::Index i; 

    middle(i); 

} 

If T is a type such that T::Index cannot be dereferenced, an error is now diagnosed on the local class ShallowChecks. Note that because the local class is not actually used, the added code does not impact the running time of the shell() function. Unfortunately, many compilers will warn about the fact that ShallowChecks is not used (and neither are its members). Tricks such as the use of the ignore() template can be used to inhibit such warnings, but they add to the complexity of the code.

Clearly, the development of the dummy code in our example can become as complex as the code that implements the actual functionality of the template. To control this complexity it is natural to attempt to collect various snippets of dummy code in some sort of library. For example, such a library could contain macros that expand to code that triggers the appropriate error when a template parameter substitution violates the concept underlying that particular parameter. The most popular such library is the Concept Check Library, which is part of the Boost distribution (see [BCCL]).

Unfortunately, the technique isn't particularly portable (the way errors are diagnosed differs considerably from one compiler to another) and sometimes masks issues that cannot be captured at a higher level.

6.6.3 Long Symbols

The error message analyzed in Section 6.6.1 on page 75 demonstrates another problem of templates: Instantiated template code can result in very long symbols. For example, in the implementation used earlier std::string is expanded to

_STL::basic_string<char,_STL::char_traits<char>, 

                        _STL::allocator<char> > 

Some programs that use the C++ standard library produce symbols that contain more than 10,000 characters. These very long symbols can also cause errors or warnings in compilers, linkers, and debuggers. Modern compilers use compression techniques to reduce this problem, but in error messages this is not apparent.

6.6.4 Tracers

So far we have discussed bugs that arise when compiling or linking programs that contain templates. However, the most challenging task of ensuring that a program behaves correctly at run time often follows a successful build. Templates can sometimes make this task a little more difficult because the behavior of generic code represented by a template depends uniquely on the client of that template (certainly much more so than ordinary classes and functions). A tracer is a software device that can alleviate that aspect of debugging by detecting problems in template definitions early in the development cycle.

A tracer is a user-defined class that can be used as an argument for a template to be tested. Often, it is written just to meet the requirements of the template and no more than those requirements. More important, however, a tracer should generate a trace of the operations that are invoked on it. This allows, for example, to verify experimentally the efficiency of algorithms as well as the sequence of operations.

Here is an example of a tracer that might be used to test a sorting algorithm:

// basics/tracer.hpp 

#include <iostream> 

class SortTracer { 

  private: 

    int value;                // integer value to be sorted 

    int generation;           // generation of this tracer 

    static long n_created;    // number of constructor calls 

    static long n_destroyed;  // number of destructor calls 

    static long n_assigned;   // number of assignments 

    static long n_compared;   // number of comparisons 

    static long n_max_live;   // maximum of existing objects 

    // recompute maximum of existing objects 

    static void update_max_live() { 

        if (n_created-n_destroyed > n_max_live) { 

            n_max_live = n_created-n_destroyed; 

        } 

    } 

  public: 

    static long creations() { 

        return n_created; 

    } 

    static long destructions() { 

        return n_destroyed; 

    } 

    static long assignments() { 

        return n_assigned; 

    } 

    static long comparisons() { 

        return n_compared; 

    } 

    static long max_live() { 

        return n_max_live; 

    } 

  public: 

    // constructor 

    SortTracer (intv=0):value(v), generation(1) { 

        ++n_created; 

        update_max_live(); 

        std::cerr << "SortTracer #" << n_created 

                  << ", created generation " << generation 

                << " (total: " << n_created - n_destroyed 

                << ")\n"; 

  } 

    // copy constructor 

    SortTracer (SortTracer const& b) 

     : value(b.value), generation(b.generation+1) { 

        ++n_created; 

        update_max_live(); 

        std::cerr << "SortTracer #" << n_created 

                  << ", copied as generation " << generation 

                  << " (total: " << n_created - n_destroyed 

                  << ")\n"; 

    } 

    // destructor 

    ~SortTracer() { 

        ++n_destroyed; 

        update_max_live(); 

        std::cerr << "SortTracer generation " << generation 

                  << " destroyed (total: " 

                  << n_created - n_destroyed << ")\n"; 

    } 

    // assignment 

    SortTracer& operator= (SortTracer const& b) { 

        ++n_assigned; 

        std::cerr << "SortTracer assignment #" << n_assigned 

                  << " (generation " << generation 

                  << " = " << b.generation 

                  << ")\n"; 

        value = b.value; 

        return *this; 

    } 

    // comparison 

    friend bool operator < (SortTracer const& a, 

                            SortTracer const& b) { 

        ++n_compared; 

        std::cerr << "SortTracer comparison #" << n_compared 

                  << " (generation " << a.generation 

                  << " < " << b.generation 

                  << ")\n"; 

        return a.value < b.value; 

    } 

    int val() const { 

        return value; 

    } 

}; 

In addition to the value to sort, value, the tracer provides several members to trace an actual sort: generation traces for each object how many copies it is from the original. The other static members trace the number of creations (constructor calls), destructions, assignment comparisons, and the maximum number of objects that ever existed.

The static members are defined in a separate dot-C file:

// basics/tracer.cpp 

#include "tracer.hpp" 

long SortTracer::n_created = 0; 

long SortTracer::n_destroyed = 0; 

long SortTracer::n_max_live = 0; 

long SortTracer::n_assigned = 0; 

long SortTracer::n_compared = 0; 

This particular tracer allows us to track the pattern or entity creation and destruction as well as assignments and comparisons performed by a given template. The following test program illustrates this for the std::sort algorithm of the C++ standard library:

// basics/tracertest.cpp 

#include <iostream> 

#include <algorithm> 

#include "tracer.hpp" 

int main() 

{ 

    // prepare sample input: 

    SortTracer input[]={7,3,5,6,4,2,0,1,9,8}; 

    // print initial values: 

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

        std::cerr << input[i].val() << ' '; 

    } 

    std::cerr << std::endl; 

    // remember initial conditions: 

    long created_at_start = SortTracer::creations(); 

    long max_live_at_start = SortTracer::max_live(); 

    long assigned_at_start = SortTracer::assignments(); 

    long compared_at_start = SortTracer::comparisons(); 

    // execute algorithm: 

    std::cerr << "---[ Start std::sort() ]--------------------\n"; 

    std::sort<>(&input[0], &input[9]+1); 

    std::cerr << "---[ End std::sort() ]----------------------\n"; 

    // verify result: 

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

        std::cerr << input[i].val() << ' '; 

    } 

    std::cerr << "\n\n"; 

    // final report: 

    std::cerr << "std::sort() of 10 SortTracer's" 

              << " was performed by:\n " 

              << SortTracer::creations() - created_at_start 

              << " temporary tracers\n " 

              << "up to " 

              << SortTracer::max_live() 

              << " tracers at the same time (" 

              << max_live_at_start << " before)\n " 

              << SortTracer::assignments() - assigned_at_start 

              << " assignments\n " 

              << SortTracer::comparisons() - compared_at_start 

              << " comparisons\n\n"; 

} 

Running this program creates a considerable amount of output, but much can be concluded from the "final report." For one implementation of the std::sort() function, we find the following:

std::sort() of 10 SortTracer's was performed by: 

 15 temporary tracers 

 up to 12 tracers at the same time (10 before) 

 33 assignments 

 27 comparisons 

For example, we see that although 15 temporary tracers were created in our program while sorting, at most two additional tracers existed at any one time.

Our tracer thus fulfills two roles: It proves that the standard sort() algorithm requires no more functionality than our tracer (for example, operators == and > were not needed), and it gives us a sense of the cost of the algorithm. It does not, however, reveal much about the correctness of the sorting template.

6.6.5 Oracles

Tracers are relatively simple and effective, but they allow us to trace the execution of templates only for specific input data and for a specific behavior of its related functionality. We may wonder, for example, what conditions must be met by the comparison operator for the sorting algorithm to be meaningful (or correct), but in our example we have only tested a comparison operator that behaves exactly like less-than for integers.

An extension of tracers is known in some circles as oracles (or run-time analysis oracles). They are tracers that are connected to a so-called inference engine梐 program that can remember assertions and reasons about them to infer certain conclusions. One such system that was applied to certain parts of a standard library implementation is called MELAS and is discussed in [MusserWangDynaVeri]. Refer to notes below.

Notes: One author, David Musser, was also a key figure in the development of the C++ standard library. Among other things, he designed and implemented the first associative containers.

Oracles allow us, in some cases, to verify template algorithms dynamically without fully specifying the substituting template arguments (the oracles are the arguments) or the input data (the inference engine may request some sort of input assumption when it gets stuck). However, the complexity of the algorithms that can be analyzed in this way is still modest (because of the limitations of the inference engines), and the amount of work is considerable. For these reasons, we do not delve into the development of oracles, but the interested reader should examine the publication mentioned earlier (and the references contained therein).

6.6.6 Archetypes

We mentioned earlier that tracers often provide an interface that is the minimal requirement of the template they trace. When such a minimal tracer does not generate run-time output, it is sometimes called an archetype. An archetype allows us to verify that a template implementation does not require more syntactic constraints than intended. Typically, a template implementer will want to develop an archetype for every concept identified in the template library.

6.7 Afternotes

The organization of source code in header files and dot-C files is a practical consequence of various incarnations of the so-called one-definition rule or ODR. An extensive discussion of this rule is presented in Appendix A.

The inclusion versus separation model debate has been a controversial one. The inclusion model is a pragmatic answer dictated largely by existing practice in C++ compiler implementations. However, the first C++ implementation was different: The inclusion of template definitions was implicit, which created a certain illusion of separation (see Chapter 10 for details on this original model).

[StroustrupDnE] contains a good presentation of Stroustrup's vision for template code organization and the associated implementation challenges. It clearly wasn't the inclusion model. Yet, at some point in the standardization process, it seemed as if the inclusion model was the only viable approach after all. After some intense debates, however, those envisioning a more decoupled model garnered sufficient support for what eventually became the separation model. Unlike the inclusion model, this was a theoretical model not based on any existing implementation. It took more than five years to see its first implementation published (May 2002).

It is sometimes tempting to imagine ways of extending the concept of precompiled headers so that more than one header could be loaded for a single compilation. This would in principle allow for a finer grained approach to precompilation. The obstacle here is mainly the preprocessor: Macros in one header file can entirely change the meaning of subsequent header files. However, once a file has been precompiled, macro processing is completed, and it is hardly practical to attempt to patch a precompiled header for the preprocessor effects induced by other headers.

A fairly systematic attempt to improve C++ compiler diagnostics by adding dummy code in high-level templates can be found in Jeremy Siek's Concept Check Library (see [BCCL]). It is part of the Boost library (see [Boost]).

6.8 Summary

·         Templates challenge the classic compiler-plus-linker model. Therefore there are different approaches to organize template code: the inclusion model, explicit instantiation, and the separation model.

·         Usually, you should use the inclusion model (that is, put all template code in header files).

·         By separating template code into different header files for declarations and definitions, you can more easily switch between the inclusion model and explicit instantiation.

·         The C++ standard defines a separate compilation model for templates (using the keyword export). It is not yet widely available, however.

·         Debugging code with templates can be challenging.

·         Template instances may have very long names.

·         To take advantage of precompiled headers, be sure to keep the same order for #include directives.

 

Chapter 5. Tricky Basics

This chapter covers some further basic aspects of templates that are relevant to the practical use of templates: an additional use of the typename keyword, defining member functions and nested classes as templates, template template parameters, zero initialization, and some details about using string literals as arguments for function templates. These aspects can be tricky at times, but every day-to-day programmer should have heard of them.

5.1 Keyword typename

The keyword typename was introduced during the standardization of C++ to clarify that an identifier inside a template is a type. Consider the following example:

template <typename T> 

class MyClass { 

   typename T::SubType * ptr; 

   … 

}; 

Here, the second typename is used to clarify that SubType is a type defined within class T. Thus, ptr is a pointer to the type T::SubType.

Without typename, SubType would be considered a static member. Thus, it would be a concrete variable or object. As a result, the expression

T::SubType * ptr 

would be a multiplication of the static SubType member of class T with ptr.

In general, typename has to be used whenever a name that depends on a template parameter is a type. This is discussed in detail in Section 9.3.2 on page 130.

A typical application of typename is the access to iterators of STL containers in template code:

// basics/printcoll.hpp 

#include <iostream> 

// print elements of an STL container 

template <typename T> 

void printcoll (T const& coll) 

{ 

    typename T::const_iterator pos;  // iterator to iterate over coll 

    typename T::const_iterator end(coll.end());  // end position 

    for (pos=coll.begin(); pos!=end; ++pos) { 

        std::cout << *pos << ' '; 

    } 

    std::cout << std::endl; 

} 

In this function template, the call parameter is an STL container of type T. To iterate over all elements of the container, the iterator type of the container is used, which is declared as type const_iterator inside each STL container class:

class stlcontainer { 

  … 

  typedef …   iterator;        // iterator for read/write access 

  typedef …   const_iterator;  // iterator for read access 

  … 

}; 

Thus, to access type const_iterator of template type T, you have to qualify it with a leading typename:

typename T::const_iterator pos; 

The .template Construct

A very similar problem was discovered after the introduction of typename. Consider the following example using the standard bitset type:

template<int N> 

void printBitset (std::bitset<N> const& bs) 

{ 

    std::cout << bs.template to_string<char,char_traits<char>, 

                                       allocator<char> >(); 

} 

The strange construct in this example is .template. Without that extra use of template, the compiler does not know that the less-than token (<) that follows is not really "less than" but the beginning of a template argument list. Note that this is a problem only if the construct before the period depends on a template parameter. In our example, the parameter bs depends on the template parameter N.

In conclusion, the .template notation (and similar notations such as ->template) should be used only inside templates and only if they follow something that depends on a template parameter. See Section 9.3.3 on page 132 for details.

5.2 Using this->

For class templates with base classes, using a name x by itself is not always equivalent to this->x, even though a member x is inherited. For example:

template <typename T> 

class Base { 

  public: 

    void exit(); 

};

template <typename T> 

class Derived : Base<T> { 

  public: 

    void foo() { 

        exit();   // calls external exit() or error 

    } 

}; 

In this example, for resolving the symbol exit inside foo(), exit() defined in Base is never considered. Therefore, either you have an error, or another exit() (such as the standard exit()) is called.

We discuss this issue in Section 9.4.2 on page 136 in detail. For the moment, as a rule of thumb, we recommend that you always qualify any symbol that is declared in a base that is somehow dependent on a template parameter with this-> or Base<T>::. If you want to avoid all uncertainty, you may consider qualifying all member accesses (in templates).

5.3 Member Templates

Class members can also be templates. This is possible for both nested classes and member functions. The application and advantage of this ability can again be demonstrated with the Stack<> class template. Normally you can assign stacks to each other only when they have the same type, which implies that the elements have the same type. However, you can't assign a stack with elements of any other type, even if there is an implicit type conversion for the element types defined:

Stack<int> intStack1, intStack2;   // stacks for ints 

Stack<float> floatStack;           // stack for floats 

… 

intStack1 = intStack2;   // OK: stacks have same type 

floatStack = intStack1;  // ERROR: stacks have different types 

The default assignment operator requires that both sides of the assignment operator have the same type, which is not the case if stacks have different element types.

By defining an assignment operator as a template, however, you can enable the assignment of stacks with elements for which an appropriate type conversion is defined. To do this you have to declare Stack<> as follows:

// basics/stack5decl.hpp 

template <typename T> 

class Stack { 

  private: 

    std::deque<T> elems;   // elements 

  public: 

    void push(T const&);   // push element 

    void pop();            // pop element 

    T top() const;         // return top element 

    bool empty() const {   // return whether the stack is empty 

        return elems.empty(); 

    } 

    // assign stack of elements of type T2 

    template <typename T2> 

    Stack<T>& operator= (Stack<T2> const&); 

}; 

The following two changes have been made:

1.       We added a declaration of an assignment operator for stacks of elements of another type T2.

2.       The stack now uses a deque as an internal container for the elements. Again, this is a consequence of the implementation of the new assignment operator.

The implementation of the new assignment operator looks like this:

// basics/stack5assign.hpp 

template <typename T> 

 template <typename T2> 

Stack<T>& Stack<T>::operator= (Stack<T2> const& op2) 

{ 

    if ((void*)this == (void*)&op2) {    // assignment to itself? 

        return *this; 

    } 

    Stack<T2> tmp(op2);             // create a copy of the assigned stack 

    elems.clear();                  // remove existing elements 

    while (!tmp.empty()) {          // copy all elements 

        elems.push_front(tmp.top()); 

        tmp.pop(); 

    } 

    return *this; 

} 

First let's look at the syntax to define a member template. Inside the template with template parameter T, an inner template with template parameter T2 is defined:

template <typename T> 

 template <typename T2> 

… 

Inside the member function you may expect simply to access all necessary data for the assigned stack op2. However, this stack has a different type (if you instantiate a class template for two different types, you get two different types), so you are restricted to using the public interface. It follows that the only way to access the elements is by calling top(). However, each element has to become a top element, then. Thus, a copy of op2 must first be made, so that the elements are taken from that copy by calling pop(). Because top() returns the last element pushed onto the stack, we have to use a container that supports the insertion of elements at the other end of the collection. For this reason, we use a deque, which provides push_front() to put an element on the other side of the collection.

Having this member template, you can now assign a stack of ints to a stack of floats:

Stack<int> intStack;     // stack for ints 

Stack<float> floatStack; // stack for floats 

… 

floatStack = intStack;   // OK: stacks have different types, 

                         //     but int converts to float 

Of course, this assignment does not change the type of the stack and its elements. After the assignment, the elements of the floatStack are still floats and therefore pop() still returns a float.

It may appear that this function would disable type checking such that you could assign a stack with elements of any type, but this is not the case. The necessary type checking occurs when the element of the (copy of the) source stack is moved to the destination stack:

elems.push_front(tmp.top()); 

If, for example, a stack of strings gets assigned to a stack of floats, the compilation of this line results in an error message stating that the string returned by tmp.top() cannot be passed as an argument to elems.push_front() (the message varies depending on the compiler, but this is the gist of what is meant):

Stack<std::string> stringStack;  // stack of ints 

Stack<float>       floatStack;   // stack of floats 

… 

floatStack = stringStack;  // ERROR: std::string doesn't convert to float 

Note that a template assignment operator doesn't replace the default assignment operator. For assignments of stacks of the same type, the default assignment operator is still called.

Again, you could change the implementation to parameterize the internal container type:

// basics/stack6decl.hpp 

template <typename T, typename CONT = std::deque<T> > 

class Stack { 

  private: 

    CONT elems;            // elements 

  public: 

    void push(T const&);   // push element 

    void pop();            // pop element 

    T top() const;         // return top element 

    bool empty() const {   // return whether the stack is empty 

        return elems.empty(); 

    } 

    // assign stack of elements of type T2 

    template <typename T2, typename CONT2> 

    Stack<T,CONT>& operator= (Stack<T2,CONT2> const&); 

}; 

Then the template assignment operator is implemented like this:

// basics/stack6assign.hpp 

template <typename T, typename CONT> 

 template <typename T2, typename CONT2> 

Stack<T,CONT>& 

Stack<T,CONT>::operator= (Stack<T2,CONT2> const& op2) 

{ 

    if ((void*)this == (void*)&op2) {    // assignment to itself? 

        return *this; 

    } 

    Stack<T2> tmp(op2);              // create a copy of the assigned stack 

    elems.clear();                   // remove existing elements 

    while (!tmp.empty()) {           // copy all elements 

        elems.push_front(tmp.top()); 

        tmp.pop(); 

    } 

    return *this; 

} 

Remember, for class templates, only those member functions that are called are instantiated. Thus, if you avoid assigning a stack with elements of a different type, you could even use a vector as an internal container:

// stack for ints using a vector as an internal container 

Stack<int,std::vector<int> > vStack; 

… 

vStack.push(42); 

vStack.push(7); 

std::cout << vStack.pop() << std::endl; 

Because the assignment operator template isn't necessary, no error message of a missing member function push_front() occurs and the program is fine.

For the complete implementation of the last example, see all the files with a name that starts with "stack6" in the subdirectory basics. Refer to notes below.

Notes: Don't be surprised if your compiler reports errors with these sample files. In the samples, we use almost every important template feature. Thus, you need a compiler that conforms closely to the standard.

5.4 Template Template Parameters

It can be useful to allow a template parameter itself to be a class template. Again, our stack class template can be used as an example.

To use a different internal container for stacks, the application programmer has to specify the element type twice. Thus, to specify the type of the internal container, you have to pass the type of the container and the type of its elements again:

Stack<int,std::vector<int> > vStack;  // integer stack that uses a vector 

Using template template parameters allows you to declare the Stack class template by specifying the type of the container without respecifying the type of its elements:

stack<int,std::vector> vStack;        // integer stack that uses a vector 

To do this you must specify the second template parameter as a template template parameter. In principle, this looks as follows. Refer to notes below.

There is a problem with this version that we explain in a minute. However, this problem affects only the default value std::deque. Thus, we can illustrate the general features of template template parameters with this example.

// basics/stack7decl.hpp 

template <typename T, 

          template <typename ELEM> class CONT = std::deque > 

class Stack { 

  private: 

    CONT<T> elems;         // elements 

  public: 

    void push(T const&);   // push element 

    void pop();            // pop element 

    T top() const;         // return top element 

    bool empty() const {   // return whether the stack is empty 

        return elems.empty(); 

    } 

}; 

The difference is that the second template parameter is declared as being a class template:

template <typename ELEM> class CONT 

The default value has changed from std::deque<T> to std::deque. This parameter has to be a class template, which is instantiated for the type that is passed as the first template parameter:

CONT<T> elems; 

This use of the first template parameter for the instantiation of the second template parameter is particular to this example. In general, you can instantiate a template template parameter with any type inside a class template.

As usual, instead of typename you could use the keyword class for template parameters. However, CONT is used to define a class and must be declared by using the keyword class. Thus, the following is fine:

template <typename T, 

          template <class ELEM> class CONT = std::deque>  // OK 

class Stack { 

  … 

}; 

but the following is not:

template <typename T, 

          template <typename ELEM> typename CONT = std::deque> 

class Stack {                                             // ERROR 

  … 

}; 

Because the template parameter of the template template parameter is not used, you can omit its name:

template <typename T, 

          template <typename> class CONT = std::deque > 

class Stack { 

  … 

}; 

Member functions must be modified accordingly. Thus, you have to specify the second template parameter as the template template parameter. The same applies to the implementation of the member function. The push() member function, for example, is implemented as follows:

template <typename T, template <typename> class CONT> 

void Stack<T,CONT>::push (T const& elem) 

{ 

    elems.push_back(elem);    // append copy of passed elem 

} 

Template template parameters for function templates are not allowed.

Template Template Argument Matching

If you try to use the new version of Stack, you get an error message saying that the default value std::deque is not compatible with the template template parameter CONT. The problem is that a template template argument must be a template with parameters that exactly match the parameters of the template template parameter it substitutes. Default template arguments of template template arguments are not considered, so that a match cannot be achieved by leaving out arguments that have default values.

The problem in this example is that the std::deque template of the standard library has more than one parameter: The second parameter (which describes a so-called allocator) has a default value, but this is not considered when matching std::deque to the CONT parameter.

There is a workaround, however. We can rewrite the class declaration so that the CONT parameter expects containers with two template parameters:

template <typename T, 

          template <typename ELEM, 

                    typename ALLOC = std::allocator<ELEM> > 

                    class CONT = std::deque> 

class Stack { 

  private: 

    CONT<T> elems;         // elements 

    … 

}; 

Again, you can omit ALLOC because it is not used.

The final version of our Stack template (including member templates for assignments of stacks of different element types) now looks as follows:

// basics/stack8.hpp 

#ifndef STACK_HPP 

#define STACK_HPP 

#include <deque> 

#include <stdexcept> 

#include <allocator> 

template <typename T, 

          template <typename ELEM, 

                    typename = std::allocator<ELEM> > 

                    class CONT = std::deque> 

class Stack { 

  private: 

    CONT<T> elems;        // elements 

  public: 

    void push(T const&);  // push element 

    void pop();            // pop element 

    T top() const;         // return top element 

    bool empty() const {   // return whether the stack is empty 

        return elems.empty(); 

    } 

    // assign stack of elements of type T2 

    template<typename T2, 

             template<typename ELEM2, 

                      typename = std::allocator<ELEM2> 

                      >class CONT2> 

    Stack<T,CONT>& operator= (Stack<T2,CONT2> const&); 

}; 

template <typename T, template <typename,typename> class CONT> 

void Stack<T,CONT>::push (T const& elem) 

{ 

    elems.push_back(elem);    // append copy of passed elem 

} 

template<typename T, template <typename,typename> class CONT> 

void Stack<T,CONT>::pop () 

{ 

    if (elems.empty()) { 

        throw std::out_of_range("Stack<>::pop(): empty stack"); 

    } 

    elems.pop_back();         // remove last element 

} 

template <typename T, template <typename,typename> class CONT> 

T Stack<T,CONT>::top () const 

{ 

    if (elems.empty()) { 

        throw std::out_of_range("Stack<>::top(): empty stack"); 

    } 

    return elems.back();      // return copy of last element 

} 

template <typename T, template <typename,typename> class CONT> 

 template <typename T2, template <typename,typename> class CONT2> 

Stack<T,CONT>& 

Stack<T,CONT>::operator= (Stack<T2,CONT2> const& op2) 

{ 

    if ((void*)this == (void*)&op2) {    // assignment to itself? 

        return *this; 

    } 

    Stack<T2> tmp(op2);              // create a copy of the assigned stack 

    elems.clear();                   // remove existing elements 

    while (!tmp.empty()) {           // copy all elements 

        elems.push_front(tmp.top()); 

        tmp.pop(); 

    } 

    return *this; 

} 

#endif // STACK_HPP 

The following program uses all features of this final version:

// basics/stack8test.cpp 

#include <iostream> 

#include <string> 

#include <cstdlib> 

#include <vector> 

#include "stack8.hpp" 

int main() 

{ 

    try { 

        Stack<int> intStack;        // stack of ints 

        Stack<float> floatStack;    // stack of floats 

        // manipulate int stack 

        intStack.push(42); 

        intStack.push(7); 

        // manipulate float stack 

        floatStack.push(7.7); 

        // assign stacks of different type 

        floatStack = intStack; 

        // print float stack 

        std::cout << floatStack.top() << std::endl; 

        floatStack.pop(); 

        std::cout << floatStack.top() << std::endl; 

        floatStack.pop(); 

        std::cout << floatStack.top() << std::endl; 

        floatStack.pop(); 

    } 

    catch (std::exception const& ex) { 

        std::cerr << "Exception: " << ex.what() << std::endl; 

    } 

    // stack for ints using a vector as an internal container 

    Stack<int,std::vector> vStack; 

    … 

    vStack.push(42); 

    vStack.push(7); 

    std::cout << vStack.top() << std::endl; 

    vStack.pop(); 

} 

The program has the following output:

7 

42 

Exception: Stack<>::top(): empty stack 

7 

Note that template template parameters are one of the most recent features required for compilers to conform to the standard. Thus, this program is a good evaluation of the conformity of your compiler regarding template features.

For further discussions and examples of template template parameters, see Section 8.2.3 on page 102 and Section 15.1.6 on page 259.

5.5 Zero Initialization

For fundamental types such as int, double, or pointer types, there is no default constructor that initializes them with a useful default value. Instead, any noninitialized local variable has an undefined value:

void foo() 

{ 

    int x;     // x has undefined value 

    int* ptr;  // ptr points to somewhere (instead of nowhere) 

} 

Now if you write templates and want to have variables of a template type initialized by a default value, you have the problem that a simple definition doesn't do this for built-in types:

template <typename T> 

void foo() 

{ 

    T x;      // x has undefined value if T is built-in type 

} 

For this reason, it is possible to call explicitly a default constructor for built-in types that initializes them with zero (or false for bool). That is, int() yields zero. As a consequence you can ensure proper default initialization even for built-in types by writing the following:

template <typename T> 

void foo() 

{ 

    T x = T();    // x is zero (or false)ifT is a built-in type 

} 

To make sure that a member of a class template, for which the type is parameterized, gets initialized, you have to define a default constructor that uses an initializer list to initialize the member:

template <typename T> 

class MyClass { 

  private: 

    T x; 

  public: 

    MyClass() : x() {  // ensures that x is initialized even for built-in types 

    } 

    … 

};

5.6 Using String Literals as Arguments for Function Templates

Passing string literal arguments for reference parameters of function templates sometimes fails in a surprising way. Consider the following example:

// basics/max5.cpp 

#include <string> 

// note: reference parameters 

template <typename T> 

inline T const& max (T const& a, T const& b) 

{ 

    return a < b ? b : a; 

} 

int main() 

{ 

    std::string s; 

    ::max("apple","peach");   // OK: same type 

    ::max("apple","tomato");  // ERROR: different types 

    ::max("apple",s);         // ERROR: different types 

} 

The problem is that string literals have different array types depending on their lengths. That is, "apple" and "peach" have type char const[6] whereas "tomato" has type char const[7]. Only the first call is possible because the template expects both parameters to have the same type. However, if you declare nonreference parameters, you can substitute them with string literals of different size:

// basics/max6.cpp 

#include <string> 

// note: nonreference parameters 

template <typename T> 

inline T max (T a, T b) 

{ 

    return a < b ? b : a; 

} 

int main() 

{ 

    std::string s; 

    ::max("apple","peach");   // OK: same type 

    ::max("apple","tomato");  // OK: decays to same type 

    ::max("apple",s);         // ERROR: different types 

} 

The explanation for this behavior is that during argument deduction array-to-pointer conversion (often called decay) occurs only if the parameter does not have a reference type. This is demonstrated by the following program:

// basics/refnonref.cpp 

#include <typeinfo> 

#include <iostream> 

template <typename T> 

void ref (T const& x) 

{ 

    std::cout << "x in ref(T const&): " 

              << typeid(x).name() << '\n'; 

} 

template <typename T> 

void nonref (T x) 

{ 

    std::cout << "x in nonref(T): " 

              << typeid(x).name() << '\n'; 

} 

int main() 

{ 

    ref("hello"); 

    nonref("hello"); 

} 

The example passes a string literal to function templates that declare their parameter to be a reference or nonreference respectively. Both function templates use the typeid operator to print the type of the instantiated parameters. The typeid operator returns an lvalue of type std::type_info, which encapsulates a representation of the type of the expression passed to the typeid operator. The member function name() of std::type_info is intended to return a human-readable text representation of the latter type. The C++ standard doesn't actually say that name() must return something meaningful, but on good C++ implementations, you should get a string that gives a good description of the type of the expression passed to typeid (with some implementations this string is mangled, but a demangler is available to turn it into human-readable text). For example, the output might be as follows:

x in ref(T const&): char [6] 

x in nonref(T):     const char * 

If you encounter a problem involving a mismatch between an array of characters and a pointer to characters, you might have stumbled on this somewhat surprising phenomenon. Refer to notes below. There is unfortunately no general solutions to address this problem. Depending on the context, you can

Notes: In fact, this is the reason that you cannot create a pair of values initialized with string literals using the original C++ standard library (see [Standard98]):

std::make_pair("key","value") // ERROR according to [Standard98] 

This was fixed with the first technical corrigendum by replacing the reference parameters of make_pair() by nonreference parameters (see [Standard02]).

·         use nonreferences instead of references (however, this can lead to unnecessary copying)

·         overload using both reference and nonreference parameters (however, this might lead to ambiguities; see Section B.2.2 on page 492)

·         overload with concrete types (such as std::string)

·         overload with array types, for example:

·         template <typename T, int N, int M> 

·         T const* max (T const (&a)[N], T const (&b)[M]) 

·         { 

·             return a < b ? b : a; 

} 

·         force application programmers to use explicit conversions

In this example it is best to overload max() for strings (see Section 2.4 on page 16). This is necessary anyway because without overloading in cases where the call to max() is valid for string literals, the operation that is performed is a pointer comparison: a<bcompares the addresses of the two string literals and has nothing to do with lexicographical order. This is another reason why it is usually preferable to use a string class such as std::string instead of C-style strings.

See Section 11.1 on page 168 for details.

5.7 Summary

·         To access a type name that depends on a template parameter, you have to qualify the name with a leading typename.

·         Nested classes and member functions can also be templates. One application is the ability to implement generic operations with internal type conversions. However, type checking still occurs.

·         Template versions of assignment operators don't replace default assignment operators.

·         You can also use class templates as template parameters, as so-called template template parameters.

·         Template template arguments must match exactly. Default template arguments of template template arguments are ignored.

·         By explicitly calling a default constructor, you can make sure that variables and members of templates are initialized by a default value even if they are instantiated with a built-in type.

·         For string literals there is an array-to-pointer conversion during argument deduction if and only if the parameter is not a reference.

 

Chapter 4. Nontype Template Parameters

For function and class templates, template parameters don't have to be types. They can also be ordinary values. As with templates using type parameters, you define code for which a certain detail remains open until the code is used. However, the detail that is open is a value instead of a type. When using such a template, you have to specify this value explicitly. The resulting code then gets instantiated. This chapter illustrates this feature for a new version of the stack class template. In addition, we show an example of nontype function template parameters and discuss some restrictions to this technique.

4.1 Nontype Class Template Parameters

In contrast to the sample implementations of a stack in previous chapters, you can also implement a stack by using a fixed-size array for the elements. An advantage of this method is that the memory management overhead, whether performed by you or by a standard container, is avoided. However, determining the best size for such a stack can be challenging. The smaller the size you specify, the more likely it is that the stack will get full. The larger the size you specify, the more likely it is that memory will be reserved unnecessarily. A good solution is to let the user of the stack specify the size of the array as the maximum size needed for stack elements.

To do this, define the size as a template parameter:

// basics/stack4.hpp 

#include <stdexcept> 

template <typename T, int MAXSIZE> 

class Stack { 

  private: 

    T elems[MAXSIZE];        // elements 

    int numElems;            // current number of elements 

  public: 

    Stack();                 // constructor 

    void push(T const&);     // push element 

    void pop();              // pop element 

    T top() const;           // return top element 

    bool empty() const {     // return whether the stack is empty 

        return numElems == 0; 

    } 

    bool full() const {      // return whether the stack is full 

        return numElems == MAXSIZE; 

    } 

}; 

// constructor 

template <typename T, int MAXSIZE> 

Stack<T,MAXSIZE>::Stack () 

  : numElems(0)              // start with no elements 

{ 

    // nothing else to do 

} 

template <typename T, int MAXSIZE> 

void Stack<T,MAXSIZE>::push (T const& elem) 

{ 

    if (numElems == MAXSIZE) { 

        throw std::out_of_range("Stack<>::push(): stack is full"); 

    } 

    elems[numElems] = elem;  // append element 

    ++numElems;              // increment number of elements 

} 

template<typename T, int MAXSIZE> 

void Stack<T,MAXSIZE>::pop () 

{ 

    if (numElems <= 0) { 

        throw std::out_of_range("Stack<>::pop(): empty stack"); 

    } 

    --numElems;              // decrement number of elements 

} 

template <typename T, int MAXSIZE> 

T Stack<T,MAXSIZE>::top () const 

{ 

    if (numElems <= 0) { 

        throw std::out_of_range("Stack<>::top(): empty stack"); 

    } 

    return elems[numElems-1];  // return last element 

} 

The new second template parameter, MAXSIZE, is of type int. It specifies the size of the array of stack elements:

template <typename T, int MAXSIZE> 

class Stack { 

  private: 

    T elems[MAXSIZE];     // elements 

    … 

}; 

In addition, it is used in push() to check whether the stack is full:

template <typename T, int MAXSIZE> 

void Stack<T,MAXSIZE>::push (T const& elem) 

{ 

    if (numElems == MAXSIZE) { 

        throw "Stack<>::push(): stack is full"; 

    } 

    elems[numElems] = elem;   // append element 

    ++numElems;               // increment number of elements 

} 

To use this class template you have to specify both the element type and the maximum size:

// basics/stack4test.cpp 

#include <iostream> 

#include <string> 

#include <cstdlib> 

#include "stack4.hpp" 

int main() 

{ 

    try { 

        Stack<int,20>         int20Stack;    // stack of up to 20 ints 

        Stack<int,40>         int40Stack;    // stack of up to 40 ints 

        Stack<std::string,40> stringStack;   // stack of up to 40 strings 

        // manipulate stack of up to 20 ints 

        int20Stack.push(7); 

        std::cout << int20Stack.top() << std::endl; 

        int20Stack.pop(); 

        // manipulate stack of up to 40 strings 

        stringStack.push("hello"); 

        std::cout << stringStack.top() << std::endl; 

        stringStack.pop(); 

        stringStack.pop(); 

    } 

    catch (std::exception const& ex) { 

        std::cerr << "Exception: " << ex.what() << std::endl; 

        return EXIT_FAILURE;  // exit program with ERROR status 

    } 

} 

Note that each template instantiation is its own type. Thus, int20Stack and int40Stack are two different types, and no implicit or explicit type conversion between them is defined. Thus, one cannot be used instead of the other, and you cannot assign one to the other.

Again, default values for the template parameters can be specified:

template <typename T = int, int MAXSIZE = 100> 

class Stack { 

  … 

}; 

However, from a perspective of good design, this may not be appropriate in this example. Default values should be intuitively correct. But neither type int nor a maximum size of 100 seems intuitive for a general stack type. Thus, it is better when the programmer has to specify both values explicitly so that these two attributes are always documented during a declaration.

4.2 Nontype Function Template Parameters

You can also define nontype parameters for function templates. For example, the following function template defines a group of functions for which a certain value can be added:

// basics/addval.hpp 

template <typename T, int VAL> 

T addValue (T const& x) 

{ 

    return x + VAL; 

} 

These kinds of functions are useful if functions or operations in general are used as parameters. For example, if you use the Standard Template Library (STL) you can pass an instantiation of this function template to add a value to each element of a collection:

std::transform (source.begin(), source.end(),  // start and end of source 

                dest.begin(),                  // start of destination 

                addValue<int,5>);              // operation 

The last argument instantiates the function template addValue() to add 5 to an int value. The resulting function is called for each element in the source collection source, while it is translated into the destination collection dest.

Note that there is a problem with this example: addValue<int,5> is a function template, and function templates are considered to name a set of overloaded functions (even if the set has only one member). However, according to the current standard, sets of overloaded functions cannot be used for template parameter deduction. Thus, you have to cast to the exact type of the function template argument:

std::transform (source.begin(), source.end(),  // start and end of source 

                dest.begin(),                  // start of destination 

                (int(*)(int const&)) addValue<int,5>);  // operation 

There is a proposal for the standard to fix this behavior so that the cast isn't necessary in this context (see [CoreIssue115] for details), but until then the cast may be necessary to be portable.

4.3 Restrictions for Nontype Template Parameters

Note that nontype template parameters carry some restrictions. In general, they may be constant integral values (including enumerations) or pointers to objects with external linkage.

Floating-point numbers and class-type objects are not allowed as nontype template parameters:

template <double VAT>        // ERROR: floating-point values are not 

double process (double v)    //        allowed as template parameters 

{ 

    return v * VAT; 

} 

template <std::string name>  // ERROR: class-type objects are not 

class MyClass {              //        allowed as template parameters 

  … 

}; 

Not being able to use floating-point literals (and simple constant floating-point expressions) as template arguments has historical reasons. Because there are no serious technical challenges, this may be supported in future versions of C++ (see Section 13.4 on page 210).

Because string literals are objects with internal linkage (two string literals with the same value but in different modules are different objects), you can't use them as template arguments either:

template <char const* name> 

class MyClass { 

  … 

}; 

MyClass<"hello"> x;   // ERROR: string literal "hello" not allowed 

You cannot use a global pointer either:

template <char const* name> 

class MyClass { 

  … 

}; 

char const* s = "hello"; 

MyClass<s> x;         // ERROR: s is pointer to object with internal linkage 

However, the following is possible:

template <char const* name> 

class MyClass { 

  … 

}; 

extern char const s[] = "hello"; 

MyClass<s> x;        // OK 

The global character array s is initialized by "hello" so that s is an object with external linkage.

See Section 8.3.3 on page 109 for a detailed discussion and Section 13.4 on page 209 for a discussion of possible future changes in this area.

4.4 Summary

·         Templates can have template parameters that are values rather than types.

·         You cannot use floating-point numbers, class-type objects, and objects with internal linkage (such as string literals) as arguments for nontype template parameters.

 

Chapter 3. Class Templates

Similar to functions, classes can also be parameterized with one or more types. Container classes, which are used to manage elements of a certain type, are a typical example of this feature. By using class templates, you can implement such container classes while the element type is still open. In this chapter we use a stack as an example of a class template.

3.1 Implementation of Class Template Stack

As we did with function templates, we declare and define class Stack<> in a header file as follows (we discuss the separation of declaration and definition in different files in Section 7.3 on page 89):

// basics/stack1.hpp 

#include <vector> 

#include <stdexcept> 

template <typename T> 

class Stack { 

  private: 

    std::vector<T> elems;     // elements 

  public: 

    void push(T const&);      // push element 

    void pop();               // pop element 

    T top() const;            // return top element 

    bool empty() const {      // return whether the stack is empty 

        return elems.empty(); 

    } 

}; 

template <typename T> 

void Stack<T>::push (T const& elem) 

{ 

    elems.push_back(elem);    // append copy of passed elem 

} 

template<typename T> 

void Stack<T>::pop () 

{ 

    if (elems.empty()) { 

        throw std::out_of_range("Stack<>::pop(): empty stack"); 

    } 

    elems.pop_back();         // remove last element 

} 

template <typename T> 

T Stack<T>::top () const 

{ 

    if (elems.empty()) { 

        throw std::out_of_range("Stack<>::top(): empty stack"); 

    } 

    return elems.back();      // return copy of last element 

} 

As you can see, the class template is implemented by using a class template of the C++ standard library: vector<>. As a result, we don't have to implement memory management, copy constructor, and assignment operator, so we can concentrate on the interface of this class template.

3.1.1 Declaration of Class Templates

Declaring class templates is similar to declaring function templates: Before the declaration, a statement declares an identifier as a type parameter. Again, T is usually used as an identifier:

template <typename T> 

class Stack { 

  … 

}; 

Here again, the keyword class can be used instead of typename:

template <class T> 

class Stack { 

  … 

}; 

Inside the class template, T can be used just like any other type to declare members and member functions. In this example, T is used to declare the type of the elements as vector of Ts, to declare push() as a member function that gets a constant T reference as an argument, and to declare top() as a function that returns a T:

template <typename T> 

class Stack { 

  private: 

    std::vector<T> elems;  // elements 

  public: 

    Stack();               // constructor 

    void push(T const&);   // push element 

    void pop();            // pop element 

    T top() const;         // return top element 

}; 

The type of this class is Stack<T>, with T being a template parameter. Thus, you have to use Stack<T> whenever you use the type of this class in a declaration. If, for example, you have to declare your own copy constructor and assignment operator, it looks like this(Refer to note below)

Note: According to the standard, there are some exceptions to this rule (see Section 9.2.3 on page 126). However, to be sure, you should always write the full type when the type is required.

template <typename T> 

class Stack { 

    … 

    Stack (Stack<T> const&);                 // copy constructor 

    Stack<T>& operator= (Stack<T> const&);   // assignment operator 

    … 

}; 

However, when the name and not the type of the class is required, only Stack has to be used. This is the case when you specify the name of the class, the constructors, and the destructor.

3.1.2 Implementation of Member Functions

To define a member function of a class template, you have to specify that it is a function template, and you have to use the full type qualification of the class template. Thus, the implementation of the member function push() for type Stack<T> looks like this:

template <typename T> 

void Stack<T>::push (T const& elem) 

{ 

    elems.push_back(elem);    // append copy of passed elem 

} 

In this case, push_back() of the element vector is called, which appends the element at the end of the vector.

Note that pop_back() of a vector removes the last element but doesn't return it. The reason for this behavior is exception safety. It is impossible to implement a completely exception-safe version of pop() that returns the removed element (this topic was first discussed by Tom Cargill in [CargillExceptionSafety] and is discussed as Item 10 in [SutterExceptional]). However, ignoring this danger, we could implement a pop() that returns the element just removed. To do this, we simply use T to declare a local variable of the element type:

template<typename T> 

T Stack<T>::pop () 

{ 

    if (elems.empty()) { 

        throw std::out_of_range("Stack<>::pop(): empty stack"); 

    } 

    T elem = elems.back();    // save copy of last element 

    elems.pop_back();         // remove last element 

    return elem;              // return copy of saved element 

} 

Because the vectors back() (which returns the last element) and pop_back() (which removes the last element) have undefined behavior when there is no element in the vector, we have to check whether the stack is empty. If it is empty, we throw an exception of type std::out_of_range. This is also done in top(), which returns but does not remove the top element:

template<typename T> 

T Stack<T>::top () const 

{ 

    if (elems.empty()) { 

        throw std::out_of_range("Stack<>::top(): empty stack"); 

    } 

    return elems.back();      // return copy of last element 

} 

Of course, as for any member function, you can also implement member functions of class templates as an inline function inside the class declaration. For example:

template <typename T> 

class Stack { 

    … 

    void push (T const& elem) { 

        elems.push_back(elem);   // append copy of passed elem 

    } 

    … 

};

3.2 Use of Class Template Stack

To use an object of a class template, you must specify the template arguments explicitly. The following example shows how to use the class template Stack<>:

// basics/stack1test.cpp 

#include <iostream> 

#include <string> 

#include <cstdlib> 

#include "stack1.hpp" 

int main() 

{ 

    try { 

        Stack<int>         intStack;       // stack of ints 

        Stack<std::string> stringStack;    // stack of strings 

        // manipulate int stack 

        intStack.push(7); 

        std::cout << intStack.top() << std::endl; 

        // manipulate string stack 

        stringStack.push("hello"); 

        std::cout << stringStack.top() << std::endl; 

        stringStack.pop(); 

        stringStack.pop(); 

    } 

    catch (std::exception const& ex) { 

        std::cerr << "Exception: " << ex.what() << std::endl; 

        return EXIT_FAILURE;  // exit program with ERROR status 

    } 

} 

By declaring type Stack<int>, int is used as type T inside the class template. Thus, intStack is created as an object that uses a vector of ints as elements and, for all member functions that are called, code for this type is instantiated. Similarly, by declaring and using Stack<std::string>, an object that uses a vector of strings as elements is created, and for all member functions that are called, code for this type is instantiated.

Note that code is instantiated only for member functions that are called. For class templates, member functions are instantiated only when they are used. This, of course, saves time and space. It has the additional benefit that you can instantiate a class even for those types that cannot perform all the operations of all the member functions, as long as these member functions are not called. As an example, consider a class in which some member functions use the operator < to sort elements. If you refrain from calling these member functions, you can instantiate the class template for types for which operator < is not defined.

In this example, the default constructor, push(), and top() are instantiated for both int and strings. However, pop() is instantiated only for strings. If a class template has static members, these are instantiated once for each type.

You can use a type of an instantiated class template as any other type, as long as the operations are supported:

void foo (Stack<int> const& s)     // parameter s is int stack 

{ 

    Stack<int> istack[10];         // istack is array of 10 int stacks 

… 

} 

By using a type definition, you can make using a class template more convenient:

typedef Stack<int> IntStack; 

void foo (IntStack const& s)   // s is stack of ints 

{ 

    IntStack istack[10];       // istack is array of 10 stacks of ints 

    … 

} 

Note that in C++ a type definition does define a "type alias" rather than a new type. Thus, after the type definition

typedef Stack<int> IntStack; 

IntStack and Stack<int> are the same type and can be used for and assigned to each other.

Template arguments may be any type, such as pointers to floats or even stacks of ints:

Stack<float*>      floatPtrStack;  // stack of float pointers 

Stack<Stack<int> > intStackStack;  // stack of stack of ints 

The only requirement is that any operation that is called is possible according to this type.

Note that you have to put whitespace between the two closing template brackets. If you don't do this, you are using operator >>, which results in a syntax error:

Stack<Stack<int>> intStackStack;  // ERROR: >> is not allowed

3.3 Specializations of Class Templates

You can specialize a class template for certain template arguments. Similar to the overloading of function templates (see page 15), specializing class templates allows you to optimize implementations for certain types or to fix a misbehavior of certain types for an instantiation of the class template. However, if you specialize a class template, you must also specialize all member functions. Although it is possible to specialize a single member function, once you have done so, you can no longer specialize the whole class.

To specialize a class template, you have to declare the class with a leading template<> and a specification of the types for which the class template is specialized. The types are used as a template argument and must be specified directly following the name of the class:

template<> 

class Stack<std::string> { 

  … 

}; 

For these specializations, any definition of a member function must be defined as an "ordinary" member function, with each occurrence of T being replaced by the specialized type:

void Stack<std::string>::push (std::string const& elem) 

{ 

    elems.push_back(elem);    // append copy of passed elem 

} 

Here is a complete example of a specialization of Stack<> for type std::string:

// basics/stack2.hpp 

#include <deque> 

#include <string> 

#include <stdexcept> 

#include "stack1.hpp" 

template<> 

class Stack<std::string> { 

  private: 

    std::deque<std::string> elems;  // elements 

  public: 

    void push(std::string const&);  // push element 

    void pop();                     // pop element 

    std::string top() const;        // return top element 

    bool empty() const {            // return whether the stack is empty 

        return elems.empty(); 

    } 

}; 

void Stack<std::string>::push (std::string const& elem) 

{ 

    elems.push_back(elem);    // append copy of passed elem 

} 

void Stack<std::string>::pop () 

{ 

    if (elems.empty()) { 

        throw std::out_of_range 

                ("Stack<std::string>::pop(): empty stack"); 

    } 

    elems.pop_back();         // remove last element 

} 

std::string Stack<std::string>::top () const 

{ 

    if (elems.empty()) { 

        throw std::out_of_range 

                ("Stack<std::string>::top(): empty stack"); 

    } 

    return elems.back();      // return copy of last element 

} 

In this example, a deque instead of a vector is used to manage the elements inside the stack. Although this has no particular benefit here, it does demonstrate that the implementation of a specialization might look very different from the implementation of the primary template. Refer to note belowl

Note: In fact, there is a benefit for using a deque instead of a vector to implement a stack: A deque frees memory when elements are removed, and it can't happen that elements have to be moved as a result of reallocation. However, this is no particular benefit for strings. For this reason it is probably a good idea to use a deque in the primary class template (as is the case in class std::stack<> of the C++ standard library).

3.4 Partial Specialization

Class templates can be partially specialized. You can specify special implementations for particular circumstances, but some template parameters must still be defined by the user. For example, for the following class template

template <typename T1, typename T2> 

class MyClass { 

  … 

}; 

the following partial specializations are possible:

// partial specialization: both template parameters have same type 

template <typename T> 

class MyClass<T,T> { 

  … 

}; 

// partial specialization: second type is int 

template <typename T> 

class MyClass<T,int> { 

  … 

}; 

// partial specialization: both template parameters are pointer types 

template <typename T1, typename T2> 

class MyClass<T1*,T2*> { 

  … 

}; 

The following example shows which template is used by which declaration:

MyClass<int,float> mif;    // uses MyClass<T1,T2> 

MyClass<float,float> mff;  // uses MyClass<T,T> 

MyClass<float,int> mfi;    // uses MyClass<T,int> 

MyClass<int*,float*> mp;   // uses MyClass<T1*,T2*> 

If more than one partial specialization matches equally well, the declaration is ambiguous:

MyClass<int,int> m;        // ERROR: matches MyClass<T,T> 

                           //        and MyClass<T,int> 

MyClass<int*,int*> m;      // ERROR: matches MyClass<T,T> 

                           //        and MyClass<T1*,T2*> 

To resolve the second ambiguity, you can provide an additional partial specialization for pointers of the same type:

template <typename T> 

class MyClass<T*,T*> { 

  … 

}; 

For details, see Section 12.4 on page 200.

3.5 Default Template Arguments

For class templates you can also define default values for template parameters. These values are called default template arguments. They may even refer to previous template parameters. For example, in class Stack<> you can define the container that is used to manage the elements as a second template parameter, using std::vector<> as the default value:

// basics/stack3.hpp 

#include <vector> 

#include <stdexcept> 

template <typename T, typename CONT = std::vector<T> > 

class Stack { 

  private: 

    CONT elems;               // elements 

  public: 

    void push(T const&);      // push element 

    void pop();               // pop element 

    T top() const;            // return top element 

    bool empty() const {      // return whether the stack is empty 

        return elems.empty(); 

    } 

}; 

template <typename T, typename CONT> 

void Stack<T,CONT>::push (T const& elem) 

{ 

    elems.push_back(elem);    // append copy of passed elem 

} 

template <typename T, typename CONT> 

void Stack<T,CONT>::pop () 

{ 

    if (elems.empty()) { 

        throw std::out_of_range("Stack<>::pop(): empty stack"); 

    } 

    elems.pop_back();         // remove last element 

} 

template <typename T, typename CONT> 

T Stack<T,CONT>::top () const 

{ 

    if (elems.empty()) { 

        throw std::out_of_range("Stack<>::top(): empty stack"); 

    } 

    return elems.back();      // return copy of last element 

} 

Note that we now have two template parameters, so each definition of a member function must be defined with these two parameters:

template <typename T, typename CONT> 

void Stack<T,CONT>::push (T const& elem) 

{ 

    elems.push_back(elem);    // append copy of passed elem 

} 

You can use this stack the same way it was used before. Thus, if you pass a first and only argument as an element type, a vector is used to manage the elements of this type:

template <typename T, typename CONT = std::vector<T> > 

class Stack { 

  private: 

    CONT elems;    // elements 

  … 

}; 

In addition, you could specify the container for the elements when you declare a Stack object in your program:

// basics/stack3test.cpp 

#include <iostream> 

#include <deque> 

#include <cstdlib> 

#include "stack3.hpp" 

int main() 

{ 

    try { 

        // stack of ints: 

        Stack<int> intStack; 

        // stack of doubles which uses a std::deque<> to mange the elements 

        Stack<double,std::deque<double> > dblStack; 

        // manipulate int stack 

        intStack.push(7); 

        std::cout << intStack.top() << std::endl; 

        intStack.pop(); 

        // manipulate double stack 

        dblStack.push(42.42); 

        std::cout << dblStack.top() << std::endl; 

        dblStack.pop(); 

        dblStack.pop(); 

    } 

    catch (std::exception const& ex) { 

        std::cerr << "Exception: " << ex.what() << std::endl; 

        return EXIT_FAILURE;  // exit program with ERROR status 

    } 

} 

With

Stack<double,std::deque<double> > 

you declare a stack for doubles that uses a std::deque<> to manage the elements internally.

3.6 Summary

·         A class template is a class that is implemented with one or more type parameters left open.

·         To use a class template, you pass the open types as template arguments. The class template is then instantiated (and compiled) for these types.

·         For class templates, only those member functions that are called are instantiated.

·         You can specialize class templates for certain types.

·         You can partially specialize class templates for certain types.

·         You can define default values for class template parameters. These may refer to previous template parameters.

Chapter 2. Function Templates

This chapter introduces function templates. Function templates are functions that are parameterized so that they represent a family of functions.

2.1 A First Look at Function Templates

Function templates provide a functional behavior that can be called for different types. In other words, a function template represents a family of functions. The representation looks a lot like an ordinary function, except that some elements of the function are left undetermined: These elements are parameterized. To illustrate, let's look at a simple example.

2.1.1 Defining the Template

The following is a function template that returns the maximum of two values:

// basics/max.hpp 

template <typename T> 

inline T const& max (T const& a, T const& b) 

{ 

    // if a < b then use b else use a 

    return a<b?b:a; 

} 

This template definition specifies a family of functions that returns the maximum of two values, which are passed as function parameters a and b. The type of these parameters is left open as template parameter T. As seen in this example, template parameters must be announced with syntax of the following form:

template < comma-separated-list-of-parameters > 

In our example, the list of parameters is typename T. Note how the less-than and the greater-than symbols are used as brackets; we refer to these as angle brackets. The keyword typename introduces a so-called type parameter. This is by far the most common kind of template parameter in C++ programs, but other parameters are possible, and we discuss them later (see Chapter 4).

Here, the type parameter is T. You can use any identifier as a parameter name, but using T is the convention. The type parameter represents an arbitrary type that is specified by the caller when the caller calls the function. You can use any type (fundamental type, class, and so on) as long as it provides the operations that the template uses. In this case, type T has to support operator < because a and b are compared using this operator.

For historical reasons, you can also use class instead of typename to define a type parameter. The keyword typename came relatively late in the evolution of the C++ language. Prior to that, the keyword class was the only way to introduce a type parameter, and this remains a valid way to do so. Hence, the template max() could be defined equivalently as follows:

template <class T> 

inline T const& max (T const& a, T const& b) 

{ 

    // if a < b then use b else use a 

    return a<b?b:a; 

} 

Semantically there is no difference in this context. So, even if you use class here, any type may be used for template arguments. However, because this use of class can be misleading (not only class types can be substituted for T), you should prefer the use of typename in this context. Note also that unlike class type declarations, the keyword struct cannot be used in place of typename when declaring type parameters.

2.1.2 Using the Template

The following program shows how to use the max() function template:

// basics/max.cpp 

#include <iostream> 

#include <string> 

#include "max.hpp" 

int main() 

{ 

    int i = 42; 

    std::cout << "max(7,i): " << ::max(7,i) << std::endl; 

    double f1 = 3.4; 

    double f2 = -6.7; 

    std::cout << "max(f1,f2): " << ::max(f1,f2) << std::endl; 

    std::string s1 = "mathematics"; 

    std::string s2 = "math"; 

    std::cout << "max(s1,s2): " << ::max(s1,s2) << std::endl; 

} 

Inside the program, max() is called three times: once for two ints, once for two doubles, and once for two std::strings. Each time, the maximum is computed. As a result, the program has the following output:

max(7,i):   42 

max(f1,f2): 3.4 

max(s1,s2): mathematics 

Note that each call of the max() template is qualified with ::. This is to make sure that our max() template is found in the global namespace. There is also an std::max() template in the standard library, which under some circumstances may be called or may lead to ambiguity. ^[1]

^[1] For example, if one argument type is defined in namespace std (such as strings), according to the lookup rules of C++, both the global and the std max() template are found.

Normally, templates aren't compiled into single entities that can handle any type. Instead, different entities are generated from the template for every type for which the template is used. ^[2] Thus, max() is compiled for each of these three types. For example, the first call of max()

^[2] The "one-entity-fits-all" alternative is conceivable but rare in practice. All language rules are based on the concept that different entities are generated.

int i = 42; 

…  max(7,i) … 

uses the function template with int as template parameter T. Thus, it has the semantics of calling the following code:

inline int const& max (int const& a, int const& b) 

{ 

    // if a < b then use b else use a 

    return a<b?b:a; 

} 

The process of replacing template parameters by concrete types is called instantiation. It results in an instance of a template. Unfortunately, the terms instance and instantiate are used in a different context in object-oriented programming梟amely, for a concrete object of a class. However, because this book is about templates, we use this term for the "use" of templates unless otherwise specified.

Note that the mere use of a function template can trigger such an instantiation process. There is no need for the programmer to request the instantiation separately.

Similarly, the other calls of max() instantiate the max template for double and std::string as if they were declared and implemented individually:

const double& max (double const&, double const&); 

const std::string& max (std::string const&, std::string const&); 

An attempt to instantiate a template for a type that doesn't support all the operations used within it will result in a compile-time error. For example:

std::complex<float> c1, c2;    // doesn't provide operator < 

… 

max(c1,c2);                    // ERROR at compile time 

Thus, templates are compiled twice:

1.       Without instantiation, the template code itself is checked for correct syntax. Syntax errors are discovered, such as missing semicolons.

2.       At the time of instantiation, the template code is checked to ensure that all calls are valid. Invalid calls are discovered, such as unsupported function calls.

This leads to an important problem in the handling of templates in practice: When a function template is used in a way that triggers its instantiation, a compiler will (at some point) need to see that template's definition. This breaks the usual compile and link distinction for ordinary functions, when the declaration of a function is sufficient to compile its use. Methods of handling this problem are discussed in Chapter 6. For the moment, let's take the simplest approach: Each template is implemented inside a header file by using inline functions.

2.2 Argument Deduction

When we call a function template such as max() for some arguments, the template parameters are determined by the arguments we pass. If we pass two ints to the parameter types T const&, the C++ compiler must conclude that T must be int. Note that no automatic type conversion is allowed here. Each T must match exactly. For example:

template <typename T> 

inline T const& max (T const& a, T const& b); 

… 

max(4,7)     // OK: T is int for both arguments 

max(4,4.2)   // ERROR: first T is int, second T is double 

There are three ways to handle such an error:

1.       Cast the arguments so that they both match:

max(static_cast<double>(4),4.2)    // OK 

2.       Specify (or qualify) explicitly the type of T:

max<double>(4,4.2)                 // OK 

3.       Specify that the parameters may have different types.

For a detailed discussion of these topics, see the next section.

 

2.3 Template Parameters

Function templates have two kinds of parameters:

1.       Template parameters, which are declared in angle brackets before the function template name:

template <typename T>            // T is template parameter 

2.       Call parameters, which are declared in parentheses after the function template name:

…   max (T const& a, T const& b)   // a and b are call parameters 

You may have as many template parameters as you like. However, in function templates (unlike class templates) no default template arguments can be specified. ^[3] For example, you could define the max() template for call parameters of two different types:

^[3] This restriction is mainly the result of a historical glitch in the development of function templates. There are probably no technical hindrances to implementing such a feature in modern C++ compilers, and in the future it will probably be available (see Section 13.3 on page 207).

template <typename T1, typename T2> 

inline T1 max (T1 const& a, T2 const& b) 

{ 

    return a < b ? b : a; 

} 

… 

max(4,4.2)   // OK, but type of first argument defines return type 

This may appear to be a good method to enable passing two call parameters of different types to the max() template, but in this example it has drawbacks. The problem is that the return type must be declared. If you use one of the parameter types, the argument for the other parameter might get converted to this type, regardless of the caller's intention. C++ does not provide a means to specify choosing "the more powerful type" (however, you can provide this feature by some tricky template programming, see Section 15.2.4 on page 271). Thus, depending on the call argument order the maximum of 42 and 66.66 might be the double 66.66 or the int 66. Another drawback is that converting the type of the second parameter into the return type creates a new, local temporary object. As a consequence, you cannot return the result by reference. ^[4] In our example, therefore, the return type has to be T1 instead of T1 const&.

^[4] You are not allowed to return values by reference if they are local to a function because you'd return something that doesn't exist when the program leaves the scope of this function.

Because the types of the call parameters are constructed from the template parameters, template and call parameters are usually related. We call this concept function template argument deduction. It allows you to call a function template as you would an ordinary function.

However, as mentioned earlier, you can instantiate a template explicitly for certain types:

template <typename T> 

inline T const& max (T const& a, T const& b); 

… 

max<double>(4,4.2)    // instantiate T as double 

In cases when there is no connection between template and call parameters and when template parameters cannot be determined, you must specify the template argument explicitly with the call. For example, you can introduce a third template argument type to define the return type of a function template:

template <typename T1, typename T2, typename RT> 

inline RT max (T1 const& a, T2 const& b); 

However, template argument deduction does not match up return types, ^[5] and RT does not appear in the types of the function call parameters. Therefore, RT cannot be deduced. As a consequence, you have to specify the template argument list explicitly. For example:

^[5] Deduction can be seen as part of overload resolution梐 process that is not based on selection of return types either. The sole exception is the return type of conversion operator members.

template <typename T1, typename T2, typename RT> 

inline RT max (T1 const& a, T2 const& b); 

… 

max<int,double,double>(4,4.2)    // OK, but tedious 

So far, we have looked at cases in which either all or none of the function template arguments were mentioned explicitly. Another approach is to specify only the first arguments explicitly and to allow the deduction process to derive the rest. In general, you must specify all the argument types up to the last argument type that cannot be determined implicitly. Thus, if you change the order of the template parameters in our example, the caller needs to specify only the return type:

template <typename RT, typename T1, typename T2> 

inline RT max (T1 const& a, T2 const& b); 

… 

max<double>(4,4.2)    // OK: return type is double 

In this example, the call to max<double> explicitly sets RT to double, but the parameters T1 and T2 are deduced to be int and double from the arguments.

Note that all of these modified versions of max() don't lead to significant advantages. For the one-parameter version you can already specify the parameter (and return) type if two arguments of a different type are passed. Thus, it's a good idea to keep it simple and use the one-parameter version of max() (as we do in the following sections when discussing other template issues).

See Chapter 11 for details of the deduction process.

2.4 Overloading Function Templates

Like ordinary functions, function templates can be overloaded. That is, you can have different function definitions with the same function name so that when that name is used in a function call, a C++ compiler must decide which one of the various candidates to call. The rules for this decision may become rather complicated, even without templates. In this section we discuss overloading when templates are involved. If you are not familiar with the basic rules of overloading without templates, please look at Appendix B, where we provide a reasonably detailed survey of the overload resolution rules.

The following short program illustrates overloading a function template:

// basics/max2.cpp 

// maximum of two int values 

inline int const& max (int const& a, int const& b) 

{ 

    return a<b?b:a; 

} 

// maximum of two values of any type 

template <typename T> 

inline T const& max (T const& a, T const& b) 

{ 

    return a<b?b:a; 

} 

// maximum of three values of any type 

template <typename T> 

inline T const& max (T const& a, T const& b, T const& c) 

{ 

    return max (max(a,b), c); 

} 

int main() 

{ 

    ::max(7, 42, 68);     // calls the template for three arguments 

    ::max(7.0, 42.0);     // calls max<double> (by argument deduction) 

    ::max('a', 'b');      // calls max<char> (by argument deduction) 

    ::max(7, 42);         // calls the nontemplate for two ints 

    ::max<>(7, 42);       // calls max<int> (by argument deduction) 

    ::max<double>(7, 42); // calls max<double> (no argument deduction) 

    ::max('a', 42.7);     // calls the nontemplate for two ints 

} 

As this example shows, a nontemplate function can coexist with a function template that has the same name and can be instantiated with the same type. All other factors being equal, the overload resolution process normally prefers this nontemplate over one generated from the template. The fourth call falls under this rule:

max(7, 42)      // both int values match the nontemplate function perfectly 

If the template can generate a function with a better match, however, then the template is selected. This is demonstrated by the second and third call of max():

max(7.0, 42.0)  // calls the max<double> (by argument deduction) 

max('a', 'b');  // calls the max<char> (by argument deduction) 

It is also possible to specify explicitly an empty template argument list. This syntax indicates that only templates may resolve a call, but all the template parameters should be deduced from the call arguments:

max<>(7, 42)    // calls max<int> (by argument deduction) 

Because automatic type conversion is not considered for templates but is considered for ordinary functions, the last call uses the nontemplate function (while 'a' and 42.7 both are converted to int):

max('a', 42.7)      // only the nontemplate function allows different argument types 

A more useful example would be to overload the maximum template for pointers and ordinary C-strings:

// basics/max3.cpp 

#include <iostream> 

#include <cstring> 

#include <string> 

// maximum of two values of any type 

template <typename T> 

inline T const& max (T const& a, T const& b) 

{ 

    return a < b ? b : a; 

} 

// maximum of two pointers 

template <typename T> 

inline T* const& max (T* const& a, T* const& b) 

{ 

    return *a < *b ? b : a; 

} 

// maximum of two C-strings 

inline char const* const& max (char const* const& a, 

                               char const* const& b) 

{ 

    return std::strcmp(a,b) < 0 ? b : a; 

} 

int main () 

{ 

    int a=7; 

    int b=42; 

    ::max(a,b);      // max() for two values of type int 

    std::string s="hey"; 

    std::string t="you"; 

    ::max(s,t);      // max() for two values of type std::string 

    int* p1 = &b; 

    int* p2 = &a; 

    ::max(p1,p2);    // max() for two pointers 

    char const* s1 = "David"; 

    char const* s2 = "Nico"; 

    ::max(s1,s2);    // max() for two C-strings 

} 

Note that in all overloaded implementations, we pass all arguments by reference. In general, it is a good idea not to change more than necessary when overloading function templates. You should limit your changes to the number of parameters or to specifying template parameters explicitly. Otherwise, unexpected effects may happen. For example, if you overload the max() template, which passes the arguments by reference, for two C-strings passed by value, you can't use the three-argument version to compute the maximum of three C-strings:

// basics/max3a.cpp 

#include <iostream> 

#include <cstring> 

#include <string> 

// maximum of two values of any type (call-by-reference) 

template <typename T> 

inline T const& max (T const& a, T const& b) 

{ 

    return a < b ? b : a; 

} 

// maximum of two C-strings (call-by-value) 

inline char const* max (char const* a, char const* b) 

{ 

    return std::strcmp(a,b) < 0 ? b : a; 

} 

// maximum of three values of any type (call-by-reference) 

template <typename T> 

inline T const& max (T const& a, T const& b, T const& c) 

{ 

    return max (max(a,b), c); // error, if max(a,b) uses call-by-value 

} 

int main () 

{ 

    ::max(7, 42, 68); // OK 

    const char* s1 = "frederic"; 

    const char* s2 = "anica"; 

    const char* s3 = "lucas"; 

    ::max(s1, s2, s3); // ERROR 

} 

The problem is that if you call max() for three C-strings, the statement

return max (max(a,b), c); 

becomes an error. This is because for C-strings, max(a,b) creates a new, temporary local value that may be returned by the function by reference.

This is only one example of code that might behave differently than expected as a result of detailed overload resolution rules. For example, the fact that not all overloaded functions are visible when a corresponding function call is made may or may not matter. In fact, defining a three-argument version of max() without having seen the declaration of a special two-argument version of max() for ints causes the two-argument template to be used by the three-argument version:

// basics/max4.cpp 

// maximum of two values of any type 

template <typename T> 

inline T const& max (T const& a, T const& b) 

{ 

    return a<b?b:a; 

} 

// maximum of three values of any type 

template <typename T> 

inline T const& max (T const& a, T const& b, T const& c) 

{ 

    return max (max(a,b), c);  // uses the template version even for ints 

}                              // because the following declaration comes 

                               // too late: 

// maximum of two int values 

inline int const& max (int const& a, int const& b) 

{ 

    return a<b?b:a; 

} 

We discuss details in Section 9.2 on page 121, but for the moment, as a rule of thumb you should always have all overloaded versions of a function declared before the function is called.

2.5 Summary

·         Template functions define a family of functions for different template arguments.

·         When you pass template arguments, function templates are instantiated for these argument types.

·         You can explicitly qualify the template parameters.

·         You can overload function templates.

·         When you overload function templates, limit your changes to specifying template parameters explicitly.

·         Make sure you see all overloaded versions of function templates before you call them.

 

 

Linkage in C and C++

Scope regions in C and C++

Storage class specifiers and storage duration

informit - static declarations

Type casting

Smart pointers in C++

Smart pointers in Boost


<Explicit constructor>

A note on Explicit Initialization in C++

Explicit Constructor in C++

explicit keyword

Templates FAQ

C++ Template: function template

C++ Template: class template

C++ Template: Nontype template parameters

C++ Template: Tricky Basics

C++ Template: Using Templates in Practice

C++ Template: Basic Template Terminology

const

2009故事会

今天看到一道EMC面试题：

补充语句，使下面程序if判断语句始终为真，不能改动if判断语句，即只能在之前加语句

if ((*f = 0)||(void *)f == (void *)&f)
{
  /* statements always executed*/
}

先回顾下数组的几个知识点：

1。常量指针与指向常量的指针的区别。以指针*为分隔符，const在*的右边表示指针本身具有不可修改的属性，在*的左边表示指针指向的数据具有不可修改的属性。

指向常量的指针：int const * 或 const int *
常量指针：int * const

举例：

int int1 = 1;
int int2 = 3;

int const * ptr1 = &int1;
ptr1 = &int2;
*ptr1 = 10; //编译出错，无法改变const对象的值

int * const ptr2 = &int1;
*ptr2 = 10;
ptr2 = &int2;  //编译出错，无法改变const对象的值
int * const ptr3;  //编译出错，const对象定义时必须初始化

2。数组名是数组的首地址，即第一个元素的地址。所以，下面这些表达式表示的含义都是一样的。假设int a[] = {1, 2, 3}

a      &a      &a[0]

3。数组名是一个常量指针(const pointer to value)，是一个右值(r-value)。以下都是错误的：

a++;
a = &y;

所以，这道题目的答案就是:  int f[10];