C++基础——构造函数，析构函数，赋值运算操作符

几乎写的每个类都会有一或多个构造函数，一个析构函数，一个copy assignment操作符。如果这些函数出错，会导致严重的后果，任何程序开发工作的基础就是要编写正确无误的类。让我们来关注这些基础知识。

如果你自己什么都没有申明，一个类默认会生成以下函数：

1 class Empty
2 {
3 };

上面这个什么都没有申明的类，就好像写成这样一样：

1 class Empty
2 {
3  public:
4     Empty(){}
5     ~Empty(){}
6     Empty(const Empty& rhs){}
7     Empty& operator=(const Empty& rhs){}
8 };

C++编译器默认生成了这些函数。当用户自己申明构造函数，或其他函数时，编译器不再为它创建default构造函数。

有几点需要注意：

 //class include non-const,non-reference data member
 1 #include <iostream>
 2 using namespace std;
 3 
 4 class normalMemberClass
 5 {
 6 public:
 7     normalMemberClass(const string& aName, int aValue)
 8       : mName_(aName)
 9       , mValue_(aValue)
10     {
11     }
12 
13 private:
14     string mName_; //non-const,non-reference data member
15     int mValue_;
16 };
17 
18 int main( void )
19 {
20     string name1("dog");
21     int value1 = 1;
22 
23     string name2("cat");
24     int value2 = 2;
25 
26     normalMemberClass p(name1, value1);
27     normalMemberClass s(name2, value2);
28 
29     p = s; //call copy assignment operator
30 
31     return 0;
32 }

1.内含引用成员的class，必须自己定义copy assignment操作符。否则编译器将拒绝编译那一行赋值动作。

 1 //class include reference data member
 2 #include <iostream>
 3 using namespace std;
 4 
 5 class refMemberClass
 6 {
 7 public:
 8     refMemberClass(string aName, int aValue)
 9       : mName_(aName)
10       , mValue_(aValue)
11     {
12     }
13 
14 private:
15     string& mName_; // reference data member
16     int mValue_;
17 };
18 
19 int main( void )
20 {
21     string name1("dog");
22     int value1 = 1;
23 
24     string name2("cat");
25     int value2 = 2;
26 
27     refMemberClass p(name1, value1);
28     refMemberClass s(name2, value2);
29 
30     p = s; //call copy assignment operator
31 
32     return 0;
33 }

2.内含const成员的class，必须自己定义copy assignment操作符。否则编译器将拒绝编译那一行赋值动作。

 1 //class include const data member
 2 #include <iostream>
 3 using namespace std;
 4 
 5 class constMemberClass
 6 {
 7 public:
 8     constMemberClass(string aName, int aValue)
 9       : mName_(aName)
10       , mValue_(aValue)
11     {
12     }
13 
14 private:
15     const string mName_; // const data member
16     int mValue_;
17 };
18 
19 int main( void )
20 {
21     string name1("dog");
22     int value1 = 1;
23 
24     string name2("cat");
25     int value2 = 2;
26 
27     constMemberClass p(name1, value1);
28     constMemberClass s(name2, value2);
29 
30     p = s; //call copy assignment operator
31 
32     return 0;
33 }

3.如果某个base class将它的copy assignment操作符申明为private，则编译器不会为derived class生成一个copy assignment操作符。

 1 #include <iostream>
 2 using namespace std;
 3 
 4 class baseClass
 5 {
 6 public:
 7     baseClass(string aName, int aValue)
 8       : mName_(aName)
 9       , mValue_(aValue)
10     {
11     }
12 
13 private: //Declare copy assigment operator to be private
14     baseClass& operator=(const baseClass& rhs)
15     {
16         mName_ = rhs.mName_;
17         mValue_ = rhs.mValue_;
18         return *this;
19     }
20 
21 private:
22     string mName_; 
23     int mValue_;
24 };
25 
26 class derivedClass : public baseClass
27 {
28 public:
29     derivedClass(string aName, int aValue)
30         : baseClass(aName, aValue)
31     {
32     }
33 };
34 
35 int main( void )
36 {
37     string name1("dog");
38     int value1 = 1;
39 
40     string name2("cat");
41     int value2 = 2;
42 
43     derivedClass p(name1, value1);
44     derivedClass s(name2, value2);
45 
46     p = s; //call copy assignment operator
47 
48     return 0;
49 }

待续

posted on 2011-05-25 15:11  ActiveChange  阅读(198)  评论(0)  编辑  收藏  举报

导航