c++ 类的简单设计（第二次作业）

主要内容：
构造析构和拷贝的主要发生时间
函数返回引用和返回自身
静态成员变量
const

/*再次浅谈一下对函数返回引用和函数返回对象的区别吧：
函数返回对象： 因为是用一个对象去调的这个函数，所以函数一定会修改掉原来的值，同时函数会按照所给的地址（也就是原对象的地址）拷贝一份其中的内容赋给胡乱来的一个新对象，（也就是临时变量）所以函数返回的并不是它本身，你再去继续调用其他的函数，鬼知道它调到哪里去了！
函数返回引用： 废话不多说，就是返回它本身，嗯，一般都是返回常引用，你改来改去，鬼知道，你会改成什么样。规范
附加规范：一般传参，都传常引用，返回值都传对象。
       一般简单函数写在里面，复杂函数写在外面，因为里面的函数自动为inline类型。*/
//关于函数返回它自身和返回一个新的Point 类的测试
#include<iostream>
using namespace std;

class Point
{
public:
    Point(double a = 0):x_(a), y_(a) {}
    Point(double a, double b) :x_(a), y_(b) {}
    Point(const Point &p) :x_(p.x_), y_(p.y_) {}
    Point & copy(double a, double b);
    Point copy(double a)
    {
        x_ = a;
        y_ = a;
        cout << "返回对象" << endl;
        // 新建一个对象但是指向同一个地址  这句话是错的啊
    //新建了一个对象，和原对象的地址不同啊 只是按照地址                             //把原对象的东西给拷过来了
        return *this;
    }
    double x()
    {
        return x_;
    }
    double y()
    {
        return y_;
    }
    void reset(double a, double b)
    {
        x_ = a;
        y_ = b;
    }
    ~Point()
    {
        i++;
        cout << i << endl;
    }
private:
    double x_, y_;
    static int i;
};
Point& Point:: copy(double a, double b) // 不建立新的类，一切的改变都是对其自身做的；
{
    x_ = a;
    y_ = b;
    cout << "返回本身" << endl;
    return *this;
}
int Point :: i = 0;
int main()
{
    Point p(0), q(2,3), pp(p);
    cout << &p <<" " << &q << " " << &pp <<endl;
    p.copy(2,3);
    Point m = q.copy(5);
    cout << &p << " " << &q << " " << &m << endl;
    m.reset(1,2);
    cout << m.x() << " " << m.y()<< endl;
    cout << q.x() << " " << q.y() << endl;
    return 0;
}

/*
第一题：有关精度控制；
setprecision()函数和 fixed 的用法:
头文件：iomanip, 包含在std命名空间中。
如果在setprecision前不加fixed则自动保存原位数超过限定才截，如果加上fixed那么就会固定输出括号里的位数
std::cout << "Point : (" <<std:: setprecision(16)<<x << ", " << y << ")" << std::endl;
*/

/*
第二题： 有关构造， 拷贝，析构的时间问题
拷贝在对象建立时进行， 拷贝在原对象被复制的时候用， 析构则是在这个对象的生命周期结束时调用。
*/

/*
第三题：关于在类外函数调用类内函数，传类。
void showPoint(Point p)
{
    p.show();
}
void showPoint(Point q1,Point q2,Point q)
{
    q1.show();
    q2.show();
    q.show();
}
*/

/* 第四题： 主要是关于类的构建析构和复制的时间，类析构与离它最近的那个分号，
函数传参数时要拷贝形参别忘了！！！
关于静态变量： 只有静态变量才能在类外赋值，非静态没有这个特权。 只有在Public 中的变量才能在类外改值。 就算是Private 内的静态也不能在类外直接改值。
静态变量一定要在类外赋值再用。
*/

/*第五题：返回对象本身， Point & copy(const Point p)
                        {
                            return *this;
                        }
                        相当于引用，不产生新的对象
                        具体返回本身和返回新对象的区别见整理的例子。
*/


/* 第六题： const 的知识
   要解决的问题：
        为什么要返回自身？ copy 和 inverse 函数；  因为copy中的要求，和inverse函数要继续返回要是一个Point 类。
        有关const 难道只能在类里面用吗？在普通的函数里是不是用不了？但是传参数的时候要注明传的是const
        类型；
        const 在函数前后的区别：
        const加在函数后只能用在类的成员函数中，类外函数不能用。表示不修改函数内的值，只读不写。
        关于数的计算；
*/

/*浅谈const:
   1.只有成员变量中才能在其后加const，加了之后其成员变量则不能修改。
   2.如果一个const 类型的量要做参数，注意了啊，他将要复制传给的形参也一定是const类型的。不然人家身份高贵不要你。不传给你。
   3.const常量只能为左值，不能修改；只能调用常量成员函数，非const 则二者皆可。
   4.注意函数返回const以后就一直都是这个类型了，跟你一辈子吧

//最后一题的代码：
#include<iostream>
#include<iomanip>
using namespace std;

class Point
{
public:
    Point()
    {
        x_ = 0;
        y_ = 0;
        num++;
        i = num;
    }
    /*
    Point(double a = 0)
    {
      ..........  
    }
    */ // 这样子会和上面重定义。
    Point(double a, double b)
    {
        x_ = a;
        y_ = b;
        num++;
        i = num;
    }
    Point(const Point  &p)
    {
        x_ = p.x_;
        y_ = p.y_;
    }


    Point & setPoint(double a, double b)
    {
        x_ = a;
        y_ = b;
        return *this;
    }
    Point& inverse(Point p)
    {
        x_ = p.y_;
        y_ = p.x_;
    }
    Point& inverse()
    {
        double tem;
        tem = x_;
        x_ = y_;
        y_ = tem;
    }
    void show() const
    {
        cout << "Point[" << i << "] : (" << setprecision(16) << x_ << ", " << y_ <<")" << endl;
    }
    double x() const
    {
        return x_;
    }
    double y() const
    {
        return y_;
    }
    double x(double a)
    {
        x_= a;
        return x_;
    }
    double y(double b)
    {
        y_ = b;
        return y_;
    }
    Point& copy(Point p)
    {
        x_ = p.x_;
        y_ = p.y_;
    }
    int isEqual(Point p) const  // 加上const 的成员函数。不能修改对象中的成员变量。 只有类中的成员函数才可以这样用哟。
    {
        if(x_ == p.x_ && y_ == p.y_)
            return 1;
        else
            return 0;
    }
    void showSumOfPoint() const
    {
        cout << "In total : "<< num <<" points." << endl;
    }

private:
    double x_, y_;
    int i;
    static int num;
};



    int Point::num = 0;
    //int Point::i = 0;
void ShowPoint(double a, double b)  // 对于这个函数返回值const的限定，加在返回类型前后都可，就是你返回了const就要一直以后不能把它抛弃了。。。。。随时注意啊。 
{
 cout <<"Point : ("<<  a << ", "<< b << ")" << endl;
}
void ShowPoint (const Point &p)  //人家是const 类型，你当然就得传const类型喽。
{
    cout << "Point : (" << p.x() << ", " << p.y() << ")" << endl;

}

int main()
{
    int l(0);
    char c;
    double a, b;
    Point p, q, pt[60]; // 目前已经建立了62个对象，数组啊，不是闹着玩的啊。
    while(std::cin>>a>>c>>b)
    {
        if(a == b)
            p.copy(pt[l].setPoint(a, b));
        if(a > b)
            p.copy(pt[l].setPoint(a, b).inverse());
        if(a < b)
            p.inverse(pt[l].setPoint(a, b));
        if(a < 0)
            q.copy(p).inverse();
        if(b < 0)
            q.inverse(p).copy(pt[l]);
        pt[l++].show();
        p.show();
    }
    q.show();
    cout<<"==========gorgeous separator=========="<<endl;
    double x(0), y(0);
    for(int i = 0; i < l; i++)
        x += pt[i].x(), y -= pt[i].y();
    pt[l].x(y), pt[l].y(x);
    q.copy(pt[l]).show();
    for(int i = 0; i <= l; i++)
        pt[i].show();
    cout<<"==========gorgeous separator=========="<<endl;
    const Point const_point(3, 3);
    const_point.show();
    for(int i = 0; i <= l; i++)
    {
        if(const_point.isEqual(pt[i]))
        {
            ShowPoint(const_point);
            ShowPoint(const_point.x(), const_point.y());
            ShowPoint(Point(const_point.x(), const_point.y()));
        }
    }
    const_point.showSumOfPoint();
}