版权声明：本文为博主原创文章，转载请注明出处，谢谢!

1.练习1.10
这个是阿克曼函数，真的很牛，花了我很长时间。
表达式的求值就不说了。
(define (f n) (A 0 n)) ——-2n
(define (g n) (A 1 n))——-2的n次方
(define (h n) (A 2 n))——-n个2的次方，例如：(h 4)表示为2的2次方的2次方的2次方
2.练习1.11
递归计算过程：

1
2
3
4
5
6

(define (f1 n)
  (if (< n 3)
      n
      (+ (f1 (- n 1))
	 (* 2 (f1 (- n 2)))
	 (* 3 (f1 (- n 3))))))

迭代计算过程：

1
2
3
4
5
6
7
8
9
10

(define (f2 n)
  (f2-iter 2 1 0 3 n))
(define (f2-iter a b c num n)
  (cond ((< n 3) n)
	((> num n) a)
	(else (f2-iter (+ a
			  (* 2 b)
			  (* 3 c))
		       a b (+ num 1) n))))

解释一下迭代计算过程吧，利用a b c 三个数字保存临时的数据，num表示目前计算的状态，当num>n时，表示已经求得的结果在a中。
下面的结果是别人的例子，不是有多好，只是给我很大的启发，参数的移动可以增强程序的灵活性，不错！！我得记住这一点。。。

1
2
3
4
5
6
7
8

(define (myf-iter a b c n)
  (format #t "Caculating n, n is ~S, a is ~S, b is ~S, c is ~S ~%" n a b c)
  (if (= n 0)
      a
  (myf-iter b c ( + (* 3 a) (* 2 b) c) (- n 1))))
(define (newf n)
  (myf-iter 0 1 2 n))

3.练习1.12

1
2
3
4
5

(define (yanghui row col)
  (cond ((> col row) -1)
	((or (= 1 col) (= row col)) 1)
	(else (+ (yanghui (- row 1) (- col 1))
		 (yanghui (- row 1) col)))))

row表示第几行，col表示第row行的第几个数数字。当col为row行的第1个或者最后一个数的时候，结果为1；否则，结果为row－1行的col－1的数加上row－1行的col的数。4.练习1.13
不知道证明的对不对，对0和1的求值略去。
假设在n-1和n时，满足方程，代入n＋1的方程 Φn ＋Φn －1=Φn ＋1，接着证明(Υn＋Υn-1)/根5小于0.5，上式可变为Υn-1(Υ+1)/根5，可知Υn-1/根5小于0.5，而(Υ+1)/根5明显小于1，所以这个式子小于0.5，所以根据数学归纳法。。。
5.练习1.14
2的11次？
6.练习1.15
都是logn？
7.练习1.16

1
2
3
4
5
6
7

(define (fast-expt-iter a b n)
  (cond ((= n 1) (* a b))
	((not (even? n)) (fast-expt-iter (* a b) b (- n 1)))
       	(else (fast-expt-iter a (square b) (/ n 2)))))
(define (fast-expt b n)
  (fast-expt-iter 1 b n))

通过这道题，我总结到了，在目前的lisp学习中，主要是递归过程，所以应该在最开始的时候将出口留好，而不是放在随后的过程中。
8.练习1.17

1
2
3
4

(define (* a b)
  (cond ((= b 1) a)
	((even? b) (double (* a (halve b))))
	(else (+ a (* a (- b 1))))))

这道题，额，没考虑b为0的时候，看来测试用例做的不够全面啊。改为

1
2
3
4

(define (* a b)
  (cond ((= b 0) 0)
	((even? b) (double (* a (halve b))))
	(else (+ a (* a (- b 1))))))

即可！不过貌似也没考虑正负数什么了，说白了就是练习，理解这种“折半”的计算方式。

版权声明：本文为博主原创文章，转载请注明出处，谢谢!

1. 练习1.1
   这个题没有什么好说的了，只要把代码敲出来，运行一遍就可以了。
2. 练习1.2
   这个题应该不算难吧，没有看过别人的答案，我把我的贴出来吧。

1
2

(/ (+ 5 4 (- 2 (- 3 (+ 6 (/ 4 5)))))
   (* 3 (- 6 2) (- 2 7)))

3.练习1.3我的方法是求出3个数的和，再将减去最小的数，算不上最好的方法吧，马马虎虎。

1
2
3
4
5

(define (sumofmax2 x y z)
  (- (+ x y z)
     (cond ((and (< x y) (< x z)) x)
	   ((and (< y x) (< y z)) y)
	   (else z))))

4.练习1.4这个函数首先判断b是否大于0，根据判断结果使用加法或者减法，这也是Lisp的奇妙之出，可以将运算符作为返回值。
5.练习1.5
这个题我没有亲自试验，且从理论上分析下吧。
Scheme的解释器用的是应用序，所以在求表达式(test 0 (p))时首先会将(p)进行展开，可以看到p的实现时他自己，所以会进入一个无穷的递归，最终导致“死机”或者奔溃。
而在使用正则序时，解释器先不去求参数的值，而是将参数替换到过程中去，将过程展开，接着看展开的结果中是否还有其他过程，有的话继续展开，将过程完全展开后再进行计算，然后根据计算结果归约。
本题最后假设：特殊形式if的求值规则总是一样的。其中谓词部分先行求值，根据其结果确定随后求值的子表达式。
所以当正则序先展开为

1
2
3

(if (= 0 0)
     0
    (p))

时，只会求if表达式中的谓词部分，根据谓词部分再判断展开那部分，这道题的if中的谓词为t，所以不会展开（p），所以时可以终止的。6.练习1.6
这道题类似于上一题，特殊形式if的求值规则总是一样的。其中谓词部分先行求值，根据其结果确定随后求值的子表达式。但是自定义的函数new-if时没有这种求值规则的，所以会不断的展开sqrt-iter函数，而不会由于new-if中的条件判断而中止。
7.练习1.7

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

(define (good-enough? guess old-guess)
  (and (> (/ guess old-guess) 0.99999999999999)
       (< (/ guess old-guess) 1.00000000000001)))
(define (average x y)
  (/ (+ x y) 2))
(define (improve guess x)
  (average guess (/ x guess)))
(define (sqrt-iter guess old-guess x)
  (if (good-enough? guess old-guess)
      guess
      (sqrt-iter (improve guess x) guess x)))
(define (sqrt x)
  (sqrt-iter 1.0 0.1 x))

8.练习1.8

1
2
3
4
5
6
7
8
9
10
11
12
13
14

(define (good-enough? guess old-guess)
  (and (> (/ guess old-guess) 0.9999)
       (< (/ guess old-guess) 1.0001)))
(define (improve guess x)
  (/ (+ (/ x (* guess guess)) (* 2 guess)) 3))
(define (cbrt-iter guess old-guess x)
  (if (good-enough? guess old-guess)
      guess
      (cbrt-iter (improve guess x) guess x)))
(define (cbrt x)
  (cbrt-iter 1.0 0.1 x))

9.练习1.9第一个是递归计算过程，因为在无法在一开始确定inc的参数，要推迟计算。
第二个是迭代计算过程，因为在计算的过程中只需要保存参数的值就可以了。

原地址：点击打开链接

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319

;;使用C-x C-e检测配置的正确性
(global-linum-mode t);显示行号
(setq column-number-mode t);显示列号
(setq auto-image-file-mode t);让Emacs可以直接打开和显示图片
(auto-compression-mode t);打开压缩文件时自动解压缩
;(setq global-font-lock-mode t);进行语法加亮
(setq x-select-enable-clipboard t);允许emacs和外部其他程序的粘贴
(setq mouse-yank-at-point t);使用鼠标中键可以粘贴
(set-scroll-bar-mode nil);;取消滚动栏
(tool-bar-mode nil);取消工具栏
;;;;;;;;;;;;;;;;;;;;;;;;;;;; 显示时间设置 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(display-time-mode 1);;启用时间显示设置，在minibuffer上面的那个杠上
(setq display-time-24hr-format t);;时间使用24小时制
(setq display-time-day-and-date t);;时间显示包括日期和具体时间
(setq display-time-use-mail-icon t);;时间栏旁边启用邮件设置
(setq display-time-interval 10);;时间的变化频率，单位多少来着？
;;;;;;;;;;;;;;;;;;;;;;;;;;; 显示时间设置结束 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(setq visible-bell t)
;;关闭烦人的出错时的提示声
(setq inhibit-startup-message t)
;;关闭emacs启动时的画面
;(setq font-lock-maximum-decoration t)
;(setq font-lock-global-modes '(not shell-mode text-mode))
;(setq font-lock-verbose t)
;(setq font-lock-maximum-size '((t . 1048576) (vm-mode . 5250000)))
;; 语法高亮。除 shell-mode 和 text-mode 之外的模式中使用语法高亮。
(fset 'yes-or-no-p 'y-or-n-p)
;; 改变 Emacs 固执的要你回答 yes 的行为。按 y 或空格键表示 yes，n 表示 no。
(ansi-color-for-comint-mode-on)
;真正shell－mode乱码解决。
(setq default-fill-column 80)
;默认显示 80列就换行
(setq default-fill-column 120)
;;把 fill-column 设为 60. 这样的文字更好读
(setq default-major-mode 'text-mode)
(add-hook 'text-mode-hook 'turn-on-auto-fill)
;;设置缺省主模式是text，,并进入auto-fill次模式.而不是基本模式fundamental-mode
(show-paren-mode t);显示括号匹配
(setq show-paren-style 'parenthesis)
;;括号匹配时可以高亮显示另外一边的括号，但光标不会烦人的跳到另一个括号处。
(mouse-avoidance-mode 'animate)
;;光标靠近鼠标指针时，让鼠标指针自动让开，别挡住视线。
;;;;;;;disable tip of the day
(setq ecb-tip-of-the-day nil)
(setq-default indent-tabs-mode nil)
(setq default-tab-width 4)
(setq tab-stop-list ())
;;不用 TAB 字符来indent, 这会引起很多奇怪的错误。编辑 Makefile 的时候也不用担心，因为 makefile-mode 会把 TAB 键设置成真正的 TAB 字符，并且加亮显示的。
(setq-default make-backup-files nil);不要生成临时文件
(setq backup-directory-alist '(("." . "~/.autosave")))
;;设置自动备份文件保存的目录,以免把你的磁盘弄得乱七八糟(你可以
;;去掉这一行试试看:P ~/.autosave 表示 主目录下的一个叫.autosave 的子目录，
;;按照前面的方法设置主目录。
;;最大化
(defun my-maximized ()  
  (interactive)  
  (x-send-client-message  
   nil 0 nil "_NET_WM_STATE" 32  
   '(2 "_NET_WM_STATE_MAXIMIZED_HORZ" 0))  
  (x-send-client-message  
   nil 0 nil "_NET_WM_STATE" 32  
   '(2 "_NET_WM_STATE_MAXIMIZED_VERT" 0)))  
(my-maximized)
;;自动插入匹配的括号
;;C/C++  mode
(defun my-c-mode-auto-pair ()
  (interactive)
  (make-local-variable 'skeleton-pair-alist)
  (setq skeleton-pair-alist  '(
;;    (?' _ "'")
    (?\" _ "\"")
    (?\(  _ ")")
    (?\[  _ "]")
    (?{ \n > _ \n ?} >)))
  (setq skeleton-pair t)
  (local-set-key (kbd "(") 'skeleton-pair-insert-maybe)
  (local-set-key (kbd "{") 'skeleton-pair-insert-maybe)
;;  (local-set-key (kbd "'") 'skeleton-pair-insert-maybe)
  (local-set-key (kbd "\"") 'skeleton-pair-insert-maybe)
  (local-set-key (kbd "[") 'skeleton-pair-insert-maybe))
(add-hook 'c-mode-hook 'my-c-mode-auto-pair)
(add-hook 'c++-mode-hook 'my-c-mode-auto-pair)
;;输入左边的括号，就会自动补全右边的部分.包括(), "", [] , {} , 等等。
;;;;自动补齐
(defun my-indent-or-complete ();;;;如果在单词中间就补齐，否则就是tab
   (interactive)
   (if (looking-at "\\>")
       (hippie-expand nil)
       (indent-for-tab-command))
 )
(global-set-key [(control tab)] 'my-indent-or-complete)
;;;hippie的自动补齐策略，优先调用了senator的分析结果：
(autoload 'senator-try-expand-semantic "senator")
(setq hippie-expand-try-functions-list
       '(
        senator-try-expand-semantic
        try-expand-dabbrev
        try-expand-dabbrev-visible
        try-expand-dabbrev-all-buffers
        try-expand-dabbrev-from-kill
        try-expand-list
        try-expand-list-all-buffers
        try-expand-line
        try-expand-line-all-buffers
        try-complete-file-name-partially
        try-complete-file-name
        try-expand-whole-kill
        )
)
;;;; 当输入"."或">"时，在另一个窗口中列出结构体或类的成员
;; (defun my-c-mode-cedet-hook ()
;;   (local-set-key "." 'semantic-complete-self-insert)
;;   (local-set-key ">" 'semantic-complete-self-insert))
;; (add-hook 'c-mode-common-hook 'my-c-mode-cedet-hook)
;; (add-hook 'c++-mode-commom-hook 'my-c-mode-cedet-hook)
;;配置CEDET
(load-file "~/.emacs.d/my_plus/cedet-1.0/common/cedet.el")
(semantic-load-enable-excessive-code-helpers)
(global-ede-mode t)
(require 'semantic-ia)
(require 'semantic-gcc)
(global-srecode-minor-mode 1)
(semantic-load-enable-semantic-debugging-helpers)
(global-set-key [f12] 'semantic-ia-fast-jump);代码跳转
;;
(global-set-key [S-f12]
                (lambda ()
                  (interactive)
                  (if (ring-empty-p (oref semantic-mru-bookmark-ring ring))
                      (error "Semantic Bookmark ring is currently empty"))
                  (let* ((ring (oref semantic-mru-bookmark-ring ring))
                         (alist (semantic-mrub-ring-to-assoc-list ring))
                         (first (cdr (car alist))))
                    (if (semantic-equivalent-tag-p (oref first tag)
                                                   (semantic-current-tag))
                        (setq first (cdr (car (cdr alist)))))
                    (semantic-mrub-switch-tags first))))
;;代码跳转（跳回上次的位置）
(require 'eassist nil 'noerror)
(add-hook 'c-mode-common-hook
          (lambda ()
(define-key c-mode-base-map [M-f12] 'eassist-switch-h-cpp)
));;;;;eassist.el就提供了一个在C++的头文件和实现文件间跳转
(setq eassist-header-switches
      '(("h" . ("cpp" "cxx" "c++" "CC" "cc" "C" "c" "mm" "m"))
        ("hh" . ("cc" "CC" "cpp" "cxx" "c++" "C"))
        ("hpp" . ("cpp" "cxx" "c++" "cc" "CC" "C"))
        ("hxx" . ("cxx" "cpp" "c++" "cc" "CC" "C"))
        ("h++" . ("c++" "cpp" "cxx" "cc" "CC" "C"))
        ("H" . ("C" "CC" "cc" "cpp" "cxx" "c++" "mm" "m"))
        ("HH" . ("CC" "cc" "C" "cpp" "cxx" "c++"))
        ("cpp" . ("hpp" "hxx" "h++" "HH" "hh" "H" "h"))
        ("cxx" . ("hxx" "hpp" "h++" "HH" "hh" "H" "h"))
        ("c++" . ("h++" "hpp" "hxx" "HH" "hh" "H" "h"))
        ("CC" . ("HH" "hh" "hpp" "hxx" "h++" "H" "h"))
        ("cc" . ("hh" "HH" "hpp" "hxx" "h++" "H" "h"))
        ("C" . ("hpp" "hxx" "h++" "HH" "hh" "H" "h"))
        ("c" . ("h"))
        ("m" . ("h"))
        ("mm" . ("h"))));;;;填补eassist-switch-h-cpp扩展名不全的BUG
;(add-hook 'c-mode-common-hook 'my-c-mode-common-hook)
;(defun my-c-mode-common-hook()
(add-hook 'c-mode-common-hook
          (lambda ()
;(define-key c-mode-base-map [M-S-f12] 'semantic-analyze-proto-impl-toggle);;;;;在函数和声明和实现间跳转，不是这个功能不是十分准确，一般在cpp中函数实现处想跳到函数声明处正常，但是从声明处跳到实现处的话cedet不一定能找到cpp文件的位置。
(define-key c-mode-base-map (kbd "M-n") 'semantic-ia-complete-symbol-menu);;;;;;代码补全
))
;;;;;;;;;;;;;;配置ecb
(add-to-list 'load-path "~/.emacs.d/my_plus/ecb-2.40")
(require 'ecb)
(ecb-activate)
;;定制ecb窗口布局
(custom-set-variables  
  ;; custom-set-variables was added by Custom.  
  ;; If you edit it by hand, you could mess it up, so be careful.  
  ;; Your init file should contain only one such instance.  
  ;; If there is more than one, they won't work right.  
 '(ecb-fix-window-size t)  
 '(ecb-layout-window-sizes nil)  
 '(ecb-options-version "2.40")  
 ;; '(ecb-primary-secondary-mouse-buttons (quote mouse-1--mouse-2))  
 '(ecb-windows-width 0.18))
;颜色配置
(add-to-list 'load-path "~/.emacs.d/my_plus")
(require 'color-theme)
(color-theme-initialize)
(color-theme-calm-forest)
(global-set-key [f1] 'shell)                              ; 进入shell
(global-set-key [S-f9] 'gdb)                              ; 调试
;(setq compile-command "g++ ")                            ; 编译
(global-set-key [f9] 'compile)
;; c-mode公共设置
(add-hook 'c-mode-common-hook 'my-c-mode-common-hook)
(defun my-c-mode-common-hook ()
  (setq default-tab-width 4)
  (setq tab-width 4)
  (setq c-basic-offset 4)
  (hs-minor-mode t)
  (define-key c-mode-base-map [(tab)] 'my-indent-or-complete)
  (define-key c-mode-base-map [(meta ?/)] 'semantic-ia-complete-symbol-menu)
  ;;;最后两行是代码自动补齐的快捷键
)
(global-set-key [S-f10] 'comment-or-uncomment-region)     ; 注释 / 取消注释
(global-set-key [f10] 'c-indent-line-or-region)           ; 格式化代码
;全屏
(defun my-fullscreen ()
  (interactive)
  (x-send-client-message
   nil 0 nil "_NET_WM_STATE" 32
   '(2 "_NET_WM_STATE_FULLSCREEN" 0))
  ;; (x-send-client-message  
  ;;  nil 0 nil "_NET_WM_STATE" 32  
  ;;  '(2 "_NET_WM_STATE_MAXIMIZED_VERT" 0))
  )
;; (my-fullscreen)
(global-set-key [f11] 'my-fullscreen) ; emacs全屏
;gdb快捷键设置
(add-hook 'gdb-mode-hook '(lambda ()
                            (define-key c-mode-base-map [(f5)] 'gud-go)
                            (define-key c-mode-base-map [(f7)] 'gud-step)
                            (define-key c-mode-base-map [(f8)] 'gud-next)
                            (define-key c-mode-base-map [(f6)] 'gud-cont)))
;;代码折叠
(global-set-key [f2] 'hs-toggle-hiding)
;;;auctex配置
(load "auctex.el" nil t t)
(load "preview-latex.el" nil t t)
(add-hook 'LaTeX-mode-hook #'LaTeX-install-toolbar)
(add-hook 'LaTeX-mode-hook 'turn-on-reftex) ; with AUCTeX LaTeX mode
(add-hook 'latex-mode-hook 'turn-on-reftex) ; with Emacs latex mode
(add-hook 'LaTeX-mode-hook (lambda()
                              (add-to-list 'TeX-command-list '("XeLaTeX" "%`xelatex%(mode)%' %t" TeX-run-TeX nil t))
                              (setq TeX-command-default "XeLaTeX")
                                 (setq TeX-save-query  nil )
                                  (setq TeX-show-compilation t)
                                                               ))
(setq TeX-auto-save t)
(setq TeX-parse-self t)
(setq-default TeX-master nil)
(setq TeX-engine 'xetex)
(setq TeX-PDF-mode t)
;;;;;;;;;;;;weibo;;;;;;;;;;
;;;;;;使用M-x weibo-timeline
(add-to-list 'load-path "~/.emacs.d/my_plus/austin------weibo.emacs-0cf9784")
(require 'weibo)
;;;;;;保存上次emacs关闭时的状态
(load "desktop")
(desktop-load-default)
(desktop-read)
;;当emacs退出时保存文件打开状态
(add-hook 'kill-emacs-hook
          '(lambda()(desktop-save "~/")))
;;;;;;;;;;;;;;;;w3m设置;;;;;;;;;;;;;;;;;
;; (add-to-list 'load-path "/usr/share/emacs/site-lisp/w3m/")
;; (require 'w3m)
;; (setq w3m-home-page "http://www.google.com.hk") ;设置主页
;; (require 'mime-w3m)
;;  ;设置显示图片
;; (setq w3m-default-display-inline-images t)
;; (setq w3m-default-toggle-inline-images t)
;; ;;显示图标
;; (setq w3m-show-graphic-icons-in-header-line t)
;; (setq w3m-show-graphic-icons-in-mode-line t)
;; ;;启用cookie
;; (setq w3m-use-cookies t)
;; ;;设定w3m运行的参数，分别为使用cookie和使用框架
;; (setq w3m-command-arguments '("-cookie" "-F"))
;; ;;;解决wrong type argument: stringp, nil问题
;; (setq debug-on-error t);;

最近终于下定决心学习一下lisp，打算从SICP开始吧。
编辑器打算采用Emacs，原因是它是用C和Emacs Lisp（Lisp的一种方言）编写的程序。
Emacs还真的是难学啊，在掌握了基本（基本）的操作后，开始配置Emacs的环境，参考的很多网上的一些代码，就不多说了。
这里要说的是我在借鉴了大牛王垠的配置后，在使用的时候会报一个找不到find函数的的错误，源代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

(defun scheme-split-window ()
  (cond
   ((= 1 (count-windows))
    (delete-other-windows)
    (split-window-vertically (floor (* 0.68 (window-height))))
    (other-window 1)
    (switch-to-buffer "*scheme*")
    (other-window 1))
   ((not (find "*scheme*"
               (mapcar (lambda (w) (buffer-name (window-buffer w)))
                       (window-list))
               :test 'equal))
    (other-window 1)
    (switch-to-buffer "*scheme*")
    (other-window -1))))
(defun scheme-send-last-sexp-split-window ()
  (interactive)
  (scheme-split-window)
  (scheme-send-last-sexp))
(defun scheme-send-definition-split-window ()
  (interactive)
  (scheme-split-window)
  (scheme-send-definition))
(add-hook 'scheme-mode-hook
  (lambda ()
    (paredit-mode 1)
    (define-key scheme-mode-map (kbd "<f5>") 'scheme-send-last-sexp-split-window)
    (define-key scheme-mode-map (kbd "<f6>") 'scheme-send-definition-split-window)))

问题就出在了schem-split-window函数的find语句，不知道为什么在我的电脑上不好使。

1
2

但是我的心里不爽，十分想要把这个函数搞定，于是在完全对Lisp没有学习的我进行了不断的尝试。下面是结果：

1
2
3
4
5

(defun check-scheme()
   (let ((res 21))
   (dolist (x (mapcar(lambda (w) (setq a (buffer-name (window-buffer w)))) (window-list))) (when (string= "*scheme*" x)(setq res 100)))
   (= res 100)
   ))

1
2
3
4
5
6
7
8
9
10
11
12

(defun scheme-split-window ()
  (cond
   ((= 1 (count-windows))
    (delete-other-windows)
    (split-window-vertically (floor (* 0.68 (window-height))))
    (other-window 1)
    (switch-to-buffer "*scheme*")
    (other-window 1))
    ((not (check-scheme))
    (other-window 1)
    (switch-to-buffer "*scheme*")
    (other-window -1))))

可以看到，主要使定义了一个check-scheme的函数，这个函数虽然是我写的不过我也是对它一知半解，真是汗颜。下面应该开始努力学习SICP了，这可是个持久战啊，加油吧。

点击打开链接

Emacs是用Buffer来组织编辑区域的，一个Buffer就代表一个文件或者一个临时编辑区域，我们可以用一些函数来切换到前一个或后一个Buffer，也可以列出所有的Buffer来进行选择。一些现代编辑器都支持一种特性，那就是Tab，用标签来列出所有的文件并可以方便地在文件之间切换，直观而方便。万能的Emacs当然也可以做到这个。
增加标签特性需要tabbar.el，emacswiki上可以下载到这个插件：
http://www.emacswiki.org/emacs/tabbar.el
放在任意目录并把这个目录添加到载入列表中，比如我们把tabbar.el放在~/.mylisp/下：

1
2

;;main plugin path  
(add-to-list 'load-path "~/.mylisp/")

然后require这个插件并打开tabbar模式：

1
2

(require 'tabbar)
(tabbar-mode 1)

进行一些快捷键设置：

1
2

(global-set-key [(meta j)] 'tabbar-backward)
(global-set-key [(meta k)] 'tabbar-forward)

重新启动Emacs或eval-buffer就可以看到tabbar了：

默认的tabbar样式很难看，而且字体太小，不容易看清楚，我们接下来需要做的就是修改它的样式和配色。
下面使用一段网友菩提老祖给出的代码：
在.emacs下加入:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

;; 设置tabbar外观  
;; 设置默认主题: 字体, 背景和前景颜色，大小  
(set-face-attribute 'tabbar-default-face nil  
                    :family "DejaVu Sans Mono"  
                    :background "gray80"  
                    :foreground "gray30"  
                    :height 1.0  
                    )  
;; 设置左边按钮外观：外框框边大小和颜色  
(set-face-attribute 'tabbar-button-face nil  
                    :inherit 'tabbar-default  
                    :box '(:line-width 1 :color "yellow70")  
                    )  
;; 设置当前tab外观：颜色，字体，外框大小和颜色  
(set-face-attribute 'tabbar-selected-face nil  
                    :inherit 'tabbar-default  
                    :foreground "DarkGreen"  
                    :background "LightGoldenrod"  
                    :box '(:line-width 2 :color "DarkGoldenrod")  
                    :overline "black"  
                    :underline "black"  
                    :weight 'bold  
                    )  
;; 设置非当前tab外观：外框大小和颜色  
(set-face-attribute 'tabbar-unselected-face nil  
                    :inherit 'tabbar-default  
                    :box '(:line-width 2 :color "#00B2BF")  
                    )

现在我们的tabbar外观变成这样：

可以看出，已经几乎完成了，美中不足的是左边的几个按钮尺寸不正确，还需要修正。
打开~/.mylisp/tabbar.el，可以在里面找到类似这样的内容：

1
2
3
4
5
6
7
8
9
10
11
12

(defconst tabbar-home-button-enabled-image
  '((:type pbm :ascent center :data "/
P2
10 10
255
184 184 184 184 0 184 184 184 184 184 184 184 184 0 0 0 184 184 184 184
184 184 0 0 0 0 0 184 184 184 184 0 0 0 0 0 0 0 184 184 184 184 255 0 0
0 255 255 255 184 184 0 0 0 0 0 0 0 184 184 184 184 0 0 0 0 0 255 255 184
184 184 184 0 0 0 255 255 184 184 184 184 184 184 0 255 255 184 184 184
184 184 184 184 184 255 184 184 184 184
"))
  "Default image for the enabled home button.")

这部分就是设定home-button的图像，同样，另外几个按钮的图像也可以找到：
tabbar-home-button-disabled-image
tabbar-scroll-left-button-enabled-image
tabbar-scroll-left-button-disabled-image
tabbar-scroll-right-button-enabled-image
tabbar-scroll-right-button-disabled-image

这种图片的格式是pbm，pbm是Portable Bitmap Format(便携位图格式)的缩写，该系列共有三种格式：
PBM 位图黑白位图
PGM 灰度位图
PPM 带颜色的像素位图
文件的前两个字节指明了该文件到底属于哪种格式：
Magic Number 类型 编码
P1 Portable bitmap ASCII
P2 Portable graymap ASCII
P3 Portable pixmap ASCII
P4 Portable bitmap Binary
P5 Portable graymap Binary
P6 Portable pixmap Binary
如果编码是ASCII的话文件的内容就由直接可读的数字组成，数字之间用空格隔开。
我们修改后的tabbar高度变为20像素，宽度没变，减去原来的10像素那么上下分别加宽5像素。
也就是增加5 10 = 30个数字，5 10 = 10个数字。
修改tabbar里每个图片的数据块
P2保持不变，接下来的两个数字分别是宽度和高度，那么原来的”10 10”就要修改为”10 19”，255为白色的值，保持为原来的255.然后在描述各个像素的数据前后分别加上50个184，保持和原来的颜色一样。
tabbar-home-button-enabled-image的那段就变为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

(defconst tabbar-home-button-enabled-image
  '((:type pbm :ascent center :data "/
P2
10 20
255
184 184 184 184 184 184 184 184 184 184 
184 184 184 184 184 184 184 184 184 184 
184 184 184 184 184 184 184 184 184 184 
184 184 184 184 184 184 184 184 184 184 
184 184 184 184 184 184 184 184 184 184 
184 184 184 184 0 184 184 184 184 184 184 184 184 0 0 0 184 184 184 184
184 184 0 0 0 0 0 184 184 184 184 0 0 0 0 0 0 0 184 184 184 184 255 0 0
0 255 255 255 184 184 0 0 0 0 0 0 0 184 184 184 184 0 0 0 0 0 255 255 184
184 184 184 0 0 0 255 255 184 184 184 184 184 184 0 255 255 184 184 184
184 184 184 184 184 255 184 184 184 184
184 184 184 184 184 184 184 184 184 184 
184 184 184 184 184 184 184 184 184 184 
184 184 184 184 184 184 184 184 184 184 
184 184 184 184 184 184 184 184 184 184 
184 184 184 184 184 184 184 184 184 184 
"))
  "Default image for the enabled home button.")

其他部分也照着这样修改就行了，最后的效果如图：

出处：http://blog.csdn.net/guolin_blog/article/details/8714621

人人客户端有一个特效还是挺吸引人的，在主界面手指向右滑动，就可以将菜单展示出来，而主界面会被隐藏大部分，但是仍有左侧的一小部分同菜单一起展示。
据说人人客户端的这个特效是从facebook客户端模仿来的，至于facebook是不是又从其它地方模仿来的就不得而知了。好，今天我们就一起来实现这个效果，总之我第一次看到这个特效是在人人客户端看到的，我也就主观性地认为我是在模仿人人客户端的特效了。
虽然现在网上类似这种效果的实现也非常多，可是我发现实现方案大都非常复杂，并不容易理解。但其实这种效果并不难实现，因此我今天给大家带来的也是史上最简单的滑动菜单实现方案。
首先还是讲一下实现原理。在一个Activity的布局中需要有两部分，一个是菜单(menu)的布局，一个是内容(content)的布局。两个布局横向排列，菜单布局在左，内容布局在右。初始化的时候将菜单布局向左偏移，以至于能够完全隐藏，这样内容布局就会完全显示在Activity中。然后通过监听手指滑动事件，来改变菜单布局的左偏移距离，从而控制菜单布局的显示和隐藏。原理图如下：

将菜单布局的左偏移值改成0时，效果图如下：

好，我们开始用代码来实现。首先在Eclipse中新建一个Android项目，项目名就叫做RenRenSlideMenuDemo。然后写一下布局文件，创建或打开layout目录下的activity_main.xml文件，加入如下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    xmlns:tools="http://schemas.android.com/tools"  
    android:layout_width="fill_parent"  
    android:layout_height="fill_parent"  
    android:orientation="horizontal"  
    tools:context=".MainActivity" >  
  
    <LinearLayout  
        android:id="@+id/menu"  
        android:layout_width="fill_parent"  
        android:layout_height="fill_parent"  
        android:background="@drawable/menu" >  
    </LinearLayout>  
  
    <LinearLayout  
        android:id="@+id/content"  
        android:layout_width="fill_parent"  
        android:layout_height="fill_parent"  
        android:background="@drawable/content" >  
    </LinearLayout>  
  
</LinearLayout>

这个布局文件的最外层布局是一个LinearLayout，排列方向是水平方向排列。这个LinearLayout下面嵌套了两个子LinearLayout，分别就是菜单的布局和内容的布局。这里为了要让布局尽量简单，菜单布局和内容布局里面没有加入任何控件，只是给这两个布局各添加了一张背景图片，这两张背景图片是我从人人客户端上截下来的图。这样我们可以把注意力都集中在如何实现滑动菜单的效果上面，不用关心里面各种复杂的布局了。
创建或打开MainActivity，这个类仍然是程序的主Activity，也是这次demo唯一的Activity，在里面加入如下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279

public class MainActivity extends Activity implements OnTouchListener {  
  
    /** 
     * 滚动显示和隐藏menu时，手指滑动需要达到的速度。 
     */  
    public static final int SNAP_VELOCITY = 200;  
  
    /** 
     * 屏幕宽度值。 
     */  
    private int screenWidth;  
  
    /** 
     * menu最多可以滑动到的左边缘。值由menu布局的宽度来定，marginLeft到达此值之后，不能再减少。 
     */  
    private int leftEdge;  
  
    /** 
     * menu最多可以滑动到的右边缘。值恒为0，即marginLeft到达0之后，不能增加。 
     */  
    private int rightEdge = 0;  
  
    /** 
     * menu完全显示时，留给content的宽度值。 
     */  
    private int menuPadding = 80;  
  
    /** 
     * 主内容的布局。 
     */  
    private View content;  
  
    /** 
     * menu的布局。 
     */  
    private View menu;  
  
    /** 
     * menu布局的参数，通过此参数来更改leftMargin的值。 
     */  
    private LinearLayout.LayoutParams menuParams;  
  
    /** 
     * 记录手指按下时的横坐标。 
     */  
    private float xDown;  
  
    /** 
     * 记录手指移动时的横坐标。 
     */  
    private float xMove;  
  
    /** 
     * 记录手机抬起时的横坐标。 
     */  
    private float xUp;  
  
    /** 
     * menu当前是显示还是隐藏。只有完全显示或隐藏menu时才会更改此值，滑动过程中此值无效。 
     */  
    private boolean isMenuVisible;  
  
    /** 
     * 用于计算手指滑动的速度。 
     */  
    private VelocityTracker mVelocityTracker;  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
        initValues();  
        content.setOnTouchListener(this);  
    }  
  
    /** 
     * 初始化一些关键性数据。包括获取屏幕的宽度，给content布局重新设置宽度，给menu布局重新设置宽度和偏移距离等。 
     */  
    private void initValues() {  
        WindowManager window = (WindowManager) getSystemService(Context.WINDOW_SERVICE);  
        screenWidth = window.getDefaultDisplay().getWidth();  
        content = findViewById(R.id.content);  
        menu = findViewById(R.id.menu);  
        menuParams = (LinearLayout.LayoutParams) menu.getLayoutParams();  
        // 将menu的宽度设置为屏幕宽度减去menuPadding  
        menuParams.width = screenWidth - menuPadding;  
        // 左边缘的值赋值为menu宽度的负数  
        leftEdge = -menuParams.width;  
        // menu的leftMargin设置为左边缘的值，这样初始化时menu就变为不可见  
        menuParams.leftMargin = leftEdge;  
        // 将content的宽度设置为屏幕宽度  
        content.getLayoutParams().width = screenWidth;  
    }  
  
    @Override  
    public boolean onTouch(View v, MotionEvent event) {  
        createVelocityTracker(event);  
        switch (event.getAction()) {  
        case MotionEvent.ACTION_DOWN:  
            // 手指按下时，记录按下时的横坐标  
            xDown = event.getRawX();  
            break;  
        case MotionEvent.ACTION_MOVE:  
            // 手指移动时，对比按下时的横坐标，计算出移动的距离，来调整menu的leftMargin值，从而显示和隐藏menu  
            xMove = event.getRawX();  
            int distanceX = (int) (xMove - xDown);  
            if (isMenuVisible) {  
                menuParams.leftMargin = distanceX;  
            } else {  
                menuParams.leftMargin = leftEdge + distanceX;  
            }  
            if (menuParams.leftMargin < leftEdge) {  
                menuParams.leftMargin = leftEdge;  
            } else if (menuParams.leftMargin > rightEdge) {  
                menuParams.leftMargin = rightEdge;  
            }  
            menu.setLayoutParams(menuParams);  
            break;  
        case MotionEvent.ACTION_UP:  
            // 手指抬起时，进行判断当前手势的意图，从而决定是滚动到menu界面，还是滚动到content界面  
            xUp = event.getRawX();  
            if (wantToShowMenu()) {  
                if (shouldScrollToMenu()) {  
                    scrollToMenu();  
                } else {  
                    scrollToContent();  
                }  
            } else if (wantToShowContent()) {  
                if (shouldScrollToContent()) {  
                    scrollToContent();  
                } else {  
                    scrollToMenu();  
                }  
            }  
            recycleVelocityTracker();  
            break;  
        }  
        return true;  
    }  
  
    /** 
     * 判断当前手势的意图是不是想显示content。如果手指移动的距离是负数，且当前menu是可见的，则认为当前手势是想要显示content。 
     *  
     * @return 当前手势想显示content返回true，否则返回false。 
     */  
    private boolean wantToShowContent() {  
        return xUp - xDown < 0 && isMenuVisible;  
    }  
  
    /** 
     * 判断当前手势的意图是不是想显示menu。如果手指移动的距离是正数，且当前menu是不可见的，则认为当前手势是想要显示menu。 
     *  
     * @return 当前手势想显示menu返回true，否则返回false。 
     */  
    private boolean wantToShowMenu() {  
        return xUp - xDown > 0 && !isMenuVisible;  
    }  
  
    /** 
     * 判断是否应该滚动将menu展示出来。如果手指移动距离大于屏幕的1/2，或者手指移动速度大于SNAP_VELOCITY， 
     * 就认为应该滚动将menu展示出来。 
     *  
     * @return 如果应该滚动将menu展示出来返回true，否则返回false。 
     */  
    private boolean shouldScrollToMenu() {  
        return xUp - xDown > screenWidth / 2 || getScrollVelocity() > SNAP_VELOCITY;  
    }  
  
    /** 
     * 判断是否应该滚动将content展示出来。如果手指移动距离加上menuPadding大于屏幕的1/2， 
     * 或者手指移动速度大于SNAP_VELOCITY， 就认为应该滚动将content展示出来。 
     *  
     * @return 如果应该滚动将content展示出来返回true，否则返回false。 
     */  
    private boolean shouldScrollToContent() {  
        return xDown - xUp + menuPadding > screenWidth / 2 || getScrollVelocity() > SNAP_VELOCITY;  
    }  
  
    /** 
     * 将屏幕滚动到menu界面，滚动速度设定为30. 
     */  
    private void scrollToMenu() {  
        new ScrollTask().execute(30);  
    }  
  
    /** 
     * 将屏幕滚动到content界面，滚动速度设定为-30. 
     */  
    private void scrollToContent() {  
        new ScrollTask().execute(-30);  
    }  
  
    /** 
     * 创建VelocityTracker对象，并将触摸content界面的滑动事件加入到VelocityTracker当中。 
     *  
     * @param event 
     *            content界面的滑动事件 
     */  
    private void createVelocityTracker(MotionEvent event) {  
        if (mVelocityTracker == null) {  
            mVelocityTracker = VelocityTracker.obtain();  
        }  
        mVelocityTracker.addMovement(event);  
    }  
  
    /** 
     * 获取手指在content界面滑动的速度。 
     *  
     * @return 滑动速度，以每秒钟移动了多少像素值为单位。 
     */  
    private int getScrollVelocity() {  
        mVelocityTracker.computeCurrentVelocity(1000);  
        int velocity = (int) mVelocityTracker.getXVelocity();  
        return Math.abs(velocity);  
    }  
  
    /** 
     * 回收VelocityTracker对象。 
     */  
    private void recycleVelocityTracker() {  
        mVelocityTracker.recycle();  
        mVelocityTracker = null;  
    }  
  
    class ScrollTask extends AsyncTask<Integer, Integer, Integer> {  
  
        @Override  
        protected Integer doInBackground(Integer... speed) {  
            int leftMargin = menuParams.leftMargin;  
            // 根据传入的速度来滚动界面，当滚动到达左边界或右边界时，跳出循环。  
            while (true) {  
                leftMargin = leftMargin + speed[0];  
                if (leftMargin > rightEdge) {  
                    leftMargin = rightEdge;  
                    break;  
                }  
                if (leftMargin < leftEdge) {  
                    leftMargin = leftEdge;  
                    break;  
                }  
                publishProgress(leftMargin);  
                // 为了要有滚动效果产生，每次循环使线程睡眠20毫秒，这样肉眼才能够看到滚动动画。  
                sleep(20);  
            }  
            if (speed[0] > 0) {  
                isMenuVisible = true;  
            } else {  
                isMenuVisible = false;  
            }  
            return leftMargin;  
        }  
  
        @Override  
        protected void onProgressUpdate(Integer... leftMargin) {  
            menuParams.leftMargin = leftMargin[0];  
            menu.setLayoutParams(menuParams);  
        }  
  
        @Override  
        protected void onPostExecute(Integer leftMargin) {  
            menuParams.leftMargin = leftMargin;  
            menu.setLayoutParams(menuParams);  
        }  
    }  
  
    /** 
     * 使当前线程睡眠指定的毫秒数。 
     *  
     * @param millis 
     *            指定当前线程睡眠多久，以毫秒为单位 
     */  
    private void sleep(long millis) {  
        try {  
            Thread.sleep(millis);  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
    }  
}

全部的代码都在这里了，我们可以看到，加上注释总共才两百多行的代码就能实现滑动菜单的特效。下面我来对以上代码解释一下，首先初始化的时候调用initValues方法，在这里面将内容布局的宽度设定为屏幕的宽度，菜单布局的宽度设定为屏幕的宽度减去menuPadding值，这样可以保证在菜单布局展示的时候，仍有一部分内容布局可以看到。如果不在初始化的时候重定义两个布局宽度，就会按照layout文件里面声明的一样，两个布局都是fill_parent，这样就无法实现滑动菜单的效果了。然后将菜单布局的左偏移量设置为负的菜单布局的宽度，这样菜单布局就会被完全隐藏，只有内容布局会显示在界面上。
之后给内容布局注册监听事件，这样当手指在内容布局上滑动的时候就会触发onTouch事件。在onTouch事件里面，根据手指滑动的距离会改变菜单布局的左偏移量，从而控制菜单布局的显示和隐藏。当手指离开屏幕的时候，会判断应该滑动到菜单布局还是内容布局，判断依据是根据手指滑动的距离或者滑动的速度，细节可以看代码中的注释。
最后还是给出AndroidManifest.xml的代码，都是自动生成的，非常简单：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

<?xml version="1.0" encoding="utf-8"?>  
<manifest xmlns:android="http://schemas.android.com/apk/res/android"  
    package="com.example.renrenslidemenudemo"  
    android:versionCode="1"  
    android:versionName="1.0" >  
  
    <uses-sdk  
        android:minSdkVersion="8"  
        android:targetSdkVersion="8" />  
  
    <application  
        android:allowBackup="true"  
        android:icon="@drawable/ic_launcher"  
        android:label="@string/app_name"  
        android:theme="@android:style/Theme.NoTitleBar" >  
        <activity  
            android:name="com.example.renrenslidemenudemo.MainActivity"  
            android:label="@string/app_name" >  
            <intent-filter>  
                <action android:name="android.intent.action.MAIN" />  
  
                <category android:name="android.intent.category.LAUNCHER" />  
            </intent-filter>  
        </activity>  
    </application>  
  
</manifest>

好了，现在我们运行一下，看一下效果吧，首先是程序刚打开的时候，显示的是内容布局。用手指在界面向右滑动，可以看到菜单布局出现。


而当菜单布局完全展示的时候，效果如下图：

今天大家看到了史上最简单的滑动菜单实现方案，确实是非常简单。那么有朋友也许会问了，在一个Activity当中这样实现滑动菜单是很简单，可是如果我的应用程序有好多个Activity都需要滑动菜单，每个Activity里都这么实现一遍，也变得复杂了。没错，当前的这个解决方案只适用于单个Activity中，如果是想在多个Activity中都实现滑动菜单的效果，请参考我的另一篇文章 Android滑动菜单框架完全解析，教你如何一分钟实现滑动菜单特效。
有对双向滑动菜单感兴趣的朋友请转阅 Android双向滑动菜单完全解析，教你如何一分钟实现双向滑动特效。
好了，今天的讲解到此结束，有疑问的朋友可以在下面留言。

出处：点击打开链接
看到大家在讨论github的使用，我用的也不多，偶尔clone一些好的源代码而已。我用的是Eclipse的插件EGit，全部操作直接在eclispe里就可以完成了，哈哈，我比较懒，官网上教的那些git clone 什么的高深操作我也不会，感觉egit还是比较好用的，所以上网搜了一个关于egit的详细操作的帖子，现在搬过来和大家一起分享一下。我找到的这个帖子的地址是：http://blog.csdn.net/luckarecs/article/details/7427605。虽然这篇帖子也写的是转载，我没找到最原始的出处，（PS:有人反馈说原始出处是这：http://blog.csdn.net/laizhenhai88/article/details/7234974，我不敢确定，不过还是把这个链接放上来吧，谢谢@ter 的反馈），不过如果大家转载的话，还是要把这个链接加上，这也算是保护知识产权了吧，哈哈，好了，费话不多说了，以下是详细内容：

一_安装EGIT插件

http://download.eclipse.org/egit/updates/
或者使用Eclipse Marketplace，搜索EGit

二_使用EGIT前的配置

配置个人信息，最重要的是user.name和user.email
l Preferences > Team > Git > Configuration
l New Entry

三_新建GIT仓库

新建NC module project

l File > Team > Share Project 选择GIT


创建仓库后，在$workspace\demo目录下的.git文件夹，就是git的仓库地址。和CVS、SVN不同，GIT不会在每一个目录下建立版本控制文件夹，仅在根目录下建立仓库

同时，eclipse中的project也建立git版本控制，此时未创建分支，处于NO-HEAD状态

文件夹中的符号”?”表示此文件夹处于untracked状态，这样就成功创建GIT仓库。
四_配置.gitignore

此时我们尝试做一次提交
l Team -> Commit…

如上图所示，Author和Committer会默认为Git配置的用户信息。下面的Files窗口中可以看到此次提交的文件，其中有非常多带有NC_HOME的文件，此时可以猜测出，在我们的project中链接的NC_HOME也被GIT默认到版本控制中了，如下图：

显然NC_HOME和out是不需要进行版本控制的，我们可以通过配置.gitignore来排除这两个文件夹
打开Navigator窗口，在project根目录中添加.gitignore文件，将需要排除控制的目录写入.gitignore文件中

再次尝试commit，需要提交的文件已经被过滤

首次提交后，会自动生成master分支

然后在public中新建一个文件，可以看到图标依然是问号，处于untracked状态，即git没有对此文件进行监控

通过Team -> Add to index可以将文件加入git索引，进行版本监控

可以看到图标显示也有了变化（EGIT中只要Commit就可以默认将untracked的文件添加到索引再提交更新，不需要分开操作）

也可以通过Team -> Untrack将文件从索引控制中排除。
将此次新增的文件commit到仓库中，文件将处于unmodified状态，或者说，这就是一种staged状态

然后修改文件的内容，文件将处于modified状态

五_查看历史记录Team
-> Show in history可以查看版本历史提交记录

可以选择对比模式

六_远程GIT仓库此小结的前提是已经搭建GIT服务器，并通过SSH协议连接，可参看文档《RHEL下搭建GIT服务器》《WindowsXP下搭建GIT服务器》《GIT服务器使用基础》。本文使用RHEL5.5系统下的GIT-2012-01-11，用户root/password，GIT仓库统一存放在/app/gitspace目录下。
首先通过shell工具连接到服务器，建立空仓库gitdemo，此时的ssh访问地址如下,分别由协议名称、用户名、IP、端口、git仓库目录组成。
ssh://root@192.168.1.101:22/app/gitspace/gitdemo
打开GIT资源库窗口，选择克隆资源库





现在已经把远程的GIT仓库克隆到本地，接下来需要将仓库检出为NC模块项目。


最后得到gitdemo模块项目，分支是mirror

七_推送远程仓库

克隆服务器端仓库后，会在本地建立一个一样的仓库，称本地仓库。在本地进行commit操作将把更新提交到本地仓库，然后可以将服务器端的更新pull到本地仓库进行合并，最后将合并好的本地仓库push到服务器端，这样就进行了一次远程提交。

先提交一次到本地仓库

然后push到服务器端的mirror分支，Team -> remote -> Push

完成推送后，可以在服务器端mirror镜像的log中查看到此次记录

八_解决推送冲突

多人协作开发的情况下，往服务器推送更新时难免出现冲突，所以推送之前需要解决服务器端的最新版本和本地仓库的冲突。Pull操作就是把服务器端的更新拉拢到本地仓库进行合并，解决好合并冲突后，就可以顺利push到服务器分支了。
假设现在Mairo兄弟在用GIT协作开发NewSuperMairoBro游戏，目前服务器端的mushroom.java文件的内容如下：

MairoBro克隆出代码后，Mairo哥哥做了如下修改

Mairo弟弟做了如下修改

然后Mairo弟弟先push代码，Mairo哥哥使用pull来合并本地仓库和远程仓库，将发行文件出现冲突，此时GIT会自动合并冲突的文件，如下图所示：



很明显自动合并的冲突文件不能直接使用，我们可以手动调整，右键发生冲突的文件，选择Team -> Merge Tool

第一项是将GIT自动合并过的文件和服务器端文件进行对比
第二项是用本地最新版本的文件和服务器端文件进行对比，建议用此项
接下来就是熟悉的对比界面

Mairo哥哥将冲突文件修改如下

然后右键点击此冲突文件，选择Team -> Add to index再次将文件加入索引控制，此时文件已经不是冲突状态，并且可以进行提交并push到服务器端

解决合并冲突后，Mairo弟弟只需要将服务器中合并后的版本pull到本地，就完成了一次协作开发的代码合并。从历史记录中可以看到，从mushroom开始历史进入分支，先是mushroomA的记录，然后是mushroomB的记录，最后历史分支合并。

九_Rebase和Merge的区别
Rebase和Merge操作最终的结果是一样的，但是实现原理不一样。
从上面的MairoBro例子可以知道pull大概对历史记录进行了怎样的合并操作，其实默认pull的操作就是一个分支的merge操作，如下图重现一下：
Mairo弟弟的提交记录如下：

Mairo哥哥的提交记录如下：

首先是Mairo弟弟把更新push到服务器，这样服务器端的记录就和Mairo弟弟本地的记录是一样的，接着Mairo哥哥执行pull操作，现在分析下pull是如何操作的。
l pull默认就是先把服务器端的最新记录更新到本地的Remote Tracking中对应的mirror分支
l 接着对Local的mirror分支和Remote Tracking的mirror分支进行merge操作

Merge操作后的结果就是会新增加一个merge记录节点，如下所示：

从上图可以看出，mushroomA是在mushroomB之前的，这个时间关系不取决于谁先执行push，而取决于本地仓库中谁先执行commit。所以merge会按照时间顺序严格的记录每一次commit。
接下来看看rebase，其实rebase也是把两个分支进行合并的操作，当Mairo弟弟push更新后，服务器端的mirror分支的历史如下：

Mairo哥哥本地的历史如下：

现在Mairo哥哥不是执行merge操作，而是执行rebase操作，最后结果如下：

很明显的区别是没有出现分支的记录，而且注意到mushroomA，请注意这个记录和mushroomA不是同一个记录，我们先分析下rebase操作下，Mairo哥哥的历史记录都做了哪些变化：
l 先将当前分支的更新部分保存到临时区域，而当前分支重置到上一次pull的记录

l 然后将服务器端的更新添加到当前分支，此时当前分支和服务器端分支是一样的

l 最后将原分支的更新部分mushroomA提交到当前分支的后面，就是要在mushroomB的后面添加mushroomA的更新，当然此时更新记录已经不是之前的mushroomA了，如果出现冲突则使用对比工具解决冲突，最后记录变成mushroomA。

如果Mairo哥哥提交过mushroomA1、mushroomA2、mushroomA3，那么执行rebase后会对mushroomA1、mushroomA2、mushroomA3分别顺序执行上图所示的合并，最后记录为mushroomA1、mushroomA2、mushroomA3*。很显然rebase操作更复杂，冲突的概率也更高，并且不是按照时间顺序记录。

十_Rebase和Merge如何选择的简单解析

此小结为什么说是简单解析呢，因为rebase和merge的选择问题讨论比较激烈，笔者也没有一个定论，而且git也处于研究发展阶段，很多理论还没有完全的纯熟。
对于一个多人开发团队频繁提交更新的情况，如果使用merge会使得历史线图非常复杂，并且merge一次就会新增一个记录点，如果使用rebase就是完全的线性开发。

上图所示是Merge和Rebase的两个结果，显然你不想要merge的混乱结果吧，你能告诉我merge图中那条线是master分支吗？
所以给出如下建议，如果同一文件反复修改或提交次数比较多，预期会出现很多的conflict，那么可以使用merge合并，仅需要解决一次冲突即可（不过，大范围主题式的修改，是不是应该事先就新开一个分支呢？）；如果修改范围小，预期conflict少，则建议使用rebase。
EGIT中默认的pull操作是Fetch+Merge，如果要用rebase，可以分开操作。先执行Fetch更新remote tracking，再执行rebase进行合并（下一小节将介绍rebase操作）。或者修改pull的默认操作，在.git/config文件中配置：

上述配置只对mirror分支有效，也可做全局配置，在$HOME/.gitconfig中配置，windows系统如果没有配置HOME变量的话就默认在$documents and settings/ USER目录下：

十一_Fetch和Rebase

MairoBro来做fetch和rebase的测试，首先Mairo弟弟在client中添加文件OPQ分别提交，并push到服务器，如图：

此时服务器端的历史已经被更新，但是Mairo哥哥的remote tracking中mirror分支并没有更新到最新的记录，如图：

所以需要更新remote tracking中的分支，使得它与服务器端的分支同步，右键点击资源库选择Fetch


这样就更新了本地的remote tracking中的分支，使得它和服务器端分支同步。

然后Mairo哥哥在本地的private中添加文件ABC，并分别提交到本地仓库中。

然后将本地mirror分支和remote tracking中的mirror分支进行rebase，先checkout本地mirror分支 ，然后右键点击选择Rebase




如上图可以看到历史记录的顺序是OPQABC，已经rebase成功，接着push到服务器即可。

十二_重置功能

GIT中有三种重置功能，分别是soft、mixed、hard，区别如下：
l Soft - 当前分支重置到指定commit记录位置，索引和工作树不变；
l Mixed - 当前分支重置到指定commit记录位置，索引被更新，工作树不变；
l Hard - 当前分支重置到指定commit记录位置，索引和工作树都更新。
貌似不好理解，首先要理解GIT的三个区域（工作树、索引区、仓库），可以参考文档《GIT简介》。
先做soft的测试，新建Soft.java文件，可以看到此文件未添加到索引控制

先进行一次提交，提交后在History窗口中重置此次提交，如图：

重置后查看工作树，如图

从上图可以看出，soft文件还存在，说明重置没有改变工作树，而且soft文件不是“问号”图标，说明已经添加到索引，说明索引也没有变。唯一重置的是历史记录。
然后新建Mixed.java文件，此时Mixed.java也没有添加到索引控制，然后提交。

在History窗口中重置

重置后查看工作树结果如下：

从上图可以看出，Mixed.java文件还存在，说明工作树没有改变，但是文件状态是untracked，说明索引被更新，此时文件没有添加索引控制。
最后来看hard重置，新建Hard.java文件，此时文件没有添加索引，然后提交。

在History界面重置此次提交，如图：

重置后再查看工作树，结果如下：

可以看到Hard.java文件已经不存在了，说明索引和工作树都被更新。

PS：这里对第六点远程GIT仓库稍微做个补充，我们一般情况下从github官网上clone代码的时候，这个远程仓库就是github了，首先我们在github上找到自己想要的源代码，这里以eoe客户端的源代码为例，如图：

在网页的顶部我们可以找到地址，有https,ssh,和git only三个，我一般都是选的ssh,然后把这个地址copy出来，再回到eclipse中，点击打开clone a git repository,在URI中把刚才复制的地址粘贴进去，然后在protocol中选择ssh就行了，其它信息会自动补全
未命名.jpg (55.7 KB, 下载次数: 0)
下载附件 保存到相册
2013-4-28 11:18 上传

接着点next就行了，往后的操作就和文章中介绍的一样了

原文链接： Bob Nystrom
翻译： 伯乐在线 - deathmonkey
译文链接： http://blog.jobbole.com/53376/

本文由 伯乐在线 - deathmonkey 翻译自 Bob Nystrom。欢迎加入技术翻译小组。转载请参见文章末尾处的要求。

伯乐在线补充：本文作者 Bob Nystrom 是 Google Dart 团队的一名工程师，所以下文中”处理一些工作上的事情“中的链接是指向了Dart 官网。Bob 之前（曾在 EA 公司）做过游戏开发，UI 设计。更多信息，请看他的简历。

每当我倍感压力以及有很多事情要做的时候，我总是有这样一种反常的反应，那就是希望做一些其他的事情来摆脱这种状况。通常情况下，这些事情都是些我能够编写并实现的独立的小程序。

一天早上，我几乎要被一堆事情给整疯了——我得写我那本《游戏编程模式》、处理一些工作上的事情、还要准备一场Strange Loop的演讲，然后这时我突然想到：“我该写一个垃圾收集器了”。

是的，我知道那一刻让我看上去有多疯狂。不过我的神经故障却是你实现一段基础的程序语言设计的免费教程！在100行左右毫无新意的c代码中，我设法实现一个基本的标记和扫描#Na.C3.AFve_mark-and-sweep)模块。

垃圾收集被认为是有更多编程牛人出没的水域之一，但在这里，我会给你一个漂亮的儿童游泳池去玩耍。可能这里面仍然会有一些能手，但至少这会是一个浅水区。

精简、复用、再复用

垃圾回收背后有这样一个基本的观念：编程语言（大多数的）似乎总能访问无限的内存。而开发者可以一直分配、分配再分配——像魔法一样，取之不尽用之不竭。

当然，我们从来都没有无限的内存。所以计算机实现回收的方式就是当机器需要分配一些内存，而内存又不足时，让它回收垃圾。

“垃圾(Garbage)”在这里表示那些事先分配过但后来不再被使用的内存。而基于对无限内存的幻想，我们需要确保“不再被使用”对于编程语言来说是非常安全的。要知道在你的程序试图访问一些随机的对象时它们却刚好正在得到回收，这可不是一件好玩的事情。

为了实现回收，编程语言需要确保程序不再使用那个对象。如果该程序不能得到一个对象的引用，那么显然它也不会再去使用它。所以关于”in use”的定义事实上非常简单：

1. 任何被一个变量引用的对象，仍然在作用域内，就属于”in use”状态。
2. 任何被另一个对象引用的对象，仍在使用中，就是”in use”状态。

如果对象A被一个变量引用，而它又有一些地方引用了对象B，那么B就是在使用中(“in use”)，因为你能够通过A来访问到它。这样到最后的结果就是得到一张可访问的对象图——以一个变量为起点并能够遍历到的所有对象。任何不在图中的对象对于程序来说都是死的，而它的内存也是时候被回收了。

标记并清理

有很多不同的方法#Tracing_garbage_collectors)可以实现关于查找和回收所有未被使用的对象的操作，但是最简单也是第一个被提出的算法就是”标记-清除”算法。它由John McCarthy——Lisp(列表处理语言)的发明者提出，所以你现在做的事情就像是与一个古老的神在交流，但希望你别用一些洛夫克拉夫特式的方法——最后以你的大脑和视网膜的完全枯萎而结束。该算法的工作原理几乎与我们对”可访问性(reachability)”的定义完全一样：

1. 从根节点开始，依次遍历整个对象图。每当你访问到一个对象，在上面设置一个”标记(mark)”位，置为true。
2. 一旦搞定，找出所有标记位为”not”的对象集，然后删除它们。

对，就是这样。我猜你可能已经想到了，对吧？如果是，那你可能就成为了一位被引用了数百次的文章的作者。所以这件事情的教训就是，想要在CS(计算机科学)领域中出名，你不必开始就搞出一个很牛的东西，你只需要第一个整出来即可，哪怕这玩意看上去很搓。

对象对

在我们落实这两个步骤之前，让我们先做些不相关的准备工作。我们不会为一种语言真正实现一个解释器——没有分析器，字节码、或任何这种愚蠢的东西。但我们确实需要一些少量的代码来创建一些垃圾去收集。
让我们假装我们正在为一种简单的语言编写一个解释器。它是动态类型，并且有两种类型的变量：int 和 pair。 下面是用枚举来标示一个对象的类型：

1
2
3
4

typedef enum {
    OBJ_INT,
    OBJ_PAIR
} ObjectType;

其中，pair可以是任何一对东西，两个int、一个int和另一个pair，什么都可以。随你怎么想都行。因为一个对象在虚拟机中可以是这两个当中的任意一种类型，所以在c中实现对象的典型方法是时用一个标记联合体

1
2
3
4
5
6
7
8
9
10
11
12
13

 typedef struct sObject {
 	ObjectType type;	 
  	union {
    	/* OBJ_INT */
    	int value;
 
    	/* OBJ_PAIR */
    	struct {
      	struct sObject* head;
      	struct sObject* tail;
    	};
  	};
} Object;

这个Object结构拥有一个type字段表示它是哪种类型的值——要么是int要么是pair。接下来用一个union来持有这个int或是pair的数据。如果你对c语言很生疏，一个union就是一个结构体，它将字段重叠在内存中。由于一个给定的对象只能是int或是pair，我们没有任何理在一个单独的对象中同时为所有这3个字段分配内存。一个union就搞定。帅吧。

小虚拟机

现在我们可以将其包装在一个小的虚拟机结构中了。它(指虚拟机)在这里的角色是用一个栈来存储在当前作用域内的变量。大多数语言虚拟机要么是基于栈(如JVM和CLR)的，要么是基于寄存器(如Lua)的。但是不管哪种情况，实际上仍然存在这样一个栈。它用来存放在一个表达式中间需要用到的临时变量和局部变量。
我们来简洁明了地建立这个模型，如下：

1
2
3
4
5
6

#define STACK_MAX 256
 
typedef struct {
  	Object* stack[STACK_MAX];
  	int stackSize;
} VM;

现在我们得到了一个合适的基本数据结构，接下来我们一起敲些代码来创建些东西。首先，我们来写一个方法创建并初始化一个虚拟机：

1
2
3
4
5

VM* newVM() {
  VM* vm = malloc(sizeof(VM));
  vm->stackSize = 0;
  return vm;
}

一旦我们得到了虚拟机，我们需要能够操作它的堆栈：

1
2
3
4
5
6
7
8
9

void push(VM* vm, Object* value) {
  assert(vm->stackSize < STACK_MAX, "Stack overflow!");
  vm->stack[vm->stackSize++] = value;
}
 
Object* pop(VM* vm) {
  assert(vm->stackSize > 0, "Stack underflow!");
  return vm->stack[--vm->stackSize];
}

好了，现在我们能敲些玩意到”变量”中了，我们需要能够实际的创建对象。首先来一些辅助函数：

1
2
3
4
5

Object* newObject(VM* vm, ObjectType type) {
  Object* object = malloc(sizeof(Object));
  object->type = type;
  return object;
}

它实现了内存的分配和设置类型标记。我们一会儿会重温它的。利用它，我们可以编写方法将每种类型的对象压到虚拟机的栈上：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

void pushInt(VM* vm, int intValue) {
  Object* object = newObject(vm, OBJ_INT);
  object->value = intValue;
  push(vm, object);
}
 
Object* pushPair(VM* vm) {
  Object* object = newObject(vm, OBJ_PAIR);
  object->tail = pop(vm);
  object->head = pop(vm);
 
  push(vm, object);
  return object;
}

这就是我们的小小虚拟机。如果我们有调用这些方法的解析器和解释器，那我们手上就有了一种对上帝都诚实的语言。而且，如果我们有无限的内存，它甚至能够运行真正的程序。可惜咱们没有，所以让我们来收集些垃圾吧。

标记

第一个阶段就是标记(marking)。我们需要扫遍所有可以访问到的对象，并设置其标志位。现在我们需要做的第一件事就是为对象添加一个标志位(mark bit)：

1
2
3
4

typedef struct sObject {
  unsigned char marked;
  /* Previous stuff... */
} Object;

一旦我们创建了一个新的对象，我们将修改newObject()方法初始化marked为0。为了标记所有可访问的对象，我们从内存中的变量入手，这样就意味着要扫一遍堆栈。看上去就像这样：

1
2
3
4
5
6

void markAll(VM* vm)
{
  for (int i = 0; i < vm->stackSize; i++) {
    mark(vm->stack[i]);
  }
}

里面又调用了mark。我们来分几步搭建它。第一：

1
2
3

void mark(Object* object) {
  object->marked = 1;
}`

毫无疑问，这是最重要的一点。我们标记了这个对象自身是可访问的，但记住，我们还需要处理对象中的引用：可访问性是递归的。如果该对象是一个pair，它的两个字段也是可访问的。操作很简单：

1
2
3
4
5
6
7
8

void mark(Object* object) {
  object->marked = 1;
 
  if (object->type == OBJ_PAIR) {
    mark(object->head);
    mark(object->tail);
  }
}

但是这里有一个bug。你看到了吗？我们正在递归，但我们没有检查循环。如果你有一堆pair在一个循环中相互指向对方，这就会造成栈溢出并崩溃。
为了解决这个情况，我们仅需要做的是在访问到了一个已经处理过的对象时，退出即可。所以完整的mark()方法应该是：

1
2
3
4
5
6
7
8
9
10
11
12

void mark(Object* object) {
  /* If already marked, we're done. Check this first
     to avoid recursing on cycles in the object graph. */
  if (object->marked) return;
 
  object->marked = 1;
 
  if (object->type == OBJ_PAIR) {
    mark(object->head);
    mark(object->tail);
  }
}

现在我们可以调用markAll()方法了，它会准确的标记内存中所有可访问的对象。我们已经成功一半了！

清理

下一个阶段就是清理一遍所有我们已经分配过(内存)的对象并释放那些没有被标记过的(对象)。但这里有一个问题：所有未被标记的对象——我们所定义的——都不可达！我们都不能访问到它们！
虚拟机已经实现了对象引用的语义：所以我们只在变量和pair元素中储存指向对象的指针。当一个对象不再被任何指针指向时，那我们就完全失去它了，而这也实际上造成了内存泄露。
解决这个问题的诀窍是：虚拟机可以有它自己的对象引用，而这不同于对语言使用者可读的那种语义。换句话说，我们自己可以保留它们的痕迹。
这么做最简单的方法是仅维持一张由所有分配过(内存)的对象(组成)的链表。我们在这个链表中将对象自身扩展为一个节点：

1
2
3
4
5
6

typedef struct sObject {
  /* The next object in the list of all objects. */
  struct sObject* next;
 
  /* Previous stuff... */
} Object;

虚拟机会保留这个链表头的痕迹：

1
2
3
4
5
6

typedef struct {
  /* The first object in the list of all objects. */
  Object* firstObject;
  /* Previous stuff... */
} VM;

在newVM()方法中我们确保将firstObject初始化为NULL。无论何时创建一个对象，我们都将其添加到链表中：

1
2
3
4
5
6
7
8
9
10
11

Object* newObject(VM* vm, ObjectType type) {
  Object* object = malloc(sizeof(Object));
  object->type = type;
  object->marked = 0;
  /* Insert it into the list of allocated objects. */
  object->next = vm->firstObject;
  vm->firstObject = object;
  return object;
}

这样一来，即便是语言找不到一个对像，它还是可以被实现。想要清理并删除那些未被标记的对象，我们只需要遍历该链表：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

void sweep(VM* vm)
{
  Object** object = &vm->firstObject;
  while (*object) {
    if (!(*object)->marked) {
      /* This object wasn't reached, so remove it from the list
         and free it. */
      Object* unreached = *object;
      *object = unreached->next;
      free(unreached);
    } else {
      /* This object was reached, so unmark it (for the next GC)
         and move on to the next. */
      (*object)->marked = 0;
      object = &(*object)->next;
    }
  }
}

这段代码读起来有点棘手，因为那个指针(指object)指向的是一个指针，但是通过它的工作你会发现它还是非常简单的。它只是扫遍了整张链表。只要它碰到了一个未被标记的对象，它就会释放该对象的内存并将其从链表中移除。最后，我们将会删除所有不可访问的对象。
祝贺你！我们已经有了一个垃圾收集器！现在只剩下一点工作了：实际调用它！首先我们将这两个阶段整合在一起：

1
2
3
4

void gc(VM* vm) {
  markAll(vm);
  sweep(vm);
}

没有比这更明显的”标记-清除”算法了。现在最棘手的是搞清楚什么时候来实际调用它。”内存不足(low on memory)”是个什么意思？尤其是对于现在的计算机，它们几乎拥有无限的虚拟内存！
事实证明，我们没有完全正确或错误的答案。这真的取决于你使用虚拟机的目的以及让它运行在什么样的硬件上。为了让这个例子看上去很简单，我们仅在进行了一定数量的内存分配之后开始收集。事实上一些语言的实现就是这么做的，而这也很容易。
我们将邀请虚拟机来追踪我们到底创建了多少(对象)：

1
2
3
4
5
6
7
8
9

typedef struct {
  /* The total number of currently allocated objects. */
  int numObjects;
 
  /* The number of objects required to trigger a GC. */
  int maxObjects;
 
  /* Previous stuff... */
} VM;

接下来，初始化：

1
2
3
4
5
6
7

VM* newVM() {
  /* Previous stuff... */
 
  vm->numObjects = 0;
  vm->maxObjects = INITIAL_GC_THRESHOLD;
  return vm;
}

其中，INITIAL_GC_THRESHOLD为你启动第一个GC(垃圾收集器)的对象数量。较小的值会更节省内存，而较大的值则更省时。自己看着办吧。
每当我们创建一个对象，我们增加numObjects，如果它达到最大值就启动一次收集：

1
2
3
4
5
6
7
8

Object* newObject(VM* vm, ObjectType type) {
  if (vm->numObjects == vm->maxObjects) gc(vm);
 
  /* Create object... */
 
  vm->numObjects++;
  return object;
}

我不会费心的显示它(指numObjects)，但是我们也会稍微调整sweep()方法，每释放一次就递减numObjects。最后，我们修改了gc()方法来更新最大值：

1
2
3
4
5
6
7
8

void gc(VM* vm) {
  int numObjects = vm->numObjects;
 
  markAll(vm);
  sweep(vm);
 
  vm->maxObjects = vm->numObjects * 2;
}

每次收集之后，我们更新maxObjects——以进行收集后仍在活动的对象为基准。乘法器让我们的堆随着活动中的对象数量的增加而增加。同样，也会随着一些对象最终被释放掉而自动减少。

最后

你成功了！如果你全部照做了，那你现在已经得到了一个简单的垃圾收集算法的句柄。如果你想看完整的代码，在这里。我再强调一点，尽管这个收集器很简单，但它可不是一个玩具。
你可以在这上面做一大堆的优化（像在GC和程序设计语言这些事情中，90%的努力都在优化上），但它的核心代码可是真正的GC。它与目前Ruby和Lua中的收集器非常的相似。你可以使用一些类似的代码到你的项目中。去做些很酷的事情吧！

点击打开链接

一.前言

最近在学习2dx，看了几个源码，手很是痒痒，下面跟我一下编写一个类似保卫大萝卜的塔防游戏吧。

二.不废话开始编代码。

我用的cocos2d-x 的版本是2.04 ，编辑器是vs2010.首先创建一个工程，我们取名字叫“TDgame”。
之后我们添加几个常用到的模块。
1.动画管理器，AnimationManager类
AnimationManager类这是个单例的类,大家要问这样弄个单例类出来有什么好处呢，有什么作用呢，一开始我也是不明白，最后看了看魔塔的源代码，总结了一下：1. 实现了一体化，也就是说把所有的动画加载都放到一个函数中，我们可以让这个函数出现在想要的位置上，比如,我们有一大堆的精灵动画，如果在游戏中加载起来会让游戏有点卡，这时候我们就可以创建一个进入游戏时的加载页面，同时执行加载动画。一般游戏也都是这么做的。

1. 规范代码，有利于编写代码。

好了它的优点和作用就说到这吧，肯定还有很多，我也就不知道了。

关于单例的问题大家可以看看这篇文章
http://www.zilongshanren.com/cocos2d-x-design-pattern-singleton1/

回到主题，首先我们粘贴一段代码。

第一步：复制黏贴

在魔塔的源代码中有一个单例类的模板，无脑的复制黏贴，这个模板是动画管理器AnimationManager的基类，这个有什么用呢，其实用处很简单就是一个单例的模板让继承他的子类都变成单例模式，下次再做别的游戏时用到直接继承，多方便。当然你也可以不用这个模板，直接让AnimationManager变成单例类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

#ifndef _SINGLETON_H 
#define _SINGLETON_H 
 
template <class T> 
class Singleton 
{ 
public: 
    //获取类的唯一实例 
    static inline T* instance(); 
    //释放类的唯一实例 
    void release(); 
protected: 
    Singleton(void){} 
    ~Singleton(void){} 
    static T* _instance; 
}; 
 
template <class T> 
inline T* Singleton<T>::instance() 
{ 
    if(!_instance) 
        _instance = new T; 
    return _instance; 
} 
 
template <class T> 
void Singleton<T>::release() 
{ 
    if (!_instance) 
        return; 
    delete _instance; 
    _instance = 0; 
} 
 
//cpp文件中需要先声明静态变量 
#define DECLARE_SINGLETON_MEMBER(_Ty)   \ 
    template <> _Ty* Singleton<_Ty>::_instance = NULL; 
 
#endif//_SINGLETON_H

好了这样我们的标准的单例基类就写好了,记住这是一个.h文件 注意：
1.子类要在子类的cpp文件开始写上DECLARE_SINGLETON_MEMBER(子类的名字)
2.子类最好写上构造和析构函数

第二步：编写动画管理器AnimationManager类

先看代码：###AnimationManager.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

#ifndef _ANIMATION_MANAGER_H_ 
#define _ANIMATION_MANAGER_H_ 
 
#include "cocos2d.h" 
#include "Singleton.h" 
#include "type.h" 
using namespace cocos2d; 
 
class AnimationManager : public Singleton<AnimationManager> 
{ 
public: 
    AnimationManager(); 
    ~AnimationManager(); 
    //初始化动画模版缓存表 
    bool initAnimationMap(); 
    //根据名字得到一个动画模板 
    CCAnimation* getAnimation(int key); 
    //创建一个动画实例 
    CCAnimate* createAnimate(int key); 
    //创建一个动画实例 
    CCAnimate* createAnimate(const char* key); 
    //清空所有缓存 
    void releaseAllCacha(); 
protected: 
    //加载勇士行走动画模版 
    CCAnimation* createAnimationByDirection(HeroDirection direction); 
}; 
//定义动画管理器实例的别名 
#define sAnimationMgr AnimationManager::instance() 
 
#endif

AnimationManager.cpp

#include "AnimationManager.h" 
DECLARE_SINGLETON_MEMBER(AnimationManager); 



AnimationManager::AnimationManager() 
{ 

} 

AnimationManager::~AnimationManager() 
{ 

} 

bool AnimationManager::initAnimationMap() 
{ 
    bool sRet = false; 
    do  
    { 
        //1.添加图片进内存 
        CCTexture2D * creepTexture = CCTextureCache::sharedTextureCache()->addImage("boy.png"); 
        CC_BREAK_IF(!creepTexture); 
        //2.加载各个方向的敌人动画 
        char temp[20]; 
        sprintf(temp, "%d", aDown); 
        //加载勇士向下走的动画 
        CCAnimationCache::sharedAnimationCache()->addAnimation(createAnimationByDirection(kDown), temp); 
        sprintf(temp, "%d", aRight); 
        //加载勇士向右走的动画 
        CCAnimationCache::sharedAnimationCache()->addAnimation(createAnimationByDirection(kRight), temp); 
        sprintf(temp, "%d", aLeft); 
        //加载勇士向左走的动画 
        CCAnimationCache::sharedAnimationCache()->addAnimation(createAnimationByDirection(kLeft), temp); 
        sprintf(temp, "%d", aUp); 
        //加载勇士向上走的动画 
        CCAnimationCache::sharedAnimationCache()->addAnimation(createAnimationByDirection(kUp), temp); 

        sRet = true; 
    } while (0); 
    return sRet; 
} 

CCAnimation* AnimationManager::getAnimation( int key ) 
{ 
    char temp[20]; 
    sprintf(temp, "%d", key); 
    return CCAnimationCache::sharedAnimationCache()->animationByName(temp); 
} 

CCAnimate* AnimationManager::createAnimate( int key ) 
{ 
    //获取指定动画模版 
    CCAnimation* anim = getAnimation(key); 
    if(anim) 
    { 
        //根据动画模版生成一个动画实例 
    //  return cocos2d::CCAnimate::actionWithAnimation(anim); 
        return cocos2d::CCAnimate::create(anim); 
    } 
    return NULL; 
} 

CCAnimate* AnimationManager::createAnimate( const char* key ) 
{ 
    //获取指定动画模版 
    CCAnimation* anim = CCAnimationCache::sharedAnimationCache()->animationByName(key); 
    if(anim) 
    { 
        //根据动画模版生成一个动画实例 
        return cocos2d::CCAnimate::create(anim); 
    } 
    return NULL; 
} 

CCAnimation* AnimationManager::createAnimationByDirection( HeroDirection direction ) 
{ 
    //3.生产剪切动画 
    CCTexture2D * creepTexture=CCTextureCache::sharedTextureCache()->textureForKey("boy.png"); 
    CCSpriteFrame *frame0, *frame1, *frame2, *frame3; 
    frame0 = CCSpriteFrame::createWithTexture(creepTexture, cocos2d::CCRectMake(47*0, 95*direction, 47, 95)); 
    frame1 = CCSpriteFrame::createWithTexture(creepTexture, cocos2d::CCRectMake(47*1, 95*direction, 47, 95)); 
    frame2 = CCSpriteFrame::createWithTexture(creepTexture, cocos2d::CCRectMake(47*2, 95*direction, 47, 95)); 
    frame3 = CCSpriteFrame::createWithTexture(creepTexture, cocos2d::CCRectMake(47*3, 95*direction, 47, 95)); 
    CCArray * animFrames = new CCArray(4); 
    animFrames->addObject(frame0); 
    animFrames->addObject(frame1); 
    animFrames->addObject(frame2); 
    animFrames->addObject(frame3); 
    CC_SAFE_RETAIN(animFrames); 
    CCAnimation * animation= CCAnimation::createWithSpriteFrames(animFrames,0.5f); 

    animFrames->release(); 
    return animation; 
} 

void AnimationManager::releaseAllCacha() 
{ 

}

建立完这个动画管理单例后，用法也是很简单,只需要调用那几个getXXXX 就行，当然这个动画管理器功能还比较简单，因为我是个新手所以不能一下吧所有的功能都写上，还是先用到哪些写那些。

第三步：全局数据

之后我们在建立一个单例类，来保存一些全局数据
HWorld.h

#ifndef __HWORLD_H__ 
#define __HWORLD_H__ 

#include "cocos2d.h" 
#include "type.h" 
#include "Singleton.h" 
using namespace cocos2d; 
class HWorld: 
    public Singleton<HWorld> 
{ 
public: 
    HWorld(); 
    ~HWorld(); 
    //初始化 
    bool initHWorld(); 
    //清空所有缓存 
    void releaseAll(); 
public: 
    //路点数组 
    CCPointArray * _wayPoint;    
}; 
//定义动画管理器实例的别名 
#define sHWorld HWorld::instance() 
#endif

HWorld.cpp

#include "HWorld.h"  
DECLARE_SINGLETON_MEMBER(HWorld);  

bool HWorld::initHWorld()  
{  
    return true;  
}  

void HWorld::releaseAll()  
{  
}  

HWorld::HWorld()  
{  
}  

HWorld::~HWorld()  
{  
}

目前这个类里面之后一个路点的数组，这个数组中保存了地图上需要转弯地方的坐标,其他的东西以后再添加。
当然还有我们的枚举，把它放在一个.h文件中，方便查看
type.h

#ifndef __TYPE_H__  
#define __TYPE_H__  

typedef enum {  
    kDown =  0,//向下方向  
    kLeft = 1,//向左方向  
    kRight= 2,//向右方向  
    kUp = 3,//向上方向  
    kNormal,  
} HeroDirection;//勇士方向  


typedef enum 
{  
    aDown = 0,//向下行走动画  
    aLeft,//向左行走动画  
    aRight,//向右行走动画  
    aUp,//向上行走动画  
    aFight,//刀光动画  
} AnimationKey;//动画模版键值  
//定义怪物的类型  
typedef enum 
{  
    kHighBlood=0,//高血量怪物  
    kQuick = 1,  

}CreepType;  
//----------------定义一个creep中所用到的tag--------  
typedef enum 
{  
    kSprite =0,//精灵的标签  
    kSpeedAction = 1,//控制速度的action所用的标签  
    kFoveverAction = 2,//控制精灵帧的action标签  
}CreepTag;  
 enum   
{  
    kZMap = 0,//地图的zOrder  
    kZNPC,  
    kZTeleport,  
    kZHero,//勇士精灵的zOrder  
    kZTip,//提示信息的zOrder  
};//GameLayer中各部分的显示zOrder及tag  
#endif

好了，生成一下。

版权声明：本文为博主原创文章，转载请注明出处，谢谢!

Evaluate the value of an arithmetic expression in Reverse Polish Notation.
Valid operators are +, -, *, /.
Each operand may be an integer or another expression.
Some examples:

["2", "1", "+", "3", "*"] -> ((2 + 1) * 3) -> 9
["4", "13", "5", "/", "+"] -> (4 + (13 / 5)) -> 6

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

public class Solution {
	public int evalRPN(String[] tokens) {
		// IMPORTANT: Please reset any member data you declared, as
		// the same Solution instance will be reused for each test case.
		Stack<Integer> numbers = new Stack<Integer>();
		for (String token : tokens) {
			if (token.equals("+") || token.equals("-") || token.equals("*")
					|| token.equals("/")) {
				int number2 = numbers.pop();
				int number1 = numbers.pop();
				if (token.equals("+")) {
					numbers.push(number1 + number2);
				}
				if (token.equals("-")) {
					numbers.push(number1 - number2);
				}
				if (token.equals("*")) {
					numbers.push(number1 * number2);
				}
				if (token.equals("/")) {
					numbers.push(number1 / number2);
				}
			} else {
				numbers.push(Integer.valueOf(token));
			}
		}
		return numbers.pop();
	}