读《数据结构学习指导和习题解答》（C++语言版）有感

第三章

1、

class Point

{

         public:

                   Point(double=0.0,double=0.0);

                   Point(constPoint&);

                   ~Point();

                   Point&operator=(const Point&);

                   doublex() const;

                   doubley() const;

                   stringtoString() const;

         protected:

                   double_x,_y;

};

第一个是默认构造函数，无论何时通过如下声明，构造一个对象，默认都会调用它：

         Pointp2(7.2,4.9);//最后的结果是：_x=7.2,_y=4.9;

         Pointp1(7.2);//最后的结果是：_x=7.2,_y=0.0;

         Pointp0;//最后的结果是：_x=0.0,_y=0.0;

在构造匿名的对象时也会调用默认构造函数，如下：

P1=Point(7.2);

第二个构造函数是复制构造函数。当通过构造现有对象的一个副本来复制它时，就会调用这个构造函数。

第三个成员函数是类的析构函数。当对象超出作用域时，就会自动调用它。

第四个成员函数是重载的赋值运算符，其调用方式如下：

         P0=p1；

第五个和第六个成员函数是访问器函数。它们允许间接访问对象的protect数据，如下所示：

         doublex1=p1.x（）；

最后一个成员函数返回一个代表对象的字符串，可以像下面这样使用它：

         strings1=p1.toString();//最后的结果是：_x=7.2,_y=0.0;

PS：注意：关于复制构造函数在另一个文件中有详解。拷贝构造函数文件。以上代码仅供参考，经过本人测试，貌似出了一些问题，现在正在解决。

 

2015年3月27日16:44:502、

 

2、在这里提几个关于类的东西，这几天特别烦闷啊。

         （1）匿名对象。

看一下代码：

         #include<iostream>

using namespace std;

class some

{

         intn;

public:

         some(){n=0;}

         some(ints){n=s;}

         ~some(){cout<<"destroy\n";cout<<n<<endl<<endl;}

         intret(){return n;}

};

int main()

{

         cout<<some(111).ret()<<endl;

 

         cout<<some(10).ret()<<endl;

 

         somes;

         cout<<s.ret()<<endl;

 

         somess(120);

         cout<<ss.ret()<<endl;

 

         cout<<endl<<"The~some(s,ss):"<<endl;

         return0;

}

输出的结果为：

         111

destroy

111

 

10

destroy

10

 

0

120

 

The ~some(s,ss):

destroy

120

 

destroy

0

 

Press any key to continue

 

PS：我们发现，前两个用some（111或10）.rest（）的方法，直接调用构造函数对私有成员n赋值后，函数结束了，直接被释放了。而后面的通过定义一个对象s或s（120）来调用类的构造函数，最后析构函数到程序结束后才调用。这就是匿名对象的效果。自我感觉这是因为：直接给值得方法，没有创建对象，如果调用后不释放，以后就无法访问它的地址，也就找到不到它的值，为了内存，所以在结束函数调用后，把内存里的东西马上释放，保证了内存的合理利用吧，这就是C++的严谨之处。而后面的就不同前面了，它是存在实际的对象，最后通过对象的名字，还可以通过地址访问到内存里的值，这样就不用担心内存了，但是在最后程序结束释放还是有必要的。

         （2）explicit关键字

作用：explicit用来防止由构造函数定义的隐式转换。

要明白它的作用，首先要了解隐式转换：可以用单个实参来调用的构造函数定义了从形参类型到该类类型的一个隐式转换。

PS：（这个现在还没理解，待学习。详见：

http://www.cnblogs.com/likebeta/archive/2012/07/31/explicit.html）

2015年3月27日20:44:52

3、在文件夹中，记录了两个问题代码。着实让我头疼啊，这个问题，我记得在大一的时候也遇到了，暂且先放放吧。

2015年3月28日21:25:28

4、PS：现在解决昨天的那两个问题代码，问题是我在回寝室的时候，叫住学长，刚要问，然后我就发先错误了，其实错误很简单啊。如题：

错误源码：

public:

Point& operator=(const Point &p);

                   doublex() const;

                   doubley() const;

protected:

                   double_x,_y;

 

 

Point::Point(const Point &p)

{

         _x=p.x;

         _y=p.y;

}

double Point::x() const {return _x;}

double Point::y() const {return _y;}

 

前两段是声明，后两段是定义，你们发现了什么，为什么我要拿出这些呢？

好了问题来了，那个_x=p.x;_y=p.y;中的xy到底是什么呢，你是不是想把对象p中的_x,_y赋值给到_x,_y中，为什么xy没有加下划线呢？所以这是错误之处，我找了很长时间错，就是不知道因为什么，也许是上面的double x() const;   double y()const;函数影响了我把。所以以后不要这样定义函数，太坑人了。

 

还有一个文件中的类似。不解释了，都是同样的错误。

 

还有那个文件中的错误，就更简单了，我把：using namespace std;写到函数的定义下面了，然后流输入河流输出就一直找不到头文件了。然后就没有然后了。。。

这三段代码给自己一个教训吧！