C++_函数参数、函数重载、函数指针、封装

函数的默认参数
如果默认参数出现，那么默认参数右面必须都是默认参数
如果填写默认参数，形参为填写的值，否则为默认值

void print(int x=2){
	cout<<x;
} 
int main(){
	print();	//打印2
	print(5);	//打印5 
	return 0;
}

函数的占位参数
函数调用时，必须写够参数

void print(int a, int b, int){
	cout<<a<<b;
} 
int main(){
	print(1, 2);	//	错误
	print(1, 2, 3);	//正确 
	return 0; 
}

默认参数和占位参数一起的情况

void func(int a, int b, int =0){
	cout<<a<<b;
} 
int main(){
	func(1, 2);		//正确
	func(1, 2, 3);	//正确 
	return 0; 
}

函数重载
函数名相同，相互独立的不同函数；编译器自动匹配
当函数名和不同参数搭配时，函数的含义不同
函数重载的判断标准：名称相同，参数不一样(个数或类型)
注意：返回值不是判断函数重载的标准

//下面这两个函数不是函数重载 
void print(int a, int b){
	cout<<a<<b;
} 
int print(int a, int b){
	return a;
}

//当产生二义性时，编译失败
void print(int a, int b, int c=0){
	cout<<a<<b; 
} 
void print(int a, int b){
	cout<<a<<b;
}
int main(){
	print(1, 2);	//编译失败 
} 

函数指针

声明一个函数类型
typedef void (mytypefunc)(int a, int b);
定义一个函数指针，这个指针指向函数的入口地址
mytypefunc *myfuncp=NULL;


声明一个函数指针类型
typedef void (*myfuncp)(int a, int b);
通过函数指针类型定义一个函数指针
myfuncp fp=NULL;


定义一个函数指针变量
void (*func_var)(int a, int b); 


函数指针
(1)函数名就是函数的指针
(2)用法 
int func(int a);
int (*fp)(int);
fp=func;
(3)使用指针来调用函数
int x=func(4);
int y=(*fp)(4);
int y=fp(4);

封装
封装的两层含义
1、把属性和方法进行封装
2、对属性和方法进行访问控制

public 修饰的成员变量和函数，可以在类的内部和外部访问
private 修饰的成员变量和函数，只能在类的内部访问
protected 修饰的成员变量和函数，只能在类的内部访问，用在继承里面
注意：类内部声明的成员变量和函数默认为private

#include <iostream>
using namespace std;
class circle{
public:
	double m_r, m_s;
public:
	void get_r(double r){
		m_r=r;	
	}	
	double get_s(){
		m_s=3.14*m_r*m_r;
		return m_s;
	}
}; 
void print(circle *r){
	cout<<r->get_s();
}
void print(circle &r){
	cout<<r.get_s();
}
void print(circle r){
	cout<<r.get_s();
}

把属性和方法进行封装
int main(){
	circle r;
	r.get_r(10);
	print(&r);
	print(r);	//产生二义性 
} 


对属性和方法进行访问控制
class circle{
private:
	double m_r, m_s;
public:
	void get_r(double r){
		m_r=r;
	} 
	double get_s(){
		m_s=3.14*m_r*m_r;
		return m_s;
	}
}; 
int main(){
	circle c1, c2;
	c1.m_r=10;	//编译不通过，无法访问
	c1.get_r(10); //编译通过， 在public中 
}

struct和class的区别
struct中定义的默认属性为public
class中定义的默认属性为private