c++对c的函数扩展

 

1 内联函数

#define  _CRT_SECURE_NO_WARNINGS 
#include <iostream>

using namespace std;

//inline 是一个关键字，代表此函数是内联函数， 放在函数返回值的前面
#define MY_MAX(a, b) ((a) < (b)? (a):(b))

inline int   my_func(int a, int b)
{
	return (a < b ? a : b);
}

inline void printAB(int a, int b);

int main(void)
{
	int a = 10;
	int b = 20;

	//1 内联函数 在调用的时候，不想普通函数有压栈 和出栈的开销
	//2 内联函数 仅仅是把普通函数的压站和出栈开销省去了， 所有的编译器词法分析和校验 都有 ，他是有编译器处理的
	  // 而宏函数，是由预处理器处理的，没有想函数一样的校验
	//my_func(a, b);
	{
		return (a < b ? a : b);
	}
	//printAB(a, b);
	{
		cout << "a = " << a << ", b = " << b << endl;
	}

	MY_MAX(a++, b);
	(a++) < (b) ? (a++) : (b);
	my_func(a++, b);

	//MY_MAX("adsad", "dasdas");
	//my_func("adsad", "dasdsa");

	
	
	return 0;
}

//如果函数声明写了 inline 关键字  但是 函数定义没有写inline 编译器依然不会当inline函数处理
void printAB(int a, int b)
{
	cout << "a = " << a << ", b = " << b << endl;
}

2 默认参数和占位符

#define  _CRT_SECURE_NO_WARNINGS 
#include <iostream>

using namespace std;


// c++中 允许给一个形参 默认设置为一个值, 当外部调用函数的时候，如果不传递参数的，那么x就是100
//如果外部传递实参，那么x的值就是实参的值
int func1(int x , int = 0)
{
	cout << "func1: x = " << x << endl;

	return 0;
}


//求一个 立方体的体积
//默认参数，必须是从右向左设置， 只有有一个参数是带有默认参数 的，那么他右边的所有参数都必须有默认值。
int volume(int len , int width, int high= 30)
{
	return len *width * high;
}

int main(void)
{
	int x = 10;
	int v = 0;

	func1(x);

	int len = 10;
	int w = 20;
	int h = 30;

	//v = volume(len, w, h);
	v = volume(len, w,h);

	cout << "v = " << v << endl;
	
	return 0;
}

 

3 函数重载

#define  _CRT_SECURE_NO_WARNINGS 
#include <iostream>

using namespace std;

//决定一个函数的  1 返回值， 2 参数列表

void func(int a)//void (*fp)(int)
{
	cout << "func1 " << endl;
	cout << a << endl;
}

//函数重载 是对一种函数的 添加的 意义， 对一个函数名  添加多中不同的实现  （+）
//函数重载， 就是对参数列表的 变换不是 函数返回值的变化
//返回值必须一样，参数列表不同， 并且函数名 相同的函数 都是重载函数
//void func(int a, int b = 10)
void func(int a, int b )
{
	cout << "func2" << endl;
	cout << a << "," <<b << endl;
}

//如果函数 完全相同 也不是一个函数重载
/*

void func(int a, int b)
{

}
*/


void func(int a, int b, char *str)
{
	cout << "func3" << endl;
	cout << a << ", " << b << ", " << str << endl;
}

//返回值类型不同，不能构成重载
/*
char func()
{

}
*/

void print(double a)
{
	cout << "print double " << endl;
	cout << a << endl;
}

void print(float a)
{
	cout <<"print float" <<endl;
	cout <<a <<endl;
}


#if 0
void print(int a)
{
	cout << "print int" << endl;
	cout << a << endl;
}

void print(char a)
{
	cout << "print char" << endl;
	cout << a << endl;
}
#endif




int main(void)
{
	//定义一个 指向void func(int a)的函数指针
	//void(*fp)(int) = func;//fp 就是执行 void()(int) 这种函数类型的指针

	//fp(10);


	func(10); //编译器 会根据用户传递的参数类型和个数 进行重载函数的匹配
	//如果说函数重载 加上了默认参数， 回导致调用函数的时候出现二义性，
	//记住：  函数重载 最好不要有默认参数，
	func(10, 20);
	func(10, 20, "abc");


	//print(10); //void print(int a)
	//print(1.1);//void print(double a)

	//print(1.1f); // 经过隐式转换 会调用void print(double a)
	//print('a'); //经过隐式转化， 'a' ->int   void print(int a)

	//print("asbdasd");

	//1 严格进行参数列表匹配
	//2 如果隐式转换可以找到匹配 那么依然可以调用
	//3 如果匹配不到， 直接报错。


	
	
	return 0;
}

 

4 函数指针和函数重载

#define  _CRT_SECURE_NO_WARNINGS 
#include <iostream>

using namespace std;

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

void func(int a, int b, int c)
{
	cout << a << b << c << endl;
}


void func(int a, int b, int c, int d)
{
	cout << a << b << c <<d << endl;
}

//1 定义一个函数类型
typedef void(myfunctype)(int, int); //定义了一个函数类型， 返回值void 参数列表是 int，int   ,, void()(int,int)

//2 定义一个函数指针类型 
typedef void(*myfunctype_pointer)(int, int); //定义了一个函数指针类型， 返回值void 参数列表是 int，int   ,, void(*)(int,int)

int main(void)
{
	//1  定义一个函数指针
	myfunctype * fp1 = NULL;

	fp1 = func;

	fp1(10, 20);


	// 2 定义一个函数指针
	myfunctype_pointer fp2 = NULL;
	fp2 = func;
	fp2(10, 20);

	//3 直接定义一个函数指针
	void(*fp3)(int, int) = NULL;

	fp3 = func;

	fp3(10, 20);

	cout << " -----------------" << endl;

	//此时的fp3 是 void(*)(int,int)
	//fp3(10, 30, 30); //fp3 恒定指向一个 函数入口，void func(int, int) 的函数入口
	//fp3(10, 30, 40, 50); //想要通过函数指针，发生函数重载 是不可能。
	fp3(10, 20);

	void(*fp4)(int, int, int) = func; //在堆函数指针赋值的时候，函数指针会根据自己的类型 找到一个重载函数

	fp4(10, 10, 10);
	//fp4(10, 10, 10, 10);
	//函数指针，调用的时候是不能够发生函数重载的。

	void(*fp5)(int, int, int, int) = func;// void func(int ,int ,int ,int )
	fp5(10, 10, 10, 10);
	
	return 0;
}