for (int club_i = 0; club_i < clubs.size(); club_i++) {
	for (int member_j = 0; member_j < clubs[i].members.size(); member_j++) {
		for (int user_k = 0; user_k < users.size(); user_k++) {
			if (clubs[club_i].members[member_j] == users[user_k]) {
				cout << "user[" << user_k << "] is in club[" << club_i << "]" << endl;
			}
		}
	}
}
通过添加club,member,user这样的前缀，我们通过索引访问数组时就不容易写错了
通过首字母缩写来实现也可以：ci, mj, uk

if (debug) {
	map<string, int> m;
	LookUpNamesNumbers(&m);
	Print(m);
}

static const int kMaxOpenFiles = 100;
class LogReader {
    public:
    	void OpenFile(string local_file);
    private:
    	int offset_;
    	DISALLOW_COPY_AND_ASSIGN(LogReader);
};

// A class for keeping track of a series of doubles
// and methods for quick statistics about them
class StatsKeeper {
	public:
		void Add(double d);
		double Average();
	private:
		list<double> past_items;
		int count; // how many so far
		
		double minimum;
		double maximum;
};

DatabaseConnection database_connection;
string error;
assert(ExpandFullName(database_connection, "Doug Adams", &error)
	== "Mr. Douglas Adams");
assert(error == "");
assert(ExpandFullName(database_connection, " Jake Brown", &error)
	== "Mr. Jacob Brown III");
assert(error == "");
assert(ExpandFullName(database_connection, "No Such Guy", &error) == "");
assert(error == "no match found");
assert(ExpandFullName(database_connection, "John", &error) == "");
assert(error == "more than one result");

void CheckFullName(string partial_name,
				 string expected_full_name,
				 string expected_error) {
	// database_connection is now a class member
    string error;
    string full_name = ExpandFullName(database_connection, partial_name, &error);
    assert(error == expected_error);
    assert(full_name == expected_full_name);
}

CheckFullName("Doug Adams", "Mr. Douglas Adams", "");
CheckFullName(" Jake Brown", "Mr. Jacob Brown III", "");
CheckFullName("No Such Guy", "", "no match found");
CheckFullName("John", "", "more than one result");

class FrontendServer {
	public:	
		FrontendServer();
		~FrontendServer();
	
		// Handlers
		void ViewProfile(HttpRequest* request);
		void SaveProfile(HttpRequest* request);
		void FindProfile(HttpRequest* request);
		
		// Request / Reply Utilities
		string ExtractQueryParam(HttpRequest* request, string param);
		void ReplyOK(HttpRequest* request, string html);
		void ReplyNotFound(HttpRequest* request, string error);

		// Database Helpers
		void OpenDatabase(string location, string user);
		void CloseDatabase(string location);
};

struct Recorder {
	vector<float> data;
	...
	void Clear() {
		// Force vector to relinquish its memory (look up "STL swap trick")
		vector<float>().swap(data);
	}
};
C++程序员看到Clear函数都会想，为毛不直接用data.clear()，反而还要用一个空向量交换
原因是只有这样才能强制使向量真正将内存归还给内存分配器

// the int is the CategoryType
// the first float in the inner pair is the 'score'
// the second is the 'weoght'
typedef hash_map<int, pair<float, float> ScoreMap;

完全可以改成
// CategoryType -> (score, weight)
typedef hash_map<int, pair<float, float> ScoreMap;

// Insert the data into the cache, but check if it's too big first
it 到达指的是data还是cache呢？

// Insert the data into the cache, but check if the data is too big first

// Count how many newline bytes ('\n') are in the file
int CountLines(string filename) {...}

// 正常解释函数行为
// Example: Partition([8 5 9 8 2], 8) might result in [5 2 | 8 9 8] and return 1
int Partition(vector<int>* v, int pivot);

void Connect(int timeout,bool use_encryption){ }

# Call the function using named parameters
Connect(/*timeout_ms = */ 10, /* use_encryption = */ False)

这个处理的问题是类似于下面这种：
if (a == b) {
	// case one
} else {
	// case two
}

等价于 
if (a != b) {
	// case two
} else {
	// case one
}
这两种写法，那种好一点的问题 

1） not (a or b or c)  <=> (not a) and (not b) and (not c)
2)  not (a and b and c) <=> (not a) or (not b) or (not c)

使用德摩根定理的原因是为了使得布尔表达式更加可读
if (!(file_exists && !is_protected)) Error("Sorry, could not read file.");

改写为：
if (!file_exists || is_protected) Error("Sorry, could not read file.");

struct Range {
	int begin;
	int end;
	// For example, [0, 5) overlaps with [3, 8)
	bool OverlapsWith(Range other);
};

OverlapsWith是判断两个区间是否有重叠部分：
	如果正向判断，那么就有很多种情况
	如果反向判断，就只有两种：
		另一个范围在这个范围前结束
		另一个范围在这个范围后开始

bool Range::OverlapsWith(Range other) {
	if (other.end <= begin) return false;
	if (other.begin >= end) return false;
	return true;
}

class LargeClass {
    string str_;
    void Method1() {
        str_ = ...;
        Method2();
    }
    void Method2() {
        // use str_
    }
    // Lots of method don't use str_ ...
};

上面的类中，就两个方法用了str_，声明为类成员变量就没必要
  
class LargeClass {
    void Method1() {
        string str_ = ...;
        Method2(str_);
    }
    void Method2(string str_) {
        // uss str_
    } 
};

if (PaymentInfo* info = database.ReadPaymentInfo()) {
	cout << "User paid: " << info->amount << endl;
}
直接将info定义在逻辑表达式中，这样info的作用域就只在if语句内部了

需求：只有拥有文档的用户或者管理员才能看到页面

自然语言描述：
授权有两种方式：
	是管理员
	拥有当前文档

那么代码就直接写：
if (is_admin_request()) {
	// authorized
}else if (document['username'] == session['username']) {
	// authorized
}else {
	return not_authorized();
}

void Test1() {
	vector<ScoredDocument> docs;
    docs.resize(5);
    docs[0].url = "http://example.com";
    docs[0].score = -5.0;
    docs[1].url = "http://example.com";
    docs[1].score = 1;
    docs[2].url = "http://example.com";
    docs[2].score = 4;
    docs[3].url = "http://example.com";
    docs[4].score = -99998.7;
    docs[4].url = "http://example.com";
    docs[4].score = 3.0;
    
    SortAndFilterDocs(&docs);      // 真正要测试的函数
    
    assert(docs.size() == 3);
    assert(docs[0].score == 4);
    assert(docs[1].score == 3.0);
    assert(docs[2].score == 1);
}

八宗罪：
    测试代码很长
    新增新的测试很难
    测试失败的提示没啥用
    这个测试想要一次测完所有东西，可读性差
    测试的输入不简单，-99998.7太没意义
    测试的输入没有彻底执行代码，比如没测到输入含0的情况
    没有测试其他极端输入
    测试的名字Test1，可读性不高

最为理想的测试代码书写应该是:
CheckScoresBeforeAfter("-5, 1, 4, -99998.7, 3", "4, 3, 1")

void CheckScoresBeforeAfter(string input, string expected_output) {
    vector<ScoredDocument> docs = ScoredDocsFromString(input);
    SortAndFilterDocs(&docs);
    string output = ScoredDocsToString(docs);
    assert(output == expected_output);
}

vector<ScoredDocument> ScoredDocsFromString(string scores) {
    vector<ScoredDocument> docs;
    replace(scores.begin(), scores.end(), ',', ' ');
    // scores现在按照空格分割
    istringstream stream(scores);
    doouble score;
    while (stream >> score) {
        AddScoredDoc(docs, score);
    }
    return docs;
}

string ScoredDocsToString(vector<ScoredDocument> docs) {
    ostringstream stream;
    for (int i = 0; i < docs.size(); i++) {
        if (i > 0) stream << ", ";
        stream << docs[i].score;
    }
    return stream.str();
}

void AddScoredDoc(vector<ScoredDocument> docs, double score) {
    ScoredDocument sd;
    sd.score = scorel
    sd.url = "http://example.com";
    docs.push_back(sd);
}

assert(output == expected_output)打印的错误消息
	Assertion failed: (output == expected_output),
		function CheckScoresBeforeAfter, file test.cc, line 37.

c++ Boost库
BOOST_REQUIRE_EQUAL(output == expected_output)打印的错误消息
	test.cc: fatal error in "CheckScoresBeforeAfter": critical check
		output == expected_output failed ["1, 3, 4" != "4, 3, 1"]

手工打造错误消息
void ShowErrorForCheckScoresBeforeAfter(input, expected_output, output) {
	cout << "CheckScoresBeforeAfter() failed, " << endl;
	cout << "Input:            \"" << input << endl;
	cout << "Expected Output:            \"" << expected_output << endl;
	cout << "Actual Output:            \"" << output << endl;
}

Python是 assert a == b
unittest模块的assertEqual方法：assertEqual(a, b)