[今日鸡汤：脚踏实地，是一切负面情绪的良药]
[今日真相：所谓问题，就是期待与现实的落差]
函数的默认参数
（默认值放在右边）
（如果函数声明有默认参数，那么函数实现就不能写；反之亦然）
int func(int a,int b = 20); // 声明
int func(int a,int b) // 实现
{
return a + b;
}
函数的占位参数
占位参数还可以有默认值，运算符重载的时候有用
void func(int)
{
cout<<"it is func"<<endl;
}
使用时：
函数重载
作用：函数名可以相同，提高复用性
函数重载满足条件：
- 同一个作用域下（全局/局部）
- 函数名称相同
- 函数参数类型不同，或者个数不同，或者顺序不同
注意：函数的返回值不可以作为函数重载的条件
#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<<"func(double a, int b) 的调用"<<endl;
}
int main()
{
func();
func(10);
func(3.14);
func(1, 2.3);
func(5.6, 7);
system("pause");
return 0;
}
运行结果：
func 的调用
func(int a) 的调用
func(double a) 的调用
func(int a, double b) 的调用
func(double a, int b) 的调用
请按任意键继续. . .
函数重载注意事项
- 引用作为重载条件
-
函数重载碰到函数默认参数（尽量别写默认参数）
func(int a , int b=10)
func(int a)
使用时
func(10)，会调用哪个函数呢？这样会产生二义性
#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;
}
int main()
{
int a = 10;
func(a); // a 是变量
cout<<"----------"<<endl;
func(10); // 10是常量
system("pause");
return 0;
}
运行结果：
func(int &a) 的调用
----------
func(const int &a) 的调用
请按任意键继续. . .
类和对象
C++面向对象的三大特性：封装、继承、多态
封装
意义：
将属性和行为作为一个整体，表现生活中的事物
通常：属性用变量，行为用函数
实例化：通过一个类创建一个对象的过程
类中的属性和行为，我们统一称为“成员”（member）
属性-->成员属性，成员变量
行为-->成员函数，成员方法
示例1：设计一个圆类，求圆的周长
#include <iostream>
using namespace std;
// 设计一个圆类，求圆的周长
// 2 * PI * 半径
const double PI = 3.14;
class Circle
{
public:
// 属性用变量
int r; // 半径
// 行为用函数
double calculateZC()
{
return 2*PI*r;
}
};
int main()
{
Circle c1; // 实例化
c1.r = 10;
cout<<"圆的周长为："<<c1.calculateZC()<<endl;
system("pause");
return 0;
}
运行结果：
圆的周长为：62.8
请按任意键继续. . .
示例2：设计一个学生类，属性有姓名和学号，可以给姓名和学号赋值，可以显示学生的姓名和学号。
#include <iostream>
#include <string>
using namespace std;
// 学生类
class Student{
public:
string name;
int id;
void showStu()
{
cout<<"Name: "<<name<<" ID: "<<id<<endl;
}
int m_age;
void setAge(int age)
{
m_age = age;
}
};
int main()
{
Student s1;
s1.name = "Alex";
s1.id = 10086;
s1.showStu();
Student s2;
s2.name = "Egon";
s2.id = 10010;
s2.showStu();
s2.setAge(23);
cout<<s2.m_age<<endl;
system("pause");
return 0;
}
运行结果：
Name: Alex ID: 10086
Name: Egon ID: 10010
23
请按任意键继续. . .
将属性和行为加以权限控制
访问权限有三种：
- public 公共权限 （内可，外可）
- protected 保护权限 （内可，外不可）
- private 私有权限 （内可，外不可）
（在继承时，保护权限和私有权限有区别：保护权限中，儿子可以使用父亲的保护内容）
struct和class区别
区别：默认的访问权限不同
struct 默认权限为公共 （C++里struct的内部可以写函数的）
class 默认权限为私有
成员属性设置为私有
优点1：可以自己控制读写权限
优点2：对于“写”权限，我们可以检测数据的有效性
#include <iostream>
#include <string>
using namespace std;
// 类的权限
class Person{
public:
string m_Name;
protected:
string m_Car;
private:
int m_Passwaord;
int m_age;
string m_nickname;
public:
void func()
{
m_Name = "Tank";
m_Car = "BYD";
m_Passwaord = 123456;
}
public:
void setAge(int age)
{
m_age = age;
}
int getAge()
{
return m_age;
}
void set_nickname(string nickname)
{
m_nickname = nickname;
}
string get_nickname()
{
return m_nickname;
}
};
int main()
{
Person p1;
p1.m_Name = "Alex";
cout<<p1.m_Name<<endl;
p1.setAge(23);
cout<<p1.getAge()<<endl;
p1.set_nickname("英雄");
cout<<p1.get_nickname()<<endl;
system("pause");
return 0;
}
运行结果：
Alex
23
英雄
请按任意键继续. . .
练习案例1：设计立方体类
设计立方体类（Cube），求出立方体的面积和体积，分别用全局函数和成员函数判断两个立方体是否相等。
#include <iostream>
using namespace std;
// 立方体
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_L*m_H + 2*m_W*m_H;
}
// 体积
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 true;
}
return false;
}
private:
int m_L;
int m_W;
int m_H;
};
// 利用全局函数判断两个立方体是否相等
bool isSame(Cube &c1, Cube &c2)
{
if(c1.getL()==c2.getL() && c1.getW()==c2.getW() && c1.getH()==c2.getH())
{
return true;
}
return false;
}
int main()
{
Cube c1;
c1.setL(10);
c1.setW(10);
c1.setH(10);
cout<<"面积："<<c1.calculateS()<<endl;
cout<<"体积："<<c1.calculateV()<<endl;
Cube c2;
c2.setL(10);
c2.setW(10);
c2.setH(10);
// 全局判断
bool ret = isSame(c1,c2);
if(ret)
{
cout<<"全局判断：c1和c2相等"<<endl;
}
else
{
cout<<"全局判断：c1和c2不相等"<<endl;
}
// 成员判断
bool ret2 = c1.isSameByClass(c2);
if(ret2)
{
cout<<"成员判断：c1和c2相等"<<endl;
}
else
{
cout<<"成员判断：c1和c2不相等"<<endl;
}
system("pause");
return 0;
}
运行结果：
面积：600
体积：1000
全局判断：c1和c2相等
成员判断：c1和c2相等
请按任意键继续. . .
练习案例2：点和圆的关系
设计一个圆形类（Circle），和一个点类（Point），计算点和圆的关系。
如何计算点到圆心的距离呢？
(x1-x2)^2 + (y1-y2)^2 然后开根号
接着跟半径的平方 m_R 作对比
(x1-x2)^2 + (y1-y2)^2 和 m_R ^2 作对比
#include <iostream>
using namespace std;
// 点和圆的关系
// 点类
class Point{
public:
void setX(int x)
{
m_X = x;
}
int getX()
{
return m_X;
}
void setY(int y)
{
m_Y = y;
}
int getY()
{
return m_Y;
}
private:
int m_X;
int m_Y;
};
// 圆类
class Circle
{
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;
}
private:
int m_R; // 半径
Point 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(10);
// 判断关系
isInCircle(c,p);
system("pause");
return 0;
}
运行结果：
点在圆上
请按任意键继续. . .
![C语言第四章自述2第四章 选择结构程序设计[图]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)