【贪玩巴斯】c++核心编程，你需要敲出这些程序 ！（二）{ c++中函数默认参数、占位参数、函数重载、类和对象中的封装、权限} //2021-04-11

//

//  main.cpp

//  _day2

//

//  Created by AchesonD16 贪玩巴斯 on 2021/4/6.

//

 

 

 

一、函数提高

 

1、函数默认参数

/*

//函数默认参数

//在 c++ 中，函数的形参列表中的形参是可以有默认值的

//语法： 返回值类型 函数名 （参数 = 默认值）

//             {}

 

 

#include<iostream>

using namespace std;

 

int func(int a, int b = 10, int c = 10)

{

    return a + b + c;

}

 

//1.如果某个位置参数有默认值，那么从这个位置往后，从左往右，必须都要有默认值

//2.如果函数声明有默认值，函数实现的时候就不能有默认参数

 

int func2(int a = 10, int b = 10);

int func2(int a, int b)

{

    return a + b;

}

 

int main()

{

    cout << "ret = " << func(20,20) << endl;

    cout << "ret = " << func(100) << endl;

    

    system("pause");

    return 0;

}

*/

 

 

 

2、函数占位参数

/*

//函数占位参数

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

 

//语法： 返回值类型 函数名（数据类型）

//      {}

 

//现阶段函数的占位参数存在意义不大，但是后面的课程中会用到该技术

 

#include<iostream>

using namespace std;

 

void func(int a,int)

{

    cout << "this is func" << endl;

}

 

int main()

{

    func(10,10);   //占位参数必须同类型填补

    

    system("pause");

    return 0;

}

*/

 

 

 

3、函数重载

/*

//函数重载

 

//函数重载概述

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

//函数重载满足条件：

//1、同一个作用域下

//2、函数名称相同

//3、函数参数列表不同：参数类型不同 或者 个数不同 或者 顺序不同

//注意：函数的返回值 不可以 作为函数重载的条件（见最后的情况）

 

#include<iostream>

using namespace std;

 

void func()

{

    cout << "func 的调用！" << endl;

}

 

void func(int a)

{

    cout << "func(int a) 的调用！" << endl;

}

 

void func(double a)

{

    cout << "func(double a) 的调用！" << endl;

}

 

void func(int a, double b)

{

    cout << "func(int a, double b) 的调用！" << endl;

}

 

void func(double a, int b)

{

    cout << "fnuc(double a, int b) 的调用！" << endl;

}

 

// 函数返回值 不可以作为函数重载的条件

//int func(double a, int b)

//{

//    cout << "func(double a, int b) 的调用！" << endl;

//}

 

int main()

{

    func();

    func(10);

    func(3.14);

    func(10, 3.14);

    func(3.14, 10);

    

    system("pause");

    return 0;

}

结果是:

func 的调用！

func(int a) 的调用！

func(double a) 的调用！

func(int a, double b) 的调用！

fnuc(double a, int b) 的调用！

*/

 

 

 

4、函数重载注意事项

/*

//函数重载注意事项：

 

//引用作为重载条件

//函数重载碰到函数默认参数

 

//函数重载注意事项

 

4、1引用作为重载条件

//1、引用作为重载条件

#include<iostream>

using namespace std;

 

void func(int &a)

{

    cout << "func (int &a) 调用" << endl;

}

 

void func(const int &a)

{

    cout << "func (const int &a) 调用" << endl;

}

 

 

 

4、2函数重载碰到函数默认参数

 

//2、函数重载碰到函数默认参数

 

void func2(int a, int b = 10)

{

    cout << "func2(int a, int b = 10) 调用" << endl;

}

 

void func2(int a)

{

    cout << "func2(int a) 调用" << endl;

}

 

int main()

{

    int a = 10;

    func(a);     //调用无const

    func(10);    //调用有const

这里调用的是上面的4、1的func

    

    //func2(10);    碰到默认参数产生歧义，需要避免

    

    system("pause");

    return 0;

}

 

结果:

func (int &a) 调用

func (const int &a) 调用

 

*/

 

 

 

二、类和对象

 

类和对象

//c++ 面向对象的三大特性为： 封装、继承、多态

//c++ 认为万事万物都皆为对象，对象上有其属性和行为

//具有相同性质的对象，我们可以抽象称为类。

 

1、封装

 

//封装

//封装的意义

//封装是c++面向对象三大特性之一

//封装的意义：

//1、将属性和行为作为一个整体，表现生活中的事物

//2、将属性和行为加以权限控制

 

1.1意义一

 

//封装意义一：

//在设计类的时候，属性和行为写在一起，表现事物

//语法：

//class 类名

//{

//  访问权限：

//      属性

//  访问权限：

//      行为

//}

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

/*

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

 

#include<iostream>

using namespace std;

 

//圆周率

const double PI = 3.14;

 

//1、封装的意义

//将属性和行为作为一个整体，用来表现生活中的事物

 

//封装一个圆类，求圆的周长

//class代表设计一个类，后面跟着的是类名

class Circle

{

public: //访问权限 公共的权限

    //属性

    int m_r; //半径

    

public:

    //行为

    //获取到圆的周长

    double calculateZC()

    {

        // 2 * PI * r

        // 获取圆的周长

        return 2 * PI *  m_r;

    }

};

 

 

int main()

{

    //通过圆类，创建圆的对象

    // c1就是一个具体的圆

    Circle c1;     //类的实例化

    c1.m_r = 10;   //给圆对象的半径  进行赋值操作

    

    // 2 * PI * 10 == 62.8

    cout << "圆的周长为：" << c1.calculateZC() << endl;

    

    system("pause");

    return 0;

    

}

结果：

圆的周长为：62.8

*/

 

 

 

1、2定义一个学生类，属性有姓名和学号，可以给姓名和学号赋值，可以显示学生的姓名和学号

/*

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

 

#include <iostream>

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

    stu.setName("吴彦祖");

    stu.setID(98907329);

    stu.showStudent();

    

    system("pause");

    return 0;

}

 

结果:

name: 吴彦祖 ID: 98907329

*/

 

 

 

 

2.2封装的意义二

 

/*

//封装意义二：

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

//访问权限有三种：

//1、public 公共权限

//2、protected 保护权限

//3、private 私有权限

 

#include<iostream>

using namespace std;

 

//三种权限

//公共权限 public    类内可以访问 类外可以访问

//保护权限 protected 类内可以访问 类外不可以访问

//私有权限 private   类内可以访问 类外不可以访问

 

class Person

{

    //姓名 公共权限

public:

    string m_Name;

    

    //汽车 保护权限

protected:

    string m_Car;

    

    //银行卡密码 私有权限

private:

    int m_Password;

 

public:

    void func()

    {

        m_Name = "张三";

        m_Car = "拖拉机";

        m_Password = 231451;

    }

    

   

    

    void showv()

    {

        cout << "m_Name:" << m_Name << " m_Car:" << m_Car << " m_Password:" << m_Password;

    }

};

 

int main()

{

    Person p;

    p.func();

    

    p.m_Name = "吴彦祖";

//    p.m_Car = "奔驰";         //保护权限类外访问不到

//    p.m_Password = 11345;    //私有权限类外访问不到

    

    p.showv();

    

    system("pause");

    return 0;

}

结果：

m_Name:吴彦祖 m_Car:拖拉机 m_Password:231451

*/

 

 

 

 

 

 

2、struct 和 class 的区别

/*

//struct 和 class 的区别

//在c++中struct 和 class 唯一的区别在于 默认的访问权限不同！

//区别：

//struct  默认权限为公共

//class    默认权限为私有

 

#include <iostream>

using namespace std;

 

class C1

{

    int m_A;  //默认是私有权限

};

 

struct C2

{

    int m_A;   //默认是公共权限

};

 

int main()

{

    //C1 c1;

    //c1.m_A = 10; //错误。class类的默认权限是私有

    

    C2 c2;

    c2.m_A = 10; //正确，访问权限是公共的

    system("pause");

    return 0;

}

*/

 

 

 

 

 

3、成员属性设置为私有

/*

//成员属性设置为私有

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

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

 

#include<iostream>

using namespace std;

 

class Person

{

public:

    

    //姓名设置可读可写

    void setName(string name)

    {

        m_Name = name;

    }

    string getName()

    {

        return m_Name;

    }

    

    //获取年龄

    int getAge()

    {

        return m_Age;

    }

    //设置年龄

    void setAge(int age)

    {

        if(age < 0 || age > 150)

        {

            cout << "你个老妖精！" << endl;

            return;

        }

        m_Age = age;

    }

    

    //情人设置为只写

    void setLover(string lover)

    {

        m_Lover = lover;

    }

    

private:

    string m_Name;    //可读可写 姓名

    int m_Age;        //只读    年龄

    string m_Lover;   //只写    情人

};

 

int main()

{

    Person p;

    //姓名设置

    p.setName("吴彦祖");

    cout << " 姓名：" << p.getName() << endl;

    

    //年龄设置

    p.setAge(50);

    cout << " 年龄：" << p.getAge() << endl;

    

    //情人设置

    p.setLover("王祖贤");

    //cout << " 情人：" << p.m_Lover << endl; //它是只写属性，不可以读取

    

    system("pause");

    return 0;

    

}

结果：

姓名：吴彦祖

年龄：50

*/