请阅读该文档(http://www.boost.org/doc/libs/1_49_0/libs/smart_ptr/shared_ptr.htm)，回答以下问题：

1. boost::shared_ptr能存放数组指针吗？如果不能，应该使用什么？
2. 与std::auto_ptr相比，boost::shared_ptr有什么优势？
3. 对于一般指针的dynamic_cast，boost::shared_ptr应该怎么cast？
4. 什么情况下使用shared_from_this?
5. 如何获取shared_ptr中保存的具体对象的指针？
6. 如果要释放某shared_ptr对指针的引用，应该怎么操作？
7. 什么情况使用weak_ptr?
8. shared_ptr怎么管理file, MYSQL_RES, CURL等资源？

智能指针

为了避免

1. 遗忘释放内存、资源
2. 中途return，需要多处调用释放内存，资源
3. 放到容器中的指针，错误释放内存，资源

我们写c++程序时，都使用智能指针来帮助管理内存和资源。c++不是c，提供的便捷要利用起来：

不使用任何明确的delete语句

熟悉并熟练使用 std::auto_ptr, boost::shared_ptr, boost::shared_array, boost::scoped_ptr, boost::scoped_array

Don’t

动态分配内存，不要使用以下方法. 因为 1 处会抛出异常造成delete无法释放。

int n = 100;
char *p = new char[n];
....// 1: 使用p
delete []p;

Do

使用以下任一方法分配、管理内存

int n = 100;
std::vector v;
v.resize(n);
....// 使用 &v.at(0)或者&v[0], 与上面的p等价
// 不需要调用delete[]

或者

int n = 100;
boost::shared_array p(new char[n]); // 或者使用boost::scoped_array
// 不需要调用delete[]

不要直接调用系统锁资源和解锁资源

使用以下方法管理mutex

void foo(const char* fileName)
{
  boost::unique_lock lock(gMutex);
  // 竞争区域的代码
  return;
}

不要直接调用close, fclose, mysql_close, mysql_free_result, curl_easy_cleanup这些方关闭文件、数据库等资源的方法

Don’t

打开文件，关闭文件，不要使用以下方法. 因为 2 处会抛出异常造成fclose无法释放。

FILE *file = fopen(filename, "rb");
// 2, 使用 file
fclose(file);

Do

使用以下方法管理文件指针

struct CFileCloser{
  void operator ()(FILE* file){
    if (file) fclose(file);
  }
};

void foo(const char* fileName)
{
  boost::shared_ptr backgroundFile(fopen(fileName, "rb"), CFileCloser());
}

使用以下方法管理MYSQL_RES

boost::shared_ptr
    resultSp(mysql_store_result(&mysql_), mysql_free_result);

if (!resultSp) {
    LOG4CXX_ERROR(gLogger, "error in mysql connection: " << mysql_error(&mysql_));
    return false;
}

boost::uint64_t numRows = mysql_num_rows(resultSp.get());
MYSQL_ROW row = mysql_fetch_row(resultSp.get());

使用以下方法管理CURL

bool performUrl(const std::string url, std::string& result)
{
        std::stringstream oss;

        CURL* curl = curl_easy_init();
        boost::shared_ptr  pointer(curl, curl_easy_cleanup);
        if(curl)
        {
                curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
                curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1);
                curl_easy_setopt(curl, CURLOPT_TIMEOUT, 1);
                curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writeData);
                curl_easy_setopt(curl, CURLOPT_WRITEDATA, &oss);
                curl_easy_perform(curl);

                result = oss.str();
                return true;
        }
        return false;
}

换掉一些可能造成crash的不安全函数

使用std::ostringstream或者snprintf代替sprintf

  std::ostringstream oss;
  oss << DaemonConfig::disconnectNotifyURL << "?id=" << playerId;

逆序输出字符串

普通程序员

#include <iostream>
using namespace std;
char *str = "n!dlrow olleh";

int main (int argc, char** argv) {
  for(char *p = str + strlen(str); p >= str; p--){
    cout << *p;
  }
  return 0;
}

文艺程序员

#include <iostream>
#include <iterator>
#include <algorithm>

using namespace std;

static char *str = "n!dlrow olleh";

int main (int argc, char** argv) {
  reverse_copy(str, str + strlen(str) + 1, 
    ostream_iterator<char>(cout, ""));
  return EXIT_SUCCESS;
}

2B程序员

#include <iostream.h>

static char *str = "n!dlrow olleh";

int main () {
  char *p = str + strlen(str);
  putchar(*(p--));
  putchar(*(p--));
  putchar(*(p--));
  putchar(*(p--));
  putchar(*(p--));
  putchar(*(p--));
  putchar(*(p--));
  putchar(*(p--));
  putchar(*(p--));
  putchar(*(p--));
  putchar(*(p--));
  putchar(*(p--));
  putchar(*(p--));
  putchar(*(p--));
}

失足程序员

#include <iostream>
using namespace std;

const char str[] = "n!dlrow olleh";

template< int N >
struct Printer{
    void operator()(){
        cout << *(str + N);
    }
};

template< template < int > class C, int N >
struct Rev{
    Rev(){
        C< N >()();
        Rev< C, N - 1>();
    }
};

template< template < int > class C >
struct Rev<C, 0>{
    Rev(){
        C< 0 >()();
    }
};

template <int N>
int len_trait(const char (&)[N])
{
    static Rev< Printer, N > rev;
    return 0;
}

static int dummy = len_trait(str);

int main(int argc, char** argv)
{
    return EXIT_SUCCESS;
}