类

类和对象：

　　类：

　　　　描述一类事物的属性和行为。

　　对象：

　　　　代表具体的事物，拥有所属类的属性和行为，还有独有的属性和行为。

　　关系：

　　　　类是指一类事物，对象是一个类里面的实体。

　　　　类是一种模型，一种模型可以创建出不同的实体。

　　　　一个类可以有很多对象，一个对象只属于一个类。

　　注意：

　　　　一个类不一定有对象，类之间存在相互关系，一个对象可能属于不同的类，对象实例不可以完全相同。

 

类之间的关系

　　继承：

　　　　从已经存在的类中细分出来的类和原类之间有继承关系。

　　　　继承的类（子类）拥有和原类（父类）的全部的属性和行为。

　　组合：

　　　　一些类的存在必须依赖其他的类而存在。

　　　　组合的类在某一局部上有其他类组成（同生死）。

 

属性： 在类中变量的定义。

行为： 在类中函数的实现，或者在类中的声明和在别处的实现。

 

封装：

　　　　类使用访问级别来实现封装，实现了类的使用方法和内部细节相分离。

　　　　类的成员变量：表示类的属性。

　　　　类的成员函数：表示类的行为。

　　　　C++中成员变量和成员函数的访问级别：

　　　　　　private：成员变量和成员函数可以被类的内部被访问和调用

　　　　　　public：成员变量和成员函数可以被类的内部和外部被访问和调用

　　　　类成员的作用域：

　　　　　　1. 类成员的作用域都只在类的内部外部无法直接访问。

　　　　　　2. 成员函数可以通过成员变量和其他成员函数。

　　　　　　3. 类的外部可以通过成员变量访问public成员。

　　　　　　4. 类成员作用域和访问级别没有关系。

　　　　　　5. 类的所有成员默认访问级别为public。

                     访问级别是对于外部来说的，作用域是对于内部来说的。

 

如何定义一个类：

　　　　　    用 struct 或者 class  （定义新的类型，定义新的类）

　　　　　　区别：

　　　　　　　　class 定义一个类时，所有默认成员访问级别是 private

　　　　　　　　struct 定义一个类时，所有默认成员访问级别是 public

#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;     // 定义一个Girl类的对象g
    Boy b;
    
    g.print();
    
    b.age = 19;      // 只有通过类的对象才可以访问类的成员
    b.weight = 120;
    //b.height = 180;
    
    b.print();
    
    return 0;
}

 

类的声明和实现：

　　　　　　类的声明：

　　　　　　　　.h文件只有类的声明：成员变量和成员函数的声明。

　　　　　　类的实现：

　　　　　　　　.cpp文件只有类的实现：成员函数的具体实现。

#ifndef _OPERATOR_H_
#define _OPERATOR_H_

class Operator
{
private:
    char mOp;
    double mP1;
    double mP2;
    
public:
    bool setOperator(char op);
    void setParameter(double p1, double p2);
    bool result(double& r);
};

#endif

 

#include "Operator.h"

bool Operator::setOperator(char op)
{
    bool ret = false;
        
    if( (op == '+') || (op == '-') || (op == '*') || (op == '/') )
    {
        ret = true;
        mOp = op;
    }
    else
    {
        mOp = '\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) )
            {
                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;
}

 

 

#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;
}