类和对象(封装)(案例二)

设计一个圆类(yuan)，还有一个点类(dian)，计算点和圆的关系

解释一下

点和圆关系判断：

点到圆心距离 == 半径 点在圆上

点到圆心距离 > 半径 点在圆外

点到圆心距离 < 半径 点在圆内

怎么获取距离呢，要用到坐标了

公式是

根号:(x1-x2)的平方 +（y1-y2）的平方 和半径(m_r)去作对比

但c++中开根号不方便

所以我们可以简化一下

(x1-x2)^2 + (y1-y2)^2 ,然后和 半径(m_r)^2 对比

开始写代码

先把类设计好

#include <iostream>
using namespace std;

// 点类
class dian
{
private:
    int m_y;
    int m_x;

public:
    // 设置x
    void shezhi_x(int x)
    {
        m_x = x;
    }

    // 获取x
    int huoqu_x()
    {
        return m_x;
    }

    // 设置y
    void shezhi_y(int y)
    {
        m_y = y;
    }

    // 获取y
    int huoqu_y()
    {
        return m_y;
    }
};

// 点和圆关系案例
// 圆类
class yuan
{
private:
    int m_r;

    dian m_dian; // 圆心

public:
    // 设置半径
    void shezhi_r(int r)
    {
        m_r = r;
    }

    // 获取半径
    int huoqu_r()
    {
        return m_r;
    }

    // 设置圆心(o)
    void shezhi_o(dian o)
    {
        m_dian = o;
    }

    // 获取圆心
    dian huoqu_o()
    {
        return m_dian;
    }
};

封装一个判断圆和点的关系的函数

void if_yuan(yuan &c, dian &p)
{
    // 计算两点之间距离的平分
    int jieshou =
    (c.huoqu_o().huoqu_x() - p.huoqu_x()) * (c.huoqu_o().huoqu_x() - p.huoqu_x()) +
    (c.huoqu_o().huoqu_y() - p.huoqu_y()) * (c.huoqu_o().huoqu_y() - p.huoqu_y());

    // 计算半径的平方
    int r_pingfang = c.huoqu_r() * c.huoqu_r();

    // 判断关系
    if (jieshou == r_pingfang){
        cout<<"点在圆上"<<endl;

    }else if(jieshou > r_pingfang)
    {
        cout<<"点在圆外"<<endl;

    }else{
        cout<<"点在圆内"<<endl;

    }
    
}

回到main函数

int main(void)
{
    //创建一个圆
    yuan c;
    c.shezhi_r(10);
    dian center;
    center.shezhi_x(10);
    center.shezhi_y(0);
    c.shezhi_o(center);
    //创建一个点
    dian p;
    p.shezhi_x(10);
    p.shezhi_y(10);

    //判断关系
    if_yuan(c,p);


    return 0;
}

全源码

#include <iostream>
using namespace std;

#include <iostream>
using namespace std;

// 点类
class dian
{
private:
    int m_y;
    int m_x;

public:
    // 设置x
    void shezhi_x(int x)
    {
        m_x = x;
    }

    // 获取x
    int huoqu_x()
    {
        return m_x;
    }

    // 设置y
    void shezhi_y(int y)
    {
        m_y = y;
    }

    // 获取y
    int huoqu_y()
    {
        return m_y;
    }
};

// 点和圆关系案例
// 圆类
class yuan
{
private:
    int m_r;

    dian m_dian; // 圆心

public:
    // 设置半径
    void shezhi_r(int r)
    {
        m_r = r;
    }

    // 获取半径
    int huoqu_r()
    {
        return m_r;
    }

    // 设置圆心(o)
    void shezhi_o(dian o)
    {
        m_dian = o;
    }

    // 获取圆心
    dian huoqu_o()
    {
        return m_dian;
    }
};

// 判断点和圆的关系
void if_yuan(yuan &c, dian &p)
{
    // 计算两点之间距离的平分
    int jieshou =
    (c.huoqu_o().huoqu_x() - p.huoqu_x()) * (c.huoqu_o().huoqu_x() - p.huoqu_x()) +
    (c.huoqu_o().huoqu_y() - p.huoqu_y()) * (c.huoqu_o().huoqu_y() - p.huoqu_y());

    // 计算半径的平方
    int r_pingfang = c.huoqu_r() * c.huoqu_r();

    // 判断关系
    if (jieshou == r_pingfang){
        cout<<"点在圆上"<<endl;

    }else if(jieshou > r_pingfang)
    {
        cout<<"点在圆外"<<endl;

    }else{
        cout<<"点在圆内"<<endl;

    }
    
}

int main(void)
{
    //创建一个圆
    yuan c;
    c.shezhi_r(10);
    dian center;
    center.shezhi_x(10);
    center.shezhi_y(0);
    c.shezhi_o(center);
    //创建一个点
    dian p;
    p.shezhi_x(10);
    p.shezhi_y(10);

    //判断关系
    if_yuan(c,p);


    return 0;
}

输出结果

点在圆上

核心内容

   //在类中可以让另一个类 作为本来中的成员
   dian m_dian; // 圆心

为什么要拆开

因为后续代码会越来越多，这时候就要分开写或者分文件编写

如何分文件编写呢

首先把点类分开:

创建一个头文件dian.h，还有一个源文件dian.cpp

dian.h

#pragma once
#include<iostream>
using namespace std;

// 点类
class dian
{
private:
    int m_y;
    int m_x;
public:
    // 设置x
    void shezhi_x(int x);
    // 获取x
    int huoqu_x();
    // 设置y
    void shezhi_y(int y);
    // 获取y
    int huoqu_y();
};

dian.cpp

#include"dian.h"

void dian::shezhi_x(int x)
{
    m_x = x;
}
// 获取x
int dian::huoqu_x()
{
    return m_x;
}
// 设置y
void dian::shezhi_y(int y)
{
    m_y = y;
}
// 获取y
int dian::huoqu_y()
{
    return m_y;
}

注意源文件中要有个dian的作用域

#pragma once 是防止头文件重复包含用的

源文件只用包含实现，头文件包含声明

剩下的自己琢磨吧不会的评论区留言

分文件编写后

main.cpp

#include <iostream>
#include"dian.h"
#include"yuan.h"
using namespace std;


void if_yuan(yuan &c, dian &p)
{
    // 计算两点之间距离的平分
    int jieshou =
    (c.huoqu_o().huoqu_x() - p.huoqu_x()) * (c.huoqu_o().huoqu_x() - p.huoqu_x()) +
    (c.huoqu_o().huoqu_y() - p.huoqu_y()) * (c.huoqu_o().huoqu_y() - p.huoqu_y());

    // 计算半径的平方
    int r_pingfang = c.huoqu_r() * c.huoqu_r();

    // 判断关系
    if (jieshou == r_pingfang){
        cout<<"点在圆上"<<endl;

    }else if(jieshou > r_pingfang)
    {
        cout<<"点在圆外"<<endl;

    }else{
        cout<<"点在圆内"<<endl;

    }
    
}

int main(void)
{
    //创建一个圆
    yuan c;
    c.shezhi_r(10);
    dian center;
    center.shezhi_x(10);
    center.shezhi_y(0);
    c.shezhi_o(center);
    //创建一个点
    dian p;
    p.shezhi_x(10);
    p.shezhi_y(10);

    //判断关系
    if_yuan(c,p);


    return 0;
}

dian.h

#pragma once
#include<iostream>
using namespace std;

// 点类
class dian
{
private:
    int m_y;
    int m_x;
public:
    // 设置x
    void shezhi_x(int x);
    // 获取x
    int huoqu_x();
    // 设置y
    void shezhi_y(int y);
    // 获取y
    int huoqu_y();
};

dian.cpp

#include"dian.h"

void dian::shezhi_x(int x)
{
    m_x = x;
}
// 获取x
int dian::huoqu_x()
{
    return m_x;
}
// 设置y
void dian::shezhi_y(int y)
{
    m_y = y;
}
// 获取y
int dian::huoqu_y()
{
    return m_y;
}

yuan.h

#pragma once
#include<iostream>
using namespace std;
#include"dian.h"

class yuan
{
private:
int m_r;

dian m_dian; // 圆心

public:
// 设置半径
void shezhi_r(int r);


// 获取半径
    int huoqu_r();


// 设置圆心(o)
void shezhi_o(dian o);


// 获取圆心
dian huoqu_o();

};

yuan.cpp

#include"yuan.h"
#include"dian.h"


void yuan::shezhi_r(int r)
{
    m_r = r;
}

// 获取半径
int yuan::huoqu_r()
{
    return m_r;
}

// 设置圆心(o)
void yuan::shezhi_o(dian o)
{
    m_dian = o;
}

// 获取圆心
dian yuan::huoqu_o()
{
    return m_dian;
}

总结

这次的案例学会了类的分文件编写

好处是：

反正在代码多的时候，分文件编写是最好的

类和对象的封装你已经学会了，不会的评论区留言