函数高级
#include<iostream>
using namespace std;
//函数的默认参数
int func1(int a, int b, int c)
{
return a + b + c;
}
int func2(int a, int b = 20, int c = 30)//如果传入参数值,用传入值。如果没有传入参数值则使用默认值
{
//如果某个位置已经有了默认参数,那么从这个位置往后,从左到右都必须有默认值
return a + b + c;
}
//如果函数的声明有了默认参数,函数的实现就不能有默认参数
// 声明和实现只能有一个有默认参数
//int func3(int a=10,int b=10)函数的声明
//int func3(int a=10,int b=10)函数的实现error
//{
// return a+b;
//}
//占位参数
void func3(int a, int)//占位参数还可以有默认参数void fun3(int a,int =10)
{
cout << "this is func3" << endl;
}
//函数的重载
void func4(double a)
{
cout << "func的调用float" << endl;
}
void func4(int a)
{
cout << "func的调用int" << endl;
}
void func4(int a ,int b)
{
cout << "func的调用 两个int" << endl;
}
void func4(double a, int b)
{
cout << "func的调用 double int" << endl;
}
void func4(int a, double b)
{
cout << "func的调用 int double" << endl;
}
//函数的返回值不可以作为函数重载的条件
//int func4(int a, double b)
//{
//cout << "func的调用 int double" << endl;
//}
//引用作为函数重载的条件
void func5(int& a)
{
cout << "func(int& a)调用" << endl;
}
void func5(const int& a)
{
cout << "func(const int& a)调用" << endl;
}
void func6(int a,int b)
{
cout << "func(int a,int b)调用" << endl;
}
//void func6(int a, int b=10)
//{
// cout << "func(int a,默认int b)调用" << endl;
//}
int main()
{
//函数的默认参数
//函数的形参列表中的形参是可以有默认值的
//返回值类型 函数名(参数=默认值){}
cout << func1(10, 20, 30) << endl;
cout << func2(10) << endl;
cout << func2(10, 30) << endl;
//函数的占位参数
//函数形参列表中可以有占位参数,用来占位,调用函数时必须填补该位置
//返回值类型 函数名(数据类型){}
func3(10, 10);
//函数重载
//函数名可以相同,提高复用性
//函数重载满足条件,在同一作用域下,函数名称相同,函数的参数(形参列表)类型不同或者个数不同或者顺序不同
//函数的返回值不可以作为函数重载的条件
func4(10);
func4(10.1);
func4(10,10);
func4(10.1, 10);
func4(10, 10.1);
//函数重载的注意事项
//引用作为函数重载的条件
//函数重载碰到函数默认参数
int a = 10;
func5(a);
func5(10);
func6(10,20);//函数重载遇到默认参数经常出错,建议避免这种情况
system("pause");
return 0;
}
封装
#include<iostream>
using namespace std;
const double PI = 3.14;
//设计一个圆类,求周长
//2*PI*半径
//class代表设计一个类,类后面跟着类的名称
class circle
{
//访问权限
public://公共权限
//属性
int m_r;
//行为(通常用函数来代表行为)
double calculateZC()
{
return 2 * PI * m_r;
}
};
//设计一个学生类
class student
{
public:
//属性
string name;
int id;
//行为
/*void cinshow()
{
cout << "请输入学生的名字:" << endl;
cin >> name;
cout << "请输入学生的学号:" << endl;
cin >> id;
cout << "学生的名字是:" << name << endl;
cout << "学生的学号是:" << id << endl;
}
*/
void show()
{
cout << "学生的名字是:" << name << endl;
cout << "学生的学号是:" << id << endl;
}
void setname(string NAME)
{
name = NAME;
}
void setid(int ID)
{
id = ID;
}
};
//公共权限public 类内可以访问,类外可以访问
//保护权限protected 类内可以访问,类外不可以访问 (子类可以访问父类保护中的内容)
//私有权限private 类内可以访问,类外不可以访问 (子类不可以访问父类私有中的内容)
class person
{
//公共权限
public:
string name;
//保护权限
protected:
string car;
//私有权限
private:
int password;
public:
void func()
{
name = "张三";
car = "破车";
password = 123;
}
};
class C1
{
int m_a;//默认权限私有
};
struct C2
{
int m_a;
};
class people
{
public:
//设置姓名
void setname(string name)
{
m_name = name;
}
//获取姓名
string getname()
{
return m_name;
}
//设置姓名
void setage(int age)
{
if (age < 0 || age>120)
{
cout << "妖怪" << endl;
return;
}
m_age = age;
}
//获取年龄
int getage()
{
return m_age;
}
void setlover(string lover)
{
m_lover = lover;
}
private:
string m_name; //可读可写
int m_age; //可读可写
string m_lover;//只写
};
int main()
{
//c++面向对象的三大特性:封装,继承,多态
//万物万事皆为对象,对象上有其属性和行为
//具有相同性质的对象,抽象为类
//封装的含义
//将属性和行为作为一个整体,表现生活中的事物
//将属性和行为加以权限控制
//在设计类时,行为和属性写在一起,表现事物
//calss 类名{ 访问权限:属性/行为};
//类中的属性和行为统称为成员
//属性 成员属性 成员变量
//行为 成员函数 成员方法
//通过圆类创造具体的圆(对象)实例化一个对象
circle c;
//给圆对象的属性进行赋值
c.m_r = 10;
cout << "圆的周长为:" << c.calculateZC() << endl;
//学生类
student s1;
//s1.cinshow();
s1.setname("张三");
s1.setid(1);
//类在设计时,可以把属性和行为放在不同的访问权限下,加以控制
//访问权限有三种 public 公共访问权限 protected 保护访问权限 private 私有访问权限
person p1;
p1.name = "李四";
//保护权限 不可访问 p1.car = "奔驰";
//私有权限 不可访问 p1.password =123;
p1.func();//公共权限
//struct和class的区别
//struct和class的唯一区别在于默认的访问权限不同
//struct 默认公共权限 class默认私有权限
C1 c1;
//c1.m_a = 100; error 私有 类外不可访问
C2 c2;
c2.m_a = 100;//公共 类外可以访问
//成员属性私有化
//将所有成员属性设置为私有,可以自己控制读写权限
//对于写权限,我们可以检测数据的有效性
people P;
P.setname("张三");
cout << P.getname() << endl;
P.setage(18);
cout << P.getage() << endl;
P.setlover("李四");
system("pause");
return 0;
}