七、类中的封装

一、类的组合：

（1）.如电脑类由键盘类、鼠标类、显示类、cpu类、memory类等类组成
（2）.类通常可以分为以下两个部分：
a.类的实现细节
b.类的使用方式（用户一般只关心怎么使用，而不会关心内部到底如何实现）

二、类的封装

（1）.当使用类的时候不需要关心其实现细节
（2）.当创建一个类时，才需要考虑其内部实现细节
（3）.封装的基本概念：
a.并不是类的每个属性都是对外公开的
b.而一些类的属性是对外开放的
因此，需要在类的表示法中定义属性和行为的公开级别
c++中类的封装：
成员变量（表示类的属性）
成员函数（表示类的行为）
在c++中可以给成员变量和成员函数定义访问级别
public：成员变量和成员函数可以在类的内部和外界访问和调用
private：成员变量和成员函数只能在类的内部被访问和调用
类成员的访问属性：
struct Girl : human
{
private://冒号后面的都是私有的，外界无法访问
int age;
piblic://外界可以访问
void play()
{
printf(“hello\n”);
}
}

struct Boy : human
{
public:
int age;
void play()
{
printf(“hello\n”);
}
}
main 相对类来说就是外界。

三、类成员的作用域：

（1）.类成员的作用域都只在类的内部，外部无法直接访问
（2）.成员函数可以直接访问成员变量和调用其它成员函数，但外部只能访问public成员
（3）.c++中用struct定义的类的所有成员默认为public，而class定义的磊默认是private的

#include<iostream>
using namespace std;
class student
{
private:
    int age;
public:
    void fun()
    {
        age = 50;
        cout<<"agg = "<<student::age<<endl;
    }
};
int main()
{
        student liming;
        liming.fun();//fun函数可以访问本类中的成员
        //liming.age = 25;//这里会报错。无法访问private成员
        getchar();
        return 0;
}

四、第一个面向对象的实现：

要求：1.提供setOperator函数设置运算类型，如加、减、乘、除
2.提供setParameter函数设置运算参数，类型为整型
3.提供result函数进行运算，其返回值表示运算合法性，通过引用参数返回结果。
Operator.h:

#ifndef _OPERATOR_H_
#define _OPERATOR_H_
class Operator
{
private:
    char Opm;//操作符
    double m1,m2;//操作数
public:
    bool setOperator(char c);//设置操作符
    void setParameter(double d1, double d2);//设置操作数
    bool result(double& r);//计算并且返回结果

};
#endif

Operator.cpp:

#include "Operator.h"
#include<iostream>
using namespace std;
bool Operator::setOperator(char c)//注意指定是那个类的函数
{
    bool ret = true;
    if( ('+' == c) | ('-' == c) | ('*' == c) | ('/' == c) )
    {
        Opm = c;
    }
    else 
    {
        ret = false;
    }
    return ret;
}
void Operator::setParameter(double d1, double d2)
{
    m1 = d1;
    m2 = d2;
}
bool Operator::result(double& r)//利用引用来存储结果
{
    bool ret = true;
     switch( Opm )
    {
        case '/':
            if( (-0.000000001 < m2) && (m2 < 0.000000001) )
            {
                ret = false;
            }
            else
            {
                r = m1 / m2;
            }
            break;
        case '+':
            r = m1 + m2;
            break;
        case '*':
            r = m1 * m2;
            break;
        case '-':
            r = m1 - m2;
            break;
        default:
            ret = false;
            break;
    }
    return ret;
}

main.c

#include<iostream>
#include "Operator.h"
using namespace std;
int main()
{
    double ret = 0;
    Operator op;//注意一定要记得用类来定义对象
    op.setOperator('+');
    op.setParameter(1,5);
    if(op.result(ret))
    {
        cout<<"the result is "<<ret<<endl;//打印结果为6
    }
    getchar();
    return 0;
}

以上程序，主函数只知道怎么使用，不知道其内部如何实现，这就是类的封装