Oba's Google Style

为什么起这个名字呢，是突发了coding style的兴趣，于是搜了搜，整理一套自己的style。

下面先用于C++，如果要是以后新的语言C#等再说。

1. curly bracks放在同一行，这样减少行数，看起来简单。

2. function name用camel convention。

3. variable： 全局g_xxx，member in class xxx_，local用小写加underscore。

4. *和& 紧跟在symbole的前面，因为char* p1, p2//p1是指针而p2却还是char type，防止这个事情发生。

5. indentation用两个，简单方便。

6. 用空格的地方：

foo (int i); //between function name and the parenthesis

foo (int value) : data (value), next (NULL) {}

for ( int i = 0; i < s.length(); i++ ) {}

int main (int argc, char *argv []) {} //no space in empty brackets

int foo () { return 1; } //space near brackets, same Enum

return DoSomething(argument1, argument2, argument3); // No Space at function calls

7. 为了防止多余的include，forward declaration可以用。因为目前程序量不大，prefer在前面定义并实现class。

forward declaration为了防止没有被定义，从刚开始学的时候就是这样。

8. Comments放在相应的上边，短用//，长用/* */ 

9. Conditions: 如果只有一行，不用brackets。

if (condition) //no space near parenthesises
  DoSomething();  // 2 space indent.
if (condition) {
  DoSomething();  // 2 space indent.
}

10. Loop要注意每个case都配上break，一定要有default，如果empty loop body，要加{ }。

switch (var) {
  case 0: {  // 2 space indent
    ...      // 4 space indent
    break;
  }
  case 1: {
    ...
    break;
  }
  default: {
    assert(false);
  }
}

头文件里只定义，实现在分别的.cpp文件是因为防止被多个include之后太冗长。

Reference: http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Naming

PS一段改过的代码：

#include <iostream>

using namespace std;

template <class T>
class LinkedNode {
 public: 
  LinkedNode(T value) : data_(value), next_(NULL) {}
  ~LinkedNode() {}
  T getValue() const { return data_; }
  LinkedNode *getNext() const { return next_; }
  void setValue (T value) { data_ = value; }
  void setNext (LinkedNode* value) { next_ = value; }

 private:
  LinkedNode *next_;
  T           data_;
};

template<class T>//using LinkedNode as node
class LinkedList {
 public:
  LinkedList() { head_ = NULL; rear_ = NULL; }
  ~LinkedList() {
    LinkedNode<T> *delete_me = head_;
	while (delete_me) {
	  LinkedNode<T> * next = delete_me->getNext();
	  delete delete_me;
	  delete_me = next;
	}
	head_ = NULL;
	rear_ = NULL;
  }

  LinkedNode<T> *search (T target) const {
	LinkedNode<T> *link_node_ptr = head_;
	while (link_node_ptr != NULL)	{
	  if (link_node_ptr->getValue() == target) 
		return link_node_ptr;
	  else
		link_node_ptr = link_node_ptr->getNext();
	}
	return NULL;
  }  

  bool addFront (T value) {
	LinkedNode<T> *newnode = new LinkedNode<T> (value);
	//if the list is empty
	if (head_ == rear_)
	  rear_ = newnode;
	newnode->setNext(head_);
	head_ = newnode;
	return true;
  }
  
  bool addRear (T value) {
	LinkedNode<T> *newnode = new LinkedNode<T> (value);
	//if the list is empty
	if (head_ == rear_)
	  head_ = newnode;
	else
	  rear_->setNext(newnode);
	rear_ = newnode;
	return true;
  }
  
  bool deleteNode (T target) {
	LinkedNode<T> *link_node_ptr = head_;
	LinkedNode<T> *delete_this_ptr = search(target);
	if (!delete_this_ptr)
	  return false;		
	//special case if it's the head
	if (delete_this_ptr == head_) {
	  head = delete_this_ptr->getNext();
	  delete delete_this_ptr;
	  return true; 
	}
	while (link_node_ptr->getNext() != delete_this_ptr)	{
	  link_node_ptr = link_node_ptr->getNext();
	}
	link_node_ptr->setNext( delete_this_ptr->getNext() );
	delete delete_this_ptr;
	return true;
  }

 private:
  LinkedNode<T> *head_;
  LinkedNode<T> *rear_;
};