阿里巴巴笔试题

 

阿里巴巴笔试题

分类： 面试珠玑 2011-10-25 11:05  13652人阅读  评论(79)  收藏  举报

阿里巴巴 struct class vector constructor

1、有一个虚拟存储系统，若进程在内存中占3页（开始时内存为空），若采用先进先出（FIFO）页面淘汰算法，当执行如下访问页号序列后1，2，3，4，5,1，2，5，1，2，3，4，5，会发生多少缺页？
A、7                       B、8                            C、9                           D、10

2、设有一个顺序栈S，元素s1、s2、s3、s4、s5、s6依次进栈，如果6个元素的出栈顺序为s2、s3、s4、s6、s5、s1，则顺序栈的容量至少应为多少？
A、2                      B、3                             C、4                           D、5

3、下列关于文件索引结构的叙述中，哪一个是错误的？
A、采用索引结构，逻辑上连续的文件存放在连续的物理块中
B、系统为每个文件建立一张索引表
C、索引结构的优点是访问速度快，文件长度可以动态变化
D、索引结构的缺点是存储开销大

4、【0、2、1、4、3、9、5、8、6、7】是以数组形式存储的最小堆，删除堆顶元素0后的结果是（）
A、【2、1、4、3、9、5、8、6、7】
B、【1、2、5、4、3、9、8、6、7】
C、【2、3、1、4、7、9、5、8、6】
D、【1、2、5、4、3、9、7、8、6】

5、某页式存储管理系统中，地址寄存器长度为24位，其中页号占14位，则主存的分块大小是（）字节。
A、10                     B、2^10                      C、2^14                     D、2^24

6、在一个长为33厘米的光滑凹轨上，在第3厘米、第6厘米、第19厘米、第22厘米、第26厘米处各有一个钢珠，凹轨很细，不能同时通过两个钢珠，开始时，钢珠运动方向是任意的。两个钢珠相撞后，以相同速度反向运动。假设所有钢珠初始速度为每秒运动1厘米，那么所有钢珠离开凹轨的最长可能时间是（）
A、30                     B、26                        C、38                      D、33

7、std::vector::iterator重载了下面哪些运算符？
A、++                     B、>>                       C、*（前置）                   D、==

8、下列运算符，在C++语言中不能重载的是（）
A、*                        B、？：                    C、：：                           D、delete

9、在排序方法中，元素比较次数与元素的初始排列无关的是（）
A、Shell 排序         B、归并排序              C、直接插入排序                D、选择排序
A、C肯定不选的，归并排序的在merge中是跟序列有关，如果有序，比较次数最少n/2，最糟是元素错落n-1。而选择排序比较次数与关键字的初始状态无关，总的比较次数N=(n-1)+(n-2)+...+1=n*(n-1)/2。所以 应该是选择排序！

10、给定如下代码： int x[4]={0}; int y[4]={1}; 数组x和y的值为（）
A、{0，0，0，0}，{1，1，1，1}
B、{0，0，0，0}，{1，0，0，0}
C、{0，不确定}，{1，不确定}
D、与编译器相关

10、给出以下定义，下列哪些操作是合法的？
const char *p1 = "hello";
char* const p2 = "world";
A、p1++                      B、p1[2]='w';                     C、p2[2]='l';                    D、p2++

11、假设在n进制下，下面的等式成立，n值是（） 567*456=150216
A、9                B、10                 C、12                     D、18

假设是X进制，则567=7+6*X+5*X^2，456=6+5*X+4*X^2，所以564*456=（7+6*X+5*X^2）*（6+5*X+4*X^2）而150216=6+X+2*X^2+5*x^4+X^5，由于567*456=150216，则6+X+2*X^2+5*x^4+X^5=（7+6*X+5*X^2）*（6+5*X+4*X^2），最后解出来X=18

12、关于struct和class，下列说法正确的是（）
A、struct的成员默认是public，class的成员默认是private
B、struct不能继承，class可以继承
C、struct可以有无参构造函数
D、struct的成员变量只能是public

若不明确指定，来自class的继承按照private继承处理，来自struct的继承按照public继承处理；都可使用public/private/protected修饰符，都可以有无参构造函数

13、定义一个函数指针，指向的函数有两个int形参并且返回一个函数指针，返回的指针指向一个有一个int形参且返回int的函数？
A、int (*(*F)(int, int))(int)
B、int (*F)(int, int)
C、int (*(*F)(int, int))
D、*(*F)(int, int)(int)

14、声明一个指向含有10个元素的数组的指针，其中每个元素是一个函数指针，该函数的返回值是int，参数是int*，正确的是（）
A、（int *p[10]）（int*）;
B、int [10]*p（int *）;
C、int (*(*p)[10])(int *);
D、int ((int *)[10])*p;
E、以上选项都不正确

15、一个栈的输入序列为123.....n，若输出序列的第一个元素是n，输出第i（1<=i<=n）个元素是（）
A、不确定
B、n-i+1
C、i
D、n-i

16、下列代码编译时会产生错误的是（）

[cpp]  view plain copy

1. #include <iostream>  
2. using namespace std;  
3. struct Foo  
4. {  
5.     Foo() {  }  
6.     Foo(int) {  }  
7.     void fun()   {  }  
8. };  
9. int main(void)  
10. {  
11.     Foo a(10);    //语句1  
12.     a.fun();      //语句2  
13.     Foo b();      //语句3  
14.     b.fun();      //语句4  
15.     return 0;  
16. }  

A、语句1             B、语句2           C、语句3             D、语句4        
17、在32位机器上，下列代码中

[cpp]  view plain copy

1. #pragma pack(2)  
2. class A  
3. {  
4.     int i;  
5.     union U  
6.     {  
7.         char buff[13];  
8.         int i;  
9.     }u;  
10.     void foo() {    }  
11.     typedef char* (*f)(void*);  
12.     enum{red, green, blue} color;  
13. }a;  

sizeof(a)的值是（）

A、20       B、21       C、22        D、24           E、非以上选项

18、下面描述中，错误的是（）
A、基类定义的public成员在公有继承的派生类中可见，也能在类外被访问
B、基类定义的public和protected成员在私有继承的派生类中可见，在类外可以被访问
C、基类定义的public和protected成员在保护继承的派生类中不可见
D、基类定义的protected成员在protected继承的派生类中可见，也能在类外被访问

19、当很频繁地对序列中部进行插入和删除操作时，应该选择使用的容器是（）
A、vector     B、list      C、deque      D、stack

20、判断一个单向链表中是否存在环的最佳方法是（）
A、两重遍历      B、快慢指针      C、路径记录       D、哈希表辅助
21、给你1、2、3 这三个数字 可以使用C的各种运算符 你能表示的最大的整数是（）

A、2*3*sizeof(1)             B、3<<(2<<sizeof(1))                    C、sizeof(3)<<(sizeof(2)<<(sizeof(1)))                    D、(unsigned long)(2-3)*1

-1的二进制形式就是全1表示

22、下面代码的输出是多少？

[cpp]  view plain copy

1. class A  
2. {  
3. public:  
4.     A()  {    cout<<"A"<<endl;    }  
5.     ~A() {    cout<<"~A"<<endl;   }  
6. };  
7.   
8. class B:public A  
9. {  
10. public:  
11.     B(A &a):_a(a)  
12.     {  
13.         cout<<"B"<<endl;  
14.     }  
15.     ~B()  
16.     {  
17.         cout<<"~B"<<endl;  
18.     }  
19. private:  
20.     A _a;  
21. };  
22.   
23. int main(void)  
24. {  
25.     A a;       //很简单，定义a的时候调用了一次构造函数  
26.     B b(a);    //这里b里面的_a是通过成员初始化列表构造起来的  
27.     //而且是通过copy constructor构造的是b的成员对象_a的，这里是编译器默认的，因此在构造好_a前，先调用基类构造函数  
28.     //然后才是构造自身,顺序就是A()->_a->B()（局部）  
29.     //因此这里有两个A,一个B  
30.   
31.       
32.     //在return之前进行析构  
33.     /************************************************************************/  
34.     /*析构是按照定义对象的反顺序来的，而且同一个对象按照构造的反顺序来的，因此这里先 
35.     析构b然后才是a，那么b的构造顺序是上面的A()->_a->B()（局部），反过来，就是B()（局部）->_a->A() 
36.     因此得到的就是~B->~A->~A 
37.     在b之后就是析构a 
38.     最后结果就是 
39.     ~B->~A->~A->~A*/  
40.     return 0;  
41. }  

23、一个骰子，6面，1个面是 1， 2个面是2， 3个面是3， 问平均掷多少次能使1、2、3都至少出现一次！

24、一个有趣的抛硬币问题
假设有一个硬币，抛出字（背面）和花（正面）的概率都是0.5，而且每次抛硬币与前次结果无关。现在做一个游戏，连续地抛这个硬币，直到连续出现两次字为止，问平均要抛多少次才能结束游戏？注意，一旦连续抛出两个“字”向上游戏就结束了，不用继续抛。
上面这个题目我第一次见到是在pongba的TopLanguage的一次讨论上，提出问题的人为Shuo Chen，当时我给出了一个解法，自认为已经相当简单了，先来考虑一下抛硬币的过程：首先先抛一枚硬币，如果是花，那么需要重头开始；如果是字，那么再抛一枚硬币，新抛的这枚如果也是字，则游戏结束，如果是花，那么又需要重头开始。根据这个过程，设抛硬币的期望次数为T，可以得到关系：
　　T = 1 + 0.5T + 0.5( 1 + 0.5 * 0 + 0.5T) 
解方程可得到 T = 6。
或者根据公式，需要连续抛出n个字的一般情形，结果相当简洁：Tn = 2^(n+1) - 2，其中Tn为首次出现连续的n个字的期望投掷数。
参考链接    http://www.cnblogs.com/atyuwen/archive/2010/09/12/coin.html

25、问题描述：
12个高矮不同的人，排成两排，每排必须是从矮到高排列，而且第二排比对应的第一排的人高，问排列方式有多少种?
这个笔试题，很YD，因为把某个递归关系隐藏得很深。

问题分析:
我们先把这12个人从低到高排列，然后，选择6个人排在第一排，那么剩下的6个肯定是在第二排。
用0表示对应的人在第一排，用1表示对应的人在第二排，那么含有6个0，6个1的序列，就对应一种方案。
比如000000111111就对应着
第一排:0 1 2 3 4 5
第二排:6 7 8 9 10 11
010101010101就对应着
第一排:0 2 4 6 8 10
第二排:1 3 5 7 9 11
问题转换为，这样的满足条件的01序列有多少个。
观察1的出现，我们考虑这一个出现能不能放在第二排，显然，在这个1之前出现的那些0，1对应的人
要么是在这个1左边，要么是在这个1前面。而肯定要有一个0的，在这个1前面，统计在这个1之前的0和1的个数。
也就是要求，0的个数大于1的个数。
OK，问题已经解决.
如果把0看成入栈操作，1看成出栈操作，就是说给定6个元素，合法的入栈出栈序列有多少个。
这就是catalan数，这里只是用于栈，等价地描述还有，二叉树的枚举，多边形分成三角形的个数，圆括弧插入公式中的方法数，其通项是c(2n, n)/(n+1)。

 

分享到： 

• 上一篇：Perfect World
• 下一篇：猴子分桃问题

顶

51

踩

1

查看评论

43楼  看着捉急 5天前 08:46发表 [回复]

这些题目大部分还是比较简单的

42楼  licai2000 2012-11-21 12:19发表 [回复]

第17题答案应该为24字节，int-占4字节 Union里的char buff[13]-根据字对齐规则占用16字节，最后的enum指针占用4字节。

41楼  licui94 2012-10-07 15:59发表 [回复]

12题，C应该也对吧？！

Re:  kid1412z 6天前 15:22发表 [回复]

回复licui94：同意 我认为C也是对的

Re:  Hackbuteer1 5天前 19:05发表 [回复]

回复kid1412z：已经修改过来了

40楼  liu_su 2012-10-06 19:57发表 [回复]

9、在排序方法中，元素比较次数与元素的初始排列无关的是（）
归并排序的在merge中是跟序列有关，如果有序，比较次数最少n/2，最糟是元素错落n-1。而选择排序比较次数与关键字的初始状态无关，总的比较次数N=(n-1)+(n-2)+...+1=n*(n-1)/2。所以 应该是选择排序！

39楼  liunianyijiu 2012-10-05 16:23发表 [回复]

第7题：
std::vector::iterator 重载了*, ->,[]三个运算符
楼主。第7题答案不对哦。

38楼  evan7shi 2012-09-29 09:50发表 [回复]

mark 准备笔试中

37楼  诚朴勇毅 2012-09-10 10:46发表 [回复]

求问23题

36楼  ysu108 2012-09-01 10:03发表 [回复]

第9题：选择排序与初始序列也无关吧，如果每次选择一个最大的，不都要和所有元素比较过来么？

35楼  cygist 2012-01-04 01:59发表 [回复]

第十题, 答案C是不合法的操作. 只有p2指针指向一个数组的时候才可以修改. 而"world"是常量字符串, 不允许通过指针进行修改~请楼主确认

Re:  Hackbuteer1 2012-05-02 16:14发表 [回复]

回复cygist：p2是个常量指针，指针的指向不能变，但是指针指向的变量是可以改变的

Re:  dltdltdlt 2012-08-22 12:12发表 [回复]

35楼的解释很合理，本人之前遇到过这样的问题，望楼主再次确认一下！回复Hackbuteer1：

Re:  Hackbuteer1 2012-08-22 12:35发表 [回复]

回复dltdltdlt：是的，C选项不对的，修改过来了，是我弄错了

34楼  hanxiao08250825 2011-12-26 17:48发表 [回复]

第7题 貌似*（前置）运算符也重载了的吧！

Re:  cygist 2012-01-04 01:57发表 [回复]

回复hanxiao08250825：我也这样认为~

33楼  yubeigongshengyu 2011-11-10 16:55发表 [回复]

我不做软件 是看热闹的 24题答案好多呢？

32楼  sunyun1990 2011-11-05 20:21发表 [回复]

第17题好像选d唉~

Re:  r_mosaic 2011-11-09 12:47发表 [回复]

回复sunyun1990：有 pragma pack(2) 在前面。我一开始也没看到，以为灰色的是注释呢……:(

31楼  onlyonename 2011-11-03 18:59发表 [回复]

mark

30楼  p1079854874 2011-10-31 17:19发表 [回复]

大家好！请教第十六题

Re:  quanben 2011-10-31 20:12发表 [回复]

回复p1079854874：16题真的很恶心，如果是这个答案，应该是因为 Foo b(); 的b被编译器解释为返回Foo的参数为空的函数指针，这样显然b.fun()就没意义了。C++语法规定在非new情况下对于无参构造函数调用不能带括号。

Re:  r_mosaic 2011-11-08 08:27发表 [回复]

回复quanben：记得大学时候qiqi同学给我们演示过的，Foo b() 这样会变成一个函数声明。真是古老的C语言与新式的C++的结合体。

Re:  quanben 2011-11-08 13:16发表 [回复]

回复r_mosaic：qiqi真是先知先觉啊。果然再考证了一下，这只是一个声明，不是函数指针（函数指针一定要带星号定义的），基本上没什么用了。C++的确很搞啊，没什么特殊原因绝不去碰它了。

29楼  wb_james 2011-10-30 21:29发表 [回复]

十八题个人觉得除了A外全部错的，请楼主考证。

28楼  quanben 2011-10-30 09:09发表 [回复]

20题能否详细说一下，这个时间复杂度是多少呢？

Re:  Hackbuteer1 2011-10-30 09:49发表 [回复]

回复quanben：O(n)

27楼  y13872888163 2011-10-29 07:44发表 [回复]

第6题类似蚂蚁爬杆 两球相撞反向可视为相互穿过

26楼  jbx929205249 2011-10-28 08:10发表 [回复]

看来要好好补补知识了

25楼  无敌小猫猫 2011-10-27 20:37发表 [回复]

14题选C吧？首先是个指针耶~

Re:  Hackbuteer1 2012-05-11 15:33发表 [回复]

回复ShangYT：应该是C的，一开始弄错了

24楼  r_mosaic 2011-10-27 16:37发表 [回复]

第6题我真得编个程序算了，实在条件太复杂了……

Re:  quanben 2011-10-30 09:00发表 [回复]

回复r_mosaic：一开始看第六题也很恐怖，但想想应该不是。钢珠尺寸不计、理想正碰无摩擦情形，就是这些钢珠不相干的运动，所以应该就是单独运行的最长距离，我觉得就是3cm那个球向右移出钢轨的时间，即30秒。

Re:  r_mosaic 2011-11-09 12:34发表 [回复]

回复quanben：呀，这个想法太精彩了，我为什么没有想到呢。好比球 1 和球 2 碰后，球 1 的运行轨迹就是球 2 原先的运行轨迹的延伸，因此……
对于多球，由于速度相同的缘故，不可能多球同时碰撞。所以这个推断我觉得是正确的。应该是 30 秒。

Re:  likeyuanyuan 2012-05-15 22:15发表 [回复]

回复r_mosaic：对的，两球碰撞后同速反向运动，那么也就是可以理解为互相传阅运动，A向左，B向右，AB相撞的结果是：A向右，B向左，而本题最为关键的前提是所有球都是一样的，且为无能量损失碰撞，那么AB相撞后的结果可以看成A穿过B继续向左，B穿过A继续向右。那么本体的思路无疑就变得清晰明了了：最长时间则是凹槽两端钢球分别以1m/s的速度到达对面端的时间
。最两端球分别是位于3cm 和26cm处钢球，则3cm到达33cm末端需要30s ,26cm处钢球到达0cm处需要26cm .所以最多需要30s.

23楼  r_mosaic 2011-10-27 16:36发表 [回复]

第十一题……心算笔算都麻烦啊……要是有计算器就好了。我用 python 算了一下，终于知道答案了。

22楼  waemer 2011-10-27 13:46发表 [回复]

回复likeyuanyuan：根据我的回复Hackbuteer1：楼主的14题理解似乎有误，可以用sizeof测试一下，c答案应该是对的。根据《c专家编程》介绍的“右左法则”应该也是c选项。

Re:  Hackbuteer1 2012-05-11 15:35发表 [回复]

回复waemer：已经更正，的确是应该选择C的

21楼  BIAOBIAO齐 2011-10-26 23:41发表 [回复]

赞！发现很多算法问题都忘了。。。要补啊。

20楼  heretic 2011-10-26 19:41发表 [回复]

呵呵呵，谢谢楼主啊

19楼  likeyuanyuan 2011-10-26 16:01发表 [回复]

回复Hackbuteer1：错了 还是应该是C
int (*(*p)[10])(int *);
首先p左边有* ，说明P是个指针，（*p）右边有[10]说明P是一个指向10个元素的指针，（*p）左边有* 说明这些元素是指针，（*（*p）[10]）右边是（int*）说明这些指针是一个函数的指针，这个函数的参数是int* 返回值为int

Re:  Hackbuteer1 2012-05-11 15:34发表 [回复]

回复likeyuanyuan：是的，应该选择C的

18楼  A056313 2011-10-26 15:57发表 [回复]

第一题是7次吧应该
1,2,3
2,3,4 1次
3,4,5 1次
4,5,1 1次
5,1,2 1次
1,2,3 1次
2,3,4 1次
3,4,5 1次

Re:  fr_fanrong 2011-10-26 16:52发表 [回复]

回复A056313：还有开始的1 2 3
这个也应该算是缺页

Re:  Hackbuteer1 2011-10-26 17:03发表 [回复]

回复fr_fanrong：刚开始的3个也是缺页的

17楼  xxxshengxxx 2011-10-26 15:21发表 [回复]

回复xxxshengxxx：

16楼  likeyuanyuan 2011-10-26 14:34发表 [回复]

楼主，第14题是不是不对啊？
求解释，求详细解析，我的理解是A

Re:  Hackbuteer1 2012-05-11 15:34发表 [回复]

回复likeyuanyuan：应该选择C的

15楼  priest334 2011-10-26 14:30发表 [回复]

18题除了A其余都错

14楼  beenchop 2011-10-26 14:28发表 [回复]

流明一记

13楼  r_mosaic 2011-10-26 12:36发表 [回复]

第二题没看懂含义，能解释一下吗？

Re:  starmorning2011 2011-11-03 17:04发表 [回复]

回复r_mosaic：第二题应该选2吧?
怎么做的阿?
后进先出阿.
S1 S2 
如果容量是2的话,再进来一个后进的S2就的出来啊.第一个出来.

Re:  r_mosaic 2011-10-26 13:56发表 [回复]

回复r_mosaic：哦，明白了。就是入栈顺序确定，出栈顺序确定，但相互之间有交叉的。

Re:  Hackbuteer1 2011-10-26 12:44发表 [回复]

回复r_mosaic：第二题你模拟一下整个入栈、出栈的过程就清楚了，就是看下要达到那样的出栈效果，怎样安排入栈、出栈的操作，你看下栈中最多的时候存储了多少个元素，就是栈的容量。。

Re:  r_mosaic 2011-10-27 13:07发表 [回复]

回复Hackbuteer1：谢谢，这些题目还是挺有意思的。不过，第十题有两个答案？我也觉得 C 这个答案虽然也可以，只是这个做法不正规，合法好像是合法的。

12楼  beiwei009 2011-10-26 11:42发表 [回复]

第六题是A吧

Re:  Hackbuteer1 2011-10-26 14:47发表 [回复]

回复beiwei009：你是怎么计算的？

Re:  netiger1986 2011-10-26 17:33发表 [回复]

回复Hackbuteer1：钢珠相撞, 同速相反运动,可以看成两个钢珠穿越了彼此, 依旧保持和相撞前的同速同向前进. 所以只要找到离终点最长的那个距离就行了, 3cm处的小球如果是向33cm处移动,为可能最大值.

Re:  Hackbuteer1 2012-05-11 15:35发表 [回复]

回复netiger1986：这个解法很巧妙啊，ORZ。。

11楼  opensourcewj 2011-10-26 11:30发表 [回复]

简单

10楼  kenel32 2011-10-26 10:08发表 [回复]

第一题就不会做啊 哥。。。

9楼  sunwardyhqcn 2011-10-26 09:35发表 [回复]

楼主写一下自己的答案啊

8楼  leezy_2000 2011-10-26 01:36发表 [回复]

阿里不是整网站的么，老考C++干什么？

Re:  Hackbuteer1 2011-10-26 09:49发表 [回复]

回复leezy_2000：不清楚啊

7楼  xinwa520 2011-10-25 23:15发表 [回复]

楼主。17个答案是错误的。。。应该是24。。牵扯字节对齐。。别误导了大家。。。。

Re:  Hackbuteer1 2011-10-26 09:49发表 [回复]

回复xinwa520：是22的，你在认真看下

Re:  bdcbdk 2011-10-26 08:09发表 [回复]

回复xinwa520：是22的，因为#pragma pack （2）

6楼  Random 2011-10-25 22:17发表 [回复]

lz 18题B也是错的吧

Re:  bdcbdk 2011-10-26 08:10发表 [回复]

回复huanyongshen：貌似protected的无论在子类中是何种继承都是可见，但类外不可访问的吧

5楼  myhaikuotiankong 2011-10-25 20:53发表 [回复]

楼主是什么意思？有的有答案，有的没有啊。。。

Re:  Hackbuteer1 2011-10-25 21:16发表 [回复]

回复myhaikuotiankong：有的还正在做，还没有整理出来

4楼  Kiven 2011-10-25 20:38发表 [回复]

没有答案怎么做

Re:  Hackbuteer1 2011-10-25 21:16发表 [回复]

回复huzhiqiang123456：答案已经添加了

3楼  zsjgs 2011-10-25 12:41发表 [回复]

楼主写一下自己的答案啊

2楼  hardy1696 2011-10-25 12:34发表 [回复] [引用] [举报]

第一题怎么算阿。

Re:  明明如月 2011-10-26 15:35发表 [回复]

回复hardy1696：还要算上最初始的那三次缺页。我在上述的回答中有些疏漏

Re:  明明如月 2011-10-26 15:33发表 [回复] [引用] [举报]

回复hardy1696：10次，操作系统的知识（记得大概），缓存3页，进来一页，那么需要剔除一页，如果进来的那页在此时的缓存3个页中能够找到的话，则不发生缺页；如果找不到，就要把最先进入的那页（在缓存中逗留最久的那页）剔除，此时就叫做缺页。例如：刚开始的三页：1 2 3；-->进来4（4不存在缓存页中）-->剔除1（在缓存中逗留最久的那页）-->就变成了2 3 4 -->此时称之为 1次缺页。然后进 5 -->缓存变成 3 4 5（第二次缺页），进1后-->缓存变为 4 5 1（第三次缺页）；进2后-->缓存变为5 1 2 （第四次缺页）；进5（缓存中有5）--> 缓存变为1 2 5（此次不算缺页）；之后以此类推。。。。

1楼  yuantuji 2011-10-25 11:35发表 [回复]

怎么转载呢？

Re:  Hackbuteer1 2011-10-25 12:26发表 [回复]

回复yuantuji：不能转载的