C++学习：类与对象
一、分类的思想
物以类聚，人以群分，在生活中，我们习惯将事物进行分类，在程序设计中也是可以引入分类的思想。
中国的12生肖可以将人分成不同的类型；
外国的12星座也是将人分成不同的类型；
按照财富的多少分高产、中产、低产，也是将人进行分类；
官员的九品等级也是将官员进行分类；
老虎也分为东北虎、华南虎，孟加拉虎等；
二、面向对象的意义
将日常生活中的思维习惯引入到程序设计中；
将需求中的概念直观的映射到解决方案中；
以模块为中心构建可复用的软件系统；
提高软件产品的可维护性和可扩展性；
三、类与对象
类：指的是一类事物，是一个抽象的概念，比如高产、中产、低产；
对象：指的是某个类的具体实体，比如笔者就是低产这类人中的一个对象；
一个类又可以分成多个小类，比如人类是一个类，人类可以分成黄种人、白种人、黑种人等小类，黄种人还可以继续分类，如中国人、韩国人、日本人等。
把事物分类就是为了方便区分，分类一般是按照属性和行为来分的。
四、类之间的基本关系（继承与组合）
继承
从已存在的类中细分出来的类与原类之间具有继承关系；
继承的类，也叫做子类，拥有原类，也叫做父类的所有属性和行为；
如东北虎是从老虎这个类中细分出来的，东北虎具有老虎的所有属性和行为；
组合
一些类的存在依赖于其他的类，这种关系叫组合；
组合的类在某个局部行由其他的类组成；
比如电脑这个类，是由内存、主板、显示器、硬盘等东哥类组成的；
五、类的表示方法
1、汉字描述法
生物类（可细分成动物类和植物类）
生物类的属：有生命
动物类（继承于生物类类）
动物类的属性：有生命，可移动
动物类的行为：找事物
植物类（继承于生物类类）
植物类的属性：有生命，可生长
人类（继承于动物类）
人类的属性：有生命，可移动
人类的行为：找食物、睡觉、劳动
禽兽类（继承于动物类）
禽兽类的属性：有生命、可移动
禽兽类的行为：找食物、睡觉
2、汉字+符号表示法
类：生物{
属性：有生命
}
类：动物继承生物{
属性：可移动
行为：找食物
}
类：植物继承生物{
属性：可生长
}
类：禽兽继承动物{
行为：睡觉
}
类：人类继承动物{
行为：睡觉
行为：劳动
}3、汉字+符号+单词表示法
struct 生物{
属性：有生命
}
struct 动物:生物{
属性：可移动
行为：找食物
}
struct 植物:生物{
属性：可生长
}
struct 禽兽:动物{
行为：睡觉
}
struct 人类:动物{
行为：睡觉
行为：劳动
}4、C++语言表示法
struct Biology
{
bool living;
};
struct Animal :Biology
{
bool movable;
void findFood()
{
printf("I need food!\n");
}
};
struct Plant :Biology
{
bool growable;
};
struct Beast :Animal
{
void sleep()
{
printf("I need sleep!\n");
}
};
struct Human :Animal
{
void sleep()
{
printf("I need sleep!\n");
}
void work()
{
printf("I need work!\n");
}
};六、类与封装
当实用类的时候，不需要关心类的使用细节；
只有在创建类的时候，才需要考虑内部的实现细节；
所谓封装就是将类的实现细节封起来。
C++中类的封装有哪些内容
1、成员变量：用于表示类属性的变量
2、成员函数：用于表示类行为的函数
3、成员变量和成员函数的访问级别
C++中成员变量和成员函数的访问级别
public：成员变量和成员函数可以在类的内部和外界访问；
private：成员变量和成员函数只能在类的内部被访问；
比如：
一个女生的外貌就是公开的，自己和别人都看得到，这就是public；
但是女生的年龄别人是看不见的，只有自己知道，这就是private；
要想知道这个女生的年龄，那就得让这个女生自己告诉你才行。
程序实例1：公有属性（public）和私有属性（private）的访问
#include
struct Biology
{
bool living;
};
struct Animal :Biology
{
bool movable;
void findFood()
{
printf("I need food!\n");
}
};
struct Plant :Biology
{
bool growable;
};
struct Beast :Animal
{
void sleep()
{
printf("I need sleep!\n");
}
};
struct Human :Animal
{
void sleep()
{
printf("I need sleep!\n");
}
void work()
{
printf("I need work!\n");
}
};
struct Girl :Human
{
private: //私有属性
int age;
int weight;
public://公有属性
void print()
{
age = 22;
weight = 48;
printf("I'm %d years old.\n",age);
printf("My weight is %d.\n", weight);
}
};
struct Boy :Human
{
private://私有属性
int height;
int salary;
public://公有属性
int age;
int weight;
void print()
{
height = 175;
salary = 10000;
printf("My height is %d.\n", height);
printf("My salary is %d.\n", salary);
}
};
int main()
{
Girl g;//创建一个对象g,跟定义一个变量差不多
Boy b;//创建一个对象b
//g.age = 20; //不能直接给g.age赋值，因为女孩的年龄是私有变量，不对外公开
g.print();//可以通过询问女孩，让女孩自己告诉你
b.age = 30; //可以给b.age赋值，因为男生的年龄是公有变量
b.print();//询问男孩的身高和收入
return 0;
}
输出结果：
I'm 22 years old.
My weight is 48.
My height is 175.
My salary is 10000.七、类的成员作用域
类成员（包括成员变量和成员函数）的作用域都是在类的内部，外部无法直接访问；
类的成员函数可以直接访问成员变量和调用成员函数；
类的外部可以通过类变量（也就是对象）来访问public成员；
类成员的作用域与访问级别没有关系；
C++中用struct 定义的类，如果没有定义私有还是公有的属性，那么默认就是公有属性（public）；
程序实例2：类成员作用域
#include
int i = 1; //定义一个全局变量i
struct Test
{
private:
int i; //在类里面定义一个私有变量i
public:
int j;//在类里面定义一个公有变量j
int getI()
{
i = 3;
return i;
}
};
int main()
{
int i = 2; //定义一个局部变量i
Test test;
test.j = 4;
printf("i = %d\n", i);//打印局部变量i
printf("::i = %d\n", ::i); //打印全局变量i
//printf("test.i = %d\n",test.i); //类对象不能访问私有变量i
printf("test.j = %d\n", test.j); //类对象可以访问公有变量j
printf("test.getI() = %d\n", test.getI());//通过类成员函数访问类的私有变量
return 0;
} 输出结果：
i = 2
::i = 1
test.j = 4
test.getI() = 3八、类的真正形态
struct在C语言中是表示结构体的，但是经过不断地改进已经越来越不像结构体了，既然已经变味了那就变得彻底一点吧。C++中有个新的关键字class,专门用来定义类。
其实class关键字和struct关键字的用法基本是一样的，只有一点小差异：
在用struct定义类时，所有成员的默认访问级别是public；
在用class定义类时，所有成员的默认访问级别是private；
struct A
{
int i; //默认是public
int getI() //默认是public
{
return i;
}
};
class B
{
int i; //默认是private
int getI() //默认是private
{
return i;
}
};程序实例3：struct定义类与class定义类对比
#include
struct A
{
int i; //默认是public
int getI() //默认是public
{
return i;
}
};
class B
{
int i; //默认是private
int getI() //默认是private
{
return i;
}
};
int main()
{
A a;
B b;
a.i = 4;//struct定义的类默认的是公有变量，可以直接访问
printf("a.getI() = %d\n",a.getI());
//b.i = 5;//class定义的类默认的是私有变量，不能直接访问
//printf("b.getI() = %d\n", b.getI());
return 0;
} 九、开发一个四则运算的类
提供setOperatior函数设置运算类型；
提供setParameter函数设置运算参数；
提供result函数进行运算：返回值表示运算的合法性，通过引用参数返回结果。
C++的类支持声明和实现分开操作，将类的实现和定义分开：
.h头文件中只有类的声明，包括成员变量和成员函数的声明；
.cpp源文件中完成类中成员函数的具体实现；
头文件Operator.h
#pragma once
class Operator
{
private:
char mOp;
double mP1;
double mP2;
public:
bool setOperator(char op);
void setParameter(double p1, double p2);
bool result(double& r);
};源文件Operator.cpp
#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;
}main函数中使用类
#include
#include "Operator.h"
int main()
{
Operator op;
double r = 0;
op.setOperator('/');
op.setParameter(5,3);
if (op.result(r))
{
printf("r = %lf\n", r);
}
else
{
printf("calculate error\n");
}
return 0;
}