C++ 光速入门指南day13函数重载和面向对象初识

函数占位参数

C++中函数的形参列表里可以有占位参数，用来做占位，调用函数时必须填补该位置

#include <iostream>
using namespace std;
void func(int a, int ){
    cout<< "this is func"<< endl;
}
int main() {
    func(10, 100);// 占位参数必须填补

}

函数重载

作用：函数名可以相同，提高复用性

(同名不同参)

函数重载满足条件：

• 同一个作用域下
• 函数名称相同
• 函数参数类型不同 或者 个数不同 或者 顺序不同

注意: 函数的返回值不可以作为函数重载的条件

#include <iostream>
using namespace std;
void func(){
    cout<< "this is func"<< endl;
}
void func(int a){
    cout<< "this is func int a"<< endl;
}
void func(double a){
    cout<< "this is func double a"<< endl;
}
void func(int a, double b){
    cout<< "this is func nt a, double b"<< endl;
}
void func(double a, int b){
    cout<< "this is func double a, int b"<< endl;
}
int main() {
    double x = 11.1;
    func();
    func(10);
    func(x);
    func(10, x);
    func (x, 10);

}

引用重载

#include <iostream>
using namespace std;
// 引用作为重载的重载
void func(int &a){
    cout<< "this is func int &a"<< endl;
}
void func(const int &a){
    cout<< "this is func int a const int &a"<< endl;
}
// 函数重载碰到默认参数
void func2(int a, int b =100){
    cout<< "this is func (int a, int b =100)"<< endl;
}
void func2(int a){
    cout<< "this is func func2(int a"<< endl;
}
int main() {
    int  a = 10;
    int const b = 100;
    func(a); //
    func(10);
    func(b);
    // func2(100); // 碰到默认参数产生歧义, 需要避免
}

类和对象

C++支持面向对象, 面向对象三大特性为：封装、继承、多态

面向对象编程介绍

面向对象

1. 概述

如今主流的软件开发思想有两种：一个是面向过程，另一个是面向对象。面向过程出现得较早，典型代表为C语言，开发中小型项目的效率很高，但是很难适用于如今主流的大中型项目开发场景。面向对象则出现得更晚一些，典型代表为Java或C++等语言，更加适合用于大型开发场景。两种开发思想各有长短。

对于面向过程的思想： 需要实现一个功能的时候,看重的是开发的步骤和过程,每一个步骤都需要自己亲力亲为,需要自己编写代码(自己来做)

对于面向对象的思想：当需要实现一个功能的时候,看重的并不是过程和步骤,而是关心谁帮我做这件事(偷懒,找人帮我做)

面向对象的三大特征有：封装性、继承性、多态性。

2. 生活举例

1. 洗衣服
   面向过程（手洗）：脱衣服、找一个盆、加水、加洗衣粉、浸泡30分钟、搓洗、拧衣服、倒掉水、再加水、漂洗、拧衣服、倒掉水、晾衣服。
   面向对象（机洗）：脱衣服、放入洗衣机、按下开关、拿出衣服晾晒。
2. 买电脑
   面向过程（自己买）：需要电脑、查询参数信息、横向比较机型、了解打折信息、与店家讨价还价、下单、收快递、开机验货、确认收货。
   面向对象（找人买）：需要电脑、找秘书帮我买、收电脑。
   3.吃饭
   面向过程（自己做）：我饿了、买菜、洗菜择菜、切菜、起火、炒菜、盛菜、吃饭、刷碗。
   面向对象（出去买）：我饿了、买饭、吃饭。

类和对象

万物皆对象

分类是人们认识世界的一个很自然的过程，在日常生活中会不自觉地将对象进行进行分类
对象归类
类是抽象的概念，仅仅是模板 比如说：“人”
对象是一个你能够看得到、摸得着的具体实体： 赵本山，刘德华，赵丽颖
举例

user1 = 'zhangsan'
print(type(user1))
user2 = 'lisi'
print(type(user2))
输出

<class ‘str’>
<class ‘str’>
以上str是类（python中的字符串类型），user1和user2是对象（以前我们叫变量）

面向对象编程的2个非常重要的概念：类和对象

对象是面向对象编程的核心，在使用对象的过程中，为了将具有共同特征和行为的一组对象抽象定义，提出了另外一个新的概念——类

1. 类

我们学习编程语言，就是为了模拟现实世界中的事物，实现信息化来提高工作效率。例如银行的业务系统、超市的结账系统等，都是如此。

面向对象的语言当中，“类”就是用来模拟现实事物的。

那么模拟现实世界的事物通常从两方面模拟(描述)：

1. 属性：事物的特征描述信息，用于描述某个特征“是什么”。 静
2. 行为：事物的能力行动方案，用于说明事物“能做什么”。
   研究对象
   

类型：狗
对象名：doudou
属性(特征)：
颜色：白色, 名字, 喜好
方法(行为)：
叫，跑，吃

类中也有属性、行为两个组成部分，而“对象”是类的具体实例。例如：

1. 类：抽象的，是一张“手机设计图”。
2. 对象：具体的，是一个“真正的手机实例”。

人以类聚 物以群分。
具有相似内部状态和运动规律的实体的集合(或统称为抽象)。
具有相同属性和行为事物的统称

• 类就相当于制造飞机时的图纸，用它来进行创建的飞机就相当于对象
• 类是抽象的,在使用的时候通常会找到这个类的一个具体的存在,使用这个具体的存在。一个类可以找到多个对象

对象

某一个具体事物的存在 ,在现实世界中可以是看得见摸得着的。

可以是直接使用的

类和对象之间的关系

总结: 类是对象的模板, 对象是类的具体实例

通过类创建对象的过程我们叫做类的实例化

练习：区分类和对象

奔驰汽车
奔驰smart
张三的那辆奔驰smart
狗
大黄狗
李四家那只大黄狗
水果
苹果
红苹果
红富士苹果
我嘴里吃了一半的苹果

答案

奔驰汽车 类
奔驰smart 类 
张三的那辆奔驰smart 对象
狗 类
大黄狗 类 
李四家那只大黄狗 对象
水果  类 
苹果  类 
红苹果  类 
红富士苹果   类 
我嘴里吃了一半的苹果 对象

类的构成

类(Class) 由3个部分构成

• 类的名称:类名
• 类的属性:一组数据
• 类的方法:允许对进行操作的方法 (行为)

<1> 举例：

1）人类设计,只关心3样东西:

• 事物名称(类名):人(Person)
• 属性:身高(height)、年龄(age)
• 方法(行为/功能):跑(run)、打架(fight)

2）狗类的设计

• 类名:狗(Dog)
• 属性:品种 、毛色、性别、名字、 腿儿的数量
• 方法(行为/功能):叫 、跑、咬人、吃、摇尾巴
• 

类的抽象

如何把日常生活中的事物抽象成程序中的类?

拥有相同(或者类似)属性和行为的对象都可以抽像出一个类

方法:一般名词都是类(名词提炼法)

想一想如下图中，有哪些类呢？

说明：

• 人 --> 属性(AC/HP)和行为(跳跃/开枪)
• 枪
• 子弹
• 手榴弹
• 刀子
• 箱子

想一想如下图中，有哪些类呢？

• 向日葵类
  • 类名: XRK
• 属性: 血量/阳光产量
• 行为: 放阳光
• 豌豆类
• 类名: WD
• 属性: 颜色 /血量
• 行为:发炮, 摇头
• 坚果类:
• 类名:JG
• 属性:血量 类型
• 行为:阻挡;
• 僵尸类:
• 类名:JS
• 属性:颜色、血量、 类型、速度
• 行为:走 跑跳 吃 死

类是对象的模板, 对象是类的一个实例

封装

封装的意义
封装是C++面向对象三大特性之一

封装的意义：

• 将属性和行为作为一个整体，表现生活中的事物
• 将属性和行为加以权限控制

设计一个圆类，求圆的周长

#include <iostream>
using namespace std;
const double PI = 3.14;
class Circle{
public: // 访问权限  公有的权限
    // 属性
    int m_r ;
    // 行为
    double calculateZC(){
        return 2 * PI * m_r;
    }
};
int main() {
    // 通过圆类 创建圆的对象 这个过程实例化对象
    // c1就是  Circle 的一个具体实例
    Circle c1;
    // 访问属性 对象名.属性名
    cout << "mr = " << c1.m_r << endl;
    c1.m_r = 10;
    cout << "after  mr = " << c1.m_r << endl;
    double  zc = c1.calculateZC();
    cout << "zc  = " << zc << endl;

}

设计一个学生类，属性有姓名和学号，可以给姓名和学号赋值，可以显示学生的姓名和学号

#include <iostream>
#include <cstring>
using namespace std;
class Student{
public:
    void setName(string name){
        m_name = name;
    }
    void setID(int id){
        m_id = id;
    }
    void showStudent(){
        cout << "name : "<< m_name <<"ID : " << m_id<< endl;
    }
public:
    string m_name;
    int m_id;
};

int main() {
  Student stu1;
  stu1.setName("Eric");
  stu1.setID(8888);
  stu1.showStudent();
}

封装意义二：

类在设计时，可以把属性和行为放在不同的权限下，加以控制

访问权限有三种：

1. public 公共权限 类内可以访问 类外可以访问
2. protected 保护权限 类内可以访问 类外不可以访问
3. private 私有权限 类内可以访问 类外不可以访问

#include <iostream>
#include <cstring>
using namespace std;
class Person{
public:
    string m_name;
    // 保护权限  汽车
protected:
    string m_Car;
private:
    int m_Password;
public:
    void  func(){
        m_name = "Bob";
        m_Car = "audi";
        m_Password = 123456;
        cout << m_name<< endl;
        cout << m_Car<< endl;
        cout << m_Password<< endl;
    }
};
int main() {
    Person p1;
    p1.m_name = "Eric";
//    p1.m_Car = "benz";
//    p1.m_Password =111;
    cout << p1.m_name<< endl;
    p1.func();


}



struct和class区别
在C++中 struct和class唯一的区别就在于 默认的访问权限不同
区别：
- struct 默认权限为公共
- class   默认权限为私有
```c
#include <iostream>
#include <cstring>
using namespace std;
class C1{
//public:  int m_A;// 默认私有
    int m_A;// 默认私有
};
struct C2{
    int m_A;// 默认公有
};
int main() {
    C1 c1;
//    c1.m_A; // declared private here
    C2 c2;
    c2.m_A;
}

成员属性设置为私有

优点1：将所有成员属性设置为私有，可以自己控制读写权限

优点2：对于写权限，我们可以检测数据的有效性

对象的初始化和清理

• 生活中我们买的电子产品都基本会有出厂设置，在某一天我们不用时候也会删除一些自己信息数据保证安全
• C++中的面向对象来源于生活，每个对象也都会有初始设置以及 对象销毁前的清理数据的设置

构造函数和析构函数

对象的初始化和清理也是两个非常重要的安全问题

• 一个对象或者变量没有初始状态，对其使用后果是未知

• 同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题

c++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。

对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供
编译器提供的构造函数和析构函数是空实现。

• 构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。
• 析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。

构造函数语法 : 类名(){}

1. 构造函数，没有返回值也不写void
2. 函数名称与类名相同
3. 构造函数可以有参数，因此可以发生重载
4. 程序在调用对象时候会自动调用构造，无须手动调用,而且只会调用一次

析构函数语法 : ~类名(){}

1. 析构函数，没有返回值也不写void
2. 函数名称与类名相同,在名称前加上符号 ~
3. 析构函数不可以有参数，因此不可以发生重载
4. 程序在对象销毁前会自动调用析构，无须手动调用,而且只会调用一次

#include <iostream>
#include <cstring>
using namespace std;
class Person{
public:  Person(){
        cout<< "constructor called"<< endl;
    }

public:  ~Person(){
        cout<< "xigou constructor called"<< endl;
    }
};
int main() {
    Person p1;
}