Bug's Rhapsody

一个相当牛逼的C程序

2008-06-18T04:49:00.000-07:00

/* mystery.c */
#include <stdio.h>
main(t,_,a)
char *a;
{return!0<t?t<3?main(-79,-13,a+main(-87,1-_,
main(-86, 0, a+1 )+a)):1,t<_?main(t+1, _, a ):3,main ( -94, -27+t, a
)&&t == 2 ?_<13 ?main ( 2, _+1, "%s %d %d\n" ):9:16:t<0?t<-72?main(_,
t,"@n'+,#'/*{}w+/w#cdnr/+,{}r/*de}+,/*{*+,/w{%+,/w#q#n+,/#{l,+,/n{n+\
,/+#n+,/#;#q#n+,/+k#;*+,/'r :'d*'3,}{w+K w'K:'+}e#';dq#'l q#'+d'K#!/\
+k#;q#'r}eKK#}w'r}eKK{nl]'/#;#q#n'){)#}w'){){nl]'/+#n';d}rw' i;# ){n\
l]!/n{n#'; r{#w'r nc{nl]'/#{l,+'K {rw' iK{;[{nl]'/w#q#\
n'wk nw' iwk{KK{nl]!/w{%'l##w#' i; :{nl]'/*{q#'ld;r'}{nlwb!/*de}'c\
;;{nl'-{}rw]'/+,}##'*}#nc,',#nw]'/+kd'+e}+;\
#'rdq#w! nr'/ ') }+}{rl#'{n' ')# }'+}##(!!/")
:t<-50?_==*a ?putchar(a[31]):main(-65,_,a+1):main((*a == '/')+t,_,a\
+1 ):0<t?main ( 2, 2 , "%s"):*a=='/'||main(0,main(-61,*a, "!ek;dc \
i@bK'(q)-[w]*%n+r3#l,{}:\nuwloca-O;m .vpbks,fxntdCeghiry"),a+1);}

Financial Date Algorithms

2008-02-29T09:26:00.000-08:00

Day Count Conventions

TODO:

Rolling Conventions

Firstly, given a start date and a maturity, the rolling conventions are used to determine the end date of the calculation period. Suppose today is 2007-02-28 (the last day of February), and we would like to generate a calculation period using a maturity of 6 months. The end date may be ambiguous as both 2007-08-28 and 2007-08-31 seem reasonable. In this case, the non-end-of-month convention will generate 2007-08-28, while the end-of-month convention will generate 2007-08-31.

Secondly, if the start date or end date of a calculation period falls on a non-business day, the rolling conventions are also used to adjust the dates. There are 5 adjustment conventions:

- No Adjustment: the date will not be adjusted, even if it falls on a non-business day.
- Following: the non-business date will be adjusted to the first following day that is a business day.
- Preceding: the non-business date will be adjusted to the first preceding day that is a business day.
- Modified Following: the non-business date will be adjusted to the first following day that is a business day unless that day falls in the next calendar month, in which case that date will be the first preceding day that is a business day.
- Modified Preceding: the non-business date will be adjusted to the first preceding day that is a business day unless that day falls in the previous calendar month, in which case that date will be the first following day that is a business day.

Besides, there are 2 special conventions for adjusting dates:

Two business days prior to third Wednesday of the month

This convention is related to exchange traded contracts where trading stops two business days prior to the third Wednesday of the month. For annual, semi-annual, quarterly or monthly frequencies, generated dates are adjusted to fall 2 business days prior to the third Wednesday of the month. For all other frequencies, dates are generated as usual with no adjustment. The maturity date is not adjusted.

Third Wednesday

This convention is related to exchange traded contracts where trading stops on the third Wednesday of the month. For annual, semi-annual, quarterly or monthly frequencies, generated dates are adjusted to fall on the third Wednesday of the month. For all other frequencies, dates are generated as usual with no adjustment. The maturity date is not adjusted.

Irregular Calculation Period Conventions

For financial products such as interest rate swaps, we need to generate a sequence of calculation periods. Given a start date, an end date and a frequency, there may be a remaining irregular calculation period. For example, if today (start date) is 2008-02-01, the maturity date of the swap (end date) is 2009-03-01, and the frequency is 3 months. In this case, we may use the following conventions (stubs) to determine how to generate the irregular calculation periods:

- Short Initial: generate an irregular calculation period at the beginning of the sequence, which is shorter than the frequency.
- Short Final: generate an irregular calculation period the end of the sequence, which is shorter than the frequency.
- Long Initial: generate an irregular calculation period at the beginning of the sequence, which is longer than the frequency.
- Long Final: generate an irregular calculation period at the end of the sequence, which is longer than the frequency.

References

- EURIBOR and EONIA
- BBA

The Greek Letters

2008-02-11T09:17:00.001-08:00

The Greek Letters

Each Greek letter measures a different dimension to the risk in a portfolio and the aim of a trader is to manage the Greeks so that all risks are acceptable.

Delta

The delta of a portfolio is defined as the rate of change of the portfolio price with respect to the price of the underlying asset.

The delta of a portfolio can be calculated from the deltas of the individual derivatives in the portfolio.

TODO: delta hedging.

Theta

The theta of a portfolio is the rate of change of the value of the portfolio with respect to the passage of time with all else remaining the same. Theta is sometimes referred to as the time decay of the portfolio.

Note that theta is not the same type of hedge parameter as delta. There is uncertainty about the future price of the underlying asset, but there is no certainty about the passage of time. It makes sense to hedge against changes in the price of the underlying asset, but it does not make any sense to hedge against the effect of the passage of time on a portfolio. In spite of this, many traders regard theta as a useful descriptive statistic for a portfolio. This is because in a delta-neutral portfolio, theta is a proxy of gamma.

Gamma

The gamma of a portfolio is the rate of change of the portfolio's delta with respect to the price of the underlying asset. It is the second partial derivative of the portfolio with respect to asset price.

If gamma is small, delta changes slowly, and adjustments to keep a portfolio delta-neutral need to be made only relatively infrequently. However, if gamma is large in absolute terms, delta is highly sensitive to the price of the underlying asset. It is then quite risky to leave a delta-neutral portfolio unchanged for any length of time.

TODO: gamma hedging.

Relationship Between Delta, Theta and Gamma

TODO: Who can tell me how to write mathematical formula in HTML?

Vega

The vega of a portfolio is the rate of change of the value of the portfolio with respect to the volatility of the underlying asset.

If vega is high in absolute terms, the portfolio's value is very sensitive to small changes in volatility. If vega is low in absolute terms, volatility changes have relatively little impact on the value of the portfolio.

Rho

The rho of a portfolio is the rate of change of the value of the portfolio with respect to the interest rate.

Vanilla Interest Rate Derivatives (2)

2008-01-16T05:31:00.000-08:00

Range Accrual Note (RAN)

A range accrual note (RAN) is similar to a fixed rate bond, except that interest only accrues on days when a reference rate falls within a specified range. So its payoff depends on the volatility of the reference rate: the lower the reference rate's volatility is, the higher the RAN's payoff is.

Suppose that in a RAN, the fixed rate is fix, and the reference rate is R_{ref}. The reference rate R_{ref} is observed every day during a cash flow period, and is tested against the specified range [L, U]. Define n as the number of days in the period when (L < R_{ref} < U), and N as the total number of days in the period. The payoff rate of the RAN is given by the following formula:

R_{payoff} = fix * (n / N)

If we replace the fixed rate fix by a leveraged floating rate (L * R + fix), where R is a floating rate, and the leverage L and the fixed rate fix are both constant, we can obtain a floating rate range accrual note. Its payoff rate is given by the following formula:

R_{payoff} = (L * R + fix) * (n / N)

Range Accrual Spread Note (SRAN)

In a range accrual note, if we replace the reference rate R_{ref} by a spread of two reference rates (R1 - R2), we can obtain a range accrual spread note (SRAN). In a SRAN, the condition to check is (L < R1 - R2 < U).

Dual Range Accrual Spread Note

A dual range accrual spread note is a range accrual note where the condition to check is based on two reference spreads (R11 - R12) and (R21 - R22), and two ranges [L1, U1] and [L2, U2]: ((L1 < R11 - R12 < U1) and (L2 < R21 - R22 < U2)).

Vanilla Interest Rate Derivatives (1)

2008-01-16T01:58:00.000-08:00

Function Definitions

TODO: define some functions such as min, max, bound, etc.

Interest Rate Cap, Floor and Straddle

An interest rate cap is a derivative in which the buyer receives money at the end of each cash flow period in which the specified floating rate R exceeds the agreed strike price K. An example of a cap would be an agreement to receive money for each month the LIBOR rate exceeds 2.5%.

The interest rate cap can be analyzed as a series of European call options or caplets which exists for each cash flow period the cap agreement is in existence. In formulas, the caplet rate that will be applied on the notional for a cash flow period is:

R_{payoff} = max(R - K, 0)

Where R is the underlying floating rate, and K is the cap strike.

An interest rate floor is a series of European put options or floorlets on a specified floating rate R. The buyer of the floor receives money if on the maturity of any of the floorlets, the fixed floating rate R is below the agreed strike K of the floor. In formulas, the floorlet rate that will be applied on the notional for a cash flow period is:

R_{payoff} = max(K - R, 0)

An interest rate straddle is a portfolio of an interest rate cap and an interest rate floor on the same floating rate R with the same strike K. The payoff rate of a straddle cash flow (a straddle-let) is:

R_{payoff} = max(R - K, 0) + max(K - R, 0) = abs(R - K)

An interest rate straddle can be replicated by a portfolio of an interest rate cap and an interest rate floor.

Leveraged Cap/Floor

A capped/floored floating rate is a floating rate R with an upper bound U and a lower bound L. The payoff rate of the capped/floored floating rate is:


R_{payoff} = bound(R, L, U)
           = U (if R > U), or
             R (if L <= R <= U), or
             L (if R < L)

We can re-write the formula above as the following:

R_{payoff} = R + max(L - R, 0) - max(R - U, 0)

So, the capped/floored payoff rate may be replicated using a portfolio of:

- +1 floating rate R,
- +1 floor on the floating rate R with a strike of L,
- -1 cap on the floating rate R with a strike of U.

In a capped/floored floating rate, if we replace the underlying floating rate R by a structured rate (L * R + fix), where the leverage L and the fixed rate fix are constants, we can obtain a leveraged cap/floor. The payoff rate is:

R_{payoff} = bound(L * R + fix, L, U)

The payoff rate may be replicated using a portfolio of:

- +1 leveraged floating rate R', where R' = L * R + fix,
- +1 floor on the leveraged floating rate R' with a strike of L,
- -1 cap on the leveraged floating rate R' with a strike of U.

Leveraged Spread Cap/Floor

In a capped/floored floating rate, if we replace the underlying floating rate R by a leveraged spread (L * (L1 * R1 - L2 * R2) + fix), where R1 and R2 are two floating rates (such as 3-month LIBOR and 6-month LIBOR), and the leverages L, L1, L2, and the fixed rate fix are constants, we can obtain a leveraged spread cap/floor. The payoff rate is:

R_{payoff} = bound(L * (L1 * R1 - L2 * R2) + fix, L, U)

Digit Cap/Floor

The payoff rates of a digit cap and a digit floor are defined by the following formulas:


For digit cap:
    R_{payoff} = fix (if R > K), or
                 0   (otherwise)
For digit floor:
    R_{payoff} = fix (if R < K), or
                 0   (otherwise)

By using a proper epsilon e which is small enough, we can approximately replicate a digit cap using:

- +(fix/2e) cap on the floating rate R with a strike of (K - e),
- -(fix/2e) cap on the floating rate R with a strike of (K + e).

We can approximately replicate a digit floor the same way, using:

- +(fix/2e) floor on the floating rate R with a strike of (K + e),
- -(fix/2e) floor on the floating rate R with a strike of (K - e).

Barrier Cap/Floor

There are four types of barrier cap/floor: cap-up-and-in, cap-up-and-out, floor-down-and-in, and floor-down-and-out. Their payoff rates are
defined by the following furmulas:


For cap-up-and-in:
    R_{payoff} = max(R - K, 0) (if R < B), or
                 0             (otherwise)
For cap-up-and-out:
    R_{payoff} = max(R - K, 0) (if R > B), or
                 0             (otherwise)
For floor-down-and-in:
    R_{payoff} = max(K - R, 0) (if R < B), or
                 0             (otherwise)
For floor-down-and-out:
    R_{payoff} = max(K - R, 0) (if R > B), or
                 0             (otherwise)

Where R is the floating rate, K is the strike, and B is the barrier. In a barrier cap, the barrier should be greater than the strike (B > K). In a barrier floor, the barrier should be less than the strike (B < K).

We can use the following portfolio to replicate a cap-up-and-in:

- +1 cap on the floating rate R with a strike of K,
- -1 digit cap on the floating rate R with a strike of B and a fixed rate of (B - K),
- -1 cap on the floating rate R with a strike of B.

Since a portfolio of a cap-up-and-in and a cap-up-and-out on the same floating rate R with the same strike K and the same barrier B gives the payoff of a cap on the floating rate R with the strike K, we can replicate a cap-up-and-out using the following portfolio:

- +1 cap on the floating rate R with a strike of K,
- -1 cap-up-and-in on the floating rate R with a strike of K and a barrier of B.

We can use the following portfolio to replicate a floor-down-and-out:

- +1 floor on the floating rate R with a strike of K,
- -1 digit floor on the floating rate R with a strike of B and a fixed rate of (K - B),
- -1 floor on the floating rate R with a strike of B.

And the following portfolio to replicate a floor-down-and-in:

- +1 floor on the floating rate R with a strike of K,
- -1 floor-down-and-out on the floating rate R with a strike of K and a barrier of B.

Boost Tokenizer笔记

2008-01-08T08:41:00.000-08:00

Boost Tokenizer模板类

先看boost::tokenizer模板类的声明：

// boost::tokenizer template class.
template<
  class TokenizerFunc = char_delimiters_separator<char>,
  class Iterator = std::string::const_iterator,
  class Type = std::string
> class tokenizer;

boost::tokenizer模板类的第一个模板参数TokenizerFunc是一个方法对象，用于对序列进行语法分析，以寻找token。第二个模板参数Iterator定义了被分析的序列的iterator类型。第三个模板参数Type定义了序列容器的类型。默认情况下，boost::tokenizer用于分析字符串序列，所以Iterator的默认类型是std::string::const_iterator，而Type的默认类型是std::string。

TokenizerFunc

根据Boost Tokenizer的文档：TokenizerFunc是一个方法对象（functor），它的作用是对一个给定的序列进行语法分析，直到找到了一个token为止，或者直到序列结束为止。

A TokenizerFunction is a functor whose purpose is to parse a given sequence until exactly 1 token has been found or the end is reached. It then updates the token, and informs the caller of the location in the sequence of the next element immediately after the last element of the sequence that was parsed for the current token.

TODO: How to implement a customized tokenizer func?

Boost Tokenizer库中提供了三个实现好的TokenizerFunc：

- escaped_list_separator
- offset_separator
- char_delimiters_separator

Char Delimiters Separator

boost::char_delimiters_separator使用单个字符作为token的分隔符。分隔符分为两类：返回型分隔符和非返回型分隔符。以下解释这两类分隔符的区别。

假设我们需要tokenize一个用于表示方程组的字符串，如下：

x + y = 100; x-y=10;

我们希望获得的token是：

token[0] = "x"
token[1] = "+"
token[2] = "y"
token[3] = "="
token[4] = "100"
token[5] = "x"
token[6] = "-"
token[7] = "y"
token[8] = "="
token[9] = "10"

在这种情况下，字符';'和空格字符的作用仅仅是分隔token，它们本身并不是token，因此它们是非返回型分隔符，不会被tokenizer作为一个token返回；而字符'+'，'-'和'='的作用不仅是分隔token，它们本身也是token，因此它们属于返回型分隔符，会被tokenizer作为一个token返回。

boost::char_delimiters_separator的构造函数声明如下：

// boost::char_delimiters_separator template class.
template<class Char, class Traits = std::char_traits<Char> >
class char_delimiters_separator {
public:
  // ...
  explicit char_delimiters_separator(
      bool return_delims = false,
      const Char* returnable = "",
      const Char* nonreturnable = "");
  //...
};

第一个参数return_delims决定了是否某些分隔符可以作为token被返回，注意它的默认值是false。第二个参数returnable定义了一组返回型的分隔符，注意仅当第一个参数的值为true时，这些返回型的分隔符才会被作为token返回。第三个参数nonreturnable定义了一组非返回型的分隔符。

以下代码使用了boost::tokenizer来分析上述表示方程组的字符串，并获得我们期望的结果：


#include <boost/tokenizer.hpp>
#include <string>
#include <iostream>

int main(int, char**) {
  typedef boost::char_delimiters_separator<char> separator;
  typedef boost::tokenizer<Separator>            tokenizer;
  std::string str = "x + y = 100; x-y=10;";
  separator sep(true, "+-=", " ;");
  tokenizer tok(str, sep);
  unsigned int count = 0;
  for (tokenizer::iterator i = tok.begin();
                           i != tok.end();
                           ++i, ++count) {
    std::cout << "token[" << count << "] = "
              << (*i) << std::endl;
  }
  return 0;
}

TODO: How to use escaped_list_separator and offset_separator?

Pimpl的const成员函数

2008-01-05T05:36:00.000-08:00

先给一个pimpl的例子：

////////////////////////////////////////////////////////////
// person.hpp: pimpl class header file.
//

#include <string>

class person {

public:
  explicit person();
  ~person();
  const std::string& first_name() const;
  const std::string& last_name() const;
  void set_name(const std::string& first_name,
                const std::string& last_name);

private:
  struct impl;  // forward declaration.
  impl* pimpl_; // pointer to impl.
}; // class person

////////////////////////////////////////////////////////////
// person.cpp: pimpl class source file.
//

#include "person.hpp"
#include <string>

struct person::impl {
  std::string first_name_;
  std::string last_name_;
  explicit impl(): first_name_(), last_name() {
    // Do nothing.
  }
};

person::person(): pimpl_(new impl()) {
  // Do nothing.
}

person::~person() {
  delete pimpl_;
}

const std::string& person::first_name() const {
  return pimpl_->first_name_;
}

const std::string& person::last_name() const {
  return pimpl_->last_name_;
}

void person::set_name(const std::string& first_name,
                      const std::string& last_name) {
  pimpl_->first_name_ = first_name;
  pimpl_->last_name_  = last_name;
}

注意person类的两个const成员函数first_name()和last_name()，因为被标记为const，所以这两个成员函数应该不能修改person对象的内部状态。

在C++中，每一个成员函数都拥有一个隐含的参数，即指向对象的this指针。对于一个const成员函数，this是一个被const了的指针。在没有使用pimpl的时候，如果我们试图（通过const的this指针）修改对象的状态，将产生一个编译错误。在这种情况下，编译器很体贴地帮我们保证了const成员函数语义的正确性。

可是注意，当我们使用了pimpl的时候，我们就失去了编译器这样的关怀。假设我们这样实现first_name()成员函数：

// Const member function is no longer that "const"...
const std::string& person::first_name() const {
  pimpl_->first_name_ = "Whatever"; // Note this assignment!
  return pimpl_->first_name_;
}

这段代码可以很顺利地通过编译，连一个警告都不会有。为什么？因为对于一个指向const person类型的this指针，它const的其实是pimpl_指针的地址，而不是pimpl_所指向的那个对象。也就是说，编译器只能帮我们保证在实现person的const成员函数的时候无法修改pimpl_的地址值，却无法为我们保证我们不去修改pimpl_所指向的person::impl对象的内容。

失去了编译器的检查，就增加了我们写出语义错误的代码的可能性。对此，我们可以通过如下的规范来重新获得编译器的这种关怀。

第一，在person.hpp头文件中为person类增加两个private成员函数，如下：

////////////////////////////////////////////////////////////
// person.hpp: pimpl class header file.
//

class person {

  // ...

private:
  struct impl; // forward declaration.
  const impl* pimpl() const {
    return pimpl_;
  }
  impl* pimpl() {
    return pimpl_;
  }
  impl* pimpl_;
};

第二，在实现person的成员函数时，每当我们需要使用pimpl_指针，总是通过调用pimpl()成员函数来获得：

////////////////////////////////////////////////////////////
// person.cpp: pimpl class source file.
//

// ...

const std::string& person::first_name() const {
  // Won't compile any more if we keep using pimpl().
  // pimpl()->first_name_ = "Whatever";
  return pimpl()->first_name_;
}

const std::string& person::last_name() const {
  return pimpl()->last_name_;
}

void person::set_name(const std::string& first_name,
                      const std::string& last_name) {
  pimpl()->first_name_ = first_name;
  pimpl()->last_name_  = last_name;
}

Boost Multi-index笔记

2008-01-02T05:50:00.000-08:00

Boost Multi-index介绍

注意： 为了在MSVC7.1下顺利编译boost multi-index，需要关掉/Gm选项（C/C++ | Code Generation | Enable Minimal Rebuild）。否则可能会产生Buffer Overrun错误。详情请参考Boost Multi-index文档。

不同的STL容器用不同的方法来管理自己的元素，提供不同的访问元素的方法。比如，std::set通过一个比较函数来为元素排序，std::list则允许用户自由地制定插入元素的位置。某些情况下，对于同一个元素集合，用户会希望拥有不同的访问接口，这有点类似于MVC模式中的Model和View：同一个Model拥有不同的View。Boost multi-index就是用来满足这样的需求的。

举例说明。比如我创建了一个Employee类来为公司员工建模：

#include <string>
#include <iostream>

//! The employee class...
class employee {

public:

  //! Default constructor.
  explicit employee(): id_(), email_(), name_() {
    // Do nothing.
  }

  explicit employee(const std::string& id,
                    const std::string& email,
                    const std::string& name)
  : id_(id), email_(email), name_(name) {
    // Do nothing.
  }

  // Use auto-generated copy constructor.
  // Use auto-generated copy assignment.
  // Use auto-generated destructor.

  bool operator<(const employee& rhs) const {
    return (id_ < rhs.id_);
  }

public:

  std::string id_;    // Unique ID.
  std::string email_; // Unique email address.
  std::string name_;  // Name.

}; // class employee

//! Writes an employee information to the output stream.
std::ostream& operator<<(std::ostream& os,
                         const employee& e) {
  os << "Employee #" << e.id_
     << " : " << e.name_
     << " ( " << e.email_ << " ) ";
  return os;
}

//! Compares two employees by their names.
struct comp_name {
  // TODO:
};

我希望拥有一个员工对象的集合，该集合提供了以下几种不同的访问员工对象的方式：

- 按照元素插入的顺序提供顺序访问（类似std::list）。
- 按照employee自己的比较函数（比较id_）排序，提供顺序访问（类似std::set）。
- 按照name_排序（使用CompName比较函数），提供顺序访问（类似std::set）。
- 以id_为key访问对象（类似std::map）。
- 以email_为key访问对象（类似std::map）。

容器的模型和视图

Boost multi-index中的容器模型使用boost::multi_index::multi_index_container模板类来描述，而与容器模型相联系的每个视图都由一个index类型来描述。Index类型可以被划分为以下两大类：

- Unique：不允许出现拥有相同键值的两个或多个元素。
- Non-unique：允许两个或多个元素拥有相同的键值。

对应于以上的需求，可以这样定义容器的模型：

namespace bmi = boost::multi_index; // namespace alias

//! Typedef of the multi-index container model.
typedef bmi::multi_index_container<
  employee,        // the element type...
  bmi::indexed_by< // views for this container...
    // index #0: sequenced
    bmi::sequenced<>,
    // index #1: sort by employee::operator<
    bmi::ordered_unique<bmi::identity<employee> >,
    // index #2: sort by std::less<std::string> on name_
    bmi::ordered_non_unique<
      bmi::member<employee,
                  std::string,
                  &employee::name_> >
  > // end of bmi::indexed_by
> employee_set;

对于一个employee_set容器，可以通过指定下标的方法获得不同的index视图：

//! Typedef of the sequenced index.
typedef employee_set::nth_index<0>::type sequenced_index;

//! Typedef of the built-in less-than index.
typedef employee_set::nth_index<1>::type less_than_index;

//! Typedef of the name index.
typedef employee_set::nth_index<2>::type name_index;

//! Returns the sequenced index of the underlying set.
sequenced_index& get_sequenced_index(employee_set& es) {
  return es.get<0>(); // index #0
}

//! Returns the less-than index of the underlying set.
less_than_index& get_less_than_index(employee_set& es) {
  return es.get<1>(); // index #1
}

//! Returns the name index of the underlying set.
name_index& get_name_index(employee_set& es) {
  return es.get<2>(); // index #2
}

注意：容器模型的视图需要通过引用传递，而不可以通过值拷贝。

使用Tag来标记Index

容器模型自身的成员函数

通过Index插入元素的方法

通过Index遍历元素的方法

每个一个index视图（sequenced_index，less_than_index和name_index）都提供自己的iterator和const_iterator类型，它们按照各个视图所定义的顺序来遍历容器中的元素。以下代码演示了如何通过index的const_iterator来遍历容器中的元素：

//! Iterates through all employees.
template<class Index>
void write_by(const Index& index) {
  for (Index::const_iterator i = index.begin();
                             i != index.end(); ++i) {
    std::cout << (*i) << std::endl;
  }
}

//! Iterates through all employees using different index.
void test_index_iterators() {
  // Populate employees to the container.
  employee_set es = ...;
  // Iterate through employees using different index.
  write_by(get_sequenced_index(es));
  write_by(get_less_than_index(es));
  write_by(get_name_index(es));
}

为什么没有index提供std::vector那样的[]操作符和at()函数？在没有读过boost multi-index源代码的情况下，我的理解是：在STL中，std::vector是一种很特殊的容器，它是唯一一个使用连续内存存储元素的容器（所以它可以和C语言中的数组兼容）。由于它的这种实现方法，使得[]操作符和at()函数的实现可以非常高效。而对于任何一种其它的STL容器而言，这种随机存取的方法实现起来都太昂贵了。Boost multi-index中的容器应该没有使用连续内存来存储元素，所以它也不会提供这种随机存取元素的方法。

通过Index查找元素的方法

TODO:

- How to insert elements.
- How to look up elements (find).
- How to tag an index.
- Common functions in multi_index_container.
- How to use customized comparator.
- identity: should operator equals (==) be implemented?

C++ Coding Conventions

2007-11-28T07:39:00.001-08:00

It is easier to write an incorrect program than understand a correct one.
-- Alan J. Perlis

Contents

0. Preface
1. Indentation
2. Comments
3. Naming Conventions
4. The End

0. Preface

How Strict Are These Standards

The goal of this document is to define a set of coding conventions that may help developers write human-readable C++ code. The conventions may be classified into the following 3 categories:

1. Must and must not: these are important rules that must be strictly respected without exception.
2. Should and should not: these are also important rules. They are usually the right (or wrong) way. Developers should try their best to respect them unless they really have a good reason.
3. Alternatives: all alternatives listed in this document are acceptable. Developers may choose one of them to apply.

Basic Rules

1. All should be as understandable as possible.
2. All should be as readable as possible, except when it would conflict with the previous rule.
3. All should be as simple as possible, except when it would conflict with the previous rules.

1. Indentation

Line Length

Developers must not write lines longer than 120 characters. They should keep their lines shorter than 100 or 80 charaters. Moving the bottom scrollbar hundreds of times when reading a source file is never a pleasant experience.

Indentation

Developers must indent their code. How many spaces should be used as the unit of indentation is not enforced, but developers must keep the indentation consistent at least within one file. They should use 4 spaces as the unit of indentation (which is most widely accepted as a convention). They should use blank spaces instead of tabs (which may be 4 spaces or 8 spaces, depending on the IDE settings).

Wrapping Lines

When an expression will not fit on a single line, developers should break it into multiple lines according to these general principles:

1. Break after a comma.
2. Break before an operator.
3. Prefer higher-level breaks to lower-level breaks.
4. Align the new line with the beginning of the expression at the same level on the previous line.
5. If the above rules lead to confusing code or to code that's squished up against the right margin, just indent 8 spaces instead.

Examples of breaking function calls:

// Align the function parameters at the same level.
my_function(long_expression_1,
            long_expression_2,
            long_expression_3,
            long_expression_4,
            long_expression_5);
// Indent 8 spaces for the first function call to avoid
// very deep indents, and align the parameters of the
// second function at the same level.
var = my_first_function(
        long_expression_1,
        my_second_function(long_expression_2,
                           long_expression_3));

Examples of breaking an arithmetic expression:

// Prefer higher-level breaks to lower-level breaks, and
// align the new line with the beginning of the expression
// at the same level on the previous line.
long_name_1 = long_name_2 * (long_name_3 + long_name_4)
            + 4 * long_name_5;

Examples of long function declarations.

// Align the function parameters at the same level.
void my_function(int first_param,
                 my_type another_param,
                 const std::string& yet_another,
                 const my_second_type* and_still_another);
// Indent 8 spaces to avoid very deep indents.
std::string my_function_with_a_terriblly_long_name(
        int first_param,
        my_type another_param,
        const std::string& yet_another,
        const my_second_type* and_still_another);

Examples of class/function declarations with templates:

// Align the class template parameters at the same level.
template <typename SomeType,
          typename AnotherType,
          typename YetAnotherType,
          typename AndStillAnother>
class my_class_template {
    // ...
};

Blank Spaces

Binary operators should be separated from their operands by spaces. Unary operators, such as unary minus, increment (++), and decrement (--), should not be separated from their operands. Examples:


a = (a + b) / (c * d);a += c + d;a++;
std::cout << "size is " << size << std::endl;

When declaring or calling a function with multiple parameters, developers must use a blank space to separate the parameters. Examples:

my_function(param_1, param_2, param_3);

2. Comments

Developers should use // ... instead of /* ... */ when commenting their code. This makes it easier to comment out a block of code when debugging.

Developers must write doxygen comments for public APIs (classes, functions, enumerations, typedefs, etc.) that are easy to be misused. Developers should write doxygen comments whenever necessary. The doxygen comment format is not enforced.

For more information about doxygen, check the doxygen project website at http://www.doxygen.org/

Examples of one recommended doxygen comment style:


//! Documentation of this class: what does this class
//! modelize; how should this class be used, etc.
class some_class {

public:

    //! Documentation of this function. Don't write comment
    //! to repeat code. Write something that helps the users
    //! better understand how to use this function correctly.
    //! \param param_1  description of the first parameter.
    //! \param param_2  description of the second parameter.
    //! \return describe the return value.
    //! \throws first_exception   describe when the first
    //!         exception will be thrown out.
    //! \throws second_exception  describe when the second
    //!         exception will be thrown out.
    int my_func(int param_1, const& std::string param_2);

private:

    int member1_; //!< Description of the first member.
    int member2_; //!< Description of the second member.
    
    //! If the description of this member is enough to
    //! occupy multiple lines, then this form of comment is
    //! also perfectly acceptable.
    int member3_;

}; // class some_class

3. Naming Conventions

First of all, some general guidelines for names:

1. All names (class names, identifier names, etc.), as well as the rest of the code and comments, must be written in English.
2. All user-defined names must not start with an underscore. Some underscored names are reserved by the compiler. Using such kind of names may have potential danger of name conflicts.
3. Do NOT use Hungarian notation in C++.

underscored_names and CamelCase

The following styles are commonly used to write a name consisting of compounded words or phrases:

- write_all_words_in_lower_case_and_join_them_using_underscores.
- IndicateWordBoundariesUsingCapitalization. This style has two variants: lowerCamelCase and UpperCamelCase.

The STL/boost style uses underscored_names, while the Java style and Microsoft style use CamelCase heavily. All these styles are acceptable, but developers must keep the naming convention consistent at least within one project.

Namespaces

To name a namespace:

- STL/boost style uses underscored_names.
- Java style uses lowerCamelCase.
- Microsoft style uses UpperCamelCase.

Type Names

Types define the classification of variables. A type may be an enumeration, a typedef, a class, or a struct. To name a type:

- STL/boost style uses underscored_names.
- both Java style and Microsoft style use UpperCamelCase.

Function Names

To name a function (at global level or at class level):

- STL/boost style uses underscored_names.
- Java style uses lowerCamelCase.
- Microsoft style uses UpperCamelCase.

Identifier Names

To name a variable or a function parameter:

- STL/boost style uses underscored_names.
- both Java style and Microsoft style use lowerCamelCase.

Variables, except when inside a loop, must not be named using a single character. Variables inside a loop may be named as i, j, k, m, or n.

Some additional conventions should be applied to name a member variable within a class or a struct:

- add an 'm_' prefix for non-static member variables, and add an 's_' prefix for static member variables.
- add an underscore suffix for all member variables (static or non-static).

Both the two alternatives are acceptable, but the convention must be consistent within one project.

Template Parameter Names

Developers must use UpperCamelCase to name template parameters. It is recommended that developers use pithy (single charactoer if possible) yet evocative names for template parameter names.

Constants and Macros

Constants and macros must be named using UPPER_CASES_WITH_UNDERSCORES. In addition, all macros within a project must be prefixed by the project's name and an underscore. It is recommended that guard macros (which prevent recursive inclusion of header files) be named using the pattern <PROJECT_NAME>_<HEADER_FILE_NAME>_<CREATED_DATE>__. This pattern helps distinguish guard macros from other macros.

Examples

STL/boost style:

// my_zoo.hpp: STL/boost style
#ifndef MYPROJ_MY_ZOO_HPP_20071128__
#define MYPROJ_MY_ZOO_HPP_20071128__

#define MYPROJ_LOGGING_ENABLED 1

namespace my_proj {

    typedef enum {
        tigar,
        elephant,
        lion,
        monkey,
    } animal_race;

    class animal {

    public:
        explicit animal(const std::string& name);
        virtual ~animal() = 0;
        const std::string& name() const;
        animal_race race() const;
        virtual void eat() = 0;

    private:
        std::string name_;
        animal_race race_;

    }; // class animal

    class my_zoo {

        typedef std::map<std::string, animal*> container_type;

    public:

        explicit my_zoo();
        void add(animal* the_animal);

        template<class T>
        T* find(const std::string& name) {
            animal* the_animal = find_animal(name);
            return dynamic_cast<T*>(the_animal);
        }

    private:

        animal* find_animal(const std::string& name);

    private:

        container_type animals_in_zoo_;

    }; // class my_zoo

} // namespace my_proj

#endif // MYPROJ_MY_ZOO_HPP_20071128__

Java style:

// MyZoo.hpp: Java style
#ifndef MYPROJ_MY_ZOO_HPP_20071128__
#define MYPROJ_MY_ZOO_HPP_20071128__

#define MYPROJ_LOGGING_ENABLED 1

namespace myProj {

    typedef enum {
        TIGAR,
        ELEPHANT,
        LION,
        MONKEY,
    } AnimalRace;

    class Animal {

    public:
        explicit Animal(const std::string& name);
        virtual ~Animal() = 0;
        const std::string& getName() const;
        AnimalRace getRace() const;
        virtual void eat() = 0;

    private:
        std::string name_;
        AnimalRace  race_;

    }; // class Animal

    class MyZoo {

        typedef std::map<std::string, Animal*> ContainerType;

    public:

        explicit MyZoo();
        void add(Animal* animal);

        template<class T>
        T* find(const std::string& name) {
            Animal* animal = findAnimal(name);
            return dynamic_cast<T*>(animal);
        }

    private:

        Animal* findAnimal(const std::string& name);

    private:

        ContainerType animalsInZoo_;

    }; // class MyZoo

} // namespace myProj

#endif // MYPROJ_MY_ZOO_HPP_20071128__

Microsoft style:

// MyZoo.hpp: Microsoft style
#ifndef MYPROJ_MY_ZOO_HPP_20071128__
#define MYPROJ_MY_ZOO_HPP_20071128__

#define MYPROJ_LOGGING_ENABLED 1

namespace MyProj {

    typedef enum {
        TIGAR,
        ELEPHANT,
        LION,
        MONKEY,
    } AnimalRace;

    class Animal {

    public:
        explicit Animal(const std::string& name);
        virtual ~Animal() = 0;
        const std::string& GetName() const;
        AnimalRace GetRace() const;
        virtual void Eat() = 0;

    private:
        std::string name_;
        AnimalRace  race_;
    }; // class Animal

    class MyZoo {

        typedef std::map<std::string, Animal*> ContainerType;

    public:

        explicit MyZoo();
        void Add(Animal* animal);

        template<class T>
        T* Find(const std::string& name) {
            Animal* animal = FindAnimal(name);
            return dynamic_cast<T*>(animal);
        }

    private:

        Animal* FindAnimal(const std::string& name);

    private:

        ContainerType animalsInZoo_;

    }; // class MyZoo

} // namespace MyProj

#endif // MYPROJ_MY_ZOO_HPP_20071128__

Personally, I prefere the STL/boost style. Because I use heavily STL and boost in my projects, using the same convention makes my code look consistent.

4. The End

这份文档的第一个版本是我2006年6月刚到新公司的时候奉命起草的。那个时候我刚刚离开Java阵营，还拥有一个Java程序员应有的循规蹈距。一年半以后的今天当我重看这份文档的时候，我早已习惯了C++的放荡，因此对文档中的很多限制连我自己都觉得不爽。Java程序员是一群忠厚老实的家犬，而C++程序员却是一群桀骜不驯的野猫。这是一份修改过的版本，贴在这里纪念我由狗到猫的转变。

Rendering Test / 渲染测试

2006-11-21T11:39:00.001-08:00

This post is for rendering test...

Test Fonts

Bold/粗体, typewriter/等宽字体, italic/斜体, big/大一点的字体 and small/小一点的字体.

测试一下中文

归去来兮，田园将芜胡不归！既自以心为形役，奚惆怅而独悲。悟已往之不谏，知来者之可追。实迷途其未远，觉今是而昨非。

舟遥遥以轻飏，风飘飘而吹衣。问征夫以前路。恨晨光之熹微。乃瞻衡宇，载欣载奔。僮仆欢迎，稚子候门。三经就荒，松菊犹存。携幼入室，有酒盈樽。引壶觞以自酌，眄庭柯以怡颜。倚南窗以寄傲，审容膝之易安。园日涉以成趣，门虽庙而常关。策扶老以流憩，时矫首而遐观。云无心以出岫，鸟倦飞而知还。景翳翳以将入，抚孤松而盘桓。

归去来兮，请息交以绝游。世与我而相违，复驾言兮焉求！悦亲戚之情话，乐琴书以消忧。农人告余以春及，将有事于西畴。或命巾车，或棹孤舟。既窈窕以寻壑，亦崎岖而经丘。木欣欣以向荣，泉涓涓而始流。善万物之得时，感吾生之行休。

已矣乎，寓形宇内复几时，曷不委心任去留，胡为乎遑遑欲何之？富贵非吾愿，帝乡不可期。怀良辰以孤往，或植杖而耘籽。登东皋以舒啸，临清流而赋诗。聊乘化以归尽，乐夫天命复奚疑！

-- 陶潜

Hello, World!

From Wikipedia, the free encyclopedia.

A "hello world" program is a computer program that prints out "Hello, world!" on a display device. It is used in many introductory tutorials for teaching a programming language. Such a program is typically one of the simplest programs possible in a computer language. Some are surprisingly complex, especially in some graphical user interface (GUI) contexts, but most are very simple, especially those which rely heavily on a particular command line interpreter ("shell") to perform the actual output.

While small test programs existed since the development of programmable computers, the tradition of using the phrase "Hello world!" as a test message was influenced by an example program in the book The C Programming Language. The example program from that book prints "hello, world" (without capital letters or exclamation mark), and was inherited from a 1974 Bell Laboratories internal memorandum by Brian Kernighan, Programming in C: A Tutorial, which contains the first known version:

/* hello world in C */
main() {
  printf("hello, world");
}

Hello World in C++, Python and Java

The following source code fragments are highlighted by Google Code Prettify.

The C++ version:

// hello world in C++
#include <iostream>
int main(int, char**) {
  std::cout << "hello, world" << std::endl;
  return 0;
}

The Python version:

#!/usr/bin/env python
# hello world in Python

def main():
  print 'hello, world'

if __name__ == '__main__':
  main()

The Java version:

// hello world in Java
public class HelloWorld {
  public static void main(String[] args) {
    System.out.println("hello, world");
  }
}

Test Image