我常常看到项目中，有像下面这样的代码：

bool bVisible = (FLAG_SHOW == strValue) ? true : false;

其实，这算是好的情况了，如果你跟他说这个代码可以写得更简单些：

bool bVisible = (FLAG_SHOW == strValue);

他可能会跟你争辩，说加上true/false的写法更容易理解。这就难说了，因为是否容易理解是个仁者见仁智者见智的问题，说不定还有审美趣味的因素，而我真的没有更好的理由说服他，毕竟，这只是个微不足道的单行代码而已。

下面的if...else语句与此类似，每次看到它我都要强忍住随手改之的冲动。

if (<bool表达式>) {
  return true;
} else {
  return false;
}

少写代码意味着不写不必要的代码。避免坏代码最好的方法就是少写代码。少写代码往往比多写代码需要更多的经验和觉悟。比如让你对一组浮点数进行排序：

void sort(float* values, size_t size);

最简单的方法就是使用STL的sort()：

void sort(float* values, size_t size) {
  std::sort(values, values + size);
}

这样的代码再好不过了。前提是你首先得了解STL（经验），其次要能抑制住重新发明轮子的冲动（觉悟）。

看一个我们项目中的例子，下面这个函数替换子字符串：

std::string replace(const std::string & src,const std::string & oldstr,const std::string & newstr)
{
  size_t pos = 0;
  std::string buffer = src;
  std::string::size_type newlen = newstr.length();
  std::string::size_type oldlen = oldstr.length();
  while(true)
  {
    pos = buffer.find(oldstr, pos);
    if (pos == std::string::npos) break;
    buffer.replace(pos, oldlen, newstr);
    pos += newlen;
  }
  return(buffer);
}

我之所注意到这个函数，是因为最近一位同事在重构时对它进行了优化，重构前它是下面这个样子：

std::string str::replace(const std::string & src,const std::string & oldstr,const std::string & newstr)
{
  std::string buffer=src;
  const std::string::size_type oldlen=oldstr.length();
  if (oldlen>0)
  {
    std::string::size_type index=0;
    std::string::size_type newlen=newstr.length();
    if (newlen)
    {
      if (newlen<oldlen)
      {
        if ((index=newstr.find(oldstr))!= std::string::npos)
        {
          newlen=index;
        }
      }
    }
    while ((index=buffer.find(oldstr,index))!= std::string::npos)
    {
      buffer.replace(index,oldlen,newstr);
      index+=newlen;
    }
  }
  return(buffer);
}

我想说的是，这个重构做得很不到位。其实对于字符串替换这种问题，肯定有人早就做过了，并且做得很好，比如boost algorithm就提供了replace_all/replace_all_copy。所以，这个函数可以直接删掉，用boost好了。

在我们项目中，重新发明轮子的事情实在是太多了，比如下面这个从字符串转浮点数的函数（应该是从网上拷贝来的）：

static double string_to_double(const char* s)
{
    double val = 0,power = 1;
    int i,sign = 1;
    for(i=0;isspace(s[i]);i++);
    sign=(s[i]=='-')?-1:1;
    if(s[i]=='+'||s[i]=='-')
        i++;
    for(val=0.0;isdigit(s[i]);i++)
        val=10.0*val+(s[i]-'0');
    if(s[i]=='.')
        i++;
    for(power=1.0;isdigit(s[i]);i++)
    {
        val=10.0*val+(s[i]-'0');
        power*=10.0;
    }
    return sign*val/power;
}

当然，还有double_to_string，我都不好意思贴出来了。

少写代码不是说可以随便拷贝别人的代码，特别是从网上。再举一个我们项目中的一个例子（靠！你有没有发现我们项目的伟大！？），读取一个文本文件，把内容存在字符串里：

bool ReadFile(const std::string& file, std::string& stream)
{
    /*
     * C version -- read file
     */
    // Read file characters line by line(perfect)
    FILE* fpin = NULL;
    const int   maxLen = 180; // Assume the character number of a line is less than 180
    char  buf[maxLen];
    fpin = fopen(file.c_str(), "r");
    if (NULL == fpin) return false;
    while (!feof(fpin) && fgets (buf , maxLen , fpin)) // Judge the end of file
    {
        stream += buf;
    }
    fclose(fpin);
    return true;
}

这段代码是从网上拷的，连注释都保留原样。"假定每行字符数少于180"这一句特别显眼，这种假设是荒谬的。

" Only load this indent file when no other was loaded.
if exists("b:did_indent")
  finish
endif
let b:did_indent = 1
" Set the function to do the work.
setlocal indentexpr=GetCppIndent()
" Only define the function once.
if exists("*GetCppIndent")
  finish
endif
function GetCppIndent()
  let indent = cindent(v:lnum)
  if v:lnum < 2
    return indent
  endif
  " Don't indent namespace block.
  let prev = v:lnum - 1
  let pline = getline(prev)
  if pline =~ '^\s*namespace\s\+\a\+\s*{\s*$'
    let indent = indent - &sw
  elseif pline =~ '^\s*{\s*$'
    if getline(prev - 1) =~ '^\s*namespace\s\+\a\+\s*$'
      let indent = indent - &sw
    endif
  endif
  return indent
endfunction

用VC的同学就比较悲催了：http://blog.csdn.net/ganxinjiang/archive/2010/09/13/5880541.aspx

今天编辑cue文件，中文曲目在foobar里不能正常显示，google后发现foobar是支持utf-8编码的cue文件的，只是要加上BOM。

于是在Vim里:h bom，得到方法如上。

假如你想写一个函数，把字符串转换成bool：
[code lang="cpp"]
// "true"/"false" (case ignored) -> true/false
// "1"/"0" -> true/false
... BoolFromString(...)
[/code]
首先提供参数为const char*的实现：
[code lang="cpp"]
bool BoolFromString(const char* input, bool* output) {
if (_stricmp(input, "true") == 0 || strcmp(input, "1") == 0) {
*output = true;
return true;
} else if (_stricmp(input, "false") == 0 || strcmp(input, "0") == 0) {
*output = false;
return true;
}
return false;
}
[/code]
然后，参数为const std::string&的实现只是简单的转调：
[code lang="cpp"]
bool BoolFromString(const std::string& input, bool* output) {
return BoolFromString(input.c_str(), output);
}
[/code]
这里很容易犯的错误是把转调的关系搞反：
[code lang="cpp"]
bool BoolFromString(const char* input, bool* output) {
return BoolFromString(std::string(input), output);
}
[/code]
这样的实现没有任何意义，干脆不要提供const char*的实现。

这种字符串参数的优化看似微不足道，但不可小觑，对于频繁处理字符串的程序（比如编译器），必然是可观的性能改进。

这种改进实施起来对程序员的素质要求比较高，于是就有了辅助的手段：Goolge Chromium提供了StringPiece类，而LLVM则提供了StringRef类。

StringPiece是一个指向一片固定大小内存的类字符串对象（注释原文：A string-like object that points to a sized piece of memory），类的定义大致如下：
[code lang="cpp"]
class StringPiece {
public:
typedef size_t size_type;
private:
const char* ptr_;
size_type length_;
public:
StringPiece() : ptr_(NULL), length_(0) { }
StringPiece(const char* str)
: ptr_(str), length_((str == NULL) ? 0 : strlen(str)) { }
StringPiece(const std::string& str)
: ptr_(str.data()), length_(str.size()) { }
StringPiece(const char* offset, size_type len)
: ptr_(offset), length_(len) { }
const char* data() const { return ptr_; }
size_type size() const { return length_; }
size_type length() const { return length_; }
bool empty() const { return length_ == 0; }
[/code]
StringPiece可由const char*，std::string或者一块非'\0'结尾的字符数组构造，但它不会拷贝内存。这就是它的特点。它所指向的内存必须要有较其自身更长的生命期，这便决定了它比较适合作为函数参数，而不是作为成员变量或者放在容器中。

使用StringPiece来实现BoolFromString，不必有两个函数，一个就够了：
[code lang="cpp"]
bool BoolFromString(const StringPiece& input, bool* output) {
if (_stricmp(input.data(), "true") == 0 || strcmp(input.data(), "1") == 0) {
*output = true;
return true;
} else if (_stricmp(input.data(), "false") == 0 || strcmp(input.data(), "0") == 0) {
*output = false;
return true;
}
return false;
}
[/code]
这个BoolFromString可以接受const char*，std::string，甚至StringPiece，不管哪一种，都没有关于字符串的多余的内存分配和释放。

LLVM的StringRef，实现上跟Google的StringPiece一样，接口方面略有差别。作为参数时，Google建议StringPiece用const&，而LLVM则直接传值。StringRef也可以传const&，但是它的名字起得不好，已经带有引用的含义了（Ref），效率上当然传const&更高。所以我更喜欢Google的StringPiece。

倒推法之所以是一种极为深刻的思维方法，本质上是因为它充分利用了题目中一个最不易被察觉到的信息——结论。

刘未鹏《暗时间》132页提及的两个例子。

例一：用9升的桶和4升的桶各一个从河里取6升的水。

思维过程：6 = 9 - 3，9已知，3未知，3 = 4 - 1，4已知，1未知，1 = 9 - 4 - 4，9和4皆已知。

所以解法是：用9升的桶取9升水，往4升的桶里倒两次，余1升水，存在4升的桶中；再用9升的桶取9升水，把已经有1升水的4升的桶倒满，则9升的桶中便剩6升水。

当然， 反向推导时，也有可能走偏。比如我一开始就这样思考的：6 = 5 +１，５ = 9 - 4，1 = 5 - 4，这一过程中5 + 1难以实现，因为9升的桶和4升的桶分别只有一个，如果有多个，还是可行的。

例二：100根火柴，两个人轮流取，每人每次只能取1~7根，谁拿到最后一根谁赢；问有必胜策略吗？有的话，是先手还是后手必胜？

设两个人为A和B，假定B必胜，先考虑最后一步（第N步）， 每一步都是A先取，B后取。反向推导过程如下：

第N步：必须为8根，这样A随便怎么取（1~7根），B都可以一次将剩余的取完。

第N-1步：要想第N步有8根，B取之前必须为9~15根，那么A取之前必须为16根。

第N-2步：要想第N-1步有16根，B取之前必须为17~23根，那么A取之前必须为24根。

第N-3步：要想第N-2步有24根，B取之前必须为25~31根，那么A取之前必须为32根。

......

这时，注意到数字8，16，24，32，......都是8的倍数。也就是说，只要B取完后，保证剩下的火柴数为8的倍数就可以了。考虑100根火柴的情况，B想必胜的话，最好B先取4根，剩下96根（8 * 12），然后A取，B再取，保证剩下88根，依此类推。最终B胜。

简单来说：假定火柴总数为N根，B先取N%8（N模8）根，随后A取m根，B就取8-m根。

如果A不知道此必胜方法，那么即使A先取，B也可能获胜。只要在当中的某步，保证B取后剩余8 * N根即可。

至此，我们没有考虑N为8的倍数的情况，当总数为8的倍数时，就得让A先取了。

举个例子，让你按行读取文本文件，你会怎么写？使用全局函数std::getline()吗？

[code lang="cpp" title="代码1"]
void read_line_by_line(std::istream& is) {
std::string line;
while (std::getline(is, line)) {
std::cout << line << std::endl;
}
}
[/code]

还是使用std::istream的成员函数getline()？
[code lang="cpp" title="代码2"]
void read_line_by_line(std::istream& is) {
char line[BUFFER_SIZE];
while (is.getline(line, BUFFER_SIZE)) {
std::cout << line << std::endl;
}
}
[/code]

有趣的是，使用成员函数的代码反倒是C风格，使用全局函数的代码却是C++风格。从性能上看，代码2比代码1要高效得多，因为代码1每读一行就会重新分配一次存储空间（有待验证），而代码2则不必如此。

代码2的缺点在于常量BUFFER_SIZE。如果BUFFER_SIZE小于某行有暗香盈袖长度，while循环便会在读取这一行时退出。性能的提升往往伴随着灵活性的下降。

当然，性能和灵活性并非总是反比的关系，灵活性不好时，性能也未必高。下面这个函数，取自我们实际的项目（便于阐述，略作改动），它在日期时间字符串之间做转换，并且输入输出格式恒定。
[code lang="cpp"]
// \param date "yyyymmdd", such as "20100114"
// \param time "hhmmss", such as "090251"
// \param dateTime "yyyy-MM-ddThh:mm:ss", such as 2010-01-14T09:02:51
const std::string& GmtFromDicomDataTime(const std::string& date,
const std::string& time,
std::string& dateTime)
{
dateTime = date.substr(0, 4) + "-" +
date.substr(4, 2) + "-" +
date.substr(6, 2) + "T" +
time.substr(0, 2) + ":" +
time.substr(2, 2) + ":" +
time.substr(4, 2);
return dateTime;
}
[/code]

这个函数共调用了6次substr()，和10次+操作符。让我们来算算共有多少个临时的字符串。6次substr()调用产生6个临时字符串，10次+操作符产生9个临时字符串，所以一共是15个。我想，没有比这个再多的实现了。

如果要优化的话，鉴于格式恒定，可以先分配好输出字符串的存储，然后将输入字符串的各部分对应到输出字符串中。
[code lang="cpp"]
const std::string& GmtFromDicomDataTime(const std::string& date,
const std::string& time,
std::string& dateTime)
{
dateTime.resize(20);
memcpy(&dateTime[0], &date[0], 4);
dateTime[4] = '-';
memcpy(&dateTime[5], &date[4], 2);
dateTime[7] = '-';
memcpy(&dateTime[8], &date[6], 2);
dateTime[10] = 'T';
memcpy(&dateTime[11], &time[0], 2);
dateTime[13] = ':';
memcpy(&dateTime[14], &time[2], 2);
dateTime[16] = ':';
memcpy(&dateTime[17], &time[4], 2);
return dateTime;
}
[/code]

如代码所示，灵活性没有任何改进，但是毋庸置疑的是，性能肯定有所提高，因为现在不会产生任何临时字符串了。

回到按行读取文本文件的例子，下面这个函数取自一个代码格式化工具，AStyle。我是无意中看到这段代码的，颇为震惊，因为它每次只读一个字符，并且每读一个字符后就调用一次std::string的append()。

[code lang="cpp" title="astyle_main.cpp"]
template<typename T>
string ASStreamIterator<T>::peekNextLine()
{
// ...
// read the next record
inStream->get(ch);
while (!inStream->eof() && ch != '\n' && ch != '\r')
{
nextLine_.append(1, ch);
inStream->get(ch);
}
// ...
}
[/code]
跟这段代码相比，使用std::getline()实在太高效了。有些开源软件的代码质量，实在不敢恭维。

[code title="app.yaml"]
application: ajaxecho
version: 1
runtime: python
api_version: 1
handlers:
- url: /.*
script: echo.py
[/code]

[code lang="python" title="echo.py"]
import os
from django.utils import simplejson
from google.appengine.ext import webapp
from google.appengine.ext.webapp import template
from google.appengine.ext.webapp import util
# ...
class EchoHandler(webapp.RequestHandler):
def get(self):
template_values = {}
path = os.path.join(os.path.dirname(__file__), "echo.html")
self.response.out.write(template.render(path, template_values))
def post(self):
send_value = self.request.get("sendValue")
# Wrap the value with {} as the echo value.
self.response.out.write(simplejson.dumps({ "echoValue": "{ %s }" % send_value }))
def main():
app = webapp.WSGIApplication([
('/', EchoHandler),
], debug=True)
util.run_wsgi_app(app)
if __name__ == '__main__':
main()
[/code]

[code lang="html" title="echo.html" smarttabs="true"]
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html>
<head>
<meta http-equiv="Content-type" content="text/html; charset=utf-8" />
<title>Ajax Echo</title>
<script src="http://ajax.googleapis.com/ajax/libs/jquery/1/jquery.min.js" type="text/javascript" charset="utf-8"></script>
<script>
$(function() {
$('#txtA').keyup(function() {
// Call the function to handle the AJAX.
// Pass the value of the text box to the function.
sendValue($(this).val());
});
});
// Function to handle ajax.
function sendValue(txt) {
$.post(
"/",
{ sendValue : txt },
// Function that will be called when server returns a value.
function(data) {
$('#txtB').val(data.echoValue)
},
// The format of the data returned from the server.
"json");
}
</script>
</head>
<body>
<label for="txtA">Type here : </label>
<input type="text" name="txtA" value="" id="txtA" >
<label for="txtB">Echo here : </label>
<input type="text" name="txtB" value="" id="txtB" >
</body>
</html>
[/code]

这些slides并不是为了教你怎么入门，所以没有语法、开发环境、应用场景等方面的内容。它侧重于语言层面上的特性，通过一些简单的例子，说明Python的强大和优雅。这里也提到了高阶函数（higher-order function）和列表推导（list comprehension），借此可以看到Python对函数式语言的借鉴。

注意里面那个try没有except IOError，因为外面已经有了。所以下面这种写法有点多余：
[code lang="python"]
try:
fsock = open(filename, "rb", 0)
try:
fsock.seek(-128, 2)
tagdata = fsock.read(128)
except IOError: # 此处多余！
# ...
finally:
fsock.close()
except IOError:
pass
[/code]

引入with语句之后的Python，不需要考虑关闭文件，写法更为简洁：
[code lang="python"]
try:
with open(filename, "rb", 0) as fsock:
fsock.seek(-128, 2)
tagdata = fsock.read(128)
except IOError:
pass
[/code]
可以说，with语句就是Python里的RAII。

Agenda

• 一种语言，方式多样
• 语言不同，风格迥异
• 风格虽同，思想有别
• 尾调用/递归
• 函数作为第一级对象

这些slides可以作为函数式编程的入门。