C++深度解析教程笔记7-类和对象

本文学习自狄泰软件学院 唐佐林老师的 C++深度解析教程，图片全部来源于课程PPT，仅用于个人学习记录

第13课 - 进阶面向对象（上）

类和对象

类和对象是面向对象中的两个基本概念
类：指的是一类事物，是一个抽象的概念
对象：指的是属于某个类的具体实体
类是一种模型，这种模型可以创建出不同的对象实体
对象实体是类模型的一个具体实例

小结

每个类可以有多个对象
每个对象必然属于某个类

第14课 - 进阶面向对象（下）

类之间的基本关系

继承

从已存在类细分出来的类和原类之间具有继承关系（is a）
继承的类（子类）拥有原类（父类）的所有属性和行为
如下图：子类是惠普电脑和苹果电脑；父类是电脑

组合

一些类的存在必须依赖于其他类的关系叫组合
组合的类在某一个局部上由其他的类组成

如下图：

类的表示法

利用继承简化重复的属性和行为

利用结构体、变量和函数描述

实验-类的继承

#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() { }
    void work() { }
};


int main()
{
    return 0;
}

第15课 - 类与封装的概念

实验-定义访问级别

#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.age=10;// error: 'int Girl::age' is private within this context
    
    g.print();
    
    b.age = 19;
    b.weight = 120;
    //b.height = 180;// error: 'int Boy::height' is private within this context
    
    b.print();
    
    return 0;
}

cmd

E:\test>g++ 15-1.cpp

E:\test>a
I'm a girl, I'm 22 years old.
My weight is 48 kg.
I'm a boy, my height is 175 cm.
My salary is 9000 RMB.

实验

#include <stdio.h>

int i = 1;

struct Test
{
private://私有的，只允许类内部访问
    int i;

public:
    int j;
        
    int getI()
    {
        i = 3;
        
        return i;
    }
};

int main()
{
    int i = 2;
    
    Test test;
    
    test.j = 4;
    
    printf("i = %d\n", i);              // i = 2;
    printf("::i = %d\n", ::i);          // ::i = 1;
    //printf("test.i = %d\n", test.i);    // Error  error: 'int Test::i' is private within this context
    printf("test.j = %d\n", test.j);    // test.j = 4
    printf("test.getI() = %d\n", test.getI());  // test.getI() = 3
    
    return 0;
}
/*
i = 2
::i = 1
test.j = 4
test.getI() = 3

*/

小结

第16课 - 类的真正形态

实验-struct&class

#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;//error: 'int B::i' is private within this context
    
    //printf("b.getI() = %d\n", b.getI());// error: 'int B::getI()' is private within this context
    
    return 0;
}
/*
E:\test>g++ 16-1.cpp

E:\test>a
a.getI() = 4
*/

实验-operator类的实现

//operator.h
#ifndef _OPERATOR_H_
#define _OPERATOR_H_
class Operator
{
private:
	char mc;
	double mp0;
	double mp1;
public:
	bool setOperator(char op);
	void setParameter(double p0,double p1);
    bool result(double& r);


};


#endif

//operator.c
#include "operator.h"
bool Operator::setOperator(char op){
    bool ret = false;

    if( (op == '+') || (op == '-') || (op == '*') || (op == '/') )
    {
        ret = true;
        mc = op;
    }
    else
    {
        mc = '\0';
    }

    return ret;

//    bool res=false;
//    operator_cla::mc=mmc;
//    res=true;
//    return res;
}
void Operator::setParameter(double p0,double p1)
{

    Operator::mp0=p0;
    Operator::mp1=p1;
}
bool Operator::result(double& r)
{
    bool res=false;
    switch(mc)
    {
        case '+':
            r=Operator::mp0+Operator::mp1;
            res=true;
            break;
        case '-':
            r=Operator::mp0-Operator::mp1;
            res=true;
            break;
        case '*':
            r=Operator::mp0*Operator::mp1;
            res=true;
            break;
        case '/':
            if(Operator::mp1>-0.000000001&&Operator::mp1<0.000000001)
            {
                //break;
            }
            else{
                    r=Operator::mp0/Operator::mp1;
                    res=true;

            }

            break;
    }
    return res;

}

//main.c
#include <stdio.h>
#include "operator.h"

int main()
{
    double r=0;
    Operator op;
    op.setOperator('+');
    op.setParameter(3.5,6);
    if(op.result(r))
    {
        printf("3.5+6=%f\n",r);
    }
    op.setOperator('-');
    op.setParameter(3.5,6);
    if(op.result(r))
    {
        printf("3.5-6=%f\n",r);
    }
    op.setOperator('/');
    op.setParameter(3.5,0);
    if(op.result(r))
    {
        printf("3.5/0=%f\n",r);
    }
    else{
        printf("3.5/0 calculate error\n");
    }





    return 0;
}
/*
3.5+6=9.500000
3.5-6=-2.500000
3.5/0 calculate error
*/

小结