C++对C的函数扩展

一、内联函数

#include <stdio.h>

#define  MAX(a, b)   f((a) > (b) ? (a) : (b))  

void f (int max)
{
	printf ("max = %d\n", max);
}

// 内联函数代替宏函数
// 在普通函数前加 关键字  inline 将函数变成内联函数
// inline 必须要和函数定义放一起，如果和函数声明放一起会被忽略
// define 是预处理器处理的 inline 是编译器处理的
// define 没有函数参数检测，返回检测，作用域检测，inline 工作方式像一个函数
// 所以会有参数类型检测等
// inline是向请求在调用该函数的时候进行函数体的替换，编译器可能拒绝内联请求
// 如果内联成功，编译完以后代码是没有这一段函数的

// 内联函数函数体不能过长，最好不要超过 5 行
// 不能有循环语句，复杂的 if 语句
// 不能对内联函数进行取地址操作
inline int max(int a,  int b)
{
	return (a>b ? a : b);
}

int main7_2()
{
	int a = 10;
	int b = 20;
	f(10);
	f (max(a, b++));
	printf ("b = %d\n", b);


	return 0;
}

int main7_1()
{
	int a = 10;
	int b = 20;
	MAX(a, b++); // f((a) > (b++) ? (a) : (b++))
	printf ("b = %d\n", b);

	return 0;
}

默认参数

#include <stdio.h>

// 函数的默认参数：当函数调用没有提供该参数的值，会使用默认的值
int mul(int a, int b = 10)
{
	return a * b;
}

// 如果给函数一个参数赋了一个默认的值,那么这个参数后面的所有参数都必须要有默认值
int mul2(int a, int b = 5, int c = 6)
{
	return  a*b*c;
}

struct A
{
	unsigned int a:10;
	unsigned int b:10;
	unsigned int  :10;   //无名位域  占着 10 bit 空间 但是不用
	unsigned int c:2; 
};

// 如果一个函数的参数只有类型，没有变量名，把这个参数叫做占位参数
// 函数的占位参数可以和默认参数一起使用
int mul3(int a, int b, int=0)
{
	return a * b;
}

int main8_2()
{
	mul3(1,2,3);
	mul3(1,2);

	return 0;
}

int main8_1()
{
	printf ("a * b = %d\n", mul(10));

	printf ("a * b = %d\n", mul(10, 20));

	printf ("a * b = %d\n", mul2(10, 20, 30));
	printf ("a * b = %d\n", mul2(10, 30));
	printf ("a * b = %d\n", mul2(10));
	return 0;
}

函数的重载

#include <stdio.h>

void print_int(int a)
{
	printf ("a = %d\n", a);
}

void print_char(char c)
{
	printf ("c = %c\n", c);
}

void print_str(char *str)
{
	printf ("str = %s\n", str);
}

// 函数重载：函数名相同，函数的参数不一样，根据调用的时候传的参数类型
// 决定调用哪一个函数
void printA(int a)
{
	printf ("a = %d\n", a);
}

// 参数个数不同
void printA(int a, int b)
{
	printf ("a = %d, b = %d\n", a, b);
}

// 函数重载遇上函数默认参数可能导致 二义性的问题
void printA(int a, int b,int c)
{
	printf ("a = %d, b = %d, c = %d\n", a, b, c);
}

void printA(int a, char *str)
{
	printf ("a = %d, str = %s\n", a, str);
}

void printA(char *str, int a)
{
	printf ("a = %d, str = %s\n", a, str);
}

void printA(char c)
{
	printf ("c = %c\n", c);
}

void printA(char *str)
{
	printf ("str = %s\n", str);
}

// 函数重载的规则：1、参数个数不同 2、参数类型不同 3、参数顺序不同

// 函数的返回值不能作为函数重载的判定条件
//int printA(int a)
//{
//
//}

int main9_2()
{
	int a = 10;
	char c = 'a';
	char *str = "hello";
	// printA(10, 20);
	printA(10,20,30);
	printA(a);
	printA(c);
	printA(str);

	return 0;
}

int main9_1()
{
	int a = 10;
	char c = 'a';
	char *str = "hello";

	print_int(a);
	print_char(c);
	print_str(str);

	return 0;
}

// 对于引用，常量性不同可以作为重载的条件
int sub(int &a, int &b)
{
	return a - b;
}

int sub(const int &a, const int &b)
{
	return  a - b;
}

int main9_3()
{
	sub(10, 20);
	int a = 10;
	int b = 20;
	sub(a, 10);

	return 0;
}


// 定义一个函数指针类型，有一个 void 返回值，和一个 int 类型的形参
typedef void (*PFUNC)(int);

int main()
{
	// 当将一个重载函数赋给一个函数指针的时候
	// 严格匹配函数指针的类型
	PFUNC pfunc = printA;

	pfunc(10);
	return 0;
}