c++,要细心不能想当然

c++,要细心不能想当然

两段想当然写下的代码，你看出问题了吧

1  class  Data;
2  Data *  FindData();
3  void  GetData(Data *  dataPtr)
4  {
5      dataPtr = FindData();
6  }
7  Data *  data = NULL;
8  GetData(data);
9  data -> somefunction();

第二段代码，更得仔细点

 1  class  A;
 2  class  B;
 3  A  const   *  GetA();
 4  B  const   *  GetB();
 5  template < typename T >
 6  int  GetSpecialValue(T *  classPtr)
 7  {
 8      return    3721 ;
 9  }
10 
11  template <>
12  int  GetSpecialValue <> (A *  classPtr)
13  {
14      return    37 ;
15  }
16  template <>
17  int  GetSpecialValue <> (B *  classPtr)
18  {
19      return   21 ;
20  }
21  A  const   *  classPtr = GetA();
22  int  ret = GetSpecialValue(classPtr);
23  cout << ret << endl;  // out 3721! why not 37?
24 
25 
26 

第一段的问题在于看到指针想当然认为是地址，data 可以带回反回值，其实因为这里是值传递，实参data把自己的值赋给了dataPtr,dataPtr后来确实从FindData()得到了想要的值，但这对一点影响也没有，所以函数返回时，data的值没有发生变化，也就是没有带回想要的值。
只要不想当然，仔细一想就明白了，解决办法很简单：

1    void  GetData(Data *&  dataPtr)
2  4  {
3  5      dataPtr = FindData();
4  6  }

第二段的问题是没有注意到那个const, T*  和 T const* 是不一样的，不能完全匹配，所以不会找到对A类型的特化版本,解决办法可以这样：

 1  template < typename T >
 2  int  GetSpecialValue(T  const *  classPtr)
 3  {
 4      return    3721 ;
 5  }
 6 
 7  template <>
 8  int  GetSpecialValue <> (A  const *  classPtr)
 9  {
10      return    37 ;
11  }
12  template <>
13  int  GetSpecialValue <> (B  const *  classPtr)
14  {
15      return   21 ;
16  }

能过这两个小例子就可以知道，C++细节很多，要仔细，不能想当然。