C++深度解析教程笔记7
- 第13课 - 进阶面向对象（上）
- 类和对象
- 小结
- 第14课 - 进阶面向对象（下）
- 类之间的基本关系
- 继承
- 组合
- 类的表示法
- 实验-类的继承
- 第15课 - 类与封装的概念
- 实验-定义访问级别
- cmd
- 实验
- 小结
- 第16课 - 类的真正形态
- 实验-struct&class
- 实验-operator类的实现
- 小结
本文学习自狄泰软件学院 唐佐林老师的 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
*/
小结
