【C++】学习笔记[七]

一、函数

（一）函数默认参数

• 在C++中，函数的形参列表中的形参是可以有默认值的。

练习代码如下：

#include <iostream>
using namespace std;

int func01(int a, int b, int c)
{
	return a + b + c;
}

int func02(int a, int b = 20, int c = 30)
{
	return a + b + c;
}

int main()
{
	cout << func01(10, 20, 30) << endl;
	cout << func02(10) << endl;
	cout << func02(10, 30) << endl;
	cout << func02(10, 30, 40) << endl;

	//结论：如果我们子传入参数，就用自己的数据，如果没有，那么就用默认值

	/*
	* 注意事项：
	* 1、如果某个位置已经有了默认参数，那么从这个位置往后，从左到右都必须要有默认值
	*   int func(int a,int b=10,int c){}是错误的
	*   必须是int func(int a,int b=10,int c=10){}才是正确的
	* 
	* 2、如果函数的声明有了默认参数，那么这个函数的实现就不能有默认参数
	*    即声明和实现只能有一个有默认参数
	*   int func(int a =10,int b=10);//声明
	*   int func(int a=10,int b=10)//错误的，会让编译器产生二义性
	*   int func(int a,int b)//正确
	*   {
	*        return a+b;
	*   }
	
	*/
	return 0;
}

（二）函数占位参数

• C++中函数的形参列表里可以有占位参数，用来做占位，调用函数时必须填补该位置
• 占位参数可以有默认参数
• 占位参数目前阶段用不到，后面碰到详细介绍

#include <iostream>
using namespace std;

//目前阶段的占位参数用不到，后面碰到了做详细介绍
void func(int a, int)//int 是占位
{
	cout << "this is func" << endl;
}

void func01(int a, int = 10)
{
	cout << "this is func01" << endl;
}

int main()
{
	//func(10);//error
	func(10, 20);//必须有参数

	func01(10);//error
	return 0;
}

（三）函数重载

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

函数重载满足条件：

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

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

练习代码如下：

#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, char b)
{
	cout << "func(int a,char b)的调用" << endl;
}

void func(char b, int a)
{
	cout << "func(char b, int a)的调用" << endl;
}

int main()
{
	func();
	func(10);
	func(3.14);
	func(10, 'a');
	func('a', 10);
	return 0;
}

函数重载的注意事项：

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

案例代码1：

#include <iostream>
using namespace std;

//引用作为重载条件
void func(int& a)//int& a = 10;//不合法
{
	cout << "func的调用" << endl;
}

void func(const int& a)//const int& a=10;合法代码
{
	cout << "const func的调用" << endl;
}


int main()
{
	//int a = 10;
	//func(a);//调用第一个函数
	func(10);//调用第二个函数
	return 0;
}

结论：

案例代码2：

#include <iostream>
using namespace std;

//函数重载碰到函数默认参数
void func(int a, int b = 10)
{
	cout << "func(int a)" << endl;
}

void func(int a)
{
	cout << "func(int a)" << endl;
}

int main()
{
	func(10);//error 两个函数都可以调用，出现了二义性,需要尽量避免这种情况
	func(10, 20);//正确，不会出现二义性

	//建议：函数重载和默认参数最好不要同时出现，很容易导致二义性
	return 0;
}

二、类和对象----封装

• C++面向对象三大特性为：封装、继承、多态
• C++认为万事万物都皆为对象，对象上有其属性和行为

例如：

• 人可以作为对象，属性有姓名、年龄、身高等，行为有行走、吃饭、睡觉等
• 车可以作为对象，属性有轮胎、方向盘等，行为有载人、放音乐等
• 等等等等

（一）封装的意义

封装的意义：

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

案例代码一：计算圆的周长

#include <iostream>
using namespace std;

const double PI = 3.14;//圆周率

//设计一个圆类，求圆的周长：2*PI*r

//封装的意义：将属性和行为封装成一个整体
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;
}

案例代码二：设计一个学生类，属性有姓名和学号，可以给姓名和学号赋值，可以显示学生的姓名和学号

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

class Student
{
public:
	string name;//姓名
	string id;//学号

	void ShowInfo()
	{
		cout << "姓名：" << name << endl;
		cout << "学号：" << id << endl;
	}
};

int main()
{
	Student s1;
	s1.name = "张三";
	s1.id = "1831050072";

	s1.ShowInfo();
	return 0;
}

提高程序健壮性的案例二：

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

class Student
{
public:
	string m_name;//姓名
	int m_id;//学号

	//给姓名赋值
	void SetName(string name)
	{
		m_name = name;
	}

	//给学号赋值
	void SetId(int id)
	{
		m_id = id;
	}

	void ShowInfo()
	{
		cout << "姓名：" << m_name << endl;
		cout << "学号：" << m_id << endl;
	}
};

int main()
{
	Student s1;
	s1.SetName("张三");
	s1.SetId(1000);
	s1.ShowInfo();
	return 0;
}

• 类中的属性和行为统一称为成员
• 属性又称 成员属性、成员变量
• 行为又称 成员函数、成员方法

（二）访问权限

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

访问权限有三种

• public 公共权限
• protected 保护权限
• private 私有权限

public

• 类内可以访问
• 类外也可以访问

protected

• 类内可以访问
• 类外不可以访问
• 儿子可以访问父亲的保护内容

private

• 类内可以访问
• 类外不可以访问
• 儿子不可以访问父亲的私有内容

练习代码如下：

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

class Person
{
public:
	string m_name;
protected:
	string m_car;
private:
	int m_password;

public:
	void func()
	{
		//三个成员属性在类内都可以访问
		m_name = "张三";
		m_car = "宝马";
		m_password = 123456;
	}
};

int main()
{
	Person p1;
	p1.m_name = "李四";
	//p1.m_car = "奔驰";//error  保护权限在类外不可以访问
	//p1.m_password = 123;//error 私有权限在类外不可以访问


	return 0;
}

struct和class的区别

在C++中，struct和class都可以用来设计一个类，唯一的区别就在于默认的访问权限不同

区别

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

（三）成员属性设置为私有

在C++中成员属性设置为私有有以下两个优点

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

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

//成员属性设置为私有
class Person
{
public:
	//设置姓名
	void SetName(string name)
	{
		m_name = name;
	}

	//获取姓名
	string GetName()
	{
		return m_name;
	}

	//获取年龄 可读可写，如果想修改（年龄范围必须是0-150）
	int Getage()
	{
		//m_age = 0;
		return m_age;
	}

	void SetAge(int age)
	{
		if (age < 0 || age>150)
		{
			m_age = 0;
			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;
	cout << "年龄：" << p.Getage() << endl;
	p.SetLover("李四");

	p.SetAge(18);
	cout << "年龄：" << p.Getage() << endl;
	return 0;
}

（四）案例设计

案例一

练习案例1：

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

案例代码如下：

#include <iostream>
using namespace std;

//立方体设计案例
//创建立方体的类
class Cube
{
public:
	//设置长
	void SetL(int length)
	{
		m_l = length;
	}

	//获取长
	int GetL()
	{
		return m_l;
	}

	//设置宽
	void SetW(int width)
	{
		m_w = width;
	}

	//获取宽
	int GetW()
	{
		return m_w;
	}

	//设置高
	void SetH(int height)
	{
		m_h = height;
	}

	//获取高
	int GetH()
	{
		return m_h;
	}

	//获取立方体面积
	int calculateS()
	{
		return 2 * (m_l * m_w + m_l * m_h + m_w * m_h);
	}

	//获取立方体体积
	int calculateV()
	{
		return m_l * m_w * m_h;
	}

	//利用成员函数判断两个立方体是否相等
	bool isSameClass(Cube& c)
	{
		if (m_h == c.GetH() && m_l == c.GetL() && m_w == c.GetW())
		{
			return true;
		}
		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.SetL(10);
	c1.SetW(10);
	c1.SetH(10);

	cout << "c1的面积为：" << c1.calculateS() << endl;//600
	cout << "c1的体积为：" << c1.calculateV() << endl;//1000

	//创建第二个立方体
	Cube c2;
	c2.SetL(10);
	c2.SetW(10);
	c2.SetH(11);

	bool ret = isSame(c1, c2);//利用全局函数判断
	if (ret)
	{
		cout << "c1 c2 是相等的" << endl;
	}
	else
	{
		cout << "c1 c2是不相等的" << endl;
	}

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

	return 0;
}

案例二

点和圆的关系

• 设计一个圆形类，和一个点类，计算点和圆的关系
• 圆和点有三种关系
• 点在圆内（点到圆心的距离<圆的半径）
• 点在圆上（点到圆心的距离==圆的半径）
• 点在圆外（点到圆心的距离>圆的半径）
• 两点之间的距离公式如下：

案例代码如下：

#include <iostream>
using namespace std;

//设计一个点类
class Point
{
private:
	int m_X;
	int m_Y;

public:
	//设置x坐标
	void SetX(int x)
	{
		m_X = x;
	}

	//获取x坐标
	int GetX()
	{
		return m_X;
	}

	//设置y坐标
	void SetY(int y)
	{
		m_Y = y;
	}

	//获取y坐标
	int GetY()
	{
		return m_Y;
	}
};

//设计一个圆类
class Circle
{
private:
	int m_R;//半径
	Point m_Center;//圆心

public:
	//设置半径
	void SetR(int r)
	{
		m_R = r;
	}

	//获取半径
	int GetR()
	{
		return m_R;
	}

	//设置圆心
	void SetCenter(Point center)
	{
		m_Center = center;
	}

	//获取圆心
	Point GetCenter()
	{
		return m_Center;
	}
};

//判断点和圆的关系
void isInCircle(Circle& c, Point& p)
{
	//计算两点之间距离的平方
	int distance =
		(c.GetCenter().GetX() - p.GetX()) * (c.GetCenter().GetX() - p.GetX()) +
		(c.GetCenter().GetY() - p.GetY()) * (c.GetCenter().GetY() - p.GetY());

	//计算半径的平方
	int rdistance = c.GetR() * c.GetR();

	//判断关系
	if (distance == rdistance)
	{
		cout << "点在圆上" << endl;
	}
	else if (distance > rdistance)
	{
		cout << "点在圆外" << endl;
	}
	else
	{
		cout << "点在圆内" << endl;
	}
}

int main()
{
	//创建圆的实例
	Circle c;
	c.SetR(10);
	Point center;
	center.SetX(10);
	center.SetY(0);
	c.SetCenter(center);


	//创建点的实例
	Point p;
	p.SetX(10);
	p.SetY(111);

	//判断关系
	isInCircle(c, p);
	return 0;
}

我们在平时工作中写的项目一般都比较大，所以需要分文件编写，这样的话阅读代码比较方便，也可以解决一个文件中源代码量过大的情况。

整个项目的结构可以分成下图所示：

main.cpp中的代码为：

#include <iostream>
#include "point.h"
#include "circle.h"
using namespace std;
//判断点和圆的关系
void isInCircle(Circle& c, Point& p)
{
	//计算两点之间距离的平方
	int distance =
		(c.GetCenter().GetX() - p.GetX()) * (c.GetCenter().GetX() - p.GetX()) +
		(c.GetCenter().GetY() - p.GetY()) * (c.GetCenter().GetY() - p.GetY());

	//计算半径的平方
	int rdistance = c.GetR() * c.GetR();

	//判断关系
	if (distance == rdistance)
	{
		cout << "点在圆上" << endl;
	}
	else if (distance > rdistance)
	{
		cout << "点在圆外" << endl;
	}
	else
	{
		cout << "点在圆内" << endl;
	}
}

int main()
{
	//创建圆的实例
	Circle c;
	c.SetR(10);
	Point center;
	center.SetX(10);
	center.SetY(0);
	c.SetCenter(center);


	//创建点的实例
	Point p;
	p.SetX(10);
	p.SetY(111);

	//判断关系
	isInCircle(c, p);
	return 0;
}

point.h中的代码为：

#pragma once//防止头文件重复包含
#include <iostream>
using namespace std;

//设计一个点类
class Point
{
private:
	int m_X;
	int m_Y;

public:
	//设置x坐标
	void SetX(int x);

	//获取x坐标
	int GetX();

	//设置y坐标
	void SetY(int y);

	//获取y坐标
	int GetY();
};

point.cpp文件中的代码为：

#include "point.h"

	//设置x坐标
void Point::SetX(int x)
{
	m_X = x;
}

	//获取x坐标
int Point::GetX()
{
	return m_X;
}

	//设置y坐标
void Point::SetY(int y)
{
	m_Y = y;
}

	//获取y坐标
int Point::GetY()
{
	return m_Y;
}

circle.h中的代码为：

#pragma once
#include <iostream>
#include "point.h"
using namespace std;

//设计一个圆类
class Circle
{
private:
	int m_R;//半径
	Point m_Center;//圆心

public:
	//设置半径
	void SetR(int r);

	//获取半径
	int GetR();

	//设置圆心
	void SetCenter(Point center);

	//获取圆心
	Point GetCenter();
};

circle.cpp中的代码为：

#include "circle.h"
#include "point.h"


void Circle::SetR(int r)
{
	m_R = r;
}

	//获取半径
int Circle::GetR()
{
	return m_R;
}

	//设置圆心
void Circle::SetCenter(Point center)
{
	m_Center = center;
}

	//获取圆心
Point Circle::GetCenter()
{
	return m_Center;
}

✨✨✨
加油！！！