C++語言（02）——封裝

類與封裝的概念

類的封裝

(1)類通常分為以下兩個部分，類的實現(xiàn)細(xì)節(jié)和類的使用方式
(2)使用類時不需要關(guān)心其細(xì)節(jié)，創(chuàng)建類時才需要考慮內(nèi)部實現(xiàn)細(xì)節(jié)
(3)C++中使用類的成員變量來表示類的屬性，用成員函數(shù)表示類的行為
C++中通過定義類成員的訪問級別來實現(xiàn)封裝機制，類的封裝機制使得類的使用和內(nèi)部細(xì)節(jié)相分離

#include <stdio.h>

#include <stdio.h>

struct Biology 
{
    bool living;
};

struct Animal : Biology     //：表示繼承
{
    bool movable;       //類的屬性
    void findFood()     //類的行為
    { 
    }   
};

struct Plant : Biology 
{
    bool growable;
};

struct Beast : Animal 
{
    void sleep() 
    { 
    }
};

struct Human : Animal 
{
    void sleep() 
    { 
        printf("I'm sleeping...\n");
    }

    void work() 
    { 
        printf("I'm working...\n");
    }
};

struct Girl : Human
{
private:
    int age;        
    int weight;
public:
    void print()
    {
        age = 22;
        weight = 48;

        printf("I'm a girl, I'm %d years old.\n", age);
        printf("My weight is %d kg.\n", weight);
    }
};

struct Boy : Human
{
private:
    int height;
    int salary;
public:
    int age;
    int weight;

    void print()
    {
        height = 175;
        salary = 9000;

        printf("I'm a boy, my height is %d cm.\n", height);
        printf("My salary is %d RMB.\n", salary);
    }    
};

int main()
{
    Girl g;     //定義類變量/對象
    Boy b;

    g.print();  //使用類變量來訪問類的public成員函數(shù)

    b.age = 19;         //使用類變量來訪問類的public成員，并賦值
    b.weight = 120;
    //b.height = 180;   //不可以在類的外部訪問類的private成員

    b.print();

    return 0;
}

類的訪問權(quán)限

(1)并不是每個類的屬性都是對外公開的，因此必須在類的表示方法中定義屬性和行為的公開級別，類似于文件的訪問權(quán)限
(2)public：成員變量和成員函數(shù)可以在類的內(nèi)部和外界訪問和調(diào)用
(3)private：成員變量和成員函數(shù)只能在類的內(nèi)部訪問和調(diào)用

類的作用域

(1)類成員的作用域都只在類的內(nèi)部，外部無法直接訪問
(2)成員函數(shù)可以直接訪問成員變量和調(diào)用成員函數(shù)
(3)類的外部可以通過類對象訪問類的public成員
注意：類成員的作用域和訪問級別沒有關(guān)系
C++中struct定義的類中的所有成員默認(rèn)為public

#include <stdio.h>

int i = 1;      //全局變量i

struct Test
{
private:
    int i;

public:
    int j;

    int getI()
    {
        i = 3;

        return i;
    }
};

int main()
{
    int i = 2;      //局部變量i

    Test test;      //定義類Test的變量test

    test.j = 4;     //使用類變量來訪問類的public成員函

    printf("i = %d\n", i);              // i = 2;
    printf("::i = %d\n", ::i);          // ::i = 1; ，::表示默認(rèn)全局空間
    // printf("test.i = %d\n", test.i);    // Error
    printf("test.j = %d\n", test.j);    // test.j = 4
    printf("test.getI() = %d\n", test.getI());  // test.getI() = 3

    return 0;
}

類的真正形態(tài)

類的關(guān)鍵字

(1)在C++中提供了新的關(guān)鍵字class，用于定義類
(2)class和struct的用法是完全相同的
(3)class和struct定義類的區(qū)別在于默認(rèn)訪問權(quán)限不同(相反)
C++中要兼容C語言，而struct在C語言中已經(jīng)有其意義（定義結(jié)構(gòu)體），所以實際工程中我們一般只使用class關(guān)鍵字來定義類

/**使用struct定義類與class定義類的區(qū)別在于默認(rèn)訪問權(quán)限不同（相反）***/
#include <stdio.h>

struct A
{
    // defualt to public
    int i;
    // defualt to public
    int getI()
    {
        return i;
    }
};

class B
{
    // defualt to private
    int i;
    // defualt to private
    int getI()
    {
        return i;
    }
};

int main()
{
    A a;
    B b;

    a.i = 4;

    printf("a.getI() = %d\n", a.getI());

    b.i = 4;

    printf("b.getI() = %d\n", b.getI());

    return 0;
}

代碼實踐

使用面向?qū)ο蟮姆椒ㄩ_發(fā)一個四則運算的類，見代碼
(1)C++中支持類的聲明和實現(xiàn)的分離
.h頭文件中只有類的聲明(成員變量和成員函數(shù))
.cpp文件中完類的其他實現(xiàn)(成員函數(shù)的具體實現(xiàn))

// test.cpp

#include <stdio.h>
#include "Operator.h"

int main()
{
    Operator op;
    double r = 0;

    op.setOperator('/');
    op.setParameter(9, 3);

    if( op.result(r) )
    {
        printf("r = %lf\n", r);
    }
    else
    {
        printf("Calculate error!\n");
    }

    return 0;
}

// operator
#include "Operator.h"

bool Operator::setOperator(char op)     //::表明是Operator類的成員函數(shù)
{
    bool ret = false;

    if( (op == '+') || (op == '-') || (op == '*') || (op == '/') )
    {
        ret = true;
        mOp = op;
    }
    else
    {
        mOp = '\0';     //'\0'是一個轉(zhuǎn)義字符，他對應(yīng)的ASCII編碼值是0，本質(zhì)就是0
    }

    return ret;
}

void Operator::setParameter(double p1, double p2)
{
    mP1 = p1;
    mP2 = p2;
}

bool Operator::result(double& r)
{
    bool ret = true;

    switch( mOp )
    {
        case '/':
            if( (-0.000000001 < mP2) && (mP2 < 0.000000001) )   //被除數(shù)不能為0
            {
                ret = false;
            }
            else
            {
                r = mP1 / mP2;
            }
            break;
        case '+':
            r = mP1 + mP2;
            break;
        case '*':
            r = mP1 * mP2;
            break;
        case '-':
            r = mP1 - mP2;
            break;
        default:
            ret = false;
            break;
    }

    return ret;
}

// operator.h

#ifndef _OPERATOR_H_
#define _OPERATOR_H_

class Operator
{
private:    //注意冒號不能丟
    char mOp;           //操作符
    double mP1,mP2;     //兩個操作數(shù)

public:
    bool setOperator(char op);  //設(shè)置運算類型
    void setParameter(double p1, double p2);    //設(shè)置運算參數(shù)
    bool result(double& r);     //進行運算，返回值表示運算的合法性，通過引用參數(shù)返回結(jié)果
};  //分號

#endif