2、面向对象 - 概念介绍

二、面向对象概念介绍

1.类和对象的概念

• 类和对象是面向对象的两个基本概念
• 类是一个抽象的模型，可以创造出不同的对象实体
• 对象是属于某个具体的实例

2.类和对象的意义

• 类用于描述某一类事物的抽象的属性
• 对象则是拥有所在类中一切的属性的具体事物

3.类之间的关系

• 继承:从已从在的类中细分出来的类

• 组合:某一些类中存在必须依赖其他的类

4.类的表示方法

#include <iostream>
#include <string>

using namespace std;

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

5.封装

1. C++中可以定义成员函数和成员变量的访问级别
2. public：可以在类的内部和外部访问成员变量和成员函数
3. private：只可以在类的内部访问成员变量和函数

• 说明：类的作用域指的是成员变量和成员函数的作用域，类之外想访问类的成员变量和成员函数，
  必须通过类对象的方式。

#include <iostream>
#include <string>

using namespace std;

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;

	cout << i << endl;           // 2 局部作用域
	cout << ::i << endl;	     // 1 全局作用域（访问默认命名空间）
	cout << test.i << endl;	     // Error  类私有变量
	cout << test.j << endl;	     // 4 类的公有变量
	cout << test.getI() << endl; // 3

	return 0;
}

6.C++类的真正形态

1. 为了兼容C语言，C++支持struct类的用法
2. 在C++中提供了新的关键词class来定义类
3. struct和class可以通用
4. 在C++中，struct定义类时，默认的成员访问级别是public
5. 在C++中，class定义类时，默认的成员访问级别是private

#include <iostream>
#include <string>

using namespace std;

struct A
{
	int i;        // 默认的成员访问级别是public
	int getI()
	{
		return i;
	}
};

class B
{
	int i;        // 默认的成员访问级别是private
	int getI()
	{
		return i;
	}
};

int main()
{
	A a;
	B b;

	a.i = 4;
	cout << "a.getI() = " << a.getI() << endl;

	b.i = 4;
	cout << "b.getI() = " << b.getI() << endl; r

	return 0;
}

实例：开发一个用于四则运算的类

1. 提供setOperator函数设置运算类型
2. 提供setParameter函数设置运算参数
3. 提供result函数进行运算

Operator.cpp
#include "Operator.h"
// 返回操作符 mOp
bool Operator::setOperator(char op)
{
  bool ret = false;

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

  return ret;
}
// 返回操作数 mP1 mP2
void Operator::setParameter(double p1, double p2)
{
  mP1 = p1;
  mP2 = p2;
}
// 返回计算结果 r
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;
}
///Operator.h
#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
///main.cpp//
#include <iostream>
#include <string>
#include "Operator.h"

using namespace std;

int main()
{
	Operator op;
	char st;
	double f1, f2;
	double r = 0;

	cin >> st;
	cin >> f1 >> f2;

	op.setOperator(st);
	op.setParameter(f1, f2);

	if (op.result(r))
	{
		cout << "r=" << r << endl;
	}
	else
	{
		cout << "Calculate error!" << endl;
	}
	return 0;
}