当心编译器生成的隐含成员函数

楼主^#

更多发布于：2004-05-10 22:45

“听说最近新开了家超市？”
　　“是啊，我去过了，什么都没有！”
　　“真的？什么都没有？”
　　“我骗你干什么！只有些牙膏、牙刷、洗衣粉……真的什么都没有。”
　　习以为常的东西总是容易被忽略。在生活中我们可以对这些经常见到的东西视而不见，但在代码中千万不要这样作。
　　问题：下面这个类有几个成员函数？
 class X
 {
 int value;
 };
　　“这么简单的问题还问！我当然知道，编译器会为没有构造函数的类生成一个缺省构造函数，为没有拷贝构造函数的类生成一个拷贝构造函数，为没有析构函数的类生成一个析构函数，为没有拷贝赋值操作符的类生成一个拷贝赋值操作符，所以它有四个隐含成员函数。”
　　是的，回答是正确的，但仅限于知道是不行的，必须把它牢牢的记住，直到你一看到这个定义眼前就能浮现出下面的定义：
 class X
 {
 int Value;
 public:
 X();
 X(const X;);
 X; operator = (const X;);
 ~X();
 };
　　为什么这样说呢？因为尽管在回答上面的问题时大家都能答对，但在实际应用时却常常把它忽略掉。让我们看一个例子：
　　比如我们要实现一个“智能指针”（什么类型的？什么类型都行，这与本题无关），这，通常都会这样写：
　　template <typename T>
 smart_ptr...
　　现在我们要为它写一个拷贝构造函数和一个拷贝赋值操作符……等一下。
　　我们这个智能指针是为了在某一应用范围内代替指针的，我们应该让它支持指针的一些特性，如自动类型转换的初始化（拷贝构造）和赋值。而类模板和真正的指针是不一样的，即使一个Derived*是一个Base*，但一个smart_ptr<Derived>却不是一个smart_ptr<Base>，从smart_ptr<Derived>到smart_ptr<Base>的转换不是编译器自动支持的，我们必须为它写一些代码来做这件事。该怎么做呢？很简单：
 template <typename T>
 smart_ptr
 {
 T* ptr_data;
 public:
 T* get_ptr();
 template<typename U>
 smart_ptr(const smart_ptr ; Source)
 {
 ptr_data = Source.get_ptr();
 //其它处理
 }
 template<typename U>
 smart_ptr<T> ; operator = (const smart_ptr ; Source)
 {
 ptr_data = Source.get_ptr();
 //其它处理
 } 
 };
　　这样当我们用smart_ptr<Derived>初始化smart_ptr<Base>的时候，编译器会自动为smart_ptr<Base>类生成一个参数为const smart_ptr<Derived>; 的构造函数，用smart_ptr<Derived>::get_ptr()的返回值（类型为Derived*）初始化smart_ptr<Base>::ptr_data（类型为Base*），而编译器会在这里进行类型检查，其检查结果和直接使用指针类型时一样。现在你松了一口气——一切OK，大功告成……可是你错了！
　　当你写下这样一段代码时：
 smart_ptr<int> a;
 ...
 smart_ptr<int> b(a);
 smart_ptr<int> c;
 c = a;
　　你会发现，它并没有调用你的构造函数的赋值操作符。什么原因呢？原因很简单：当你没有写拷贝构造函数时，编译器会为你生成一个隐含的拷贝构造函数。而拷贝构造函数的定义是“类X的拷贝构造函数是指第一个参数为const X;、X;、volatile X;或const volatile X;，并且没有其它参数或其它参数都有缺省值的非模板形式的构造函数”，因此上template<typename U>smart_ptr(const smart_ptr ; Source)这个构造函数并不是拷贝构造函数注，由于这个原因，编译器会为你生成一个隐含的拷贝构造函数。事实上你的类是这个样子的：
 template <typename T>
 smart_ptr
 {
 T* ptr_data;
 public:
 T* get_ptr();
 //以下是编译器自动生成的三个成员函数
 smart_ptr(const smart_ptr<T>;);
 smart_ptr<T>; operator = (const smart_ptr<T>;);
 ~smart_ptr();
　
 template<typename U>
 smart_ptr(const smart_ptr ; Source)
 {
 ptr_data = Source.get_ptr();
 //其它处理
 }
 template<typename U>
 smart_ptr<T> ; operator = (const smart_ptr ; Source)
 {
 ptr_data = Source.get_ptr();
 //其它处理
 } 
 };
　　现在我们看的很清楚了：由于smart_ptr(const smart_ptr<T>;);这个函数的存在，在编译代码smart_ptr<int> b(a);编译器找到了一个类型符合的非模板构造函数，它就会调用这个函数而不会去实例化你的模板形式的构造函数。同样道理，你的模板形式的赋值操作符也不是拷贝赋值操作符，编译器同样会为你生成一个从而阻止了模板的实例化。
　　解决办法很简单，既然编译器要调用拷贝构造函数和拷贝赋值操作符，而隐含的成员又不符合要求，我们就自己写一个来代替它们：
 template <typename T>
 smart_ptr
 {
 T* ptr_data;
 public:
 T* get_ptr() const;//返回封装的指针，可能还需要做一些附加操作，取决于你的智能指针的设计逻辑。
　
 //自己的拷贝构造函数和拷贝赋值操作符：
 smart_ptr(const smart_ptr<T>;)
 {
 ptr_data = Source.get_ptr();
 //其它处理
 }
 smart_ptr<T>; operator = (const smart_ptr<T>;);
 {
 ptr_data = Source.get_ptr();
 //其它处理
 } 
　
 template<typename U>
 smart_ptr(const smart_ptr ; Source)
 {
 ptr_data = Source.get_ptr();
 //其它处理
 }
 template<typename U>
 smart_ptr<T> ; operator = (const smart_ptr ; Source)
 {
 ptr_data = Source.get_ptr();
 //其它处理
 } 
 };
　　事实上在《C++ STL　中文版》中auto_ptr的实现代码中就是这样实现的。
　
　
　　注：在Nicolai M.Josuttis编写的《C++ 标准程式库》（我读的是侯捷和孟岩的译本）中把这种构造函数称为“模板形式的拷贝构造函数”（原译文为“template形式的copy建构式”）是一种不很严密的说法，容易让人误解。事实上这种模板形式的构造函数不属于拷贝构造函数。

喜欢0 评分0

[color=blue][size=4][i][b][u] 【解决不了的事情，就不要想。世界不会因为我而改变。】 [/size][/u][/b][/i][/color]

举报回复

whyerect

路人甲

注册日期2003-10-16
发帖数2827
QQ
铜币14枚
威望0点
贡献值0点
银元0个

加关注写私信

1楼^#

发布于：2004-05-11 00:15

[face=隶书]
强极则辱情深不寿
谦谦君子温润如玉
[/face]
______________________________________

举报回复喜欢评分

92412 路人甲注册日期2004-05-19 发帖数115 QQ 铜币280枚威望0点贡献值0点银元0个加关注写私信	2楼^# 发布于：2004-06-22 21:22 <P>...</P>
	举报回复(0) 喜欢(0) 评分

您需要登录后才可以回帖，登录或者注册

当心编译器生成的隐含成员函数

最新喜欢：