C++学习笔记之函数的提高和c++的封装

---

一、函数提高

1.1函数默认参数

在C++中，函数的形参列表中的形参可以有默认值
语法：返回值类型 函数名 （参数 = 默认值）{}；
形参设置默认值，函数调用时，不传递任何实参就使用默认参数，有实参则进行实参传递

1.如果某个位置参数有默认值，那么从这个位置往后，从左到右，必须有默认值
2.如果函数声明有默认值，函数实现的时候就不能有默认参数

代码如下（示例）：

int func(int a, int b = 10, int c = 10)
{
	return a + b + c;
}

int func2(int a = 10, int b = 10);
int func2(int a, int b)
{
	return a + b;
}
int main()
{
	cout << func(20,20) <<endl;
	cout << func(100) <<endl;
	
	system("pause");
	return 0;
}

1.2函数占位参数

C++中函数的形参列表里可以有占位参数，用来做占位调用函数时必须填补该位置
语法：返回值类型 函数名 （数据类型）{}

占位函数就是调用该函数时，需要补上那个位置才行
代码如下（示例）：

//占位参数也可以有默认参数
void func(int a, int){
	cout << "this" <<endl;
}

int main(){
	func(10,10); //占位参数必须填补
	system("pause");
	return 0 ;
}

1.3函数重载

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

函数重载满足条件

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

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

1.4 函数重载注意事项

• 引用作为重载条件
• 函数重载碰到函数默认参数

代码如下（示例）：

//函数重载注意事项
//1.引用作为重载条件

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

}

//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

	//func2(10);  //碰到默认参数产生歧义，需要避免
	system("pause");
	return 0;
}

二、类和对象

C++面向对象的三大特性：封装、继承、多态
C++认为万事万物皆为对象，对象上有其属性和行为
例如：
人可以作为对象，属性有姓名，年龄，身高，体重…，行为有走，跑，吃饭，唱歌等；
车可以作为对象，属性有轮胎，方向盘，车灯…,行为有载人，放音乐，放空调…
具有相同性质的对象，我们可以抽象称为类，人属于人类，车属于车类

2.1.1封装

• 将属性和行为作为一个整体，表现生活中的事物
• 将属性和行为加以权限控制
  封装的意义一：
  在设计类的时候，属性和行为写在一起，表现事物
  语法：class 类名{ 访问权限： 属性 / 行为 };
  代码如下（示例1）：

#include<iostream>
using namespace std;

//圆周率
const double PI = 3.14;

//class代表设计一个类，类后面跟着的就是类名称
class Circle
{
	//访问权限
public:

	//属性
	int m_r;
	//行为（通常用函数来代表）
	//获取圆的周长
	double calculateZC()
	{
		return 2 * PI * m_r;
	}
};
int main() 
{
	//通过圆类 创建具体的圆（）
	Circle C1;
	//给对象的属性进行赋值
	C1.m_r = 10;
	cout << C1.calculateZC() << endl;
	return 0;
}

代码如下（示例2）：.

#include<iostream>
using namespace std;
#include<string>

//学生类
class Student {
public:	//控制权限
	//行为
	void setName(string name) {
		n_name = name;
	}
	void setID(int id) {
		m_id = id;
	}

	void showStudent()
	{
		cout << "name: " << n_name << "ID: " << m_id << endl;
	}
public:
	//属性
	string n_name;
	int m_id;

};
int main()
{
	Student s1;
	s1.setName("啊这");
	s1.setID(250);
	s1.showStudent();
	return 0;
}

封装意义二：
类在设计时，可以把属性和行为放在不同的权限下，加以控制
访问权限有三种：

1. public 公共权限
2. protected 保护权限
3. private 私有权限

#include<iostream>
using namespace std;
#include<string>

//三种权限
//公共权限 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 = 132456;
		cout << m_Name << m_car << m_password << endl;
	}
};
int main()
{
	person p1;
	p1.m_Name = "李四";
	//p1.m_car = "AE86"; 不可访问
	//p1.m_password = 154579;	不可访问
	return 0;

}

2.1.2 struct和class的区别

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

• struct 默认权限是公共
• class 默认权限是私有

#include<iostream>
using namespace std;


class Cdu1
{
	int m_a; //默认是私有权限
};
struct Cdu2
{
	int m_a; //默认是公有权限
};
int main()
{
	Cdu1 C1;
	Cdu2 C2;
	C1.m_a = 10;	//这个报错，不可访问
	C2.m_a = 20;
	return 0;
}

2.1.3 成员属性私有化

优点1：将所有成员属性设置为私有，可以自己控制读写权限
优点2：对于写权限，我们可以检测数据的有效性

//类中的属性设置为私有，会提供一些public的接口来对属性进行读和写
class person {
public:

	//姓名设置可读可写
	void setname(string name) {
		m_name = name;
	}
	string getname()
	{
		return m_name;
	}
	//年龄设置只读
	int getage()
	{
		m_age = 18; //初始化为18岁
		return m_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;		//读取数据
	cout << "年龄为： " << p.getage() << endl;		//读取数据
	p.setlover("某人");		//写入数据
	return 0;
}

2.1.4 封装案例-立方体

设计立方体（Cube）

• 求出立方体的面积和体积
• 分别用全局函数和成员函数判断两个立方体是否相等

#include<iostream>
using namespace std;
#include<string>

/*
立方体类设计
1.创建立方体类
2.设计属性
3.设计行为 获取立方体的面积和体积
4.分别利用全局函数和成员函数 判断两个立方体是否相等
*/
class Cube
{
public:
	//设置长
	//获取长
	//设置宽
	//获取宽
	//设置高
	//获取高
	//获取立方体的面积
	//获取立方体的体积
	void setl(int l)
	{
		m_l = l;
	}
	int  getl()
	{
		return m_l;
	}
	void setw(int w)
	{
		m_w = w;
	}
	int  getw()
	{
		return m_w;
	}void seth(int h)
	{
		m_h = h;
	}
	int  geth()
	{
		return m_h;
	}
	int calculateS()
	{
		return 2 * m_l * m_w + 2 * m_w * m_h + 2 * m_h * m_l;
	}
	int calculateV()
	{
		return m_l * m_w * m_h;
	}
	//利用成员函数判断两个立方体是否相等
	bool issamebyclass(Cube& c)
	{
		if (m_l == c.getl() && m_w == c.getw() && m_h == c.geth())
		{
			return ture;
		}
		return false;
	}
private:
	int m_l;//长
	int m_w;//宽
	int m_h;//高
};
//利用全局函数判断 两个立方体是否相等
bool issame(Cube &c1, Cube& c2)	//值传递，引用不会再拷贝一份数据
{
	if (c1.geth() == c2.geth() && c1.getl() == c2.getl() && c1.getw() == c2.getw())
		return true;
	return false;
}
int main()
{
	Cube c1;
	c1.setw(10);
	c1.setl(10);
	c1.seth(10);
	cout << "c1的面积为：" << c1.calculateS() << endl;
	cout << "c1的体积为： " << c1.calculateV() << endl;
	//利用全局函数
	bool ret = issame(c1, c2);

	//利用成员函数
	ret = c1.issamebyclass(c2);
	if (ret)
	{
		cout << "c1和c2是相等的" << endl;
	}
	else {
		cout << "c1和c2是不相等的" << endl;
	}
	
}