c++面对对象学习

1、用面对对象的思想考虑圆与点

1、搭建场景
2、场景中应该有哪些对象：圆，点
3、对象有的属性
（1）圆：半径，圆心的x坐标和y坐标
（2）点：x坐标，y坐标
3、对象本身有的功能：
（1）圆：判断点是否在圆内
（2）点：计算点与圆心的距离（计算两个点的距离）
4、管理者将对象联动起来

1、main.cpp

#include <iostream>
#include "point.h"
#include "round.h"

using namespace std;

int main(int argc, char *argv[])
{
    //在场景中搭建一个点
    Point p;
    p.init(2,5);
    //在场景中搭建一个圆
    Round c;
    c.init(0,0,2);
    if(c.judgment(p))
        cout << "在圆上"<<endl;
    else
        cout << "不在圆上"<<endl;
    return 0;
}

2、point.c

#include "point.h"

void Point::init(int x,int y)
{
    m_x = x;
    m_y = y;
}

int Point::getx()
{
    return m_x;
}

int Point::gety()
{
    return m_y;
}

int Point::distance(Point p)
{
    int d = ((m_x-p.getx())*(m_x-p.getx()))+((m_y-p.gety())*(m_x-p.gety()));
    return d;
}

3、point.h

#ifndef POINT_H
#define POINT_H

class Point
{
public:
    //点的初始化
    void init(int x,int y);
    //计算我这个点与点p的距离
    int distance(Point p);
    //获取x坐标
    int getx();
     //获取y坐标
    int gety();
private:
    int m_x;      //点的x轴
    int m_y;      //点的y轴
};

#endif // POINT_H

4、round.c

#include "round.h"
#include "point.h"

void Round::init(int x,int y,int r)
{
    m_a.init(x,y);
    m_r = r;
}

bool Round::judgment(Point &p)
{
    //计算点与圆心（点)的距离
    int d = p.distance(m_a);
    //判断是否在园内
    if(d > m_r*m_r)
    {
        return false;
    }
    else
    {
        return true;
    }
}

5、round.h

#ifndef ROUND_H
#define ROUND_H
#include "point.h"
class Round
{
public:
    //初始化圆
    void init(int x,int y,int r);
    //判读点是否在我（圆）的内部
    bool judgment(Point &p);
private:
    Point m_a;
    int m_r;
};

#endif // ROUND_H

2、构造函数与析构函数

1、构造函数

1、什么是构造函数
只有在建造对象的时候系统自动调用的函数------>初始化对象

2、构造函数的特性
（1）构造函数的函数名与类名相同
（2）构造函数没有返回值
（3）构造函数可以被重载
（4）如果一个构造函数被调用了，那么一定是有一个新的对象创建
（5）如果创建一个新的对象，那么一定会调用构造函数（类中没有写构造函数的时候，系统会自动添加）

2、析构函数

1、什么是析构函数
当对象被释放的时候，系统会自动调用析构函数

2、析构函数的特性
（1）析构函数没有返回值
（2）析构函数的函数名为~类名
（3）没有参数（不能被重载）
3、对于构造函数与析构函数来说，先创建的对象后调用析构函数释放

3、代码实现

#include <iostream>

using namespace std;

class Test
{
public:
    //构造函数
    //只有在创建对象的时候系统会自动调用----->用于初始化对象
    //特性：1、构造函数的函数名和类相同;2、构造函数没有返回值；3、构造函数可以重载
    //如果构造函数被调用了，一定有个新对象创建；如果构造一个新对象，一定会调用构造函数
    Test()
    {
        cout<<"我是构造函数，在对象创建的时候会调用"<<endl;
        m_a = 0;
        m_b = 0;
        m_pa = new int;
    }

    Test(int a)
    {
        m_a = a;
        m_b = 0;
        m_pa = nullptr;
    }
    Test(int a,int b)
    {
        m_a = a;
        m_b = b;
        m_pa = nullptr;
    }

    //析构函数
    //当对象被释放的时候，系统会自动调用析构函数
    //1、函数名 ： ~类名；2、没有返回值；3、不能被重载（没有参数）
    ~ Test()
    {
        cout<<"析构函数：a = "<<m_a<<",b = "<<m_b<<endl;
    }

    void show()
    {
        if(m_pa != nullptr)
            delete m_pa;
        cout << "a = " <<m_a<<",b = "<<m_b<<endl;
    }

private:
    int m_a;
    int m_b;
    int *m_pa;
};

//构造函数与析构函数的顺序：先构造的后析构；
int main(int argc, char *argv[])
{
    {
        Test t;
        t.show();
    }
    Test t1 = (10);
    t1.show();
    Test t2(10,20);
    t2.show();
    Test t3 = 15;         //只适用于单个参数的构造函数
    t3.show();

    return 0;
}